package com.google.android.gms.internal.ads;

import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.security.interfaces.RSAPublicKey;
import java.util.Arrays;

/* JADX INFO: loaded from: classes2.dex */
public final class e92 implements fw1 {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public final RSAPublicKey f10709a;

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public final zzhxn f10710b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public final zzhxn f10711c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    public final int f10712d;

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public final byte[] f10713e;

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public final byte[] f10714f;

    public /* synthetic */ e92(RSAPublicKey rSAPublicKey, zzhxn zzhxnVar, zzhxn zzhxnVar2, int i10, byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        if (mz1.a()) {
            throw new GeneralSecurityException("Can not use RSA PSS in FIPS-mode, as BoringCrypto module is not available.");
        }
        h92.b(zzhxnVar);
        if (!zzhxnVar.equals(zzhxnVar2)) {
            throw new GeneralSecurityException("sigHash and mgf1Hash must be the same");
        }
        h92.c(rSAPublicKey.getModulus().bitLength());
        h92.d(rSAPublicKey.getPublicExponent());
        this.f10709a = rSAPublicKey;
        this.f10710b = zzhxnVar;
        this.f10711c = zzhxnVar2;
        this.f10712d = i10;
        this.f10713e = bArr;
        this.f10714f = bArr2;
    }

    public final void a(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        RSAPublicKey rSAPublicKey = this.f10709a;
        BigInteger publicExponent = rSAPublicKey.getPublicExponent();
        BigInteger modulus = rSAPublicKey.getModulus();
        int iBitLength = modulus.bitLength() + 7;
        int iBitLength2 = modulus.bitLength() + 6;
        if (iBitLength / 8 != bArr.length) {
            throw new GeneralSecurityException("invalid signature's length");
        }
        BigInteger bigInteger = new BigInteger(1, bArr);
        if (bigInteger.compareTo(modulus) >= 0) {
            throw new GeneralSecurityException("signature out of range");
        }
        byte[] bArrK0 = ih1.k0(bigInteger.modPow(publicExponent, modulus), iBitLength2 / 8);
        int iBitLength3 = modulus.bitLength() - 1;
        zzhxn zzhxnVar = this.f10710b;
        h92.b(zzhxnVar);
        w82 w82Var = w82.f17929e;
        MessageDigest messageDigest = (MessageDigest) w82Var.a(ih1.Y(zzhxnVar));
        messageDigest.update(bArr2);
        byte[] bArr3 = this.f10714f;
        if (bArr3.length != 0) {
            messageDigest.update(bArr3);
        }
        byte[] bArrDigest = messageDigest.digest();
        int digestLength = messageDigest.getDigestLength();
        int length = bArrK0.length;
        int i10 = this.f10712d;
        if (length < digestLength + i10 + 2) {
            throw new GeneralSecurityException("inconsistent");
        }
        if (bArrK0[length - 1] != -68) {
            throw new GeneralSecurityException("inconsistent");
        }
        int i11 = length - digestLength;
        int i12 = i11 - 1;
        byte[] bArrCopyOf = Arrays.copyOf(bArrK0, i12);
        int length2 = bArrCopyOf.length;
        byte[] bArrCopyOfRange = Arrays.copyOfRange(bArrK0, length2, length2 + digestLength);
        int i13 = 0;
        while (true) {
            int i14 = digestLength;
            int i15 = length;
            int i16 = iBitLength3;
            MessageDigest messageDigest2 = messageDigest;
            long j10 = (((long) length) * 8) - ((long) iBitLength3);
            if (i13 < j10) {
                if (((bArrCopyOf[i13 / 8] >> (7 - (i13 % 8))) & 1) != 0) {
                    throw new GeneralSecurityException("inconsistent");
                }
                i13++;
                digestLength = i14;
                length = i15;
                iBitLength3 = i16;
                messageDigest = messageDigest2;
            } else {
                MessageDigest messageDigest3 = (MessageDigest) w82Var.a(ih1.Y(this.f10711c));
                byte[] bArr4 = new byte[i12];
                int i17 = 0;
                int i18 = 0;
                for (int digestLength2 = messageDigest3.getDigestLength(); i17 <= (i11 - 2) / digestLength2; digestLength2 = digestLength2) {
                    messageDigest3.reset();
                    messageDigest3.update(bArrCopyOfRange);
                    byte[] bArr5 = bArrCopyOfRange;
                    messageDigest3.update(ih1.k0(BigInteger.valueOf(i17), 4));
                    byte[] bArrDigest2 = messageDigest3.digest();
                    int length3 = bArrDigest2.length;
                    System.arraycopy(bArrDigest2, 0, bArr4, i18, Math.min(length3, i12 - i18));
                    i18 += length3;
                    i17++;
                    bArrCopyOfRange = bArr5;
                    messageDigest3 = messageDigest3;
                }
                byte[] bArr6 = bArrCopyOfRange;
                byte[] bArr7 = new byte[i12];
                for (int i19 = 0; i19 < i12; i19++) {
                    bArr7[i19] = (byte) (bArr4[i19] ^ bArrCopyOf[i19]);
                }
                for (int i20 = 0; i20 <= j10; i20++) {
                    int i21 = i20 / 8;
                    bArr7[i21] = (byte) ((~(1 << (7 - (i20 % 8)))) & bArr7[i21]);
                }
                int i22 = 0;
                while (true) {
                    int i23 = (i11 - i10) - 2;
                    if (i22 >= i23) {
                        if (bArr7[i23] != 1) {
                            throw new GeneralSecurityException("inconsistent");
                        }
                        byte[] bArrCopyOfRange2 = Arrays.copyOfRange(bArr7, i12 - i10, i12);
                        int i24 = i14 + 8;
                        byte[] bArr8 = new byte[i10 + i24];
                        System.arraycopy(bArrDigest, 0, bArr8, 8, bArrDigest.length);
                        System.arraycopy(bArrCopyOfRange2, 0, bArr8, i24, bArrCopyOfRange2.length);
                        if (!MessageDigest.isEqual(messageDigest2.digest(bArr8), bArr6)) {
                            throw new GeneralSecurityException("inconsistent");
                        }
                        return;
                    }
                    if (bArr7[i22] != 0) {
                        throw new GeneralSecurityException("inconsistent");
                    }
                    i22++;
                }
            }
        }
    }

    @Override // com.google.android.gms.internal.ads.fw1
    public final void zza(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        byte[] bArr3 = this.f10713e;
        int length = bArr3.length;
        if (length == 0) {
            a(bArr, bArr2);
        } else {
            if (!q12.c(bArr3, bArr)) {
                throw new GeneralSecurityException("Invalid signature (output prefix mismatch)");
            }
            a(Arrays.copyOfRange(bArr, length, bArr.length), bArr2);
        }
    }
}