Java KeyParameter.getKey方法代码示例

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
static AlgorithmIdentifier determineKeyEncAlg(KeyParameter key)
{
    int length = key.getKey().length * 8;
    ASN1ObjectIdentifier wrapOid;

    if (length == 128)
    {
        wrapOid = NISTObjectIdentifiers.id_aes128_wrap;
    }
    else if (length == 192)
    {
        wrapOid = NISTObjectIdentifiers.id_aes192_wrap;
    }
    else if (length == 256)
    {
        wrapOid = NISTObjectIdentifiers.id_aes256_wrap;
    }
    else
    {
        throw new IllegalArgumentException("illegal keysize in AES");
    }

    return new AlgorithmIdentifier(wrapOid); // parameters absent
}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
static AlgorithmIdentifier determineKeyEncAlg(KeyParameter key)
{
    int length = key.getKey().length * 8;
    ASN1ObjectIdentifier wrapOid;

    if (length == 128)
    {
        wrapOid = NTTObjectIdentifiers.id_camellia128_wrap;
    }
    else if (length == 192)
    {
        wrapOid = NTTObjectIdentifiers.id_camellia192_wrap;
    }
    else if (length == 256)
    {
        wrapOid = NTTObjectIdentifiers.id_camellia256_wrap;
    }
    else
    {
        throw new IllegalArgumentException(
            "illegal keysize in Camellia");
    }

    return new AlgorithmIdentifier(wrapOid); // parameters must be
    // absent
}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
public void init(CipherParameters params)
    throws IllegalArgumentException
{
    if (!(params instanceof KeyParameter))
    {
        throw new IllegalArgumentException("'params' must be an instance of KeyParameter");
    }
    KeyParameter keyParameter = (KeyParameter)params;
    byte[] key = keyParameter.getKey();
    if (key.length != 16)
    {
        throw new IllegalArgumentException("'params' must be a 128-bit key");
    }

    this.k0 = Pack.littleEndianToLong(key, 0);
    this.k1 = Pack.littleEndianToLong(key, 8);

    reset();
}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
/**
 * initialise a Salsa20 cipher.
 *
 * @param forEncryption whether or not we are for encryption.
 * @param params the parameters required to set up the cipher.
 * @exception IllegalArgumentException if the params argument is
 * inappropriate.
 */
public void init(
    boolean             forEncryption, 
    CipherParameters     params)
{
    /* 
    * Salsa20 encryption and decryption is completely
    * symmetrical, so the 'forEncryption' is 
    * irrelevant. (Like 90% of stream ciphers)
    */

    if (!(params instanceof ParametersWithIV))
    {
        throw new IllegalArgumentException("Salsa20 Init parameters must include an IV");
    }

    ParametersWithIV ivParams = (ParametersWithIV) params;

    byte[] iv = ivParams.getIV();

    if (iv == null || iv.length != 8)
    {
        throw new IllegalArgumentException("Salsa20 requires exactly 8 bytes of IV");
    }

    if (!(ivParams.getParameters() instanceof KeyParameter))
    {
        throw new IllegalArgumentException("Salsa20 Init parameters must include a key");
    }

    KeyParameter key = (KeyParameter) ivParams.getParameters();

    workingKey = key.getKey();
    workingIV = iv;

    setKey(workingKey, workingIV);
}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
/**
 * initialise a VMPC cipher.
 * 
 * @param forEncryption
 *    whether or not we are for encryption.
 * @param params
 *    the parameters required to set up the cipher.
 * @exception IllegalArgumentException
 *    if the params argument is inappropriate.
 */
public void init(boolean forEncryption, CipherParameters params)
{
    if (!(params instanceof ParametersWithIV))
    {
        throw new IllegalArgumentException(
            "VMPC init parameters must include an IV");
    }

    ParametersWithIV ivParams = (ParametersWithIV) params;
    KeyParameter key = (KeyParameter) ivParams.getParameters();

    if (!(ivParams.getParameters() instanceof KeyParameter))
    {
        throw new IllegalArgumentException(
            "VMPC init parameters must include a key");
    }

    this.workingIV = ivParams.getIV();

    if (workingIV == null || workingIV.length < 1 || workingIV.length > 768)
    {
        throw new IllegalArgumentException("VMPC requires 1 to 768 bytes of IV");
    }

    this.workingKey = key.getKey();

    initKey(this.workingKey, this.workingIV);
}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
public void init(CipherParameters params) throws IllegalArgumentException
{
    if (!(params instanceof ParametersWithIV))
    {
        throw new IllegalArgumentException(
            "VMPC-MAC Init parameters must include an IV");
    }

    ParametersWithIV ivParams = (ParametersWithIV) params;
    KeyParameter key = (KeyParameter) ivParams.getParameters();

    if (!(ivParams.getParameters() instanceof KeyParameter))
    {
        throw new IllegalArgumentException(
            "VMPC-MAC Init parameters must include a key");
    }

    this.workingIV = ivParams.getIV();

    if (workingIV == null || workingIV.length < 1 || workingIV.length > 768)
    {
        throw new IllegalArgumentException(
            "VMPC-MAC requires 1 to 768 bytes of IV");
    }

    this.workingKey = key.getKey();

    reset();

}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
private static byte[] SingleIterationPBKDF2(byte[] P, byte[] S, int dkLen)
{
    PBEParametersGenerator pGen = new PKCS5S2ParametersGenerator(new SHA256Digest());
    pGen.init(P, S, 1);
    KeyParameter key = (KeyParameter) pGen.generateDerivedMacParameters(dkLen * 8);
    return key.getKey();
}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
/**
 * Initialize a Grain-128 cipher.
 *
 * @param forEncryption Whether or not we are for encryption.
 * @param params        The parameters required to set up the cipher.
 * @throws IllegalArgumentException If the params argument is inappropriate.
 */
public void init(boolean forEncryption, CipherParameters params)
    throws IllegalArgumentException
{
    /**
     * Grain encryption and decryption is completely symmetrical, so the
     * 'forEncryption' is irrelevant.
     */
    if (!(params instanceof ParametersWithIV))
    {
        throw new IllegalArgumentException(
            "Grain-128 Init parameters must include an IV");
    }

    ParametersWithIV ivParams = (ParametersWithIV)params;

    byte[] iv = ivParams.getIV();

    if (iv == null || iv.length != 12)
    {
        throw new IllegalArgumentException(
            "Grain-128  requires exactly 12 bytes of IV");
    }

    if (!(ivParams.getParameters() instanceof KeyParameter))
    {
        throw new IllegalArgumentException(
            "Grain-128 Init parameters must include a key");
    }

    KeyParameter key = (KeyParameter)ivParams.getParameters();

    /**
     * Initialize variables.
     */
    workingIV = new byte[key.getKey().length];
    workingKey = new byte[key.getKey().length];
    lfsr = new int[STATE_SIZE];
    nfsr = new int[STATE_SIZE];
    out = new byte[4];

    System.arraycopy(iv, 0, workingIV, 0, iv.length);
    System.arraycopy(key.getKey(), 0, workingKey, 0, key.getKey().length);

    setKey(workingKey, workingIV);
    initGrain();
}
 

import org.bouncycastle.crypto.params.KeyParameter; //导入方法依赖的package包/类
/**
 * Initialize a Grain v1 cipher.
 *
 * @param forEncryption Whether or not we are for encryption.
 * @param params        The parameters required to set up the cipher.
 * @throws IllegalArgumentException If the params argument is inappropriate.
 */
public void init(boolean forEncryption, CipherParameters params)
    throws IllegalArgumentException
{
    /**
     * Grain encryption and decryption is completely symmetrical, so the
     * 'forEncryption' is irrelevant.
     */
    if (!(params instanceof ParametersWithIV))
    {
        throw new IllegalArgumentException(
            "Grain v1 Init parameters must include an IV");
    }

    ParametersWithIV ivParams = (ParametersWithIV)params;

    byte[] iv = ivParams.getIV();

    if (iv == null || iv.length != 8)
    {
        throw new IllegalArgumentException(
            "Grain v1 requires exactly 8 bytes of IV");
    }

    if (!(ivParams.getParameters() instanceof KeyParameter))
    {
        throw new IllegalArgumentException(
            "Grain v1 Init parameters must include a key");
    }

    KeyParameter key = (KeyParameter)ivParams.getParameters();

    /**
     * Initialize variables.
     */
    workingIV = new byte[key.getKey().length];
    workingKey = new byte[key.getKey().length];
    lfsr = new int[STATE_SIZE];
    nfsr = new int[STATE_SIZE];
    out = new byte[2];

    System.arraycopy(iv, 0, workingIV, 0, iv.length);
    System.arraycopy(key.getKey(), 0, workingKey, 0, key.getKey().length);

    setKey(workingKey, workingIV);
    initGrain();
}