package defpackage;

import java.nio.ByteBuffer;
import java.security.GeneralSecurityException;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import java.util.Iterator;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

/* renamed from: ˀᵜᵮ, reason: contains not printable characters */
/* loaded from: classes3.dex */
public final class C0569 implements InterfaceC2556 {

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public final Object f2947;

    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public final /* synthetic */ int f2948;

    /* renamed from: ᵴᵳ, reason: contains not printable characters */
    public final Object f2949;

    public C0569(int i, byte[] bArr, byte[] bArr2) {
        this.f2948 = i;
        switch (i) {
            case 4:
                this.f2949 = new C4969(1, bArr);
                this.f2947 = bArr2;
                break;
            default:
                this.f2949 = new C4969(0, bArr);
                this.f2947 = bArr2;
                break;
        }
    }

    public C0569(InterfaceC2556 interfaceC2556, byte[] bArr) {
        this.f2948 = 3;
        this.f2949 = interfaceC2556;
        if (bArr.length == 0 || bArr.length == 5) {
            this.f2947 = bArr;
        } else {
            ᵹˉᵞ.ˌᵜᵹᵩ("identifier has an invalid length");
            throw null;
        }
    }

    public C0569(C4087 c4087, C2111 c2111) {
        this.f2948 = 0;
        this.f2949 = c4087;
        this.f2947 = c2111;
    }

    public C0569(byte[] bArr, C4542 c4542) throws GeneralSecurityException {
        this.f2948 = 1;
        if (!AbstractC2990.m7308(2)) {
            C0910.m3048("Can not use AES-GCM in FIPS-mode, as BoringCrypto module is not available.");
            throw null;
        }
        C1907 c1907 = AbstractC0974.f4337;
        AbstractC5437.m11082(bArr.length);
        this.f2949 = new SecretKeySpec(bArr, "AES");
        this.f2947 = c4542.m9655();
    }

    /* renamed from: ˏᵙ, reason: contains not printable characters */
    public byte[] m2410(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        if (bArr.length < 28) {
            C0910.m3048("ciphertext too short");
            return null;
        }
        byte[] bArrCopyOf = Arrays.copyOf(bArr, 12);
        return ((C4969) this.f2949).m5295(ByteBuffer.wrap(bArr, 12, bArr.length - 12), bArrCopyOf, bArr2);
    }

    @Override // defpackage.InterfaceC2556
    /* renamed from: ᵥᵯˎ, reason: contains not printable characters */
    public final byte[] mo2411(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        int i = this.f2948;
        Object obj = this.f2947;
        Object obj2 = this.f2949;
        switch (i) {
            case 0:
                byte[] bArrMo2411 = ((C4087) obj2).f15278.mo2411(bArr, bArr2);
                int length = bArr.length;
                return bArrMo2411;
            case 1:
                byte[] bArr3 = (byte[]) obj;
                if (bArr == null) {
                    C1260.m3813("plaintext is null");
                    return null;
                }
                byte[] bArrM11138 = AbstractC5513.m11138(12);
                AlgorithmParameterSpec algorithmParameterSpecM3319 = AbstractC0974.m3319(bArrM11138, 0, bArrM11138.length);
                Cipher cipher = (Cipher) AbstractC0974.f4337.get();
                cipher.init(1, (SecretKeySpec) obj2, algorithmParameterSpecM3319);
                if (bArr2 != null && bArr2.length != 0) {
                    cipher.updateAAD(bArr2);
                }
                int outputSize = cipher.getOutputSize(bArr.length);
                if (outputSize > 2147483635 - bArr3.length) {
                    C0910.m3048("plaintext too long");
                    return null;
                }
                byte[] bArrCopyOf = Arrays.copyOf(bArr3, bArr3.length + 12 + outputSize);
                System.arraycopy(bArrM11138, 0, bArrCopyOf, bArr3.length, 12);
                if (cipher.doFinal(bArr, 0, bArr.length, bArrCopyOf, bArr3.length + 12) == outputSize) {
                    return bArrCopyOf;
                }
                C0910.m3048("not enough data written");
                return null;
            case 2:
                ByteBuffer byteBufferAllocate = ByteBuffer.allocate(bArr.length + 28);
                byte[] bArrM111382 = AbstractC5513.m11138(12);
                byteBufferAllocate.put(bArrM111382);
                ((C4969) obj2).m5298(byteBufferAllocate, bArrM111382, bArr, bArr2);
                byte[] bArrArray = byteBufferAllocate.array();
                byte[] bArr4 = (byte[]) obj;
                return bArr4.length == 0 ? bArrArray : ˉᵜˆ.ᵻᵢﹳᵰ(new byte[][]{bArr4, bArrArray});
            case 3:
                byte[] bArr5 = (byte[]) obj;
                InterfaceC2556 interfaceC2556 = (InterfaceC2556) obj2;
                return bArr5.length == 0 ? interfaceC2556.mo2411(bArr, bArr2) : ˉᵜˆ.ᵻᵢﹳᵰ(new byte[][]{bArr5, interfaceC2556.mo2411(bArr, bArr2)});
            default:
                ByteBuffer byteBufferAllocate2 = ByteBuffer.allocate(bArr.length + 40);
                byte[] bArrM111383 = AbstractC5513.m11138(24);
                byteBufferAllocate2.put(bArrM111383);
                ((C4969) obj2).m5298(byteBufferAllocate2, bArrM111383, bArr, bArr2);
                byte[] bArrArray2 = byteBufferAllocate2.array();
                byte[] bArr6 = (byte[]) obj;
                return bArr6.length == 0 ? bArrArray2 : ˉᵜˆ.ᵻᵢﹳᵰ(new byte[][]{bArr6, bArrArray2});
        }
    }

    @Override // defpackage.InterfaceC2556
    /* renamed from: ᵴᵳ, reason: contains not printable characters */
    public final byte[] mo2412(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        int i = this.f2948;
        Object obj = this.f2949;
        Object obj2 = this.f2947;
        byte[] bArrMo2412 = null;
        switch (i) {
            case 0:
                Iterator it = ((C2111) obj2).m5704(bArr).iterator();
                while (true) {
                    if (!it.hasNext()) {
                        C0910.m3048("decryption failed");
                        break;
                    } else {
                        try {
                            bArrMo2412 = ((C4087) it.next()).f15278.mo2412(bArr, bArr2);
                            break;
                        } catch (GeneralSecurityException unused) {
                        }
                    }
                }
            case 1:
                byte[] bArr3 = (byte[]) obj2;
                if (bArr == null) {
                    C1260.m3813("ciphertext is null");
                    break;
                } else if (bArr.length < bArr3.length + 28) {
                    C0910.m3048("ciphertext too short");
                    break;
                } else if (!AbstractC1067.m3457(bArr3, bArr)) {
                    C0910.m3048("Decryption failed (OutputPrefix mismatch).");
                    break;
                } else {
                    AlgorithmParameterSpec algorithmParameterSpecM3319 = AbstractC0974.m3319(bArr, bArr3.length, 12);
                    Cipher cipher = (Cipher) AbstractC0974.f4337.get();
                    cipher.init(2, (SecretKeySpec) obj, algorithmParameterSpecM3319);
                    if (bArr2 != null && bArr2.length != 0) {
                        cipher.updateAAD(bArr2);
                    }
                    break;
                }
                break;
            case 2:
                byte[] bArr4 = (byte[]) obj2;
                if (bArr4.length != 0) {
                    if (!AbstractC1067.m3457(bArr4, bArr)) {
                        C0910.m3048("Decryption failed (OutputPrefix mismatch).");
                        break;
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            case 3:
                InterfaceC2556 interfaceC2556 = (InterfaceC2556) obj;
                byte[] bArr5 = (byte[]) obj2;
                if (bArr5.length != 0) {
                    if (!AbstractC1067.m3457(bArr5, bArr)) {
                        C0910.m3048("wrong prefix");
                        break;
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            default:
                byte[] bArr6 = (byte[]) obj2;
                if (bArr6.length != 0) {
                    if (!AbstractC1067.m3457(bArr6, bArr)) {
                        C0910.m3048("Decryption failed (OutputPrefix mismatch).");
                        break;
                    } else {
                        break;
                    }
                } else {
                    break;
                }
        }
        return null;
    }

    /* renamed from: ᵻᵢﹳᵰ, reason: contains not printable characters */
    public byte[] m2413(byte[] bArr, byte[] bArr2) throws GeneralSecurityException {
        if (bArr.length < 40) {
            C0910.m3048("ciphertext too short");
            return null;
        }
        byte[] bArrCopyOf = Arrays.copyOf(bArr, 24);
        return ((C4969) this.f2949).m5295(ByteBuffer.wrap(bArr, 24, bArr.length - 24), bArrCopyOf, bArr2);
    }
}