package org.snmp4j.security;

import javax.crypto.Cipher;
import org.snmp4j.agent.mo.snmp.DisplayString;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;

/* JADX INFO: loaded from: classes.dex */
public class Priv3DES extends PrivacyGeneric {
    private static final int DECRYPT_PARAMS_LENGTH = 8;
    private static final int INIT_VECTOR_LENGTH = 8;
    private static final int INPUT_KEY_LENGTH = 32;
    private static final int KEY_LENGTH = 24;
    private static final String PROTOCOL_CLASS = "DESede";
    private static final String PROTOCOL_ID = "DESede/CBC/NoPadding";
    protected Salt salt;
    public static final OID ID = new OID(SnmpConstants.usm3DESEDEPrivProtocol);
    private static final LogAdapter logger = LogFactory.getLogger(Priv3DES.class);

    public Priv3DES() {
        this.initVectorLength = 8;
        this.protocolId = PROTOCOL_ID;
        this.protocolClass = PROTOCOL_CLASS;
        this.keyBytes = 24;
        this.salt = Salt.getInstance();
        this.cipherPool = new CipherPool();
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public byte[] decrypt(byte[] bArr, int i2, int i3, byte[] bArr2, long j2, long j3, DecryptParams decryptParams) {
        if (i3 % 8 != 0 || i3 < 8 || decryptParams.length != 8) {
            throw new IllegalArgumentException("Length (" + i3 + ") is not multiple of 8 or decrypt params has not length 8 (" + decryptParams.length + ").");
        }
        if (bArr2.length >= 32) {
            byte[] bArr3 = new byte[8];
            for (int i4 = 0; i4 < 8; i4++) {
                bArr3[i4] = (byte) (bArr2[i4 + 24] ^ decryptParams.array[i4]);
            }
            return doDecrypt(bArr, i2, i3, bArr2, bArr3);
        }
        logger.error("Wrong Key length: need at least 32 bytes, is " + bArr2.length + " bytes.");
        throw new IllegalArgumentException("decryptionKey has illegal length " + bArr2.length + " (should be at least 32).");
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public byte[] encrypt(byte[] bArr, int i2, int i3, byte[] bArr2, long j2, long j3, DecryptParams decryptParams) {
        int next = (int) this.salt.getNext();
        if (bArr2.length < 32) {
            logger.error("Wrong Key length: need at least 32 bytes, is " + bArr2.length + " bytes.");
            throw new IllegalArgumentException("encryptionKey has illegal length " + bArr2.length + " (should be at least 32).");
        }
        if (decryptParams.array == null || decryptParams.length < 8) {
            decryptParams.array = new byte[8];
        }
        decryptParams.length = 8;
        decryptParams.offset = 0;
        if (logger.isDebugEnabled()) {
            logger.debug("Preparing decrypt_params.");
        }
        for (int i4 = 0; i4 < 4; i4++) {
            byte[] bArr3 = decryptParams.array;
            bArr3[3 - i4] = (byte) (255 & (j2 >> r11));
            bArr3[7 - i4] = (byte) ((next >> (i4 * 8)) & DisplayString.MAX_SIZE);
        }
        byte[] bArr4 = new byte[8];
        if (logger.isDebugEnabled()) {
            logger.debug("Preparing iv for encryption.");
        }
        for (int i5 = 0; i5 < 8; i5++) {
            bArr4[i5] = (byte) (bArr2[i5 + 24] ^ decryptParams.array[i5]);
        }
        byte[] bArrDoFinalWithPadding = null;
        try {
            Cipher cipherDoInit = doInit(bArr2, bArr4);
            bArrDoFinalWithPadding = doFinalWithPadding(bArr, i2, i3, cipherDoInit);
            this.cipherPool.offerCipher(cipherDoInit);
        } catch (Exception e2) {
            logger.error(e2);
            if (logger.isDebugEnabled()) {
                e2.printStackTrace();
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Encryption finished.");
        }
        return bArrDoFinalWithPadding;
    }

    @Override // org.snmp4j.security.PrivacyProtocol
    public byte[] extendShortKey(byte[] bArr, OctetString octetString, byte[] bArr2, AuthenticationProtocol authenticationProtocol) {
        int length = bArr.length;
        byte[] bArr3 = new byte[getMinKeyLength()];
        System.arraycopy(bArr, 0, bArr3, 0, bArr.length);
        byte[] bArrPasswordToKey = new byte[getMinKeyLength()];
        System.arraycopy(bArr, 0, bArrPasswordToKey, 0, bArr.length);
        while (length < getMinKeyLength()) {
            bArrPasswordToKey = authenticationProtocol.passwordToKey(new OctetString(bArrPasswordToKey, 0, length), bArr2);
            int iMin = Math.min(getMinKeyLength() - length, authenticationProtocol.getDigestLength());
            System.arraycopy(bArrPasswordToKey, 0, bArr3, length, iMin);
            length += iMin;
        }
        return bArr3;
    }

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

    @Override // org.snmp4j.security.PrivacyProtocol
    public int getEncryptedLength(int i2) {
        return i2 % 8 == 0 ? i2 : ((i2 / 8) + 1) * 8;
    }

    @Override // org.snmp4j.security.PrivacyProtocol, org.snmp4j.security.SecurityProtocol
    public OID getID() {
        return (OID) ID.clone();
    }

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

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