package org.snmp4j.security;

import javax.crypto.Cipher;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.OctetString;

/* JADX INFO: loaded from: classes.dex */
public abstract class PrivAES extends PrivacyGeneric implements PrivacyProtocol {
    private static final int DECRYPT_PARAMS_LENGTH = 8;
    private static final int INIT_VECTOR_LENGTH = 16;
    private static final String PROTOCOL_CLASS = "AES";
    private static final String PROTOCOL_ID = "AES/CFB/NoPadding";
    private static final LogAdapter logger = LogFactory.getLogger(PrivAES.class);
    protected Salt salt;

    public PrivAES(int i2) {
        this.initVectorLength = 16;
        this.protocolId = PROTOCOL_ID;
        this.protocolClass = PROTOCOL_CLASS;
        if (i2 == 16 || i2 == 24 || i2 == 32) {
            this.keyBytes = i2;
            this.salt = Salt.getInstance();
            this.cipherPool = new CipherPool();
        } else {
            throw new IllegalArgumentException("Only 128, 192 and 256 bit AES is allowed. Requested (" + (i2 * 8) + ").");
        }
    }

    public static String asHex(byte[] bArr) {
        return new OctetString(bArr).toHexString();
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public byte[] decrypt(byte[] bArr, int i2, int i3, byte[] bArr2, long j2, long j3, DecryptParams decryptParams) {
        byte[] bArr3 = new byte[16];
        if (bArr2.length != this.keyBytes) {
            throw new IllegalArgumentException("Needed key length is " + this.keyBytes + ". Got " + bArr2.length + ".");
        }
        bArr3[0] = (byte) ((j2 >> 24) & 255);
        bArr3[1] = (byte) ((j2 >> 16) & 255);
        bArr3[2] = (byte) ((j2 >> 8) & 255);
        bArr3[3] = (byte) (j2 & 255);
        bArr3[4] = (byte) ((j3 >> 24) & 255);
        bArr3[5] = (byte) ((j3 >> 16) & 255);
        bArr3[6] = (byte) ((j3 >> 8) & 255);
        bArr3[7] = (byte) (j3 & 255);
        System.arraycopy(decryptParams.array, decryptParams.offset, bArr3, 8, 8);
        if (logger.isDebugEnabled()) {
            logger.debug("initVect is " + asHex(bArr3));
        }
        return doDecrypt(bArr, i2, i3, bArr2, bArr3);
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public byte[] encrypt(byte[] bArr, int i2, int i3, byte[] bArr2, long j2, long j3, DecryptParams decryptParams) {
        byte[] bArr3 = new byte[16];
        long next = this.salt.getNext();
        if (bArr2.length != this.keyBytes) {
            throw new IllegalArgumentException("Needed key length is " + this.keyBytes + ". Got " + bArr2.length + ".");
        }
        if (decryptParams.array == null || decryptParams.length < 8) {
            decryptParams.array = new byte[8];
        }
        decryptParams.length = 8;
        decryptParams.offset = 0;
        bArr3[0] = (byte) ((j2 >> 24) & 255);
        bArr3[1] = (byte) ((j2 >> 16) & 255);
        bArr3[2] = (byte) ((j2 >> 8) & 255);
        bArr3[3] = (byte) (j2 & 255);
        bArr3[4] = (byte) ((j3 >> 24) & 255);
        bArr3[5] = (byte) ((j3 >> 16) & 255);
        bArr3[6] = (byte) ((j3 >> 8) & 255);
        bArr3[7] = (byte) (j3 & 255);
        int i4 = 56;
        int i5 = 8;
        while (i4 >= 0) {
            bArr3[i5] = (byte) ((next >> i4) & 255);
            i4 -= 8;
            i5++;
        }
        System.arraycopy(bArr3, 8, decryptParams.array, 0, 8);
        if (logger.isDebugEnabled()) {
            logger.debug("initVect is " + asHex(bArr3));
        }
        byte[] bArrDoFinal = null;
        try {
            Cipher cipherDoInit = doInit(bArr2, bArr3);
            bArrDoFinal = cipherDoInit.doFinal(bArr, i2, i3);
            this.cipherPool.offerCipher(cipherDoInit);
            if (logger.isDebugEnabled()) {
                logger.debug("aes encrypt: Data to encrypt " + asHex(bArr));
                logger.debug("aes encrypt: used key " + asHex(bArr2));
                logger.debug("aes encrypt: created privacy_params " + asHex(decryptParams.array));
                logger.debug("aes encrypt: encrypted Data  " + asHex(bArrDoFinal));
            }
        } catch (Exception e2) {
            logger.error("Encrypt Exception " + e2);
        }
        return bArrDoFinal;
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public byte[] extendShortKey(byte[] bArr, OctetString octetString, byte[] bArr2, AuthenticationProtocol authenticationProtocol) {
        int minKeyLength = getMinKeyLength();
        byte[] bArr3 = new byte[minKeyLength];
        int length = bArr.length;
        System.arraycopy(bArr, 0, bArr3, 0, length);
        while (length < minKeyLength) {
            byte[] bArrHash = authenticationProtocol.hash(bArr3, 0, length);
            if (bArrHash == null) {
                return null;
            }
            int digestLength = minKeyLength - length;
            if (digestLength > authenticationProtocol.getDigestLength()) {
                digestLength = authenticationProtocol.getDigestLength();
            }
            System.arraycopy(bArrHash, 0, bArr3, length, digestLength);
            length += digestLength;
        }
        return bArr3;
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public int getDecryptParamsLength() {
        return 8;
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public int getEncryptedLength(int i2) {
        return i2;
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public int getMaxKeyLength() {
        return getMinKeyLength();
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public int getMinKeyLength() {
        return this.keyBytes;
    }
}