package org.bouncycastle.jcajce.provider.symmetric.util; import com.google.android.gms.stats.CodePackage; import java.lang.reflect.Constructor; import java.nio.ByteBuffer; import java.security.AlgorithmParameters; import java.security.InvalidAlgorithmParameterException; import java.security.InvalidKeyException; import java.security.Key; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.security.spec.AlgorithmParameterSpec; import javax.crypto.BadPaddingException; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import javax.crypto.ShortBufferException; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.PBEParameterSpec; import javax.crypto.spec.RC2ParameterSpec; import javax.crypto.spec.RC5ParameterSpec; import org.bouncycastle.asn1.cms.GCMParameters; import org.bouncycastle.crypto.BlockCipher; import org.bouncycastle.crypto.BufferedBlockCipher; import org.bouncycastle.crypto.CipherParameters; import org.bouncycastle.crypto.DataLengthException; import org.bouncycastle.crypto.InvalidCipherTextException; import org.bouncycastle.crypto.OutputLengthException; import org.bouncycastle.crypto.modes.AEADBlockCipher; import org.bouncycastle.crypto.modes.CBCBlockCipher; import org.bouncycastle.crypto.modes.CCMBlockCipher; import org.bouncycastle.crypto.modes.CFBBlockCipher; import org.bouncycastle.crypto.modes.CTSBlockCipher; import org.bouncycastle.crypto.modes.EAXBlockCipher; import org.bouncycastle.crypto.modes.GCFBBlockCipher; import org.bouncycastle.crypto.modes.GCMBlockCipher; import org.bouncycastle.crypto.modes.GOFBBlockCipher; import org.bouncycastle.crypto.modes.OCBBlockCipher; import org.bouncycastle.crypto.modes.OFBBlockCipher; import org.bouncycastle.crypto.modes.OpenPGPCFBBlockCipher; import org.bouncycastle.crypto.modes.PGPCFBBlockCipher; import org.bouncycastle.crypto.modes.SICBlockCipher; import org.bouncycastle.crypto.paddings.BlockCipherPadding; import org.bouncycastle.crypto.paddings.ISO10126d2Padding; import org.bouncycastle.crypto.paddings.ISO7816d4Padding; import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher; import org.bouncycastle.crypto.paddings.TBCPadding; import org.bouncycastle.crypto.paddings.X923Padding; import org.bouncycastle.crypto.paddings.ZeroBytePadding; import org.bouncycastle.crypto.params.AEADParameters; import org.bouncycastle.crypto.params.ParametersWithIV; import org.bouncycastle.crypto.params.ParametersWithSBox; import org.bouncycastle.jcajce.spec.GOST28147ParameterSpec; import org.bouncycastle.util.Strings; /* loaded from: classes6.dex */ public class BaseBlockCipher extends BaseWrapCipher implements PBE { private static final Class gcmSpecClass = lookup("javax.crypto.spec.GCMParameterSpec"); private AEADParameters aeadParams; private Class[] availableSpecs; private BlockCipher baseEngine; private GenericBlockCipher cipher; private int digest; private BlockCipherProvider engineProvider; private boolean fixedIv; private int ivLength; private ParametersWithIV ivParam; private int keySizeInBits; private String modeName; private boolean padded; private String pbeAlgorithm; private PBEParameterSpec pbeSpec; private int scheme; /* JADX INFO: Access modifiers changed from: package-private */ /* loaded from: classes6.dex */ public interface GenericBlockCipher { int doFinal(byte[] bArr, int i) throws IllegalStateException, BadPaddingException; String getAlgorithmName(); int getOutputSize(int i); BlockCipher getUnderlyingCipher(); int getUpdateOutputSize(int i); void init(boolean z, CipherParameters cipherParameters) throws IllegalArgumentException; int processByte(byte b, byte[] bArr, int i) throws DataLengthException; int processBytes(byte[] bArr, int i, int i2, byte[] bArr2, int i3) throws DataLengthException; void updateAAD(byte[] bArr, int i, int i2); boolean wrapOnNoPadding(); } @Override // javax.crypto.CipherSpi protected void engineUpdateAAD(byte[] bArr, int i, int i2) { this.cipher.updateAAD(bArr, i, i2); } @Override // javax.crypto.CipherSpi protected void engineUpdateAAD(ByteBuffer byteBuffer) { engineUpdateAAD(byteBuffer.array(), byteBuffer.arrayOffset() + byteBuffer.position(), byteBuffer.limit() - byteBuffer.position()); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected byte[] engineUpdate(byte[] bArr, int i, int i2) { int updateOutputSize = this.cipher.getUpdateOutputSize(i2); if (updateOutputSize <= 0) { this.cipher.processBytes(bArr, i, i2, null, 0); return null; } byte[] bArr2 = new byte[updateOutputSize]; int processBytes = this.cipher.processBytes(bArr, i, i2, bArr2, 0); if (processBytes == 0) { return null; } if (processBytes == updateOutputSize) { return bArr2; } byte[] bArr3 = new byte[processBytes]; System.arraycopy(bArr2, 0, bArr3, 0, processBytes); return bArr3; } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected int engineUpdate(byte[] bArr, int i, int i2, byte[] bArr2, int i3) throws ShortBufferException { if (this.cipher.getUpdateOutputSize(i2) + i3 > bArr2.length) { throw new ShortBufferException("output buffer too short for input."); } try { return this.cipher.processBytes(bArr, i, i2, bArr2, i3); } catch (DataLengthException e) { throw new IllegalStateException(e.toString()); } } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected void engineSetPadding(String str) throws NoSuchPaddingException { BufferedGenericBlockCipher bufferedGenericBlockCipher; String upperCase = Strings.toUpperCase(str); if (upperCase.equals("NOPADDING")) { if (!this.cipher.wrapOnNoPadding()) { return; } else { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(new BufferedBlockCipher(this.cipher.getUnderlyingCipher())); } } else if (upperCase.equals("WITHCTS")) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(new CTSBlockCipher(this.cipher.getUnderlyingCipher())); } else { this.padded = true; if (isAEADModeName(this.modeName)) { throw new NoSuchPaddingException("Only NoPadding can be used with AEAD modes."); } if (upperCase.equals("PKCS5PADDING") || upperCase.equals("PKCS7PADDING")) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(this.cipher.getUnderlyingCipher()); } else if (upperCase.equals("ZEROBYTEPADDING")) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(this.cipher.getUnderlyingCipher(), new ZeroBytePadding()); } else if (upperCase.equals("ISO10126PADDING") || upperCase.equals("ISO10126-2PADDING")) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(this.cipher.getUnderlyingCipher(), new ISO10126d2Padding()); } else if (upperCase.equals("X9.23PADDING") || upperCase.equals("X923PADDING")) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(this.cipher.getUnderlyingCipher(), new X923Padding()); } else if (upperCase.equals("ISO7816-4PADDING") || upperCase.equals("ISO9797-1PADDING")) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(this.cipher.getUnderlyingCipher(), new ISO7816d4Padding()); } else { if (!upperCase.equals("TBCPADDING")) { StringBuilder sb = new StringBuilder("Padding "); sb.append(str); sb.append(" unknown."); throw new NoSuchPaddingException(sb.toString()); } bufferedGenericBlockCipher = new BufferedGenericBlockCipher(this.cipher.getUnderlyingCipher(), new TBCPadding()); } } this.cipher = bufferedGenericBlockCipher; } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected void engineSetMode(String str) throws NoSuchAlgorithmException { GenericBlockCipher aEADGenericBlockCipher; BufferedGenericBlockCipher bufferedGenericBlockCipher; BufferedGenericBlockCipher bufferedGenericBlockCipher2; String upperCase = Strings.toUpperCase(str); this.modeName = upperCase; if (upperCase.equals("ECB")) { this.ivLength = 0; aEADGenericBlockCipher = new BufferedGenericBlockCipher(this.baseEngine); } else if (this.modeName.equals("CBC")) { this.ivLength = this.baseEngine.getBlockSize(); aEADGenericBlockCipher = new BufferedGenericBlockCipher(new CBCBlockCipher(this.baseEngine)); } else { if (!this.modeName.startsWith("OFB")) { if (this.modeName.startsWith("CFB")) { this.ivLength = this.baseEngine.getBlockSize(); if (this.modeName.length() != 3) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(new CFBBlockCipher(this.baseEngine, Integer.parseInt(this.modeName.substring(3)))); } else { BlockCipher blockCipher = this.baseEngine; bufferedGenericBlockCipher2 = new BufferedGenericBlockCipher(new CFBBlockCipher(blockCipher, blockCipher.getBlockSize() << 3)); aEADGenericBlockCipher = bufferedGenericBlockCipher2; } } else if (this.modeName.startsWith("PGP")) { boolean equalsIgnoreCase = this.modeName.equalsIgnoreCase("PGPCFBwithIV"); this.ivLength = this.baseEngine.getBlockSize(); bufferedGenericBlockCipher = new BufferedGenericBlockCipher(new PGPCFBBlockCipher(this.baseEngine, equalsIgnoreCase)); } else if (this.modeName.equalsIgnoreCase("OpenPGPCFB")) { this.ivLength = 0; aEADGenericBlockCipher = new BufferedGenericBlockCipher(new OpenPGPCFBBlockCipher(this.baseEngine)); } else if (this.modeName.startsWith("SIC")) { int blockSize = this.baseEngine.getBlockSize(); this.ivLength = blockSize; if (blockSize < 16) { throw new IllegalArgumentException("Warning: SIC-Mode can become a twotime-pad if the blocksize of the cipher is too small. Use a cipher with a block size of at least 128 bits (e.g. AES)"); } this.fixedIv = false; aEADGenericBlockCipher = new BufferedGenericBlockCipher(new BufferedBlockCipher(new SICBlockCipher(this.baseEngine))); } else if (this.modeName.startsWith("CTR")) { this.ivLength = this.baseEngine.getBlockSize(); this.fixedIv = false; aEADGenericBlockCipher = new BufferedGenericBlockCipher(new BufferedBlockCipher(new SICBlockCipher(this.baseEngine))); } else if (this.modeName.startsWith("GOFB")) { this.ivLength = this.baseEngine.getBlockSize(); aEADGenericBlockCipher = new BufferedGenericBlockCipher(new BufferedBlockCipher(new GOFBBlockCipher(this.baseEngine))); } else if (this.modeName.startsWith("GCFB")) { this.ivLength = this.baseEngine.getBlockSize(); aEADGenericBlockCipher = new BufferedGenericBlockCipher(new BufferedBlockCipher(new GCFBBlockCipher(this.baseEngine))); } else if (this.modeName.startsWith("CTS")) { this.ivLength = this.baseEngine.getBlockSize(); aEADGenericBlockCipher = new BufferedGenericBlockCipher(new CTSBlockCipher(new CBCBlockCipher(this.baseEngine))); } else if (this.modeName.startsWith("CCM")) { this.ivLength = 13; aEADGenericBlockCipher = new AEADGenericBlockCipher(new CCMBlockCipher(this.baseEngine)); } else if (this.modeName.startsWith("OCB")) { if (this.engineProvider == null) { throw new NoSuchAlgorithmException("can't support mode ".concat(String.valueOf(str))); } this.ivLength = 15; aEADGenericBlockCipher = new AEADGenericBlockCipher(new OCBBlockCipher(this.baseEngine, this.engineProvider.get())); } else if (this.modeName.startsWith("EAX")) { this.ivLength = this.baseEngine.getBlockSize(); aEADGenericBlockCipher = new AEADGenericBlockCipher(new EAXBlockCipher(this.baseEngine)); } else { if (!this.modeName.startsWith(CodePackage.GCM)) { throw new NoSuchAlgorithmException("can't support mode ".concat(String.valueOf(str))); } this.ivLength = this.baseEngine.getBlockSize(); aEADGenericBlockCipher = new AEADGenericBlockCipher(new GCMBlockCipher(this.baseEngine)); } this.cipher = bufferedGenericBlockCipher; return; } this.ivLength = this.baseEngine.getBlockSize(); if (this.modeName.length() != 3) { bufferedGenericBlockCipher = new BufferedGenericBlockCipher(new OFBBlockCipher(this.baseEngine, Integer.parseInt(this.modeName.substring(3)))); this.cipher = bufferedGenericBlockCipher; return; } else { BlockCipher blockCipher2 = this.baseEngine; bufferedGenericBlockCipher2 = new BufferedGenericBlockCipher(new OFBBlockCipher(blockCipher2, blockCipher2.getBlockSize() << 3)); aEADGenericBlockCipher = bufferedGenericBlockCipher2; } } this.cipher = aEADGenericBlockCipher; } /* JADX WARN: Code restructure failed: missing block: B:146:0x01de, code lost: r21.ivParam = (org.bouncycastle.crypto.params.ParametersWithIV) r5; r5 = r5; */ /* JADX WARN: Code restructure failed: missing block: B:156:0x00d1, code lost: if (r7 != false) goto L95; */ /* JADX WARN: Code restructure failed: missing block: B:170:0x0120, code lost: if (r7 != false) goto L95; */ /* JADX WARN: Code restructure failed: missing block: B:210:0x01dc, code lost: if (r7 != false) goto L95; */ /* JADX WARN: Code restructure failed: missing block: B:25:0x0089, code lost: if (r7 != false) goto L95; */ /* JADX WARN: Multi-variable type inference failed */ /* JADX WARN: Removed duplicated region for block: B:45:0x03c7 */ /* JADX WARN: Removed duplicated region for block: B:60:0x040b */ /* JADX WARN: Removed duplicated region for block: B:65:0x0417 */ /* JADX WARN: Type inference failed for: r2v54, types: [org.bouncycastle.crypto.params.ParametersWithIV] */ /* JADX WARN: Type inference failed for: r5v0 */ /* JADX WARN: Type inference failed for: r5v12 */ /* JADX WARN: Type inference failed for: r5v15, types: [org.bouncycastle.crypto.params.RC5Parameters, org.bouncycastle.crypto.CipherParameters] */ /* JADX WARN: Type inference failed for: r5v16, types: [org.bouncycastle.crypto.params.RC2Parameters, org.bouncycastle.crypto.CipherParameters] */ /* JADX WARN: Type inference failed for: r5v17 */ /* JADX WARN: Type inference failed for: r5v18, types: [org.bouncycastle.crypto.params.ParametersWithSBox, org.bouncycastle.crypto.CipherParameters] */ /* JADX WARN: Type inference failed for: r5v19, types: [org.bouncycastle.crypto.CipherParameters] */ /* JADX WARN: Type inference failed for: r5v24, types: [org.bouncycastle.crypto.params.ParametersWithIV] */ /* JADX WARN: Type inference failed for: r5v25 */ /* JADX WARN: Type inference failed for: r5v44 */ /* JADX WARN: Type inference failed for: r5v45 */ /* JADX WARN: Type inference failed for: r5v46 */ /* JADX WARN: Type inference failed for: r5v47 */ /* JADX WARN: Type inference failed for: r5v48 */ /* JADX WARN: Type inference failed for: r5v49 */ /* JADX WARN: Type inference failed for: r5v9, types: [org.bouncycastle.crypto.CipherParameters] */ @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi /* Code decompiled incorrectly, please refer to instructions dump. To view partially-correct add '--show-bad-code' argument */ protected void engineInit(int r22, java.security.Key r23, java.security.spec.AlgorithmParameterSpec r24, java.security.SecureRandom r25) throws java.security.InvalidKeyException, java.security.InvalidAlgorithmParameterException { /* Method dump skipped, instructions count: 1139 To view this dump add '--comments-level debug' option */ throw new UnsupportedOperationException("Method not decompiled: org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.engineInit(int, java.security.Key, java.security.spec.AlgorithmParameterSpec, java.security.SecureRandom):void"); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected void engineInit(int i, Key key, SecureRandom secureRandom) throws InvalidKeyException { try { engineInit(i, key, (AlgorithmParameterSpec) null, secureRandom); } catch (InvalidAlgorithmParameterException e) { throw new InvalidKeyException(e.getMessage()); } } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected void engineInit(int i, Key key, AlgorithmParameters algorithmParameters, SecureRandom secureRandom) throws InvalidKeyException, InvalidAlgorithmParameterException { AlgorithmParameterSpec algorithmParameterSpec = null; if (algorithmParameters != null) { int i2 = 0; while (true) { Class[] clsArr = this.availableSpecs; if (i2 == clsArr.length) { break; } Class cls = clsArr[i2]; if (cls != null) { try { algorithmParameterSpec = algorithmParameters.getParameterSpec(cls); break; } catch (Exception unused) { continue; } } i2++; } if (algorithmParameterSpec == null) { StringBuilder sb = new StringBuilder("can't handle parameter "); sb.append(algorithmParameters.toString()); throw new InvalidAlgorithmParameterException(sb.toString()); } } engineInit(i, key, algorithmParameterSpec, secureRandom); this.engineParams = algorithmParameters; } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected AlgorithmParameters engineGetParameters() { if (this.engineParams == null) { if (this.pbeSpec != null) { try { this.engineParams = createParametersInstance(this.pbeAlgorithm); this.engineParams.init(this.pbeSpec); } catch (Exception unused) { return null; } } else if (this.ivParam != null) { String algorithmName = this.cipher.getUnderlyingCipher().getAlgorithmName(); if (algorithmName.indexOf(47) >= 0) { algorithmName = algorithmName.substring(0, algorithmName.indexOf(47)); } try { this.engineParams = createParametersInstance(algorithmName); this.engineParams.init(this.ivParam.getIV()); } catch (Exception e) { throw new RuntimeException(e.toString()); } } else if (this.aeadParams != null) { try { this.engineParams = createParametersInstance(CodePackage.GCM); this.engineParams.init(new GCMParameters(this.aeadParams.getNonce(), this.aeadParams.getMacSize() / 8).getEncoded()); } catch (Exception e2) { throw new RuntimeException(e2.toString()); } } } return this.engineParams; } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected int engineGetOutputSize(int i) { return this.cipher.getOutputSize(i); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected int engineGetKeySize(Key key) { return key.getEncoded().length << 3; } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected byte[] engineGetIV() { AEADParameters aEADParameters = this.aeadParams; if (aEADParameters != null) { return aEADParameters.getNonce(); } ParametersWithIV parametersWithIV = this.ivParam; if (parametersWithIV != null) { return parametersWithIV.getIV(); } return null; } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected int engineGetBlockSize() { return this.baseEngine.getBlockSize(); } /* loaded from: classes6.dex */ static class BufferedGenericBlockCipher implements GenericBlockCipher { private BufferedBlockCipher cipher; @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public boolean wrapOnNoPadding() { return !(this.cipher instanceof CTSBlockCipher); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public void updateAAD(byte[] bArr, int i, int i2) { throw new UnsupportedOperationException("AAD is not supported in the current mode."); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int processBytes(byte[] bArr, int i, int i2, byte[] bArr2, int i3) throws DataLengthException { return this.cipher.processBytes(bArr, i, i2, bArr2, i3); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int processByte(byte b, byte[] bArr, int i) throws DataLengthException { return this.cipher.processByte(b, bArr, i); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public void init(boolean z, CipherParameters cipherParameters) throws IllegalArgumentException { this.cipher.init(z, cipherParameters); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int getUpdateOutputSize(int i) { return this.cipher.getUpdateOutputSize(i); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public BlockCipher getUnderlyingCipher() { return this.cipher.getUnderlyingCipher(); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int getOutputSize(int i) { return this.cipher.getOutputSize(i); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public String getAlgorithmName() { return this.cipher.getUnderlyingCipher().getAlgorithmName(); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int doFinal(byte[] bArr, int i) throws IllegalStateException, BadPaddingException { try { return this.cipher.doFinal(bArr, i); } catch (InvalidCipherTextException e) { throw new BadPaddingException(e.getMessage()); } } BufferedGenericBlockCipher(BufferedBlockCipher bufferedBlockCipher) { this.cipher = bufferedBlockCipher; } BufferedGenericBlockCipher(BlockCipher blockCipher, BlockCipherPadding blockCipherPadding) { this.cipher = new PaddedBufferedBlockCipher(blockCipher, blockCipherPadding); } BufferedGenericBlockCipher(BlockCipher blockCipher) { this.cipher = new PaddedBufferedBlockCipher(blockCipher); } } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected byte[] engineDoFinal(byte[] bArr, int i, int i2) throws IllegalBlockSizeException, BadPaddingException { int engineGetOutputSize = engineGetOutputSize(i2); byte[] bArr2 = new byte[engineGetOutputSize]; int processBytes = i2 != 0 ? this.cipher.processBytes(bArr, i, i2, bArr2, 0) : 0; try { int doFinal = processBytes + this.cipher.doFinal(bArr2, processBytes); if (doFinal == engineGetOutputSize) { return bArr2; } byte[] bArr3 = new byte[doFinal]; System.arraycopy(bArr2, 0, bArr3, 0, doFinal); return bArr3; } catch (DataLengthException e) { throw new IllegalBlockSizeException(e.getMessage()); } } /* JADX INFO: Access modifiers changed from: package-private */ /* loaded from: classes6.dex */ public static class AEADGenericBlockCipher implements GenericBlockCipher { private static final Constructor aeadBadTagConstructor; private AEADBlockCipher cipher; @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public boolean wrapOnNoPadding() { return false; } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public void updateAAD(byte[] bArr, int i, int i2) { this.cipher.processAADBytes(bArr, i, i2); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int processBytes(byte[] bArr, int i, int i2, byte[] bArr2, int i3) throws DataLengthException { return this.cipher.processBytes(bArr, i, i2, bArr2, i3); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int processByte(byte b, byte[] bArr, int i) throws DataLengthException { return this.cipher.processByte(b, bArr, i); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public void init(boolean z, CipherParameters cipherParameters) throws IllegalArgumentException { this.cipher.init(z, cipherParameters); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int getUpdateOutputSize(int i) { return this.cipher.getUpdateOutputSize(i); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public BlockCipher getUnderlyingCipher() { return this.cipher.getUnderlyingCipher(); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int getOutputSize(int i) { return this.cipher.getOutputSize(i); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public String getAlgorithmName() { return this.cipher.getUnderlyingCipher().getAlgorithmName(); } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.GenericBlockCipher public int doFinal(byte[] bArr, int i) throws IllegalStateException, BadPaddingException { BadPaddingException badPaddingException; try { return this.cipher.doFinal(bArr, i); } catch (InvalidCipherTextException e) { Constructor constructor = aeadBadTagConstructor; if (constructor != null) { try { badPaddingException = (BadPaddingException) constructor.newInstance(e.getMessage()); } catch (Exception unused) { badPaddingException = null; } if (badPaddingException != null) { throw badPaddingException; } } throw new BadPaddingException(e.getMessage()); } } private static Constructor findExceptionConstructor(Class cls) { try { return cls.getConstructor(String.class); } catch (Exception unused) { return null; } } AEADGenericBlockCipher(AEADBlockCipher aEADBlockCipher) { this.cipher = aEADBlockCipher; } static { Class lookup = BaseBlockCipher.lookup("javax.crypto.AEADBadTagException"); aeadBadTagConstructor = lookup != null ? findExceptionConstructor(lookup) : null; } } @Override // org.bouncycastle.jcajce.provider.symmetric.util.BaseWrapCipher, javax.crypto.CipherSpi protected int engineDoFinal(byte[] bArr, int i, int i2, byte[] bArr2, int i3) throws IllegalBlockSizeException, BadPaddingException, ShortBufferException { int processBytes; if (engineGetOutputSize(i2) + i3 > bArr2.length) { throw new ShortBufferException("output buffer too short for input."); } if (i2 != 0) { try { processBytes = this.cipher.processBytes(bArr, i, i2, bArr2, i3); } catch (OutputLengthException e) { throw new IllegalBlockSizeException(e.getMessage()); } catch (DataLengthException e2) { throw new IllegalBlockSizeException(e2.getMessage()); } } else { processBytes = 0; } return processBytes + this.cipher.doFinal(bArr2, i3 + processBytes); } /* JADX INFO: Access modifiers changed from: private */ public static Class lookup(String str) { try { return BaseBlockCipher.class.getClassLoader().loadClass(str); } catch (Exception unused) { return null; } } private boolean isAEADModeName(String str) { return "CCM".equals(str) || "EAX".equals(str) || CodePackage.GCM.equals(str) || "OCB".equals(str); } /* JADX WARN: Multi-variable type inference failed */ private CipherParameters adjustParameters(AlgorithmParameterSpec algorithmParameterSpec, CipherParameters cipherParameters) { ParametersWithSBox parametersWithSBox; ParametersWithIV parametersWithIV; if (cipherParameters instanceof ParametersWithIV) { CipherParameters parameters = ((ParametersWithIV) cipherParameters).getParameters(); if (algorithmParameterSpec instanceof IvParameterSpec) { parametersWithIV = new ParametersWithIV(parameters, ((IvParameterSpec) algorithmParameterSpec).getIV()); } else { if (!(algorithmParameterSpec instanceof GOST28147ParameterSpec)) { return cipherParameters; } GOST28147ParameterSpec gOST28147ParameterSpec = (GOST28147ParameterSpec) algorithmParameterSpec; ParametersWithSBox parametersWithSBox2 = new ParametersWithSBox(cipherParameters, gOST28147ParameterSpec.getSbox()); if (gOST28147ParameterSpec.getIV() == null || this.ivLength == 0) { return parametersWithSBox2; } parametersWithIV = new ParametersWithIV(parameters, gOST28147ParameterSpec.getIV()); } this.ivParam = parametersWithIV; return parametersWithIV; } if (algorithmParameterSpec instanceof IvParameterSpec) { ParametersWithIV parametersWithIV2 = new ParametersWithIV(cipherParameters, ((IvParameterSpec) algorithmParameterSpec).getIV()); this.ivParam = parametersWithIV2; parametersWithSBox = parametersWithIV2; } else { if (!(algorithmParameterSpec instanceof GOST28147ParameterSpec)) { return cipherParameters; } GOST28147ParameterSpec gOST28147ParameterSpec2 = (GOST28147ParameterSpec) algorithmParameterSpec; ParametersWithSBox parametersWithSBox3 = new ParametersWithSBox(cipherParameters, gOST28147ParameterSpec2.getSbox()); parametersWithSBox = parametersWithSBox3; if (gOST28147ParameterSpec2.getIV() != null) { parametersWithSBox = parametersWithSBox3; if (this.ivLength != 0) { return new ParametersWithIV(parametersWithSBox3, gOST28147ParameterSpec2.getIV()); } } } return parametersWithSBox; } public BaseBlockCipher(BlockCipherProvider blockCipherProvider) { this.availableSpecs = new Class[]{RC2ParameterSpec.class, RC5ParameterSpec.class, gcmSpecClass, IvParameterSpec.class, PBEParameterSpec.class, GOST28147ParameterSpec.class}; this.scheme = -1; this.ivLength = 0; this.fixedIv = true; this.pbeSpec = null; this.pbeAlgorithm = null; this.modeName = null; this.baseEngine = blockCipherProvider.get(); this.engineProvider = blockCipherProvider; this.cipher = new BufferedGenericBlockCipher(blockCipherProvider.get()); } public BaseBlockCipher(AEADBlockCipher aEADBlockCipher, boolean z, int i) { this.availableSpecs = new Class[]{RC2ParameterSpec.class, RC5ParameterSpec.class, gcmSpecClass, IvParameterSpec.class, PBEParameterSpec.class, GOST28147ParameterSpec.class}; this.scheme = -1; this.ivLength = 0; this.fixedIv = true; this.pbeSpec = null; this.pbeAlgorithm = null; this.modeName = null; this.baseEngine = aEADBlockCipher.getUnderlyingCipher(); this.fixedIv = z; this.ivLength = i; this.cipher = new AEADGenericBlockCipher(aEADBlockCipher); } public BaseBlockCipher(AEADBlockCipher aEADBlockCipher) { this.availableSpecs = new Class[]{RC2ParameterSpec.class, RC5ParameterSpec.class, gcmSpecClass, IvParameterSpec.class, PBEParameterSpec.class, GOST28147ParameterSpec.class}; this.scheme = -1; this.ivLength = 0; this.fixedIv = true; this.pbeSpec = null; this.pbeAlgorithm = null; this.modeName = null; BlockCipher underlyingCipher = aEADBlockCipher.getUnderlyingCipher(); this.baseEngine = underlyingCipher; this.ivLength = underlyingCipher.getBlockSize(); this.cipher = new AEADGenericBlockCipher(aEADBlockCipher); } public BaseBlockCipher(BufferedBlockCipher bufferedBlockCipher, int i) { this.availableSpecs = new Class[]{RC2ParameterSpec.class, RC5ParameterSpec.class, gcmSpecClass, IvParameterSpec.class, PBEParameterSpec.class, GOST28147ParameterSpec.class}; this.scheme = -1; this.ivLength = 0; this.fixedIv = true; this.pbeSpec = null; this.pbeAlgorithm = null; this.modeName = null; this.baseEngine = bufferedBlockCipher.getUnderlyingCipher(); this.cipher = new BufferedGenericBlockCipher(bufferedBlockCipher); this.ivLength = i / 8; } public BaseBlockCipher(BlockCipher blockCipher, int i, int i2, int i3, int i4) { this.availableSpecs = new Class[]{RC2ParameterSpec.class, RC5ParameterSpec.class, gcmSpecClass, IvParameterSpec.class, PBEParameterSpec.class, GOST28147ParameterSpec.class}; this.fixedIv = true; this.pbeSpec = null; this.pbeAlgorithm = null; this.modeName = null; this.baseEngine = blockCipher; this.scheme = i; this.digest = i2; this.keySizeInBits = i3; this.ivLength = i4; this.cipher = new BufferedGenericBlockCipher(blockCipher); } public BaseBlockCipher(BlockCipher blockCipher, int i) { this.availableSpecs = new Class[]{RC2ParameterSpec.class, RC5ParameterSpec.class, gcmSpecClass, IvParameterSpec.class, PBEParameterSpec.class, GOST28147ParameterSpec.class}; this.scheme = -1; this.ivLength = 0; this.fixedIv = true; this.pbeSpec = null; this.pbeAlgorithm = null; this.modeName = null; this.baseEngine = blockCipher; this.cipher = new BufferedGenericBlockCipher(blockCipher); this.ivLength = i / 8; } public BaseBlockCipher(BlockCipher blockCipher) { this.availableSpecs = new Class[]{RC2ParameterSpec.class, RC5ParameterSpec.class, gcmSpecClass, IvParameterSpec.class, PBEParameterSpec.class, GOST28147ParameterSpec.class}; this.scheme = -1; this.ivLength = 0; this.fixedIv = true; this.pbeSpec = null; this.pbeAlgorithm = null; this.modeName = null; this.baseEngine = blockCipher; this.cipher = new BufferedGenericBlockCipher(blockCipher); } }