Add Discord community version (64-bit only)

- 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

decompiled-community/sources/com/amazonaws/auth/AWS4Signer.java

@@ -0,0 +1,261 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.Request;
+import com.amazonaws.logging.Log;
+import com.amazonaws.logging.LogFactory;
+import com.amazonaws.util.AwsHostNameUtils;
+import com.amazonaws.util.BinaryUtils;
+import com.amazonaws.util.DateUtils;
+import com.amazonaws.util.HttpUtils;
+import com.amazonaws.util.StringUtils;
+import com.facebook.internal.security.CertificateUtil;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes.dex */
+public class AWS4Signer extends AbstractAWSSigner implements ServiceAwareSigner, RegionAwareSigner {
+    protected static final String ALGORITHM = "AWS4-HMAC-SHA256";
+    private static final String DATE_PATTERN = "yyyyMMdd";
+    private static final long MAX_EXPIRATION_TIME_IN_SECONDS = 604800;
+    private static final long MILLISEC = 1000;
+    protected static final String TERMINATOR = "aws4_request";
+    private static final String TIME_PATTERN = "yyyyMMdd'T'HHmmss'Z'";
+    protected static final Log log = LogFactory.getLog(AWS4Signer.class);
+    protected boolean doubleUrlEncode;
+    protected Date overriddenDate;
+    protected String regionName;
+    protected String serviceName;
+
+    public void overrideDate(Date date) {
+        this.overriddenDate = date;
+    }
+
+    public void processRequestPayload(Request<?> request, HeaderSigningResult headerSigningResult) {
+    }
+
+    @Override // com.amazonaws.auth.RegionAwareSigner
+    public void setRegionName(String str) {
+        this.regionName = str;
+    }
+
+    @Override // com.amazonaws.auth.ServiceAwareSigner
+    public void setServiceName(String str) {
+        this.serviceName = str;
+    }
+
+    public AWS4Signer() {
+        this(true);
+    }
+
+    public AWS4Signer(boolean z) {
+        this.doubleUrlEncode = z;
+    }
+
+    @Override // com.amazonaws.auth.Signer
+    public void sign(Request<?> request, AWSCredentials aWSCredentials) {
+        if (aWSCredentials instanceof AnonymousAWSCredentials) {
+            return;
+        }
+        AWSCredentials sanitizeCredentials = sanitizeCredentials(aWSCredentials);
+        if (sanitizeCredentials instanceof AWSSessionCredentials) {
+            addSessionCredentials(request, (AWSSessionCredentials) sanitizeCredentials);
+        }
+        addHostHeader(request);
+        long dateFromRequest = getDateFromRequest(request);
+        String dateStamp = getDateStamp(dateFromRequest);
+        String scope = getScope(request, dateStamp);
+        String calculateContentHash = calculateContentHash(request);
+        String timeStamp = getTimeStamp(dateFromRequest);
+        request.addHeader("X-Amz-Date", timeStamp);
+        if (request.getHeaders().get("x-amz-content-sha256") != null && "required".equals(request.getHeaders().get("x-amz-content-sha256"))) {
+            request.addHeader("x-amz-content-sha256", calculateContentHash);
+        }
+        String str = sanitizeCredentials.getAWSAccessKeyId() + "/" + scope;
+        HeaderSigningResult computeSignature = computeSignature(request, dateStamp, timeStamp, ALGORITHM, calculateContentHash, sanitizeCredentials);
+        request.addHeader("Authorization", "AWS4-HMAC-SHA256 " + ("Credential=" + str) + ", " + ("SignedHeaders=" + getSignedHeadersString(request)) + ", " + ("Signature=" + BinaryUtils.toHex(computeSignature.getSignature())));
+        processRequestPayload(request, computeSignature);
+    }
+
+    public void addSessionCredentials(Request<?> request, AWSSessionCredentials aWSSessionCredentials) {
+        request.addHeader("x-amz-security-token", aWSSessionCredentials.getSessionToken());
+    }
+
+    public String extractRegionName(URI uri) {
+        String str = this.regionName;
+        return str != null ? str : AwsHostNameUtils.parseRegionName(uri.getHost(), this.serviceName);
+    }
+
+    public String extractServiceName(URI uri) {
+        String str = this.serviceName;
+        return str != null ? str : AwsHostNameUtils.parseServiceName(uri);
+    }
+
+    public String getCanonicalizedHeaderString(Request<?> request) {
+        ArrayList<String> arrayList = new ArrayList();
+        arrayList.addAll(request.getHeaders().keySet());
+        Collections.sort(arrayList, String.CASE_INSENSITIVE_ORDER);
+        StringBuilder sb = new StringBuilder();
+        for (String str : arrayList) {
+            if (needsSign(str)) {
+                String replaceAll = StringUtils.lowerCase(str).replaceAll("\\s+", " ");
+                String str2 = (String) request.getHeaders().get(str);
+                sb.append(replaceAll);
+                sb.append(CertificateUtil.DELIMITER);
+                if (str2 != null) {
+                    sb.append(str2.replaceAll("\\s+", " "));
+                }
+                sb.append("\n");
+            }
+        }
+        return sb.toString();
+    }
+
+    public String getSignedHeadersString(Request<?> request) {
+        ArrayList<String> arrayList = new ArrayList();
+        arrayList.addAll(request.getHeaders().keySet());
+        Collections.sort(arrayList, String.CASE_INSENSITIVE_ORDER);
+        StringBuilder sb = new StringBuilder();
+        for (String str : arrayList) {
+            if (needsSign(str)) {
+                if (sb.length() > 0) {
+                    sb.append(";");
+                }
+                sb.append(StringUtils.lowerCase(str));
+            }
+        }
+        return sb.toString();
+    }
+
+    public String getCanonicalRequest(Request<?> request, String str) {
+        String appendUri;
+        if (request.getEncodedUriResourcePath() != null) {
+            appendUri = HttpUtils.appendUriEncoded(request.getEndpoint().getPath(), request.getEncodedUriResourcePath());
+        } else {
+            appendUri = HttpUtils.appendUri(request.getEndpoint().getPath(), request.getResourcePath());
+        }
+        String str2 = request.getHttpMethod().toString() + "\n" + getCanonicalizedResourcePath(appendUri, this.doubleUrlEncode) + "\n" + getCanonicalizedQueryString(request) + "\n" + getCanonicalizedHeaderString(request) + "\n" + getSignedHeadersString(request) + "\n" + str;
+        log.debug("AWS4 Canonical Request: '\"" + str2 + "\"");
+        return str2;
+    }
+
+    public String getStringToSign(String str, String str2, String str3, String str4) {
+        String str5 = str + "\n" + str2 + "\n" + str3 + "\n" + BinaryUtils.toHex(hash(str4));
+        log.debug("AWS4 String to Sign: '\"" + str5 + "\"");
+        return str5;
+    }
+
+    public final HeaderSigningResult computeSignature(Request<?> request, String str, String str2, String str3, String str4, AWSCredentials aWSCredentials) {
+        String extractRegionName = extractRegionName(request.getEndpoint());
+        String extractServiceName = extractServiceName(request.getEndpoint());
+        String str5 = str + "/" + extractRegionName + "/" + extractServiceName + "/" + TERMINATOR;
+        String stringToSign = getStringToSign(str3, str2, str5, getCanonicalRequest(request, str4));
+        String str6 = "AWS4" + aWSCredentials.getAWSSecretKey();
+        Charset charset = StringUtils.UTF8;
+        byte[] bytes = str6.getBytes(charset);
+        SigningAlgorithm signingAlgorithm = SigningAlgorithm.HmacSHA256;
+        byte[] sign = sign(TERMINATOR, sign(extractServiceName, sign(extractRegionName, sign(str, bytes, signingAlgorithm), signingAlgorithm), signingAlgorithm), signingAlgorithm);
+        return new HeaderSigningResult(str2, str5, sign, sign(stringToSign.getBytes(charset), sign, signingAlgorithm));
+    }
+
+    public final String getTimeStamp(long j) {
+        return DateUtils.format(TIME_PATTERN, new Date(j));
+    }
+
+    public final String getDateStamp(long j) {
+        return DateUtils.format(DATE_PATTERN, new Date(j));
+    }
+
+    public final long getDateFromRequest(Request<?> request) {
+        Date signatureDate = getSignatureDate(getTimeOffset(request));
+        Date date = this.overriddenDate;
+        if (date != null) {
+            signatureDate = date;
+        }
+        return signatureDate.getTime();
+    }
+
+    public void addHostHeader(Request<?> request) {
+        String host = request.getEndpoint().getHost();
+        if (HttpUtils.isUsingNonDefaultPort(request.getEndpoint())) {
+            host = host + CertificateUtil.DELIMITER + request.getEndpoint().getPort();
+        }
+        request.addHeader(HTTP.TARGET_HOST, host);
+    }
+
+    public String getScope(Request<?> request, String str) {
+        return str + "/" + extractRegionName(request.getEndpoint()) + "/" + extractServiceName(request.getEndpoint()) + "/" + TERMINATOR;
+    }
+
+    public String calculateContentHash(Request<?> request) {
+        InputStream binaryRequestPayloadStream = getBinaryRequestPayloadStream(request);
+        binaryRequestPayloadStream.mark(-1);
+        String hex = BinaryUtils.toHex(hash(binaryRequestPayloadStream));
+        try {
+            binaryRequestPayloadStream.reset();
+            return hex;
+        } catch (IOException e) {
+            throw new AmazonClientException("Unable to reset stream after calculating AWS4 signature", e);
+        }
+    }
+
+    public static class HeaderSigningResult {
+        public final String dateTime;
+        public final byte[] kSigning;
+        public final String scope;
+        public final byte[] signature;
+
+        public HeaderSigningResult(String str, String str2, byte[] bArr, byte[] bArr2) {
+            this.dateTime = str;
+            this.scope = str2;
+            this.kSigning = bArr;
+            this.signature = bArr2;
+        }
+
+        public byte[] getSignature() {
+            byte[] bArr = this.signature;
+            byte[] bArr2 = new byte[bArr.length];
+            System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
+            return bArr2;
+        }
+    }
+
+    public void presignRequest(Request<?> request, AWSCredentials aWSCredentials, Date date) {
+        if (aWSCredentials instanceof AnonymousAWSCredentials) {
+            return;
+        }
+        long time = date != null ? (date.getTime() - System.currentTimeMillis()) / 1000 : 604800L;
+        if (time > MAX_EXPIRATION_TIME_IN_SECONDS) {
+            throw new AmazonClientException("Requests that are pre-signed by SigV4 algorithm are valid for at most 7 days. The expiration date set on the current request [" + getTimeStamp(date.getTime()) + "] has exceeded this limit.");
+        }
+        addHostHeader(request);
+        AWSCredentials sanitizeCredentials = sanitizeCredentials(aWSCredentials);
+        if (sanitizeCredentials instanceof AWSSessionCredentials) {
+            request.addParameter("X-Amz-Security-Token", ((AWSSessionCredentials) sanitizeCredentials).getSessionToken());
+        }
+        long dateFromRequest = getDateFromRequest(request);
+        String dateStamp = getDateStamp(dateFromRequest);
+        String str = sanitizeCredentials.getAWSAccessKeyId() + "/" + getScope(request, dateStamp);
+        String timeStamp = getTimeStamp(dateFromRequest);
+        request.addParameter("X-Amz-Algorithm", ALGORITHM);
+        request.addParameter("X-Amz-Date", timeStamp);
+        request.addParameter("X-Amz-SignedHeaders", getSignedHeadersString(request));
+        request.addParameter("X-Amz-Expires", Long.toString(time));
+        request.addParameter("X-Amz-Credential", str);
+        request.addParameter("X-Amz-Signature", BinaryUtils.toHex(computeSignature(request, dateStamp, timeStamp, ALGORITHM, calculateContentHashPresign(request), sanitizeCredentials).getSignature()));
+    }
+
+    public String calculateContentHashPresign(Request<?> request) {
+        return calculateContentHash(request);
+    }
+
+    public boolean needsSign(String str) {
+        return "date".equalsIgnoreCase(str) || "Content-MD5".equalsIgnoreCase(str) || "host".equalsIgnoreCase(str) || str.startsWith("x-amz") || str.startsWith("X-Amz");
+    }
+}

decompiled-community/sources/com/amazonaws/auth/AWSAbstractCognitoIdentityProvider.java

@@ -0,0 +1,125 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.AmazonWebServiceRequest;
+import com.amazonaws.services.cognitoidentity.AmazonCognitoIdentity;
+import com.amazonaws.services.cognitoidentity.model.GetIdRequest;
+import com.amazonaws.services.cognitoidentity.model.GetIdResult;
+import com.amazonaws.services.cognitoidentity.model.GetOpenIdTokenRequest;
+import com.amazonaws.services.cognitoidentity.model.GetOpenIdTokenResult;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public abstract class AWSAbstractCognitoIdentityProvider implements AWSCognitoIdentityProvider {
+    public final String accountId;
+    public final AmazonCognitoIdentity cib;
+    public String identityId;
+    public final String identityPoolId;
+    public String token;
+    public Map loginsMap = new HashMap();
+    public List listeners = new ArrayList();
+
+    public String getAccountId() {
+        return this.accountId;
+    }
+
+    @Override // com.amazonaws.auth.AWSCognitoIdentityProvider
+    public String getIdentityPoolId() {
+        return this.identityPoolId;
+    }
+
+    @Override // com.amazonaws.auth.AWSCognitoIdentityProvider
+    public Map getLogins() {
+        return this.loginsMap;
+    }
+
+    public String getUserAgent() {
+        return "";
+    }
+
+    public void setToken(String str) {
+        this.token = str;
+    }
+
+    public AWSAbstractCognitoIdentityProvider(String str, String str2, AmazonCognitoIdentity amazonCognitoIdentity) {
+        this.accountId = str;
+        this.identityPoolId = str2;
+        this.cib = amazonCognitoIdentity;
+    }
+
+    @Override // com.amazonaws.auth.AWSCognitoIdentityProvider
+    public String getIdentityId() {
+        if (this.identityId == null) {
+            GetIdRequest withLogins = new GetIdRequest().withAccountId(getAccountId()).withIdentityPoolId(getIdentityPoolId()).withLogins(this.loginsMap);
+            appendUserAgent(withLogins, getUserAgent());
+            GetIdResult id = this.cib.getId(withLogins);
+            if (id.getIdentityId() != null) {
+                identityChanged(id.getIdentityId());
+            }
+        }
+        return this.identityId;
+    }
+
+    public String getToken() {
+        if (this.token == null) {
+            GetOpenIdTokenRequest withLogins = new GetOpenIdTokenRequest().withIdentityId(getIdentityId()).withLogins(this.loginsMap);
+            appendUserAgent(withLogins, getUserAgent());
+            GetOpenIdTokenResult openIdToken = this.cib.getOpenIdToken(withLogins);
+            if (!openIdToken.getIdentityId().equals(getIdentityId())) {
+                identityChanged(openIdToken.getIdentityId());
+            }
+            this.token = openIdToken.getToken();
+        }
+        return this.token;
+    }
+
+    @Override // com.amazonaws.auth.AWSCognitoIdentityProvider
+    public boolean isAuthenticated() {
+        Map map = this.loginsMap;
+        return map != null && map.size() > 0;
+    }
+
+    @Override // com.amazonaws.auth.AWSCognitoIdentityProvider
+    public void registerIdentityChangedListener(IdentityChangedListener identityChangedListener) {
+        this.listeners.add(identityChangedListener);
+    }
+
+    @Override // com.amazonaws.auth.AWSCognitoIdentityProvider
+    public void identityChanged(String str) {
+        String str2 = this.identityId;
+        if (str2 == null || !str2.equals(str)) {
+            String str3 = this.identityId;
+            this.identityId = str;
+            Iterator it = this.listeners.iterator();
+            while (it.hasNext()) {
+                ((IdentityChangedListener) it.next()).identityChanged(str3, this.identityId);
+            }
+        }
+    }
+
+    public void appendUserAgent(AmazonWebServiceRequest amazonWebServiceRequest, String str) {
+        amazonWebServiceRequest.getRequestClientOptions().appendUserAgent(str);
+    }
+
+    public void update(String str, String str2) {
+        String str3 = this.identityId;
+        if (str3 == null || !str3.equals(str)) {
+            identityChanged(str);
+        }
+        String str4 = this.token;
+        if (str4 == null || !str4.equals(str2)) {
+            this.token = str2;
+        }
+    }
+
+    @Override // com.amazonaws.auth.AWSIdentityProvider
+    public String refresh() {
+        getIdentityId();
+        String token = getToken();
+        update(getIdentityId(), token);
+        return token;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/AWSBasicCognitoIdentityProvider.java

@@ -0,0 +1,16 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.services.cognitoidentity.AmazonCognitoIdentity;
+
+/* loaded from: classes.dex */
+public class AWSBasicCognitoIdentityProvider extends AWSAbstractCognitoIdentityProvider {
+    public AWSBasicCognitoIdentityProvider(String str, String str2, AmazonCognitoIdentity amazonCognitoIdentity) {
+        super(str, str2, amazonCognitoIdentity);
+    }
+
+    @Override // com.amazonaws.auth.AWSAbstractCognitoIdentityProvider, com.amazonaws.auth.AWSIdentityProvider
+    public String refresh() {
+        setToken(null);
+        return super.refresh();
+    }
+}

decompiled-community/sources/com/amazonaws/auth/AWSCognitoIdentityProvider.java

@@ -0,0 +1,18 @@
+package com.amazonaws.auth;
+
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public interface AWSCognitoIdentityProvider extends AWSIdentityProvider {
+    String getIdentityId();
+
+    String getIdentityPoolId();
+
+    Map getLogins();
+
+    void identityChanged(String str);
+
+    boolean isAuthenticated();
+
+    void registerIdentityChangedListener(IdentityChangedListener identityChangedListener);
+}

decompiled-community/sources/com/amazonaws/auth/AWSCredentials.java

@@ -0,0 +1,8 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public interface AWSCredentials {
+    String getAWSAccessKeyId();
+
+    String getAWSSecretKey();
+}

decompiled-community/sources/com/amazonaws/auth/AWSCredentialsProvider.java

@@ -0,0 +1,6 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public interface AWSCredentialsProvider {
+    AWSCredentials getCredentials();
+}

decompiled-community/sources/com/amazonaws/auth/AWSCredentialsProviderChain.java

@@ -0,0 +1,5 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public abstract class AWSCredentialsProviderChain implements AWSCredentialsProvider {
+}

decompiled-community/sources/com/amazonaws/auth/AWSEnhancedCognitoIdentityProvider.java

@@ -0,0 +1,16 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.services.cognitoidentity.AmazonCognitoIdentity;
+
+/* loaded from: classes.dex */
+public final class AWSEnhancedCognitoIdentityProvider extends AWSAbstractCognitoIdentityProvider {
+    public AWSEnhancedCognitoIdentityProvider(String str, String str2, AmazonCognitoIdentity amazonCognitoIdentity) {
+        super(str, str2, amazonCognitoIdentity);
+    }
+
+    @Override // com.amazonaws.auth.AWSAbstractCognitoIdentityProvider, com.amazonaws.auth.AWSIdentityProvider
+    public String refresh() {
+        getIdentityId();
+        return null;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/AWSIdentityProvider.java

@@ -0,0 +1,6 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public interface AWSIdentityProvider {
+    String refresh();
+}

decompiled-community/sources/com/amazonaws/auth/AWSSessionCredentials.java

@@ -0,0 +1,6 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public interface AWSSessionCredentials extends AWSCredentials {
+    String getSessionToken();
+}

decompiled-community/sources/com/amazonaws/auth/AbstractAWSSigner.java

@@ -0,0 +1,267 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.Request;
+import com.amazonaws.SDKGlobalConfiguration;
+import com.amazonaws.internal.SdkDigestInputStream;
+import com.amazonaws.util.Base64;
+import com.amazonaws.util.BinaryUtils;
+import com.amazonaws.util.HttpUtils;
+import com.amazonaws.util.StringInputStream;
+import com.amazonaws.util.StringUtils;
+import com.facebook.internal.security.CertificateUtil;
+import com.ironsource.v8;
+import csdk.gluads.Consts;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.net.URI;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+/* loaded from: classes.dex */
+public abstract class AbstractAWSSigner implements Signer {
+    private static final int BUFFER_SIZE_MULTIPLIER = 5;
+    private static final int DEFAULT_BUFFER_SIZE = 1024;
+    private static final int TIME_MILLISEC = 1000;
+    private static final ThreadLocal<MessageDigest> SHA256_MESSAGE_DIGEST = new ThreadLocal<MessageDigest>() { // from class: com.amazonaws.auth.AbstractAWSSigner.1
+        @Override // java.lang.ThreadLocal
+        public MessageDigest initialValue() {
+            try {
+                return MessageDigest.getInstance("SHA-256");
+            } catch (NoSuchAlgorithmException e) {
+                throw new AmazonClientException("Unable to get SHA256 Function" + e.getMessage(), e);
+            }
+        }
+    };
+    public static final String EMPTY_STRING_SHA256_HEX = BinaryUtils.toHex(doHash(""));
+
+    public String signAndBase64Encode(String str, String str2, SigningAlgorithm signingAlgorithm) {
+        return signAndBase64Encode(str.getBytes(StringUtils.UTF8), str2, signingAlgorithm);
+    }
+
+    public String signAndBase64Encode(byte[] bArr, String str, SigningAlgorithm signingAlgorithm) {
+        try {
+            return Base64.encodeAsString(sign(bArr, str.getBytes(StringUtils.UTF8), signingAlgorithm));
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to calculate a request signature: " + e.getMessage(), e);
+        }
+    }
+
+    public byte[] sign(String str, byte[] bArr, SigningAlgorithm signingAlgorithm) {
+        try {
+            return sign(str.getBytes(StringUtils.UTF8), bArr, signingAlgorithm);
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to calculate a request signature: " + e.getMessage(), e);
+        }
+    }
+
+    public byte[] sign(byte[] bArr, byte[] bArr2, SigningAlgorithm signingAlgorithm) {
+        try {
+            Mac mac = Mac.getInstance(signingAlgorithm.toString());
+            mac.init(new SecretKeySpec(bArr2, signingAlgorithm.toString()));
+            return mac.doFinal(bArr);
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to calculate a request signature: " + e.getMessage(), e);
+        }
+    }
+
+    public byte[] hash(String str) {
+        return doHash(str);
+    }
+
+    public static byte[] doHash(String str) {
+        try {
+            MessageDigest messageDigestInstance = getMessageDigestInstance();
+            messageDigestInstance.update(str.getBytes(StringUtils.UTF8));
+            return messageDigestInstance.digest();
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to compute hash while signing request: " + e.getMessage(), e);
+        }
+    }
+
+    public byte[] hash(InputStream inputStream) {
+        try {
+            SdkDigestInputStream sdkDigestInputStream = new SdkDigestInputStream(inputStream, getMessageDigestInstance());
+            while (sdkDigestInputStream.read(new byte[1024]) > -1) {
+            }
+            return sdkDigestInputStream.getMessageDigest().digest();
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to compute hash while signing request: " + e.getMessage(), e);
+        }
+    }
+
+    public byte[] hash(byte[] bArr) {
+        try {
+            MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
+            messageDigest.update(bArr);
+            return messageDigest.digest();
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to compute hash while signing request: " + e.getMessage(), e);
+        }
+    }
+
+    public String getCanonicalizedQueryString(Map<String, String> map) {
+        TreeMap treeMap = new TreeMap();
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            treeMap.put(HttpUtils.urlEncode(entry.getKey(), false), HttpUtils.urlEncode(entry.getValue(), false));
+        }
+        StringBuilder sb = new StringBuilder();
+        Iterator it = treeMap.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry entry2 = (Map.Entry) it.next();
+            sb.append((String) entry2.getKey());
+            sb.append(v8.i.b);
+            sb.append((String) entry2.getValue());
+            if (it.hasNext()) {
+                sb.append(v8.i.c);
+            }
+        }
+        return sb.toString();
+    }
+
+    public String getCanonicalizedQueryString(Request<?> request) {
+        return HttpUtils.usePayloadForQueryParameters(request) ? "" : getCanonicalizedQueryString(request.getParameters());
+    }
+
+    public byte[] getBinaryRequestPayload(Request<?> request) {
+        if (HttpUtils.usePayloadForQueryParameters(request)) {
+            String encodeParameters = HttpUtils.encodeParameters(request);
+            return encodeParameters == null ? new byte[0] : encodeParameters.getBytes(StringUtils.UTF8);
+        }
+        return getBinaryRequestPayloadWithoutQueryParams(request);
+    }
+
+    public String getRequestPayload(Request<?> request) {
+        return newString(getBinaryRequestPayload(request));
+    }
+
+    public String getRequestPayloadWithoutQueryParams(Request<?> request) {
+        return newString(getBinaryRequestPayloadWithoutQueryParams(request));
+    }
+
+    public byte[] getBinaryRequestPayloadWithoutQueryParams(Request<?> request) {
+        InputStream binaryRequestPayloadStreamWithoutQueryParams = getBinaryRequestPayloadStreamWithoutQueryParams(request);
+        try {
+            binaryRequestPayloadStreamWithoutQueryParams.mark(-1);
+            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+            byte[] bArr = new byte[Consts.APP_CUSTOM_DATA_LIMIT];
+            while (true) {
+                int read = binaryRequestPayloadStreamWithoutQueryParams.read(bArr);
+                if (read != -1) {
+                    byteArrayOutputStream.write(bArr, 0, read);
+                } else {
+                    byteArrayOutputStream.close();
+                    binaryRequestPayloadStreamWithoutQueryParams.reset();
+                    return byteArrayOutputStream.toByteArray();
+                }
+            }
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to read request payload to sign request: " + e.getMessage(), e);
+        }
+    }
+
+    public InputStream getBinaryRequestPayloadStream(Request<?> request) {
+        if (HttpUtils.usePayloadForQueryParameters(request)) {
+            String encodeParameters = HttpUtils.encodeParameters(request);
+            if (encodeParameters == null) {
+                return new ByteArrayInputStream(new byte[0]);
+            }
+            return new ByteArrayInputStream(encodeParameters.getBytes(StringUtils.UTF8));
+        }
+        return getBinaryRequestPayloadStreamWithoutQueryParams(request);
+    }
+
+    public InputStream getBinaryRequestPayloadStreamWithoutQueryParams(Request<?> request) {
+        try {
+            InputStream content = request.getContent();
+            if (content == null) {
+                return new ByteArrayInputStream(new byte[0]);
+            }
+            if (content instanceof StringInputStream) {
+                return content;
+            }
+            if (!content.markSupported()) {
+                throw new AmazonClientException("Unable to read request payload to sign request.");
+            }
+            return request.getContent();
+        } catch (Exception e) {
+            throw new AmazonClientException("Unable to read request payload to sign request: " + e.getMessage(), e);
+        }
+    }
+
+    public String getCanonicalizedResourcePath(String str) {
+        return getCanonicalizedResourcePath(str, true);
+    }
+
+    public String getCanonicalizedResourcePath(String str, boolean z) {
+        if (str == null || str.length() == 0) {
+            return "/";
+        }
+        if (z) {
+            str = HttpUtils.urlEncode(str, true);
+        }
+        return str.startsWith("/") ? str : "/".concat(str);
+    }
+
+    public String getCanonicalizedEndpoint(URI uri) {
+        String lowerCase = StringUtils.lowerCase(uri.getHost());
+        if (!HttpUtils.isUsingNonDefaultPort(uri)) {
+            return lowerCase;
+        }
+        return lowerCase + CertificateUtil.DELIMITER + uri.getPort();
+    }
+
+    public AWSCredentials sanitizeCredentials(AWSCredentials aWSCredentials) {
+        String aWSAccessKeyId;
+        String aWSSecretKey;
+        String sessionToken;
+        synchronized (aWSCredentials) {
+            try {
+                aWSAccessKeyId = aWSCredentials.getAWSAccessKeyId();
+                aWSSecretKey = aWSCredentials.getAWSSecretKey();
+                sessionToken = aWSCredentials instanceof AWSSessionCredentials ? ((AWSSessionCredentials) aWSCredentials).getSessionToken() : null;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        if (aWSSecretKey != null) {
+            aWSSecretKey = aWSSecretKey.trim();
+        }
+        if (aWSAccessKeyId != null) {
+            aWSAccessKeyId = aWSAccessKeyId.trim();
+        }
+        if (sessionToken != null) {
+            sessionToken = sessionToken.trim();
+        }
+        if (aWSCredentials instanceof AWSSessionCredentials) {
+            return new BasicSessionCredentials(aWSAccessKeyId, aWSSecretKey, sessionToken);
+        }
+        return new BasicAWSCredentials(aWSAccessKeyId, aWSSecretKey);
+    }
+
+    public String newString(byte[] bArr) {
+        return new String(bArr, StringUtils.UTF8);
+    }
+
+    public Date getSignatureDate(long j) {
+        Date date = new Date();
+        return j != 0 ? new Date(date.getTime() - (j * 1000)) : date;
+    }
+
+    public long getTimeOffset(Request<?> request) {
+        return SDKGlobalConfiguration.getGlobalTimeOffset() != 0 ? SDKGlobalConfiguration.getGlobalTimeOffset() : request.getTimeOffset();
+    }
+
+    public static MessageDigest getMessageDigestInstance() {
+        MessageDigest messageDigest = SHA256_MESSAGE_DIGEST.get();
+        messageDigest.reset();
+        return messageDigest;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/AnonymousAWSCredentials.java

@@ -0,0 +1,14 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public class AnonymousAWSCredentials implements AWSCredentials {
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSAccessKeyId() {
+        return null;
+    }
+
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSSecretKey() {
+        return null;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/BasicAWSCredentials.java

@@ -0,0 +1,28 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public class BasicAWSCredentials implements AWSCredentials {
+    public final String accessKey;
+    public final String secretKey;
+
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSAccessKeyId() {
+        return this.accessKey;
+    }
+
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSSecretKey() {
+        return this.secretKey;
+    }
+
+    public BasicAWSCredentials(String str, String str2) {
+        if (str == null) {
+            throw new IllegalArgumentException("Access key cannot be null.");
+        }
+        if (str2 == null) {
+            throw new IllegalArgumentException("Secret key cannot be null.");
+        }
+        this.accessKey = str;
+        this.secretKey = str2;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/BasicSessionCredentials.java

@@ -0,0 +1,29 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public class BasicSessionCredentials implements AWSSessionCredentials {
+    public final String awsAccessKey;
+    public final String awsSecretKey;
+    public final String sessionToken;
+
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSAccessKeyId() {
+        return this.awsAccessKey;
+    }
+
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSSecretKey() {
+        return this.awsSecretKey;
+    }
+
+    @Override // com.amazonaws.auth.AWSSessionCredentials
+    public String getSessionToken() {
+        return this.sessionToken;
+    }
+
+    public BasicSessionCredentials(String str, String str2, String str3) {
+        this.awsAccessKey = str;
+        this.awsSecretKey = str2;
+        this.sessionToken = str3;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/CognitoCachingCredentialsProvider.java

@@ -0,0 +1,213 @@
+package com.amazonaws.auth;
+
+import android.content.Context;
+import com.amazonaws.internal.keyvaluestore.AWSKeyValueStore;
+import com.amazonaws.logging.Log;
+import com.amazonaws.logging.LogFactory;
+import com.amazonaws.regions.Regions;
+import com.amazonaws.util.VersionInfoUtils;
+import csdk.gluads.Consts;
+import java.util.Date;
+
+/* loaded from: classes.dex */
+public class CognitoCachingCredentialsProvider extends CognitoCredentialsProvider {
+    public AWSKeyValueStore awsKeyValueStore;
+    public String identityId;
+    public boolean isPersistenceEnabled;
+    public final IdentityChangedListener listener;
+    public volatile boolean needIdentityRefresh;
+    public String userAgentOverride;
+    public static final String USER_AGENT = CognitoCachingCredentialsProvider.class.getName() + "/" + VersionInfoUtils.getVersion();
+    public static final Log LOG = LogFactory.getLog(CognitoCachingCredentialsProvider.class);
+    public static final String AWS_KEY_VALUE_STORE_NAMESPACE_IDENTIFIER = "com.amazonaws.android.auth";
+    public static final String ID_KEY = "identityId";
+    public static final String AK_KEY = "accessKey";
+    public static final String SK_KEY = "secretKey";
+    public static final String ST_KEY = "sessionToken";
+    public static final String EXP_KEY = "expirationDate";
+
+    @Override // com.amazonaws.auth.CognitoCredentialsProvider
+    public String getUserAgent() {
+        String str = this.userAgentOverride;
+        return str != null ? str : USER_AGENT;
+    }
+
+    public CognitoCachingCredentialsProvider(Context context, String str, String str2, String str3, String str4, Regions regions) {
+        super(str, str2, str3, str4, regions);
+        this.needIdentityRefresh = false;
+        this.listener = new IdentityChangedListener() { // from class: com.amazonaws.auth.CognitoCachingCredentialsProvider.1
+            @Override // com.amazonaws.auth.IdentityChangedListener
+            public void identityChanged(String str5, String str6) {
+                CognitoCachingCredentialsProvider.LOG.debug("Identity id is changed");
+                CognitoCachingCredentialsProvider.this.saveIdentityId(str6);
+                CognitoCachingCredentialsProvider.this.clearCredentials();
+            }
+        };
+        this.isPersistenceEnabled = true;
+        if (context == null) {
+            throw new IllegalArgumentException("context can't be null");
+        }
+        initialize(context);
+    }
+
+    public final void initialize(Context context) {
+        this.awsKeyValueStore = new AWSKeyValueStore(context, AWS_KEY_VALUE_STORE_NAMESPACE_IDENTIFIER, this.isPersistenceEnabled);
+        checkUpgrade();
+        this.identityId = getCachedIdentityId();
+        loadCachedCredentials();
+        registerIdentityChangedListener(this.listener);
+    }
+
+    @Override // com.amazonaws.auth.CognitoCredentialsProvider
+    public String getIdentityId() {
+        if (this.needIdentityRefresh) {
+            this.needIdentityRefresh = false;
+            refresh();
+            String identityId = super.getIdentityId();
+            this.identityId = identityId;
+            saveIdentityId(identityId);
+        }
+        String cachedIdentityId = getCachedIdentityId();
+        this.identityId = cachedIdentityId;
+        if (cachedIdentityId == null) {
+            String identityId2 = super.getIdentityId();
+            this.identityId = identityId2;
+            saveIdentityId(identityId2);
+        }
+        return this.identityId;
+    }
+
+    @Override // com.amazonaws.auth.CognitoCredentialsProvider, com.amazonaws.auth.AWSCredentialsProvider
+    public AWSSessionCredentials getCredentials() {
+        AWSSessionCredentials aWSSessionCredentials;
+        this.credentialsLock.writeLock().lock();
+        try {
+            if (this.sessionCredentials == null) {
+                loadCachedCredentials();
+            }
+            if (this.sessionCredentialsExpiration == null || needsNewSession()) {
+                LOG.debug("Making a network call to fetch credentials.");
+                super.getCredentials();
+                Date date = this.sessionCredentialsExpiration;
+                if (date != null) {
+                    saveCredentials(this.sessionCredentials, date.getTime());
+                }
+                aWSSessionCredentials = this.sessionCredentials;
+            } else {
+                aWSSessionCredentials = this.sessionCredentials;
+            }
+            this.credentialsLock.writeLock().unlock();
+            return aWSSessionCredentials;
+        } catch (Throwable th) {
+            this.credentialsLock.writeLock().unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.amazonaws.auth.CognitoCredentialsProvider
+    public void refresh() {
+        this.credentialsLock.writeLock().lock();
+        try {
+            super.refresh();
+            Date date = this.sessionCredentialsExpiration;
+            if (date != null) {
+                saveCredentials(this.sessionCredentials, date.getTime());
+            }
+        } finally {
+            this.credentialsLock.writeLock().unlock();
+        }
+    }
+
+    @Override // com.amazonaws.auth.CognitoCredentialsProvider
+    public void clearCredentials() {
+        this.credentialsLock.writeLock().lock();
+        try {
+            super.clearCredentials();
+            LOG.debug("Clearing credentials from SharedPreferences");
+            this.awsKeyValueStore.remove(namespace(AK_KEY));
+            this.awsKeyValueStore.remove(namespace(SK_KEY));
+            this.awsKeyValueStore.remove(namespace(ST_KEY));
+            this.awsKeyValueStore.remove(namespace(EXP_KEY));
+        } finally {
+            this.credentialsLock.writeLock().unlock();
+        }
+    }
+
+    public String getCachedIdentityId() {
+        String str = this.awsKeyValueStore.get(namespace(ID_KEY));
+        if (str != null && this.identityId == null) {
+            super.setIdentityId(str);
+        }
+        return str;
+    }
+
+    public final void loadCachedCredentials() {
+        Log log = LOG;
+        log.debug("Loading credentials from SharedPreferences");
+        String str = this.awsKeyValueStore.get(namespace(EXP_KEY));
+        if (str == null) {
+            this.sessionCredentialsExpiration = null;
+            return;
+        }
+        try {
+            this.sessionCredentialsExpiration = new Date(Long.parseLong(str));
+            if (!hasCredentials()) {
+                this.sessionCredentialsExpiration = null;
+                return;
+            }
+            String str2 = this.awsKeyValueStore.get(namespace(AK_KEY));
+            String str3 = this.awsKeyValueStore.get(namespace(SK_KEY));
+            String str4 = this.awsKeyValueStore.get(namespace(ST_KEY));
+            if (str2 == null || str3 == null || str4 == null) {
+                log.debug("No valid credentials found in SharedPreferences");
+                this.sessionCredentialsExpiration = null;
+            } else {
+                this.sessionCredentials = new BasicSessionCredentials(str2, str3, str4);
+            }
+        } catch (NumberFormatException unused) {
+            this.sessionCredentialsExpiration = null;
+        }
+    }
+
+    public final boolean hasCredentials() {
+        boolean contains = this.awsKeyValueStore.contains(namespace(AK_KEY));
+        boolean contains2 = this.awsKeyValueStore.contains(namespace(SK_KEY));
+        boolean contains3 = this.awsKeyValueStore.contains(namespace(ST_KEY));
+        if (!contains && !contains2 && !contains3) {
+            return false;
+        }
+        LOG.debug("No valid credentials found in SharedPreferences");
+        return true;
+    }
+
+    public final void saveCredentials(AWSSessionCredentials aWSSessionCredentials, long j) {
+        LOG.debug("Saving credentials to SharedPreferences");
+        if (aWSSessionCredentials != null) {
+            this.awsKeyValueStore.put(namespace(AK_KEY), aWSSessionCredentials.getAWSAccessKeyId());
+            this.awsKeyValueStore.put(namespace(SK_KEY), aWSSessionCredentials.getAWSSecretKey());
+            this.awsKeyValueStore.put(namespace(ST_KEY), aWSSessionCredentials.getSessionToken());
+            this.awsKeyValueStore.put(namespace(EXP_KEY), String.valueOf(j));
+        }
+    }
+
+    public final void saveIdentityId(String str) {
+        LOG.debug("Saving identity id to SharedPreferences");
+        this.identityId = str;
+        this.awsKeyValueStore.put(namespace(ID_KEY), str);
+    }
+
+    public final void checkUpgrade() {
+        AWSKeyValueStore aWSKeyValueStore = this.awsKeyValueStore;
+        String str = ID_KEY;
+        if (aWSKeyValueStore.contains(str)) {
+            LOG.info("Identity id without namespace is detected. It will be saved under new namespace.");
+            String str2 = this.awsKeyValueStore.get(str);
+            this.awsKeyValueStore.clear();
+            this.awsKeyValueStore.put(namespace(str), str2);
+        }
+    }
+
+    public final String namespace(String str) {
+        return getIdentityPoolId() + Consts.STRING_PERIOD + str;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/CognitoCredentialsProvider.java

@@ -0,0 +1,229 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.AmazonServiceException;
+import com.amazonaws.AmazonWebServiceRequest;
+import com.amazonaws.ClientConfiguration;
+import com.amazonaws.SDKGlobalConfiguration;
+import com.amazonaws.logging.Log;
+import com.amazonaws.logging.LogFactory;
+import com.amazonaws.regions.Region;
+import com.amazonaws.regions.Regions;
+import com.amazonaws.services.cognitoidentity.AmazonCognitoIdentity;
+import com.amazonaws.services.cognitoidentity.AmazonCognitoIdentityClient;
+import com.amazonaws.services.cognitoidentity.model.Credentials;
+import com.amazonaws.services.cognitoidentity.model.GetCredentialsForIdentityRequest;
+import com.amazonaws.services.cognitoidentity.model.GetCredentialsForIdentityResult;
+import com.amazonaws.services.securitytoken.AWSSecurityTokenService;
+import com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClient;
+import com.amazonaws.services.securitytoken.model.AssumeRoleWithWebIdentityRequest;
+import com.firemint.realracing.Platform;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/* loaded from: classes.dex */
+public class CognitoCredentialsProvider implements AWSCredentialsProvider {
+    public static final Log log = LogFactory.getLog(AWSCredentialsProviderChain.class);
+    public String authRoleArn;
+    public AmazonCognitoIdentity cib;
+    public final ReentrantReadWriteLock credentialsLock;
+    public String customRoleArn;
+    public final AWSCognitoIdentityProvider identityProvider;
+    public int refreshThreshold;
+    public final String region;
+    public AWSSecurityTokenService securityTokenService;
+    public AWSSessionCredentials sessionCredentials;
+    public Date sessionCredentialsExpiration;
+    public int sessionDuration;
+    public String token;
+    public String unauthRoleArn;
+    public final boolean useEnhancedFlow;
+
+    public String getUserAgent() {
+        return "";
+    }
+
+    public CognitoCredentialsProvider(String str, String str2, String str3, String str4, Regions regions) {
+        this(str, str2, str3, str4, regions, new ClientConfiguration());
+    }
+
+    public CognitoCredentialsProvider(String str, String str2, String str3, String str4, Regions regions, ClientConfiguration clientConfiguration) {
+        this(str, str2, str3, str4, createIdentityClient(clientConfiguration, regions), (str3 == null && str4 == null) ? null : new AWSSecurityTokenServiceClient(new AnonymousAWSCredentials(), clientConfiguration));
+    }
+
+    public static AmazonCognitoIdentityClient createIdentityClient(ClientConfiguration clientConfiguration, Regions regions) {
+        AmazonCognitoIdentityClient amazonCognitoIdentityClient = new AmazonCognitoIdentityClient(new AnonymousAWSCredentials(), clientConfiguration);
+        amazonCognitoIdentityClient.setRegion(Region.getRegion(regions));
+        return amazonCognitoIdentityClient;
+    }
+
+    public CognitoCredentialsProvider(String str, String str2, String str3, String str4, AmazonCognitoIdentityClient amazonCognitoIdentityClient, AWSSecurityTokenService aWSSecurityTokenService) {
+        this.cib = amazonCognitoIdentityClient;
+        this.region = amazonCognitoIdentityClient.getRegions().getName();
+        this.securityTokenService = aWSSecurityTokenService;
+        this.unauthRoleArn = str3;
+        this.authRoleArn = str4;
+        this.sessionDuration = Platform.INTERNET_CONNECTION_DELAY;
+        this.refreshThreshold = 500;
+        boolean z = str3 == null && str4 == null;
+        this.useEnhancedFlow = z;
+        if (z) {
+            this.identityProvider = new AWSEnhancedCognitoIdentityProvider(str, str2, amazonCognitoIdentityClient);
+        } else {
+            this.identityProvider = new AWSBasicCognitoIdentityProvider(str, str2, amazonCognitoIdentityClient);
+        }
+        this.credentialsLock = new ReentrantReadWriteLock(true);
+    }
+
+    public String getIdentityId() {
+        return this.identityProvider.getIdentityId();
+    }
+
+    public void setSessionCredentialsExpiration(Date date) {
+        this.credentialsLock.writeLock().lock();
+        try {
+            this.sessionCredentialsExpiration = date;
+        } finally {
+            this.credentialsLock.writeLock().unlock();
+        }
+    }
+
+    public String getIdentityPoolId() {
+        return this.identityProvider.getIdentityPoolId();
+    }
+
+    @Override // com.amazonaws.auth.AWSCredentialsProvider
+    public AWSSessionCredentials getCredentials() {
+        this.credentialsLock.writeLock().lock();
+        try {
+            if (needsNewSession()) {
+                startSession();
+            }
+            AWSSessionCredentials aWSSessionCredentials = this.sessionCredentials;
+            this.credentialsLock.writeLock().unlock();
+            return aWSSessionCredentials;
+        } catch (Throwable th) {
+            this.credentialsLock.writeLock().unlock();
+            throw th;
+        }
+    }
+
+    public void setIdentityId(String str) {
+        this.identityProvider.identityChanged(str);
+    }
+
+    public Map getLogins() {
+        return this.identityProvider.getLogins();
+    }
+
+    public void refresh() {
+        this.credentialsLock.writeLock().lock();
+        try {
+            startSession();
+        } finally {
+            this.credentialsLock.writeLock().unlock();
+        }
+    }
+
+    public void clearCredentials() {
+        this.credentialsLock.writeLock().lock();
+        try {
+            this.sessionCredentials = null;
+            this.sessionCredentialsExpiration = null;
+        } finally {
+            this.credentialsLock.writeLock().unlock();
+        }
+    }
+
+    public void startSession() {
+        try {
+            this.token = this.identityProvider.refresh();
+        } catch (AmazonServiceException e) {
+            if (e.getErrorCode().equals("ValidationException")) {
+                this.token = retryRefresh();
+            } else {
+                throw e;
+            }
+        }
+        if (this.useEnhancedFlow) {
+            populateCredentialsWithCognito(this.token);
+        } else {
+            populateCredentialsWithSts(this.token);
+        }
+    }
+
+    public final String retryRefresh() {
+        setIdentityId(null);
+        String refresh = this.identityProvider.refresh();
+        this.token = refresh;
+        return refresh;
+    }
+
+    public String getLoginsKey() {
+        return Regions.CN_NORTH_1.getName().equals(this.region) ? "cognito-identity.cn-north-1.amazonaws.com.cn" : "cognito-identity.amazonaws.com";
+    }
+
+    public final GetCredentialsForIdentityResult retryGetCredentialsForIdentity() {
+        Map logins;
+        String retryRefresh = retryRefresh();
+        this.token = retryRefresh;
+        if (retryRefresh != null && !retryRefresh.isEmpty()) {
+            logins = new HashMap();
+            logins.put(getLoginsKey(), this.token);
+        } else {
+            logins = getLogins();
+        }
+        return this.cib.getCredentialsForIdentity(new GetCredentialsForIdentityRequest().withIdentityId(getIdentityId()).withLogins(logins).withCustomRoleArn(this.customRoleArn));
+    }
+
+    public final void populateCredentialsWithCognito(String str) {
+        Map logins;
+        GetCredentialsForIdentityResult retryGetCredentialsForIdentity;
+        if (str != null && !str.isEmpty()) {
+            logins = new HashMap();
+            logins.put(getLoginsKey(), str);
+        } else {
+            logins = getLogins();
+        }
+        try {
+            retryGetCredentialsForIdentity = this.cib.getCredentialsForIdentity(new GetCredentialsForIdentityRequest().withIdentityId(getIdentityId()).withLogins(logins).withCustomRoleArn(this.customRoleArn));
+        } catch (AmazonServiceException e) {
+            if (e.getErrorCode().equals("ValidationException")) {
+                retryGetCredentialsForIdentity = retryGetCredentialsForIdentity();
+            } else {
+                throw e;
+            }
+        }
+        Credentials credentials = retryGetCredentialsForIdentity.getCredentials();
+        this.sessionCredentials = new BasicSessionCredentials(credentials.getAccessKeyId(), credentials.getSecretKey(), credentials.getSessionToken());
+        setSessionCredentialsExpiration(credentials.getExpiration());
+        if (retryGetCredentialsForIdentity.getIdentityId().equals(getIdentityId())) {
+            return;
+        }
+        setIdentityId(retryGetCredentialsForIdentity.getIdentityId());
+    }
+
+    public final void populateCredentialsWithSts(String str) {
+        AssumeRoleWithWebIdentityRequest withDurationSeconds = new AssumeRoleWithWebIdentityRequest().withWebIdentityToken(str).withRoleArn(this.identityProvider.isAuthenticated() ? this.authRoleArn : this.unauthRoleArn).withRoleSessionName("ProviderSession").withDurationSeconds(Integer.valueOf(this.sessionDuration));
+        appendUserAgent(withDurationSeconds, getUserAgent());
+        com.amazonaws.services.securitytoken.model.Credentials credentials = this.securityTokenService.assumeRoleWithWebIdentity(withDurationSeconds).getCredentials();
+        this.sessionCredentials = new BasicSessionCredentials(credentials.getAccessKeyId(), credentials.getSecretAccessKey(), credentials.getSessionToken());
+        setSessionCredentialsExpiration(credentials.getExpiration());
+    }
+
+    public boolean needsNewSession() {
+        if (this.sessionCredentials == null) {
+            return true;
+        }
+        return this.sessionCredentialsExpiration.getTime() - (System.currentTimeMillis() - (SDKGlobalConfiguration.getGlobalTimeOffset() * 1000)) < ((long) (this.refreshThreshold * 1000));
+    }
+
+    public final void appendUserAgent(AmazonWebServiceRequest amazonWebServiceRequest, String str) {
+        amazonWebServiceRequest.getRequestClientOptions().appendUserAgent(str);
+    }
+
+    public void registerIdentityChangedListener(IdentityChangedListener identityChangedListener) {
+        this.identityProvider.registerIdentityChangedListener(identityChangedListener);
+    }
+}

decompiled-community/sources/com/amazonaws/auth/IdentityChangedListener.java

@@ -0,0 +1,6 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public interface IdentityChangedListener {
+    void identityChanged(String str, String str2);
+}

decompiled-community/sources/com/amazonaws/auth/NoOpSigner.java

@@ -0,0 +1,10 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.Request;
+
+/* loaded from: classes.dex */
+public class NoOpSigner implements Signer {
+    @Override // com.amazonaws.auth.Signer
+    public void sign(Request<?> request, AWSCredentials aWSCredentials) {
+    }
+}

decompiled-community/sources/com/amazonaws/auth/PropertiesCredentials.java

@@ -0,0 +1,44 @@
+package com.amazonaws.auth;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Properties;
+
+/* loaded from: classes.dex */
+public class PropertiesCredentials implements AWSCredentials {
+    public final String accessKey;
+    public final String secretAccessKey;
+
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSAccessKeyId() {
+        return this.accessKey;
+    }
+
+    @Override // com.amazonaws.auth.AWSCredentials
+    public String getAWSSecretKey() {
+        return this.secretAccessKey;
+    }
+
+    public PropertiesCredentials(File file) {
+        if (!file.exists()) {
+            throw new FileNotFoundException("File doesn't exist:  " + file.getAbsolutePath());
+        }
+        FileInputStream fileInputStream = new FileInputStream(file);
+        try {
+            Properties properties = new Properties();
+            properties.load(fileInputStream);
+            if (properties.getProperty("accessKey") == null || properties.getProperty("secretKey") == null) {
+                throw new IllegalArgumentException("The specified file (" + file.getAbsolutePath() + ") doesn't contain the expected properties 'accessKey' and 'secretKey'.");
+            }
+            this.accessKey = properties.getProperty("accessKey");
+            this.secretAccessKey = properties.getProperty("secretKey");
+        } finally {
+            try {
+                fileInputStream.close();
+            } catch (IOException unused) {
+            }
+        }
+    }
+}

decompiled-community/sources/com/amazonaws/auth/QueryStringSigner.java

@@ -0,0 +1,94 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.AmazonClientException;
+import com.amazonaws.Request;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Map;
+import java.util.TimeZone;
+import java.util.TreeMap;
+
+/* loaded from: classes.dex */
+public class QueryStringSigner extends AbstractAWSSigner implements Signer {
+    private Date overriddenDate;
+
+    public void overrideDate(Date date) {
+        this.overriddenDate = date;
+    }
+
+    @Override // com.amazonaws.auth.Signer
+    public void sign(Request<?> request, AWSCredentials aWSCredentials) {
+        sign(request, SignatureVersion.V2, SigningAlgorithm.HmacSHA256, aWSCredentials);
+    }
+
+    public void sign(Request<?> request, SignatureVersion signatureVersion, SigningAlgorithm signingAlgorithm, AWSCredentials aWSCredentials) {
+        String calculateStringToSignV2;
+        if (aWSCredentials instanceof AnonymousAWSCredentials) {
+            return;
+        }
+        AWSCredentials sanitizeCredentials = sanitizeCredentials(aWSCredentials);
+        request.addParameter("AWSAccessKeyId", sanitizeCredentials.getAWSAccessKeyId());
+        request.addParameter("SignatureVersion", signatureVersion.toString());
+        request.addParameter("Timestamp", getFormattedTimestamp(getTimeOffset(request)));
+        if (sanitizeCredentials instanceof AWSSessionCredentials) {
+            addSessionCredentials(request, (AWSSessionCredentials) sanitizeCredentials);
+        }
+        if (signatureVersion.equals(SignatureVersion.V1)) {
+            calculateStringToSignV2 = calculateStringToSignV1(request.getParameters());
+        } else if (signatureVersion.equals(SignatureVersion.V2)) {
+            request.addParameter("SignatureMethod", signingAlgorithm.toString());
+            calculateStringToSignV2 = calculateStringToSignV2(request);
+        } else {
+            throw new AmazonClientException("Invalid Signature Version specified");
+        }
+        request.addParameter("Signature", signAndBase64Encode(calculateStringToSignV2, sanitizeCredentials.getAWSSecretKey(), signingAlgorithm));
+    }
+
+    private String calculateStringToSignV1(Map<String, String> map) {
+        StringBuilder sb = new StringBuilder();
+        TreeMap treeMap = new TreeMap(String.CASE_INSENSITIVE_ORDER);
+        treeMap.putAll(map);
+        for (Map.Entry entry : treeMap.entrySet()) {
+            sb.append((String) entry.getKey());
+            sb.append((String) entry.getValue());
+        }
+        return sb.toString();
+    }
+
+    private String calculateStringToSignV2(Request<?> request) {
+        return "POST\n" + getCanonicalizedEndpoint(request.getEndpoint()) + "\n" + getCanonicalizedResourcePath(request) + "\n" + getCanonicalizedQueryString(request.getParameters());
+    }
+
+    private String getCanonicalizedResourcePath(Request<?> request) {
+        String str = "";
+        if (request.getEndpoint().getPath() != null) {
+            str = "" + request.getEndpoint().getPath();
+        }
+        if (request.getResourcePath() != null) {
+            if (str.length() > 0 && !str.endsWith("/") && !request.getResourcePath().startsWith("/")) {
+                str = str + "/";
+            }
+            str = str + request.getResourcePath();
+        } else if (!str.endsWith("/")) {
+            str = str + "/";
+        }
+        if (!str.startsWith("/")) {
+            str = "/" + str;
+        }
+        return str.startsWith("//") ? str.substring(1) : str;
+    }
+
+    private String getFormattedTimestamp(long j) {
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
+        simpleDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+        Date date = this.overriddenDate;
+        if (date != null) {
+            return simpleDateFormat.format(date);
+        }
+        return simpleDateFormat.format(getSignatureDate(j));
+    }
+
+    public void addSessionCredentials(Request<?> request, AWSSessionCredentials aWSSessionCredentials) {
+        request.addParameter("SecurityToken", aWSSessionCredentials.getSessionToken());
+    }
+}

decompiled-community/sources/com/amazonaws/auth/RegionAwareSigner.java

@@ -0,0 +1,6 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public interface RegionAwareSigner extends Signer {
+    void setRegionName(String str);
+}

decompiled-community/sources/com/amazonaws/auth/ServiceAwareSigner.java

@@ -0,0 +1,6 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public interface ServiceAwareSigner extends Signer {
+    void setServiceName(String str);
+}

decompiled-community/sources/com/amazonaws/auth/SignatureVersion.java

@@ -0,0 +1,18 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public enum SignatureVersion {
+    V1("1"),
+    V2("2");
+
+    private String value;
+
+    @Override // java.lang.Enum
+    public String toString() {
+        return this.value;
+    }
+
+    SignatureVersion(String str) {
+        this.value = str;
+    }
+}

decompiled-community/sources/com/amazonaws/auth/Signer.java

@@ -0,0 +1,8 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.Request;
+
+/* loaded from: classes.dex */
+public interface Signer {
+    void sign(Request request, AWSCredentials aWSCredentials);
+}

decompiled-community/sources/com/amazonaws/auth/SignerFactory.java

@@ -0,0 +1,48 @@
+package com.amazonaws.auth;
+
+import com.amazonaws.internal.config.InternalConfig;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes.dex */
+public abstract class SignerFactory {
+    public static final Map SIGNERS;
+
+    static {
+        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();
+        SIGNERS = concurrentHashMap;
+        concurrentHashMap.put("QueryStringSignerType", QueryStringSigner.class);
+        concurrentHashMap.put("AWS4SignerType", AWS4Signer.class);
+        concurrentHashMap.put("NoOpSignerType", NoOpSigner.class);
+    }
+
+    public static Signer getSigner(String str, String str2) {
+        return lookupAndCreateSigner(str, str2);
+    }
+
+    public static Signer getSignerByTypeAndService(String str, String str2) {
+        return createSigner(str, str2);
+    }
+
+    public static Signer lookupAndCreateSigner(String str, String str2) {
+        return createSigner(InternalConfig.Factory.getInternalConfig().getSignerConfig(str, str2).getSignerType(), str);
+    }
+
+    public static Signer createSigner(String str, String str2) {
+        Class cls = (Class) SIGNERS.get(str);
+        if (cls == null) {
+            throw new IllegalArgumentException();
+        }
+        try {
+            Signer signer = (Signer) cls.newInstance();
+            if (signer instanceof ServiceAwareSigner) {
+                ((ServiceAwareSigner) signer).setServiceName(str2);
+            }
+            return signer;
+        } catch (IllegalAccessException e) {
+            throw new IllegalStateException("Cannot create an instance of " + cls.getName(), e);
+        } catch (InstantiationException e2) {
+            throw new IllegalStateException("Cannot create an instance of " + cls.getName(), e2);
+        }
+    }
+}

decompiled-community/sources/com/amazonaws/auth/SigningAlgorithm.java

@@ -0,0 +1,7 @@
+package com.amazonaws.auth;
+
+/* loaded from: classes.dex */
+public enum SigningAlgorithm {
+    HmacSHA1,
+    HmacSHA256
+}