AES 256 CBC Decode

abstract class Encryptor {
    private final SecureRandom a = new SecureRandom();
    private int b;
    private SecretKey c;
 
    /* access modifiers changed from: 0000 */
    public abstract boolean a();
 
    Encryptor() {
    }
 
    /* access modifiers changed from: 0000 */
    public void a(SecretKey secretKey) {
        this.b = 16;
        this.c = secretKey;
    }
 
    private void b() throws GeneralSecurityException {
        if (this.c == null) {
            StringBuilder sb = new StringBuilder();
            sb.append(getClass().getSimpleName());
            sb.append(" did not initialize properly, check that the encryption key is correctly configured");
            throw new GeneralSecurityException(sb.toString());
        }
    }
 
    public byte[] a(byte[] bArr) throws GeneralSecurityException {
        b();
        byte[] bArr2 = new byte[this.b];
        this.a.nextBytes(bArr2);
        Cipher instance = Cipher.getInstance("AES/CBC/PKCS7Padding");
        instance.init(1, this.c, new IvParameterSpec(bArr2));
        byte[] doFinal = instance.doFinal(bArr);
        long j = 256;
        int i = 1;
        while (((long) bArr.length) >= j) {
            j *= 256;
            i++;
        }
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
            dataOutputStream.write(bArr2);
            dataOutputStream.writeByte(i);
            byte[] bArr3 = new byte[i];
            byte[] array = ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN).putLong((long) bArr.length).order(ByteOrder.LITTLE_ENDIAN).array();
            for (int i2 = 0; i2 < i; i2++) {
                bArr3[i2] = array[(array.length - 1) - i2];
            }
            dataOutputStream.write(bArr3);
            dataOutputStream.write(doFinal);
            byte[] byteArray = byteArrayOutputStream.toByteArray();
            if (a()) {
                a(byteArray, 4);
            }
            try {
                byteArrayOutputStream.close();
            } catch (IOException e) {
                Logger.a(getClass().getSimpleName(), (Throwable) e);
            }
            return byteArray;
        } catch (IOException e2) {
            throw new GeneralSecurityException(e2.getCause());
        } catch (Throwable th) {
            try {
                byteArrayOutputStream.close();
            } catch (IOException e3) {
                Logger.a(getClass().getSimpleName(), (Throwable) e3);
            }
            throw th;
        }
    }
 
    private void a(byte[] bArr, int i) {
        for (int i2 = i; i2 < bArr.length - 8; i2++) {
            bArr[i2] = (byte) (bArr[i2] ^ bArr[i2 % i]);
        }
    }
 
    public byte[] b(byte[] bArr) throws GeneralSecurityException {
        if (bArr.length < this.b + 1) {
            return null;
        }
        b();
        if (a()) {
            a(bArr, 4);
        }
        int i = this.b;
        int i2 = i + 1;
        byte b2 = bArr[i];
        int i3 = i2;
        int i4 = 0;
        while (i4 < b2) {
            int i5 = i3 + 1;
            byte b3 = bArr[i3];
            i4++;
            i3 = i5;
        }
        Cipher instance = Cipher.getInstance("AES/CBC/PKCS7Padding");
        instance.init(2, this.c, new IvParameterSpec(bArr, 0, this.b));
        return instance.doFinal(bArr, i3, bArr.length - i3);
    }
}
 
class HttpKey {
    static final byte[] a = {-56, 33, 18, 2, 17, -50, -88, -117, -14, -10, -106, 23, -77, -39, -23, -2};
}
 
    private HttpEncryptor() {
        a((SecretKey) new SecretKeySpec(HttpKey.a, "AES"));
    }