标签:hal bad short not pack font hello adl var
- 折叠区的练习
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.sun.crypto.provider;
import java.nio.ByteBuffer;
import java.security.AlgorithmParameters;
import java.security.GeneralSecurityException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.ProviderException;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.BadPaddingException;
import javax.crypto.CipherSpi;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;
abstract class AESCipher extends CipherSpi {
private CipherCore core = null;
private final int fixedKeySize;
private boolean updateCalled;
static final void checkKeySize(Key key, int fixedKeySize) throws InvalidKeyException {
if (fixedKeySize != -1) {
if (key == null) {
throw new InvalidKeyException("The key must not be null");
}
byte[] value = key.getEncoded();
if (value == null) {
throw new InvalidKeyException("Key encoding must not be null");
}
if (value.length != fixedKeySize) {
throw new InvalidKeyException("The key must be " + fixedKeySize + " bytes");
}
}
}
protected AESCipher(int keySize) {
this.core = new CipherCore(new AESCrypt(), 16);
this.fixedKeySize = keySize;
}
protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
this.core.setMode(mode);
}
protected void engineSetPadding(String paddingScheme) throws NoSuchPaddingException {
this.core.setPadding(paddingScheme);
}
protected int engineGetBlockSize() {
return 16;
}
protected int engineGetOutputSize(int inputLen) {
return this.core.getOutputSize(inputLen);
}
protected byte[] engineGetIV() {
return this.core.getIV();
}
protected AlgorithmParameters engineGetParameters() {
return this.core.getParameters("AES");
}
protected void engineInit(int opmode, Key key, SecureRandom random) throws InvalidKeyException {
checkKeySize(key, this.fixedKeySize);
this.updateCalled = false;
this.core.init(opmode, key, random);
}
protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params, SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
checkKeySize(key, this.fixedKeySize);
this.updateCalled = false;
this.core.init(opmode, key, params, random);
}
protected void engineInit(int opmode, Key key, AlgorithmParameters params, SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
checkKeySize(key, this.fixedKeySize);
this.updateCalled = false;
this.core.init(opmode, key, params, random);
}
protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
this.updateCalled = true;
return this.core.update(input, inputOffset, inputLen);
}
protected int engineUpdate(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset) throws ShortBufferException {
this.updateCalled = true;
return this.core.update(input, inputOffset, inputLen, output, outputOffset);
}
protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen) throws IllegalBlockSizeException, BadPaddingException {
byte[] out = this.core.doFinal(input, inputOffset, inputLen);
this.updateCalled = false;
return out;
}
protected int engineDoFinal(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset) throws IllegalBlockSizeException, ShortBufferException, BadPaddingException {
int outLen = this.core.doFinal(input, inputOffset, inputLen, output, outputOffset);
this.updateCalled = false;
return outLen;
}
protected int engineGetKeySize(Key key) throws InvalidKeyException {
byte[] encoded = key.getEncoded();
if (!AESCrypt.isKeySizeValid(encoded.length)) {
throw new InvalidKeyException("Invalid AES key length: " + encoded.length + " bytes");
} else {
return Math.multiplyExact(encoded.length, 8);
}
}
protected byte[] engineWrap(Key key) throws IllegalBlockSizeException, InvalidKeyException {
return this.core.wrap(key);
}
protected Key engineUnwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType) throws InvalidKeyException, NoSuchAlgorithmException {
return this.core.unwrap(wrappedKey, wrappedKeyAlgorithm, wrappedKeyType);
}
protected void engineUpdateAAD(byte[] src, int offset, int len) {
if (this.core.getMode() == 7 && this.updateCalled) {
throw new IllegalStateException("AAD must be supplied before encryption/decryption starts");
} else {
this.core.updateAAD(src, offset, len);
}
}
protected void engineUpdateAAD(ByteBuffer src) {
if (this.core.getMode() == 7 && this.updateCalled) {
throw new IllegalStateException("AAD must be supplied before encryption/decryption starts");
} else {
if (src != null) {
int aadLen = src.limit() - src.position();
if (aadLen > 0) {
if (src.hasArray()) {
int aadOfs = Math.addExact(src.arrayOffset(), src.position());
this.core.updateAAD(src.array(), aadOfs, aadLen);
src.position(src.limit());
} else {
byte[] aad = new byte[aadLen];
src.get(aad);
this.core.updateAAD(aad, 0, aadLen);
}
}
}
}
}
public static final class AES256_GCM_NoPadding extends AESCipher.OidImpl {
public AES256_GCM_NoPadding() {
super(32, "GCM", "NOPADDING");
}
}
public static final class AES192_GCM_NoPadding extends AESCipher.OidImpl {
public AES192_GCM_NoPadding() {
super(24, "GCM", "NOPADDING");
}
}
public static final class AES128_GCM_NoPadding extends AESCipher.OidImpl {
public AES128_GCM_NoPadding() {
super(16, "GCM", "NOPADDING");
}
}
public static final class AES256_CFB_NoPadding extends AESCipher.OidImpl {
public AES256_CFB_NoPadding() {
super(32, "CFB", "NOPADDING");
}
}
public static final class AES192_CFB_NoPadding extends AESCipher.OidImpl {
public AES192_CFB_NoPadding() {
super(24, "CFB", "NOPADDING");
}
}
public static final class AES128_CFB_NoPadding extends AESCipher.OidImpl {
public AES128_CFB_NoPadding() {
super(16, "CFB", "NOPADDING");
}
}
public static final class AES256_OFB_NoPadding extends AESCipher.OidImpl {
public AES256_OFB_NoPadding() {
super(32, "OFB", "NOPADDING");
}
}
public static final class AES192_OFB_NoPadding extends AESCipher.OidImpl {
public AES192_OFB_NoPadding() {
super(24, "OFB", "NOPADDING");
}
}
public static final class AES128_OFB_NoPadding extends AESCipher.OidImpl {
public AES128_OFB_NoPadding() {
super(16, "OFB", "NOPADDING");
}
}
public static final class AES256_CBC_NoPadding extends AESCipher.OidImpl {
public AES256_CBC_NoPadding() {
super(32, "CBC", "NOPADDING");
}
}
public static final class AES192_CBC_NoPadding extends AESCipher.OidImpl {
public AES192_CBC_NoPadding() {
super(24, "CBC", "NOPADDING");
}
}
public static final class AES128_CBC_NoPadding extends AESCipher.OidImpl {
public AES128_CBC_NoPadding() {
super(16, "CBC", "NOPADDING");
}
}
public static final class AES256_ECB_NoPadding extends AESCipher.OidImpl {
public AES256_ECB_NoPadding() {
super(32, "ECB", "NOPADDING");
}
}
public static final class AES192_ECB_NoPadding extends AESCipher.OidImpl {
public AES192_ECB_NoPadding() {
super(24, "ECB", "NOPADDING");
}
}
public static final class AES128_ECB_NoPadding extends AESCipher.OidImpl {
public AES128_ECB_NoPadding() {
super(16, "ECB", "NOPADDING");
}
}
abstract static class OidImpl extends AESCipher {
protected OidImpl(int keySize, String mode, String padding) {
super(keySize);
try {
this.engineSetMode(mode);
this.engineSetPadding(padding);
} catch (GeneralSecurityException var6) {
ProviderException pe = new ProviderException("Internal Error");
pe.initCause(var6);
throw pe;
}
}
}
public static final class General extends AESCipher {
public General() {
super(-1);
}
}
}
标签:hal bad short not pack font hello adl var
原文地址:https://www.cnblogs.com/zhenqk/p/13053665.html