package U3;

import java.security.GeneralSecurityException;
import java.util.Arrays;
import javax.crypto.AEADBadTagException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/* JADX INFO: loaded from: classes.dex */
public final class b implements H3.a {

    /* JADX INFO: renamed from: e, reason: collision with root package name */
    public static final J3.b f6692e = new J3.b(4);

    /* JADX INFO: renamed from: f, reason: collision with root package name */
    public static final J3.b f6693f = new J3.b(5);

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

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

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

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

    public b(int i, byte[] bArr) throws GeneralSecurityException {
        if (!I1.a.b(1)) {
            throw new GeneralSecurityException("Can not use AES-EAX in FIPS-mode.");
        }
        if (i != 12 && i != 16) {
            throw new IllegalArgumentException("IV size should be either 12 or 16 bytes");
        }
        this.f6697d = i;
        o.a(bArr.length);
        SecretKeySpec secretKeySpec = new SecretKeySpec(bArr, "AES");
        this.f6696c = secretKeySpec;
        Cipher cipher = (Cipher) f6692e.get();
        cipher.init(1, secretKeySpec);
        byte[] bArrC = c(cipher.doFinal(new byte[16]));
        this.f6694a = bArrC;
        this.f6695b = c(bArrC);
    }

    public static byte[] c(byte[] bArr) {
        byte[] bArr2 = new byte[16];
        int i = 0;
        while (i < 15) {
            int i5 = i + 1;
            bArr2[i] = (byte) (((bArr[i] << 1) ^ ((bArr[i5] & 255) >>> 7)) & 255);
            i = i5;
        }
        bArr2[15] = (byte) (((bArr[0] >> 7) & 135) ^ (bArr[15] << 1));
        return bArr2;
    }

    public static byte[] e(byte[] bArr, byte[] bArr2) {
        int length = bArr.length;
        byte[] bArr3 = new byte[length];
        for (int i = 0; i < length; i++) {
            bArr3[i] = (byte) (bArr[i] ^ bArr2[i]);
        }
        return bArr3;
    }

    @Override // H3.a
    public final byte[] a(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        int length = bArr.length;
        int i = this.f6697d;
        if (length > 2147483631 - i) {
            throw new GeneralSecurityException("plaintext too long");
        }
        byte[] bArr3 = new byte[bArr.length + i + 16];
        byte[] bArrA = n.a(i);
        System.arraycopy(bArrA, 0, bArr3, 0, i);
        Cipher cipher = (Cipher) f6692e.get();
        SecretKeySpec secretKeySpec = this.f6696c;
        cipher.init(1, secretKeySpec);
        byte[] bArrD = d(cipher, 0, bArrA, 0, bArrA.length);
        byte[] bArr4 = bArr2 == null ? new byte[0] : bArr2;
        byte[] bArrD2 = d(cipher, 1, bArr4, 0, bArr4.length);
        Cipher cipher2 = (Cipher) f6693f.get();
        cipher2.init(1, secretKeySpec, new IvParameterSpec(bArrD));
        cipher2.doFinal(bArr, 0, bArr.length, bArr3, this.f6697d);
        byte[] bArrD3 = d(cipher, 2, bArr3, this.f6697d, bArr.length);
        int length2 = bArr.length + i;
        for (int i5 = 0; i5 < 16; i5++) {
            bArr3[length2 + i5] = (byte) ((bArrD2[i5] ^ bArrD[i5]) ^ bArrD3[i5]);
        }
        return bArr3;
    }

    @Override // H3.a
    public final byte[] b(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        int length = bArr.length;
        int i = this.f6697d;
        int i5 = (length - i) - 16;
        if (i5 < 0) {
            throw new GeneralSecurityException("ciphertext too short");
        }
        Cipher cipher = (Cipher) f6692e.get();
        SecretKeySpec secretKeySpec = this.f6696c;
        cipher.init(1, secretKeySpec);
        byte[] bArrD = d(cipher, 0, bArr, 0, this.f6697d);
        byte[] bArr3 = bArr2 == null ? new byte[0] : bArr2;
        byte[] bArrD2 = d(cipher, 1, bArr3, 0, bArr3.length);
        byte[] bArrD3 = d(cipher, 2, bArr, this.f6697d, i5);
        int length2 = bArr.length - 16;
        byte b8 = 0;
        for (int i8 = 0; i8 < 16; i8++) {
            b8 = (byte) (b8 | (((bArr[length2 + i8] ^ bArrD2[i8]) ^ bArrD[i8]) ^ bArrD3[i8]));
        }
        if (b8 != 0) {
            throw new AEADBadTagException("tag mismatch");
        }
        Cipher cipher2 = (Cipher) f6693f.get();
        cipher2.init(1, secretKeySpec, new IvParameterSpec(bArrD));
        return cipher2.doFinal(bArr, i, i5);
    }

    public final byte[] d(Cipher cipher, int i, byte[] bArr, int i5, int i8) throws BadPaddingException, IllegalBlockSizeException {
        byte[] bArrCopyOf;
        byte[] bArr2 = new byte[16];
        bArr2[15] = (byte) i;
        byte[] bArr3 = this.f6694a;
        if (i8 == 0) {
            return cipher.doFinal(e(bArr2, bArr3));
        }
        byte[] bArrDoFinal = cipher.doFinal(bArr2);
        int i9 = 0;
        while (i8 - i9 > 16) {
            for (int i10 = 0; i10 < 16; i10++) {
                bArrDoFinal[i10] = (byte) (bArrDoFinal[i10] ^ bArr[(i5 + i9) + i10]);
            }
            bArrDoFinal = cipher.doFinal(bArrDoFinal);
            i9 += 16;
        }
        byte[] bArrCopyOfRange = Arrays.copyOfRange(bArr, i9 + i5, i5 + i8);
        if (bArrCopyOfRange.length == 16) {
            bArrCopyOf = e(bArrCopyOfRange, bArr3);
        } else {
            bArrCopyOf = Arrays.copyOf(this.f6695b, 16);
            for (int i11 = 0; i11 < bArrCopyOfRange.length; i11++) {
                bArrCopyOf[i11] = (byte) (bArrCopyOf[i11] ^ bArrCopyOfRange[i11]);
            }
            bArrCopyOf[bArrCopyOfRange.length] = (byte) (bArrCopyOf[bArrCopyOfRange.length] ^ 128);
        }
        return cipher.doFinal(e(bArrDoFinal, bArrCopyOf));
    }
}