Java Wrapper.init方法代码示例

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
protected KeyParameter extractSecretKey(AlgorithmIdentifier keyEncryptionAlgorithm, AlgorithmIdentifier contentEncryptionAlgorithm, byte[] derivedKey, byte[] encryptedContentEncryptionKey)
    throws CMSException
{
    Wrapper keyEncryptionCipher = EnvelopedDataHelper.createRFC3211Wrapper(keyEncryptionAlgorithm.getAlgorithm());

    keyEncryptionCipher.init(false, new ParametersWithIV(new KeyParameter(derivedKey), ASN1OctetString.getInstance(keyEncryptionAlgorithm.getParameters()).getOctets()));

    try
    {
        return new KeyParameter(keyEncryptionCipher.unwrap(encryptedContentEncryptionKey, 0, encryptedContentEncryptionKey.length));
    }
    catch (InvalidCipherTextException e)
    {
        throw new CMSException("unable to unwrap key: " + e.getMessage(), e);
    }
}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
private void wrapAndUnwrap(byte[] kek, byte[] key, byte[] expected)
    throws Exception
{
    Wrapper wrapper = new AESWrapPadEngine();

    wrapper.init(true, new KeyParameter(kek));

    byte[] cipherText = wrapper.wrap(key, 0, key.length);
    if (!areEqual(cipherText, expected))
    {
        fail("Wrapped value does not match expected.");
    }
    wrapper.init(false, new KeyParameter(kek));
    byte[] plainText = wrapper.unwrap(cipherText, 0, cipherText.length);

    if (!areEqual(key, plainText))
    {
        fail("Unwrapped value does not match original.");
    }
}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
private void heapIssueTest()
{
	byte[] key = Hex.decode("d305ef52a6b9e72c810b821261d2d678");
	byte[] ciphertext = Hex.decode("d2b2906d209a46261d8f6794eca3179d");

	Wrapper aes = new AESWrapPadEngine();
	aes.init(false, new KeyParameter(key));
    try
    {
        byte[] result = aes.unwrap(ciphertext, 0, ciphertext.length);

        fail("incorrect pad not detected");
    }
    catch (InvalidCipherTextException e)
    {
        // ignore
    }
}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
public byte[] generateEncryptedBytes(AlgorithmIdentifier keyEncryptionAlgorithm, byte[] derivedKey, GenericKey contentEncryptionKey)
    throws CMSException
{
    byte[] contentEncryptionKeySpec = ((KeyParameter)CMSUtils.getBcKey(contentEncryptionKey)).getKey();
    Wrapper keyEncryptionCipher = EnvelopedDataHelper.createRFC3211Wrapper(keyEncryptionAlgorithm.getAlgorithm());

    keyEncryptionCipher.init(true, new ParametersWithIV(new KeyParameter(derivedKey), ASN1OctetString.getInstance(keyEncryptionAlgorithm.getParameters()).getOctets()));

    return keyEncryptionCipher.wrap(contentEncryptionKeySpec, 0, contentEncryptionKeySpec.length);
}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
private void wrapTest(
    int          id,
    BlockCipher  engine,
    byte[]       kek,
    byte[]       iv,
    SecureRandom rand,
    byte[]       in,
    byte[]       out)
    throws Exception
{
    Wrapper wrapper = new RFC3211WrapEngine(engine);

    wrapper.init(true, new ParametersWithRandom(new ParametersWithIV(new KeyParameter(kek), iv), rand));

    byte[]  cText = wrapper.wrap(in, 0, in.length);
    if (!Arrays.areEqual(cText, out))
    {
        fail("failed wrap test " + id  + " expected " + new String(Hex.encode(out)) + " got " + new String(Hex.encode(cText)));
    }

    wrapper.init(false, new ParametersWithIV(new KeyParameter(kek), iv));

    byte[]  pText = wrapper.unwrap(out, 0, out.length);
    if (!Arrays.areEqual(pText, in))
    {
        fail("rfailed unwrap test " + id  + " expected " + new String(Hex.encode(in)) + " got " + new String(Hex.encode(pText)));
    }
}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
private void testCorruption()
    throws InvalidCipherTextException
{
    byte[] kek = Hex.decode("D1DAA78615F287E6");
    byte[] iv = Hex.decode("EFE598EF21B33D6D");

    Wrapper wrapper = new RFC3211WrapEngine(new DESEngine());

    wrapper.init(false, new ParametersWithIV(new KeyParameter(kek), iv));

    byte[] block = Hex.decode("ff739D838C627C897323A2F8C436F541");
    encryptBlock(kek, iv, block);

    try
    {
        wrapper.unwrap(block, 0, block.length);

        fail("bad length not detected");
    }
    catch (InvalidCipherTextException e)
    {
        if (!e.getMessage().equals("wrapped key corrupted"))
        {
            fail("wrong exception on length");
        }
    }

    block = Hex.decode("08639D838C627C897323A2F8C436F541");
    testChecksum(kek, iv, block, wrapper);

    block = Hex.decode("08736D838C627C897323A2F8C436F541");
    testChecksum(kek, iv, block, wrapper);
    
    block = Hex.decode("08739D638C627C897323A2F8C436F541");
    testChecksum(kek, iv, block, wrapper);
}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
public byte[] wrap(byte[] in, int inOff, int inLen)
{
    if (!forWrapping)
    {
        throw new IllegalStateException("not set for wrapping");
    }
    byte[] iv = new byte[8];

    // MLI = size of key to be wrapped
    byte[] mli = Pack.intToBigEndian(inLen);
    // copy in the fixed portion of the AIV
    System.arraycopy(preIV, 0, iv, 0, preIV.length);
    // copy in the MLI after the AIV
    System.arraycopy(mli, 0, iv, preIV.length, mli.length);

    // get the relevant plaintext to be wrapped
    byte[] relevantPlaintext = new byte[inLen];
    System.arraycopy(in, inOff, relevantPlaintext, 0, inLen);
    byte[] paddedPlaintext = padPlaintext(relevantPlaintext);

    if (paddedPlaintext.length == 8)
    {
        // if the padded plaintext contains exactly 8 octets,
        // then prepend iv and encrypt using AES in ECB mode.

        // prepend the IV to the plaintext
        byte[] paddedPlainTextWithIV = new byte[paddedPlaintext.length + iv.length];
        System.arraycopy(iv, 0, paddedPlainTextWithIV, 0, iv.length);
        System.arraycopy(paddedPlaintext, 0, paddedPlainTextWithIV, iv.length, paddedPlaintext.length);

        engine.init(true, param);
        for (int i = 0; i < paddedPlainTextWithIV.length; i += engine.getBlockSize())
        {
            engine.processBlock(paddedPlainTextWithIV, i, paddedPlainTextWithIV, i);
        }

        return paddedPlainTextWithIV;
    }
    else
    {
        // otherwise, apply the RFC 3394 wrap to
        // the padded plaintext with the new IV
        Wrapper wrapper = new RFC3394WrapEngine(engine);
        ParametersWithIV paramsWithIV = new ParametersWithIV(param, iv);
        wrapper.init(true, paramsWithIV);
        return wrapper.wrap(paddedPlaintext, 0, paddedPlaintext.length);
    }

}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
public void performTest()
    throws Exception
{
    // test RFC 5649 test vectors
    byte[] kek = Hex.decode("5840df6e29b02af1ab493b705bf16ea1ae8338f4dcc176a8");
    byte[] key = Hex.decode("c37b7e6492584340bed12207808941155068f738");
    byte[] wrap = Hex.decode("138bdeaa9b8fa7fc61f97742e72248ee5ae6ae5360d1ae6a5f54f373fa543b6a");

    wrapAndUnwrap(kek, key, wrap);

    wrap = Hex.decode("afbeb0f07dfbf5419200f2ccb50bb24f");
    key = Hex.decode("466f7250617369");
    wrapAndUnwrap(kek, key, wrap);


    //
    // offset test
    //
    Wrapper wrapper = new AESWrapPadEngine();

    byte[] pText = new byte[5 + key.length];
    byte[]  cText;

    System.arraycopy(key, 0, pText, 5, key.length);

    wrapper.init(true, new KeyParameter(kek));

    cText = wrapper.wrap(pText, 5, key.length);
    if (!Arrays.areEqual(cText, wrap))
    {
        fail("failed offset wrap test expected " + new String(Hex.encode(wrap)) + " got " + new String(Hex.encode(cText)));
    }

    wrapper.init(false, new KeyParameter(kek));

    cText = new byte[6 + wrap.length];
    System.arraycopy(wrap, 0, cText, 6, wrap.length);

    pText = wrapper.unwrap(cText, 6, wrap.length);
    if (!Arrays.areEqual(pText, key))
    {
        fail("failed offset unwrap test expected " + new String(Hex.encode(key)) + " got " + new String(Hex.encode(pText)));
    }

    // test random values
    SecureRandom rnd = new SecureRandom();
    for (int i = 0; i < numOfRandomIterations; i++)
    {
        int kekLength = 128;
        boolean shouldIncrease = (rnd.nextInt() & 0x01) != 0;
        if (shouldIncrease)
        {
            kekLength = 256;
        }
        kek = new byte[kekLength / 8];
        rnd.nextBytes(kek);
        int keyToWrapSize = RNGUtils.nextInt(rnd, 256 / 8 - 8) + 8;
        byte[] keyToWrap = new byte[keyToWrapSize];
        rnd.nextBytes(keyToWrap);
        wrapAndUnwrap(kek, keyToWrap);
    }
}
 

import org.bouncycastle.crypto.Wrapper; //导入方法依赖的package包/类
public byte[] wrap(byte[] in, int inOff, int inLen)
{
    if (!forWrapping)
    {
        throw new IllegalStateException("not set for wrapping");
    }
    byte[] iv = new byte[8];

    // MLI = size of key to be wrapped
    byte[] mli = Pack.intToBigEndian(inLen);
    // copy in the fixed portion of the AIV
    System.arraycopy(preIV, 0, iv, 0, preIV.length);
    // copy in the MLI after the AIV
    System.arraycopy(mli, 0, iv, preIV.length, mli.length);

    // get the relevant plaintext to be wrapped
    byte[] relevantPlaintext = new byte[inLen];
    System.arraycopy(in, inOff, relevantPlaintext, 0, inLen);
    byte[] paddedPlaintext = padPlaintext(relevantPlaintext);

    if (paddedPlaintext.length == 8)
    {
        // if the padded plaintext contains exactly 8 octets,
        // then prepend iv and encrypt using AES in ECB mode.

        // prepend the IV to the plaintext
        byte[] paddedPlainTextWithIV = new byte[paddedPlaintext.length + iv.length];
        System.arraycopy(iv, 0, paddedPlainTextWithIV, 0, iv.length);
        System.arraycopy(paddedPlaintext, 0, paddedPlainTextWithIV, iv.length, paddedPlaintext.length);

        engine.init(true, param);
        for (int i = 0; i < paddedPlainTextWithIV.length; i += engine.getBlockSize())
        {
            engine.processBlock(paddedPlainTextWithIV, i, paddedPlainTextWithIV, i);
        }

        return paddedPlainTextWithIV;
    }
    else
    {
        // otherwise, apply the RFC 3394 wrap to
        // the padded plaintext with the new IV
        Wrapper wrapper = new RFC3394WrapEngine(engine);
        ParametersWithIV paramsWithIV = new ParametersWithIV(param, iv);
        wrapper.init(true, paramsWithIV);
        return wrapper.wrap(paddedPlaintext, inOff, paddedPlaintext.length);
    }

}