Java AESFastEngine类代码示例

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
public CipherWriteStreamValidation(byte[] secretBytes, byte[] salt) {
    this.salt = salt.clone();
    secretBytes = secretBytes.clone();
    if (secretBytes.length != KEY_SIZE_BYTES) {
        secretBytes = Hashing.sha256().hashBytes(secretBytes).asBytes();
    }
    try {
        KeyParameter key = new KeyParameter(secretBytes);
        AEADParameters params = new AEADParameters(key, MAC_SIZE_BITS, this.salt);

        this.encryptor = new GCMBlockCipher(new AESFastEngine());
        this.encryptor.init(true, params);

        this.decryptor = new GCMBlockCipher(new AESFastEngine());
        this.decryptor.init(false, params);

    } catch (Exception e) {
        throw new RuntimeException("could not create cipher for AES256", e);
    } finally {
        Arrays.fill(secretBytes, (byte) 0);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
@Override
protected StreamCipher getCipher() {
    String method = getMethod();
    AESFastEngine engine = new AESFastEngine();

    switch (method) {
        case CIPHER_AES_128_CFB:
        case CIPHER_AES_192_CFB:
        case CIPHER_AES_256_CFB:
            return new CFBBlockCipher(engine, 128);
        case CIPHER_AES_128_CFB8:
        case CIPHER_AES_192_CFB8:
        case CIPHER_AES_256_CFB8:
            return new CFBBlockCipher(engine, 8);
        case CIPHER_AES_128_OFB:
        case CIPHER_AES_192_OFB:
        case CIPHER_AES_256_OFB:
            return new OFBBlockCipher(engine, 128);
        default:
            throw new IllegalArgumentException(method);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
private byte[] encryptOrDecrypt(byte[] key, byte[] contents, boolean forEncryption) {

        // Credstash uses standard AES
        BlockCipher engine = new AESFastEngine();

        // Credstash uses CTR mode
        StreamBlockCipher cipher = new SICBlockCipher(engine);

        cipher.init(forEncryption, new ParametersWithIV(new KeyParameter(key), INITIALIZATION_VECTOR));

        byte[] resultBytes = new byte[contents.length];
        int contentsOffset = 0;
        int resultOffset = 0;
        cipher.processBytes(contents, contentsOffset, contents.length, resultBytes, resultOffset);
        return resultBytes;
    }
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
static Wrapper createWrapper(int encAlgorithm)
    throws PGPException
{
    switch (encAlgorithm)
    {
    case SymmetricKeyAlgorithmTags.AES_128:
    case SymmetricKeyAlgorithmTags.AES_192:
    case SymmetricKeyAlgorithmTags.AES_256:
        return new RFC3394WrapEngine(new AESFastEngine());
    case SymmetricKeyAlgorithmTags.CAMELLIA_128:
    case SymmetricKeyAlgorithmTags.CAMELLIA_192:
    case SymmetricKeyAlgorithmTags.CAMELLIA_256:
        return new RFC3394WrapEngine(new CamelliaEngine());
    default:
        throw new PGPException("unknown wrap algorithm: " + encAlgorithm);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
public void performTest()
{
    for (int i = 0; i < TEST_VECTORS.length; i++)
    {
        TestCase testCase = TEST_VECTORS[i];

        Mac mac = new GMac(new GCMBlockCipher(new AESFastEngine()), testCase.getTag().length * 8);
        CipherParameters key = new KeyParameter(testCase.getKey());
        mac.init(new ParametersWithIV(key, testCase.getIv()));

        testSingleByte(mac, testCase);
        testMultibyte(mac, testCase);
    }

    // Invalid mac size
    testInvalidMacSize(97);
    testInvalidMacSize(136);
    testInvalidMacSize(24);
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
private void testInvalidMacSize(int size)
{
    try
    {
        GMac mac = new GMac(new GCMBlockCipher(new AESFastEngine()), size);
        mac.init(new ParametersWithIV(null, new byte[16]));
        fail("Expected failure for illegal mac size " + size);
    }
    catch (IllegalArgumentException e)
    {
        if (!e.getMessage().startsWith("Invalid value for MAC size"))
        {
            fail("Illegal mac size failed with unexpected message");
        }
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
public SAES256v01(byte[] secretBytes, byte[] salt) {
    this.salt = salt.clone();
    secretBytes = secretBytes.clone();
    if (secretBytes.length != KEY_SIZE_BYTES) {
        secretBytes = Hashing.sha256().hashBytes(secretBytes).asBytes();
    }
    try {
        KeyParameter key = new KeyParameter(secretBytes);
        AEADParameters params = new AEADParameters(key, MAC_SIZE_BITS, this.salt);

        this.encryptor = new GCMBlockCipher(new AESFastEngine());
        this.encryptor.init(true, params);

        this.decryptor = new GCMBlockCipher(new AESFastEngine());
        this.decryptor.init(false, params);

    } catch (Exception e) {
        throw new RuntimeException("could not create cipher for AES256", e);
    } finally {
        Arrays.fill(secretBytes, (byte) 0);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
private void initCiphers(byte[] key, byte[] iv) {

		// get the keyBytes
		keyBytes = new byte[key.length];
		System.arraycopy(key, 0, keyBytes, 0, key.length);

		keyP = new KeyParameter(keyBytes);

		// get the IV
		IV = new byte[blockSize];
		System.arraycopy(iv, 0, IV, 0, IV.length);

		// create the ciphers
		// AES block cipher in CBC mode with ISO7816d4 padding
		encryptCipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(
				new AESFastEngine()), new ISO7816d4Padding());

		decryptCipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(
				new AESFastEngine()), new ISO7816d4Padding());

		// create the IV parameter
		ParametersWithIV parameterIV = new ParametersWithIV(keyP, IV);

		encryptCipher.init(true, parameterIV);
		decryptCipher.init(false, parameterIV);
	}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
@Override
public byte[] getMAC(byte[] data) {

	byte[] n = new byte[sscBytes.length + data.length];
	System.arraycopy(sscBytes, 0, n, 0, sscBytes.length);
	System.arraycopy(data, 0, n, sscBytes.length, data.length);
	n = addPadding(n);

	BlockCipher cipher = new AESFastEngine();
	Mac mac = new CMac(cipher, 64);

	mac.init(keyP);
	mac.update(n, 0, n.length);
	byte[] out = new byte[mac.getMacSize()];

	mac.doFinal(out, 0);

	return out;
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
private AesKeyId genKeyId() {
    try {
        final GCMBlockCipher gcm = new GCMBlockCipher(new AESFastEngine());
        gcm.init(true, new AEADParameters(
            new KeyParameter(key), 128, KEYID_AD, KEYID_AD));
        final byte[] ciphertext = new byte[gcm.getOutputSize(ZERO_BYTES.length)];
        final int resp = gcm.processBytes(ZERO_BYTES, 0, ZERO_BYTES.length,
            ciphertext, 0);
        gcm.doFinal(ciphertext, resp);
        return new AesKeyId(ciphertext);
    } catch (final InvalidCipherTextException e) {
        // Should be impossible when we're encrypting!
        throw new RuntimeException(
            "Unexpected behaviour in crypto libraries", e);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
public SequenceItem decrypt(final ConverterCatalog r, final AesPacket packet)
    throws InvalidInputException {
    final GCMBlockCipher gcm = new GCMBlockCipher(new AESFastEngine());
    gcm.init(false, new AEADParameters(
        new KeyParameter(key), 128, packet.nonce, ZERO_BYTES));
    final byte[] newtext = new byte[
        gcm.getOutputSize(packet.ciphertext.length)];
    final int pp = gcm.processBytes(packet.ciphertext, 0,
        packet.ciphertext.length, newtext, 0);
    try {
        gcm.doFinal(newtext, pp);
    } catch (final InvalidCipherTextException e) {
        throw new CryptographyException(e);
    }
    return ConvertUtils.fromBytes(r, SequenceItem.class, newtext);
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
public static byte[] decrypt(byte[] key, byte[] data) {
    // TODO utilize GCMAES#decrypt method
    try {
        if (data.length < NONCE_LENGTH + TAG_LENGTH) {
            throw new IllegalArgumentException("data packet too short");
        }

        int cipherTextLength = data.length - NONCE_LENGTH - TAG_LENGTH;

        byte[] nonce = Arrays.copyOf(data, NONCE_LENGTH);

        GCMBlockCipher cipher = new GCMBlockCipher(new AESFastEngine());
        AEADParameters parameters = new AEADParameters(new KeyParameter(key), TAG_LENGTH * 8, nonce);
        cipher.init(false, parameters);

        byte[] out = new byte[cipher.getOutputSize(cipherTextLength + TAG_LENGTH)];

        int pos = cipher.processBytes(data, NONCE_LENGTH, data.length - NONCE_LENGTH, out, 0);
        pos += cipher.doFinal(out, pos);

        return Arrays.copyOf(out, pos);

    } catch (IllegalStateException | InvalidCipherTextException ex) {
        throw new IllegalArgumentException(ex);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
public static byte[] decryptAESCBC(byte[] key, byte[] iv, byte[] data) {
    // AES CBC PKCS7 decrypt
    try {
        CipherParameters cipherParameters = new ParametersWithIV(new KeyParameter(key), iv);
        PaddedBufferedBlockCipher cipher
                = new PaddedBufferedBlockCipher(new CBCBlockCipher(new AESFastEngine()), new PKCS7Padding());
        cipher.init(false, cipherParameters);

        byte[] buffer = new byte[cipher.getOutputSize(data.length)];

        int pos = cipher.processBytes(data, 0, data.length, buffer, 0);
        pos += cipher.doFinal(buffer, pos);

        return Arrays.copyOf(buffer, pos);

    } catch (DataLengthException | IllegalStateException | InvalidCipherTextException ex) {
        throw new IllegalArgumentException("decrypt failed", ex);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
/**
 * Encrypt or decrypt data with AES256.
 *
 * @param data The data to encrypt.
 * @param output The output to write the encrypted data to.
 *
 * @throws IOException If there is an error reading the data.
 */
private void decryptDataAES256(InputStream data, OutputStream output) throws IOException
{
    byte[] iv = new byte[16];

    // read IV from stream
    int ivSize = data.read(iv);
    if (ivSize == -1)
    {
        return;
    }

    if (ivSize != iv.length)
    {
        throw new IOException("AES initialization vector not fully read: only " + ivSize
                + " bytes read instead of " + iv.length);
    }
    PaddedBufferedBlockCipher cipher = new PaddedBufferedBlockCipher(
            new CBCBlockCipher(new AESFastEngine()));
    cipher.init(false, new ParametersWithIV(new KeyParameter(encryptionKey), iv));
    try (CipherInputStream cis = new CipherInputStream(data, cipher))
    {
        org.apache.commons.io.IOUtils.copy(cis, output);
    }
}
 

import org.bouncycastle.crypto.engines.AESFastEngine; //导入依赖的package包/类
public static void main(String[] args)
        throws InterruptedException, IOException
    {
//        testTF_1024_1();
//        testTF_1024_2();
        testTF_512_1();
        testTF_512_2();
//        testTF_256_1();
//        testTF_256_2();
        System.out.println("Initialising test data.");
        byte[] input = new byte[DATA_SIZE];
        rand.nextBytes(input);

        System.out.println("Init complete.");
//        speedTestCipher(new ThreefishEngine(ThreefishEngine.BLOCKSIZE_256), input);
        speedTestCipher(new ThreefishEngine(ThreefishEngine.BLOCKSIZE_512), input);
//        speedTestCipher(new Skein3FishEngine(), input);
//        speedTestCipher(new ThreefishEngine(ThreefishEngine.BLOCKSIZE_1024), input);
//        speedTestCipher(new ThreefishReferenceEngine(), input);
        speedTestCipher(new AESFastEngine(), input);
//        speedTestCipher(new TwofishEngine(), input);
//        speedTestCipher(new BlowfishEngine(), input);
    }