() {
public InstantAppResolveInfo createFromParcel(Parcel in) {
return new InstantAppResolveInfo(in);
}
public InstantAppResolveInfo[] newArray(int size) {
return new InstantAppResolveInfo[size];
}
};
/**
* Helper class to generate and store each of the digests and prefixes
* sent to the Instant App Resolver.
*
* Since intent filters may want to handle multiple hosts within a
* domain [eg “*.google.com”], the resolver is presented with multiple
* hash prefixes. For example, "a.b.c.d.e" generates digests for
* "d.e", "c.d.e", "b.c.d.e" and "a.b.c.d.e".
*
* @hide
*/
@SystemApi
public static final class InstantAppDigest implements Parcelable {
static final int DIGEST_MASK = 0xfffff000;
/**
* A special instance that represents and undefined digest used for cases that a host was
* not provided or is irrelevant to the response.
*/
public static final InstantAppDigest UNDEFINED =
new InstantAppDigest(new byte[][]{}, new int[]{});
private static Random sRandom = null;
static {
try {
sRandom = SecureRandom.getInstance("SHA1PRNG");
} catch (NoSuchAlgorithmException e) {
// oh well
sRandom = new Random();
}
}
/** Full digest of the domain hashes */
private final byte[][] mDigestBytes;
/** The first 5 bytes of the domain hashes */
private final int[] mDigestPrefix;
/** The first 5 bytes of the domain hashes interspersed with random data */
private int[] mDigestPrefixSecure;
public InstantAppDigest(@NonNull String hostName) {
this(hostName, -1 /*maxDigests*/);
}
/** @hide */
public InstantAppDigest(@NonNull String hostName, int maxDigests) {
if (hostName == null) {
throw new IllegalArgumentException();
}
mDigestBytes = generateDigest(hostName.toLowerCase(Locale.ENGLISH), maxDigests);
mDigestPrefix = new int[mDigestBytes.length];
for (int i = 0; i < mDigestBytes.length; i++) {
mDigestPrefix[i] =
((mDigestBytes[i][0] & 0xFF) << 24
| (mDigestBytes[i][1] & 0xFF) << 16
| (mDigestBytes[i][2] & 0xFF) << 8
| (mDigestBytes[i][3] & 0xFF) << 0)
& DIGEST_MASK;
}
}
private InstantAppDigest(byte[][] digestBytes, int[] prefix) {
this.mDigestPrefix = prefix;
this.mDigestBytes = digestBytes;
}
private static byte[][] generateDigest(String hostName, int maxDigests) {
ArrayList digests = new ArrayList<>();
try {
final MessageDigest digest = MessageDigest.getInstance(SHA_ALGORITHM);
if (maxDigests <= 0) {
final byte[] hostBytes = hostName.getBytes();
digests.add(digest.digest(hostBytes));
} else {
int prevDot = hostName.lastIndexOf('.');
prevDot = hostName.lastIndexOf('.', prevDot - 1);
// shortcut for short URLs
if (prevDot < 0) {
digests.add(digest.digest(hostName.getBytes()));
} else {
byte[] hostBytes =
hostName.substring(prevDot + 1, hostName.length()).getBytes();
digests.add(digest.digest(hostBytes));
int digestCount = 1;
while (prevDot >= 0 && digestCount < maxDigests) {
prevDot = hostName.lastIndexOf('.', prevDot - 1);
hostBytes =
hostName.substring(prevDot + 1, hostName.length()).getBytes();
digests.add(digest.digest(hostBytes));
digestCount++;
}
}
}
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("could not find digest algorithm");
}
return digests.toArray(new byte[digests.size()][]);
}
InstantAppDigest(Parcel in) {
final int digestCount = in.readInt();
if (digestCount == -1) {
mDigestBytes = null;
} else {
mDigestBytes = new byte[digestCount][];
for (int i = 0; i < digestCount; i++) {
mDigestBytes[i] = in.createByteArray();
}
}
mDigestPrefix = in.createIntArray();
mDigestPrefixSecure = in.createIntArray();
}
public byte[][] getDigestBytes() {
return mDigestBytes;
}
public int[] getDigestPrefix() {
return mDigestPrefix;
}
/**
* Returns a digest prefix with additional random prefixes interspersed.
* @hide
*/
public int[] getDigestPrefixSecure() {
if (this == InstantAppResolveInfo.InstantAppDigest.UNDEFINED) {
return getDigestPrefix();
} else if (mDigestPrefixSecure == null) {
// let's generate some random data to intersperse throughout the set of prefixes
final int realSize = getDigestPrefix().length;
final int manufacturedSize = realSize + 10 + sRandom.nextInt(10);
mDigestPrefixSecure = Arrays.copyOf(getDigestPrefix(), manufacturedSize);
for (int i = realSize; i < manufacturedSize; i++) {
mDigestPrefixSecure[i] = sRandom.nextInt() & DIGEST_MASK;
}
Arrays.sort(mDigestPrefixSecure);
}
return mDigestPrefixSecure;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel out, int flags) {
final boolean isUndefined = this == UNDEFINED;
out.writeBoolean(isUndefined);
if (isUndefined) {
return;
}
if (mDigestBytes == null) {
out.writeInt(-1);
} else {
out.writeInt(mDigestBytes.length);
for (int i = 0; i < mDigestBytes.length; i++) {
out.writeByteArray(mDigestBytes[i]);
}
}
out.writeIntArray(mDigestPrefix);
out.writeIntArray(mDigestPrefixSecure);
}
@SuppressWarnings("hiding")
public static final Parcelable.Creator CREATOR =
new Parcelable.Creator() {
@Override
public InstantAppDigest createFromParcel(Parcel in) {
if (in.readBoolean() /* is undefined */) {
return UNDEFINED;
}
return new InstantAppDigest(in);
}
@Override
public InstantAppDigest[] newArray(int size) {
return new InstantAppDigest[size];
}
};
}
}