package org.snmp4j.security;

import com.seewo.sdk.model.SDKKeyboardCode;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.OctetString;

/* JADX INFO: loaded from: classes.dex */
public abstract class AuthGeneric implements AuthenticationProtocol {
    private int authenticationCodeLength;
    private final int digestLength;
    private final int hmacBlockSize;
    private final String protoName;
    private static final LogAdapter logger = LogFactory.getLogger(AuthGeneric.class);
    private static int HMAC_BLOCK_SIZE = 64;
    private static int DEFAULT_AUTHENTICATION_CODE_LENGTH = 12;

    public AuthGeneric(String str, int i2) {
        this.hmacBlockSize = HMAC_BLOCK_SIZE;
        this.authenticationCodeLength = DEFAULT_AUTHENTICATION_CODE_LENGTH;
        this.protoName = str;
        this.digestLength = i2;
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public boolean authenticate(byte[] bArr, byte[] bArr2, int i2, int i3, ByteArrayWindow byteArrayWindow) {
        MessageDigest digestObject = getDigestObject();
        int i4 = this.hmacBlockSize;
        byte[] bArr3 = new byte[i4];
        byte[] bArr4 = new byte[i4];
        for (int i5 = 0; i5 < this.authenticationCodeLength; i5++) {
            byteArrayWindow.set(i5, (byte) 0);
        }
        if (bArr.length > this.hmacBlockSize) {
            bArr = digestObject.digest(bArr);
        }
        for (int i6 = 0; i6 < bArr.length; i6++) {
            bArr3[i6] = (byte) (bArr[i6] ^ SDKKeyboardCode.FUNCTION_KEY_BOARD_COMMA);
            bArr4[i6] = (byte) (bArr[i6] ^ 92);
        }
        for (int length = bArr.length; length < this.hmacBlockSize; length++) {
            bArr3[length] = SDKKeyboardCode.FUNCTION_KEY_BOARD_COMMA;
            bArr4[length] = 92;
        }
        digestObject.update(bArr3);
        digestObject.update(bArr2, i2, i3);
        byte[] bArrDigest = digestObject.digest();
        digestObject.reset();
        digestObject.update(bArr4);
        digestObject.update(bArrDigest);
        byte[] bArrDigest2 = digestObject.digest();
        for (int i7 = 0; i7 < this.authenticationCodeLength; i7++) {
            byteArrayWindow.set(i7, bArrDigest2[i7]);
        }
        return true;
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public byte[] changeDelta(byte[] bArr, byte[] bArr2, byte[] bArr3) {
        MessageDigest digestObject = getDigestObject();
        int digestLength = digestObject.getDigestLength();
        if (logger.isDebugEnabled()) {
            logger.debug(this.protoName + "oldKey: " + new OctetString(bArr).toHexString());
            logger.debug(this.protoName + "newKey: " + new OctetString(bArr2).toHexString());
            logger.debug(this.protoName + "random: " + new OctetString(bArr3).toHexString());
        }
        int length = (bArr.length - 1) / digestObject.getDigestLength();
        OctetString octetString = new OctetString(bArr);
        OctetString octetString2 = new OctetString();
        for (int i2 = 0; i2 < length; i2++) {
            octetString.append(bArr3);
            digestObject.update(octetString.getValue());
            octetString.setValue(digestObject.digest());
            octetString2.append(new byte[digestLength]);
            for (int i3 = 0; i3 < digestLength; i3++) {
                int i4 = (i2 * digestLength) + i3;
                octetString2.set(i4, (byte) (octetString.get(i3) ^ bArr2[i4]));
            }
        }
        octetString.append(bArr3);
        digestObject.update(octetString.getValue());
        OctetString octetString3 = new OctetString(digestObject.digest(), 0, bArr.length - octetString2.length());
        for (int i5 = 0; i5 < octetString3.length(); i5++) {
            octetString3.set(i5, (byte) (octetString3.get(i5) ^ bArr2[(length * digestLength) + i5]));
        }
        byte[] bArr4 = new byte[bArr3.length + octetString2.length() + octetString3.length()];
        System.arraycopy(bArr3, 0, bArr4, 0, bArr3.length);
        System.arraycopy(octetString2.getValue(), 0, bArr4, bArr3.length, octetString2.length());
        System.arraycopy(octetString3.getValue(), 0, bArr4, bArr3.length + octetString2.length(), octetString3.length());
        if (logger.isDebugEnabled()) {
            logger.debug(this.protoName + "keyChange:" + new OctetString(bArr4).toHexString());
        }
        return bArr4;
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public int getAuthenticationCodeLength() {
        return this.authenticationCodeLength;
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public int getDigestLength() {
        return this.digestLength;
    }

    protected MessageDigest getDigestObject() {
        try {
            return MessageDigest.getInstance(this.protoName);
        } catch (NoSuchAlgorithmException unused) {
            throw new InternalError(this.protoName + " not supported in this VM.");
        }
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public byte[] hash(byte[] bArr) {
        MessageDigest digestObject = getDigestObject();
        digestObject.update(bArr);
        return digestObject.digest();
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public boolean isAuthentic(byte[] bArr, byte[] bArr2, int i2, int i3, ByteArrayWindow byteArrayWindow) {
        int i4 = this.authenticationCodeLength;
        ByteArrayWindow byteArrayWindow2 = new ByteArrayWindow(new byte[i4], 0, i4);
        System.arraycopy(byteArrayWindow.getValue(), byteArrayWindow.getOffset(), byteArrayWindow2.getValue(), 0, this.authenticationCodeLength);
        if (authenticate(bArr, bArr2, i2, i3, byteArrayWindow)) {
            return byteArrayWindow.equals(byteArrayWindow2, this.authenticationCodeLength);
        }
        return false;
    }

    @Override // org.snmp4j.security.SecurityProtocol
    public boolean isSupported() {
        try {
            MessageDigest.getInstance(this.protoName);
            return true;
        } catch (NoSuchAlgorithmException unused) {
            return false;
        }
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public byte[] passwordToKey(OctetString octetString, byte[] bArr) {
        MessageDigest digestObject = getDigestObject();
        byte[] bArr2 = new byte[this.hmacBlockSize];
        byte[] value = octetString.getValue();
        int i2 = 0;
        int i3 = 0;
        while (i2 < 1048576) {
            int i4 = 0;
            while (i4 < this.hmacBlockSize) {
                bArr2[i4] = value[i3 % value.length];
                i4++;
                i3++;
            }
            digestObject.update(bArr2);
            i2 += this.hmacBlockSize;
        }
        byte[] bArrDigest = digestObject.digest();
        if (logger.isDebugEnabled()) {
            logger.debug(this.protoName + "First digest: " + new OctetString(bArrDigest).toHexString());
        }
        digestObject.reset();
        digestObject.update(bArrDigest);
        digestObject.update(bArr);
        digestObject.update(bArrDigest);
        byte[] bArrDigest2 = digestObject.digest();
        if (logger.isDebugEnabled()) {
            logger.debug(this.protoName + "localized key: " + new OctetString(bArrDigest2).toHexString());
        }
        return bArrDigest2;
    }

    @Override // org.snmp4j.security.AuthenticationProtocol
    public byte[] hash(byte[] bArr, int i2, int i3) {
        MessageDigest digestObject = getDigestObject();
        digestObject.update(bArr, i2, i3);
        return digestObject.digest();
    }

    public AuthGeneric(String str, int i2, int i3) {
        this(str, i2);
        this.authenticationCodeLength = i3;
    }
}