Java AEADParameters类代码示例

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的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.params.AEADParameters; //导入依赖的package包/类
/**
 * Initialises the GMAC - requires a {@link ParametersWithIV} providing a {@link KeyParameter}
 * and a nonce.
 */
public void init(final CipherParameters params) throws IllegalArgumentException
{
    if (params instanceof ParametersWithIV)
    {
        final ParametersWithIV param = (ParametersWithIV)params;

        final byte[] iv = param.getIV();
        final KeyParameter keyParam = (KeyParameter)param.getParameters();

        // GCM is always operated in encrypt mode to calculate MAC
        cipher.init(true, new AEADParameters(keyParam, macSizeBits, iv));
    }
    else
    {
        throw new IllegalArgumentException("GMAC requires ParametersWithIV");
    }
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的package包/类
private void runTestCase(String testName, String[] testVector, int macLengthBits, byte[] K)
    throws InvalidCipherTextException
{
    int pos = 0;
    byte[] N = Hex.decode(testVector[pos++]);
    byte[] A = Hex.decode(testVector[pos++]);
    byte[] P = Hex.decode(testVector[pos++]);
    byte[] C = Hex.decode(testVector[pos++]);

    int macLengthBytes = macLengthBits / 8;

    KeyParameter keyParameter = new KeyParameter(K);
    AEADParameters parameters = new AEADParameters(keyParameter, macLengthBits, N, A);

    AEADBlockCipher encCipher = initOCBCipher(true, parameters);
    AEADBlockCipher decCipher = initOCBCipher(false, parameters);

    checkTestCase(encCipher, decCipher, testName, macLengthBytes, P, C);
    checkTestCase(encCipher, decCipher, testName + " (reused)", macLengthBytes, P, C);

    // Key reuse
    AEADParameters keyReuseParams = AEADTestUtil.reuseKey(parameters);
    encCipher.init(true, keyReuseParams);
    decCipher.init(false, keyReuseParams);
    checkTestCase(encCipher, decCipher, testName + " (key reuse)", macLengthBytes, P, C);
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的package包/类
private void doEax(byte[] key, byte[] iv, byte[] pt, byte[] aad, int tagLength, byte[] expected)
    throws InvalidCipherTextException
{
    EAXBlockCipher c = new EAXBlockCipher(new SerpentEngine());

    c.init(true, new AEADParameters(new KeyParameter(key), tagLength, iv, aad));

    byte[] out = new byte[expected.length];

    int len = c.processBytes(pt, 0, pt.length, out, 0);

    c.doFinal(out, len);

    if (!Arrays.areEqual(expected, out))
    {
        fail("EAX test failed");
    }
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的package包/类
private void runTestCase(
    GCMMultiplier   encM,
    GCMMultiplier   decM,
    String          testName,
    byte[]          K,
    byte[]          IV,
    byte[]          A,
    byte[]          SA,
    byte[]          P,
    byte[]          C,
    byte[]          T)
    throws InvalidCipherTextException
{
    AEADParameters parameters = new AEADParameters(new KeyParameter(K), T.length * 8, IV, A);
    GCMBlockCipher encCipher = initCipher(encM, true, parameters);
    GCMBlockCipher decCipher = initCipher(decM, false, parameters);
    checkTestCase(encCipher, decCipher, testName, SA, P, C, T);
    checkTestCase(encCipher, decCipher, testName + " (reused)", SA, P, C, T);

    // Key reuse
    AEADParameters keyReuseParams = AEADTestUtil.reuseKey(parameters);
    encCipher.init(true, keyReuseParams);
    decCipher.init(false, keyReuseParams);
    checkTestCase(encCipher, decCipher, testName + " (key reuse)", SA, P, C, T);
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的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.params.AEADParameters; //导入依赖的package包/类
public EAXEncryptStream(byte[] key, byte[] nonce, byte[] associatedData, OutputStream os)
{
	if(key.length != KEY_LENGTH_BYTES)
	{
		throw new IllegalArgumentException("key must be " + KEY_LENGTH_BYTES*8 + " bits");
	}
	
	this.cipher = new EAXBlockCipher(new AESEngine());
	this.os = os;
	
	keyParameter = new KeyParameter(key);
	AEADParameters par = new AEADParameters(keyParameter, EAXDecryptStream.MAC_LEN_BITS, nonce, associatedData);

	cipher.init(true, par);
	
	out = new byte[BUFFER_SIZE];
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的package包/类
public EAXDecryptStream(byte[] key, byte[] nonce, byte[] associatedData, InputStream in)
{
	if(key.length != KEY_LENGTH_BYTES)
	{
		throw new IllegalArgumentException("key must be " + KEY_LENGTH_BYTES*8 + " bits");
	}
	
	this.in = in;
	this.cipher = new EAXBlockCipher(new AESEngine());
	
	keyParameter = new KeyParameter(key);
	AEADParameters par = new AEADParameters(keyParameter, MAC_LEN_BITS, nonce, associatedData);

	cipher.init(false, par);

	out = new byte[BUFFER_SIZE];
	buf = new byte[BUFFER_SIZE];
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的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.params.AEADParameters; //导入依赖的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.params.AEADParameters; //导入依赖的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.params.AEADParameters; //导入依赖的package包/类
public static byte[] aesGcmEncrypt(Transformation transformation, byte[] raw, byte[] secret, int atLength, byte[] iv, byte[] aad) throws Exception {
	BlockCipher blockCipher = new AESEngine();
	blockCipher.init(true, new KeyParameter(new SecretKeySpec(secret, "AES").getEncoded()));

	GCMBlockCipher aGCMBlockCipher = new GCMBlockCipher(blockCipher);
	aGCMBlockCipher.init(true, new AEADParameters(new KeyParameter(secret), atLength, iv, aad));

	int len = aGCMBlockCipher.getOutputSize(raw.length);
	byte[] out = new byte[len];
	int outOff = aGCMBlockCipher.processBytes(raw, 0, raw.length, out, 0);
	aGCMBlockCipher.doFinal(out, outOff);

	return out;
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的package包/类
private void runTestCase(
    GCMMultiplier   encM,
    GCMMultiplier   decM,
    String          testName,
    byte[]          K,
    byte[]          IV,
    byte[]          A,
    byte[]          SA,
    byte[]          P,
    byte[]          C,
    byte[]          T)
    throws InvalidCipherTextException
{
    AEADParameters parameters = new AEADParameters(new KeyParameter(K), T.length * 8, IV, A);
    GCMBlockCipher encCipher = initCipher(encM, true, parameters);
    GCMBlockCipher decCipher = initCipher(decM, false, parameters);
    checkTestCase(encCipher, decCipher, testName, SA, P, C, T);
    checkTestCase(encCipher, decCipher, testName + " (reused)", SA, P, C, T);

    // Key reuse
    AEADParameters keyReuseParams = new AEADParameters(null, parameters.getMacSize(), parameters.getNonce(), parameters.getAssociatedText());
    encCipher.init(true, keyReuseParams);
    decCipher.init(false, keyReuseParams);
    checkTestCase(encCipher, decCipher, testName + " (key reuse)", SA, P, C, T);
    checkTestCase(encCipher, decCipher, testName + " (key reuse)", SA, P, C, T);
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的package包/类
/**
 * Given the IV, encrypt the provided data
 *
 * @param IV      initialization vector
 * @param message data to be encrypted
 * @return byte array with the cipher text
 * @throws RuntimeException
 */
public byte[] encrypt(final byte[] IV, final byte[] message) throws RuntimeException {

    AEADParameters aeadParams = new AEADParameters(
            new KeyParameter(key), TAG_LENGTH,
            IV,
            authData);

    cipher.init(true, aeadParams);
    byte[] cipherText = newBuffer(cipher.getOutputSize(message.length));
    int outputOffset = cipher.processBytes(message, 0, message.length, cipherText, 0);

    try {
        cipher.doFinal(cipherText, outputOffset);
    } catch (InvalidCipherTextException e) {
        throw new RuntimeException("Error: ", e);
    }

    return cipherText;
}
 

import org.bouncycastle.crypto.params.AEADParameters; //导入依赖的package包/类
/**
 * Given the IV, decrypt the provided data
 *
 * @param IV         initialization vector
 * @param cipherText data to be decrypted
 * @return byte array with the plain text
 * @throws RuntimeException
 */
public byte[] decrypt(byte[] IV, byte[] cipherText) throws RuntimeException {

    AEADParameters aeadParams = new AEADParameters(
            new KeyParameter(key), TAG_LENGTH,
            IV,
            authData);

    cipher.init(false, aeadParams);
    byte[] buffer = newByteArray(cipherText);
    byte[] plainText = newBuffer(cipher.getOutputSize(cipherText.length));
    int outputOffset = cipher.processBytes(buffer, 0, buffer.length, plainText, 0);

    try {
        cipher.doFinal(plainText, outputOffset);
    } catch (InvalidCipherTextException e) {
        throw new RuntimeException("Error: ", e);
    }

    return plainText;
}