Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
378 lines
13 KiB
Java
378 lines
13 KiB
Java
package androidx.credentials.webauthn;
|
|
|
|
import androidx.annotation.RestrictTo;
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import kotlin.collections.ArraysKt___ArraysJvmKt;
|
|
import kotlin.collections.ArraysKt___ArraysKt;
|
|
import kotlin.collections.CollectionsKt___CollectionsKt;
|
|
import kotlin.collections.MapsKt__MapsKt;
|
|
import kotlin.jvm.internal.Intrinsics;
|
|
import kotlin.jvm.internal.Ref;
|
|
import kotlin.ranges.IntRange;
|
|
import kotlin.ranges.RangesKt___RangesKt;
|
|
import kotlin.text.Charsets;
|
|
import kotlin.text.StringsKt__StringsJVMKt;
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
/* loaded from: classes.dex */
|
|
public final class Cbor {
|
|
private final int TYPE_UNSIGNED_INT;
|
|
private final int TYPE_NEGATIVE_INT = 1;
|
|
private final int TYPE_BYTE_STRING = 2;
|
|
private final int TYPE_TEXT_STRING = 3;
|
|
private final int TYPE_ARRAY = 4;
|
|
private final int TYPE_MAP = 5;
|
|
private final int TYPE_TAG = 6;
|
|
private final int TYPE_FLOAT = 7;
|
|
|
|
public final int getTYPE_ARRAY() {
|
|
return this.TYPE_ARRAY;
|
|
}
|
|
|
|
public final int getTYPE_BYTE_STRING() {
|
|
return this.TYPE_BYTE_STRING;
|
|
}
|
|
|
|
public final int getTYPE_FLOAT() {
|
|
return this.TYPE_FLOAT;
|
|
}
|
|
|
|
public final int getTYPE_MAP() {
|
|
return this.TYPE_MAP;
|
|
}
|
|
|
|
public final int getTYPE_NEGATIVE_INT() {
|
|
return this.TYPE_NEGATIVE_INT;
|
|
}
|
|
|
|
public final int getTYPE_TAG() {
|
|
return this.TYPE_TAG;
|
|
}
|
|
|
|
public final int getTYPE_TEXT_STRING() {
|
|
return this.TYPE_TEXT_STRING;
|
|
}
|
|
|
|
public final int getTYPE_UNSIGNED_INT() {
|
|
return this.TYPE_UNSIGNED_INT;
|
|
}
|
|
|
|
public static final class Item {
|
|
private final Object item;
|
|
private final int len;
|
|
|
|
public static /* synthetic */ Item copy$default(Item item, Object obj, int i, int i2, Object obj2) {
|
|
if ((i2 & 1) != 0) {
|
|
obj = item.item;
|
|
}
|
|
if ((i2 & 2) != 0) {
|
|
i = item.len;
|
|
}
|
|
return item.copy(obj, i);
|
|
}
|
|
|
|
public final Object component1() {
|
|
return this.item;
|
|
}
|
|
|
|
public final int component2() {
|
|
return this.len;
|
|
}
|
|
|
|
public final Item copy(Object item, int i) {
|
|
Intrinsics.checkNotNullParameter(item, "item");
|
|
return new Item(item, i);
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof Item)) {
|
|
return false;
|
|
}
|
|
Item item = (Item) obj;
|
|
return Intrinsics.areEqual(this.item, item.item) && this.len == item.len;
|
|
}
|
|
|
|
public final Object getItem() {
|
|
return this.item;
|
|
}
|
|
|
|
public final int getLen() {
|
|
return this.len;
|
|
}
|
|
|
|
public int hashCode() {
|
|
return (this.item.hashCode() * 31) + Integer.hashCode(this.len);
|
|
}
|
|
|
|
public String toString() {
|
|
return "Item(item=" + this.item + ", len=" + this.len + ')';
|
|
}
|
|
|
|
public Item(Object item, int i) {
|
|
Intrinsics.checkNotNullParameter(item, "item");
|
|
this.item = item;
|
|
this.len = i;
|
|
}
|
|
}
|
|
|
|
public static final class Arg {
|
|
private final long arg;
|
|
private final int len;
|
|
|
|
public static /* synthetic */ Arg copy$default(Arg arg, long j, int i, int i2, Object obj) {
|
|
if ((i2 & 1) != 0) {
|
|
j = arg.arg;
|
|
}
|
|
if ((i2 & 2) != 0) {
|
|
i = arg.len;
|
|
}
|
|
return arg.copy(j, i);
|
|
}
|
|
|
|
public final long component1() {
|
|
return this.arg;
|
|
}
|
|
|
|
public final int component2() {
|
|
return this.len;
|
|
}
|
|
|
|
public final Arg copy(long j, int i) {
|
|
return new Arg(j, i);
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof Arg)) {
|
|
return false;
|
|
}
|
|
Arg arg = (Arg) obj;
|
|
return this.arg == arg.arg && this.len == arg.len;
|
|
}
|
|
|
|
public final long getArg() {
|
|
return this.arg;
|
|
}
|
|
|
|
public final int getLen() {
|
|
return this.len;
|
|
}
|
|
|
|
public int hashCode() {
|
|
return (Long.hashCode(this.arg) * 31) + Integer.hashCode(this.len);
|
|
}
|
|
|
|
public String toString() {
|
|
return "Arg(arg=" + this.arg + ", len=" + this.len + ')';
|
|
}
|
|
|
|
public Arg(long j, int i) {
|
|
this.arg = j;
|
|
this.len = i;
|
|
}
|
|
}
|
|
|
|
public final Object decode(byte[] data) {
|
|
Intrinsics.checkNotNullParameter(data, "data");
|
|
return parseItem(data, 0).getItem();
|
|
}
|
|
|
|
/* JADX WARN: Type inference failed for: r2v0, types: [T, java.util.LinkedHashMap] */
|
|
public final byte[] encode(Object data) {
|
|
byte[] plus;
|
|
byte[] encodeToByteArray;
|
|
byte[] plus2;
|
|
byte[] plus3;
|
|
Intrinsics.checkNotNullParameter(data, "data");
|
|
if (data instanceof Number) {
|
|
if (data instanceof Double) {
|
|
throw new IllegalArgumentException("Don't support doubles yet");
|
|
}
|
|
long longValue = ((Number) data).longValue();
|
|
if (longValue >= 0) {
|
|
return createArg(this.TYPE_UNSIGNED_INT, longValue);
|
|
}
|
|
return createArg(this.TYPE_NEGATIVE_INT, (-1) - longValue);
|
|
}
|
|
if (data instanceof byte[]) {
|
|
plus3 = ArraysKt___ArraysJvmKt.plus(createArg(this.TYPE_BYTE_STRING, r6.length), (byte[]) data);
|
|
return plus3;
|
|
}
|
|
if (data instanceof String) {
|
|
byte[] createArg = createArg(this.TYPE_TEXT_STRING, r6.length());
|
|
encodeToByteArray = StringsKt__StringsJVMKt.encodeToByteArray((String) data);
|
|
plus2 = ArraysKt___ArraysJvmKt.plus(createArg, encodeToByteArray);
|
|
return plus2;
|
|
}
|
|
if (data instanceof List) {
|
|
byte[] createArg2 = createArg(this.TYPE_ARRAY, r6.size());
|
|
for (Object obj : (List) data) {
|
|
Intrinsics.checkNotNull(obj);
|
|
createArg2 = ArraysKt___ArraysJvmKt.plus(createArg2, encode(obj));
|
|
}
|
|
return createArg2;
|
|
}
|
|
if (data instanceof Map) {
|
|
byte[] createArg3 = createArg(this.TYPE_MAP, r6.size());
|
|
final Ref.ObjectRef objectRef = new Ref.ObjectRef();
|
|
objectRef.element = new LinkedHashMap();
|
|
for (Map.Entry entry : ((Map) data).entrySet()) {
|
|
Map map = (Map) objectRef.element;
|
|
Object key = entry.getKey();
|
|
Intrinsics.checkNotNull(key);
|
|
byte[] encode = encode(key);
|
|
Object value = entry.getValue();
|
|
Intrinsics.checkNotNull(value);
|
|
map.put(encode, encode(value));
|
|
}
|
|
ArrayList arrayList = new ArrayList(((Map) objectRef.element).keySet());
|
|
CollectionsKt___CollectionsKt.sortedWith(arrayList, new Comparator() { // from class: androidx.credentials.webauthn.Cbor$$ExternalSyntheticLambda0
|
|
@Override // java.util.Comparator
|
|
public final int compare(Object obj2, Object obj3) {
|
|
int encode$lambda$0;
|
|
encode$lambda$0 = Cbor.encode$lambda$0(Ref.ObjectRef.this, (byte[]) obj2, (byte[]) obj3);
|
|
return encode$lambda$0;
|
|
}
|
|
});
|
|
Iterator it = arrayList.iterator();
|
|
while (it.hasNext()) {
|
|
byte[] key2 = (byte[]) it.next();
|
|
Intrinsics.checkNotNullExpressionValue(key2, "key");
|
|
plus = ArraysKt___ArraysJvmKt.plus(createArg3, key2);
|
|
Object obj2 = ((Map) objectRef.element).get(key2);
|
|
Intrinsics.checkNotNull(obj2);
|
|
createArg3 = ArraysKt___ArraysJvmKt.plus(plus, (byte[]) obj2);
|
|
}
|
|
return createArg3;
|
|
}
|
|
throw new IllegalArgumentException("Bad type");
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public static final int encode$lambda$0(Ref.ObjectRef objectRef, byte[] bArr, byte[] bArr2) {
|
|
Object obj = ((Map) objectRef.element).get(bArr);
|
|
Intrinsics.checkNotNull(obj);
|
|
byte[] bArr3 = (byte[]) obj;
|
|
Object obj2 = ((Map) objectRef.element).get(bArr2);
|
|
Intrinsics.checkNotNull(obj2);
|
|
byte[] bArr4 = (byte[]) obj2;
|
|
if (bArr.length > bArr2.length) {
|
|
return 1;
|
|
}
|
|
if (bArr.length >= bArr2.length) {
|
|
if (bArr3.length > bArr4.length) {
|
|
return 1;
|
|
}
|
|
if (bArr3.length >= bArr4.length) {
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private final int getType(byte[] bArr, int i) {
|
|
return (bArr[i] & 255) >> 5;
|
|
}
|
|
|
|
private final Arg getArg(byte[] bArr, int i) {
|
|
long j = bArr[i] & 31;
|
|
if (j < 24) {
|
|
return new Arg(j, 1);
|
|
}
|
|
if (j == 24) {
|
|
return new Arg(bArr[i + 1] & 255, 2);
|
|
}
|
|
if (j == 25) {
|
|
return new Arg((bArr[i + 2] & 255) | ((bArr[i + 1] & 255) << 8), 3);
|
|
}
|
|
if (j == 26) {
|
|
return new Arg((bArr[i + 4] & 255) | ((bArr[i + 1] & 255) << 24) | ((bArr[i + 2] & 255) << 16) | ((bArr[i + 3] & 255) << 8), 5);
|
|
}
|
|
throw new IllegalArgumentException("Bad arg");
|
|
}
|
|
|
|
private final Item parseItem(byte[] bArr, int i) {
|
|
Map map;
|
|
IntRange until;
|
|
byte[] sliceArray;
|
|
IntRange until2;
|
|
byte[] sliceArray2;
|
|
int type = getType(bArr, i);
|
|
Arg arg = getArg(bArr, i);
|
|
System.out.println((Object) ("Type " + type + ' ' + arg.getArg() + ' ' + arg.getLen()));
|
|
if (type == this.TYPE_UNSIGNED_INT) {
|
|
return new Item(Long.valueOf(arg.getArg()), arg.getLen());
|
|
}
|
|
if (type == this.TYPE_NEGATIVE_INT) {
|
|
return new Item(Long.valueOf((-1) - arg.getArg()), arg.getLen());
|
|
}
|
|
if (type == this.TYPE_BYTE_STRING) {
|
|
until2 = RangesKt___RangesKt.until(arg.getLen() + i, i + arg.getLen() + ((int) arg.getArg()));
|
|
sliceArray2 = ArraysKt___ArraysKt.sliceArray(bArr, until2);
|
|
return new Item(sliceArray2, arg.getLen() + ((int) arg.getArg()));
|
|
}
|
|
if (type == this.TYPE_TEXT_STRING) {
|
|
until = RangesKt___RangesKt.until(arg.getLen() + i, i + arg.getLen() + ((int) arg.getArg()));
|
|
sliceArray = ArraysKt___ArraysKt.sliceArray(bArr, until);
|
|
return new Item(new String(sliceArray, Charsets.UTF_8), arg.getLen() + ((int) arg.getArg()));
|
|
}
|
|
int i2 = 0;
|
|
if (type == this.TYPE_ARRAY) {
|
|
ArrayList arrayList = new ArrayList();
|
|
int len = arg.getLen();
|
|
int arg2 = (int) arg.getArg();
|
|
while (i2 < arg2) {
|
|
Item parseItem = parseItem(bArr, i + len);
|
|
arrayList.add(parseItem.getItem());
|
|
len += parseItem.getLen();
|
|
i2++;
|
|
}
|
|
return new Item(CollectionsKt___CollectionsKt.toList(arrayList), len);
|
|
}
|
|
if (type == this.TYPE_MAP) {
|
|
LinkedHashMap linkedHashMap = new LinkedHashMap();
|
|
int len2 = arg.getLen();
|
|
int arg3 = (int) arg.getArg();
|
|
while (i2 < arg3) {
|
|
Item parseItem2 = parseItem(bArr, i + len2);
|
|
int len3 = len2 + parseItem2.getLen();
|
|
Item parseItem3 = parseItem(bArr, i + len3);
|
|
len2 = len3 + parseItem3.getLen();
|
|
linkedHashMap.put(parseItem2.getItem(), parseItem3.getItem());
|
|
i2++;
|
|
}
|
|
map = MapsKt__MapsKt.toMap(linkedHashMap);
|
|
return new Item(map, len2);
|
|
}
|
|
throw new IllegalArgumentException("Bad type");
|
|
}
|
|
|
|
private final byte[] createArg(int i, long j) {
|
|
int i2 = i << 5;
|
|
int i3 = (int) j;
|
|
if (j < 24) {
|
|
return new byte[]{(byte) ((i2 | i3) & 255)};
|
|
}
|
|
if (j <= 255) {
|
|
return new byte[]{(byte) ((i2 | 24) & 255), (byte) (i3 & 255)};
|
|
}
|
|
if (j <= 65535) {
|
|
return new byte[]{(byte) ((i2 | 25) & 255), (byte) ((i3 >> 8) & 255), (byte) (i3 & 255)};
|
|
}
|
|
if (j <= 4294967295L) {
|
|
return new byte[]{(byte) ((i2 | 26) & 255), (byte) ((i3 >> 24) & 255), (byte) ((i3 >> 16) & 255), (byte) ((i3 >> 8) & 255), (byte) (i3 & 255)};
|
|
}
|
|
throw new IllegalArgumentException("bad Arg");
|
|
}
|
|
}
|