Java KeyGenerationParameters类代码示例

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
/**
 * Generate des key.
 *
 * @param file the file
 * @throws java.io.IOException Signals that an I/O exception has occurred.
 */
public static void generateDESKey(String file) throws IOException {
    DESedeKeyGenerator kg = new DESedeKeyGenerator();
    KeyGenerationParameters kgp = new KeyGenerationParameters(
            new SecureRandom(),
            DESedeParameters.DES_EDE_KEY_LENGTH * 8);
    kg.init(kgp);
    byte[] key = kg.generateKey();
    BufferedOutputStream keystream =
            new BufferedOutputStream(new FileOutputStream(file));
    byte[] keyhex = Hex.encode(key);
    keystream.write(keyhex, 0, keyhex.length);
    keystream.flush();
    keystream.close();
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
/**
 * initialise the key generator - if strength is set to zero
 * the key generated will be 192 bits in size, otherwise
 * strength can be 128 or 192 (or 112 or 168 if you don't count
 * parity bits), depending on whether you wish to do 2-key or 3-key
 * triple DES.
 *
 * @param param the parameters to be used for key generation
 */
public void init(
    KeyGenerationParameters param)
{
    this.random = param.getRandom();
    this.strength = (param.getStrength() + 7) / 8;

    if (strength == 0 || strength == (168 / 8))
    {
        strength = DESedeParameters.DES_EDE_KEY_LENGTH;
    }
    else if (strength == (112 / 8))
    {
        strength = 2 * DESedeParameters.DES_KEY_LENGTH;
    }
    else if (strength != DESedeParameters.DES_EDE_KEY_LENGTH
            && strength != (2 * DESedeParameters.DES_KEY_LENGTH))
    {
        throw new IllegalArgumentException("DESede key must be "
            + (DESedeParameters.DES_EDE_KEY_LENGTH * 8) + " or "
            + (2 * 8 * DESedeParameters.DES_KEY_LENGTH)
            + " bits long.");
    }
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
/**
 * initialise the key generator - if strength is set to zero
 * the key generated will be 64 bits in size, otherwise
 * strength can be 64 or 56 bits (if you don't count the parity bits).
 *
 * @param param the parameters to be used for key generation
 */
public void init(
    KeyGenerationParameters param)
{
    super.init(param);

    if (strength == 0 || strength == (56 / 8))
    {
        strength = DESParameters.DES_KEY_LENGTH;
    }
    else if (strength != DESParameters.DES_KEY_LENGTH)
    {
        throw new IllegalArgumentException("DES key must be "
                + (DESParameters.DES_KEY_LENGTH * 8)
                + " bits long.");
    }
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
protected SecretKey engineGenerateKey()
{
    if (uninitialised)
    {
        engine.init(new KeyGenerationParameters(new SecureRandom(), defaultKeySize));
        uninitialised = false;
    }

    //
    // if no key size has been defined generate a 24 byte key in
    // the a-b-a format
    //
    if (!keySizeSet)
    {
        byte[]     k = engine.generateKey();

        System.arraycopy(k, 0, k, 16, 8);

        return new SecretKeySpec(k, algName);
    }
    else
    {
        return new SecretKeySpec(engine.generateKey(), algName);
    }
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
/**
 * initialise the key generator - if strength is set to zero
 * the key generated will be 192 bits in size, otherwise
 * strength can be 128 or 192 (or 112 or 168 if you don't count
 * parity bits), depending on whether you wish to do 2-key or 3-key
 * triple DES.
 *
 * @param param the parameters to be used for key generation
 */
public void init(
    KeyGenerationParameters param)
{
    super.init(param);

    if (strength == 0 || strength == (168 / 8))
    {
        strength = DESedeParameters.DES_EDE_KEY_LENGTH;
    }
    else if (strength == (112 / 8))
    {
        strength = 2 * DESedeParameters.DES_KEY_LENGTH;
    }
    else if (strength != DESedeParameters.DES_EDE_KEY_LENGTH
            && strength != (2 * DESedeParameters.DES_KEY_LENGTH))
    {
        throw new IllegalArgumentException("DESede key must be "
            + (DESedeParameters.DES_EDE_KEY_LENGTH * 8) + " or "
            + (2 * 8 * DESedeParameters.DES_KEY_LENGTH)
            + " bits long.");
    }
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
public static KeyGenerator create() {
  final SecureRandom random = new SecureRandom();
  final KeyGenerationParameters parameters = new KeyGenerationParameters(
      random,
      DESedeParameters.DES_EDE_KEY_LENGTH * 8);
  final DESedeKeyGenerator keyGenerator = new DESedeKeyGenerator();
  keyGenerator.init(parameters);
  return new KeyGenerator(keyGenerator);
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
protected void engineInit(
    int             keySize,
    SecureRandom    random)
{
    try
    {
        if (random == null)
        {
            random = new SecureRandom();
        }
        engine.init(new KeyGenerationParameters(random, keySize));
        uninitialised = false;
    }
    catch (IllegalArgumentException e)
    {
        throw new InvalidParameterException(e.getMessage());
    }
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
@Override
public void init(final KeyGenerationParameters params)
{
	strength = 0;
	random = null;

	if (params != null) {
		strength = params.getStrength();
		random = params.getRandom();
	}

	if (strength < 1)
		strength = 256;

	if (random == null)
		random = new SecureRandom();

	strengthInBytes = (strength + 7) / 8;
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
/**
 * Initalizes the key pair generator using a parameter set as input
 */
public void initialize(KeyGenerationParameters param)
{

    this.gmssParams = (GMSSKeyGenerationParameters)param;

    // generate GMSSParameterset
    this.gmssPS = new GMSSParameters(gmssParams.getParameters().getNumOfLayers(), gmssParams.getParameters().getHeightOfTrees(),
        gmssParams.getParameters().getWinternitzParameter(), gmssParams.getParameters().getK());

    this.numLayer = gmssPS.getNumOfLayers();
    this.heightOfTrees = gmssPS.getHeightOfTrees();
    this.otsIndex = gmssPS.getWinternitzParameter();
    this.K = gmssPS.getK();

    // seeds
    this.currentSeeds = new byte[numLayer][mdLength];
    this.nextNextSeeds = new byte[numLayer - 1][mdLength];

    // construct SecureRandom for initial seed generation
    SecureRandom secRan = new SecureRandom();

    // generation of initial seeds
    for (int i = 0; i < numLayer; i++)
    {
        secRan.nextBytes(currentSeeds[i]);
        gmssRandom.nextSeed(currentSeeds[i]);
    }

    this.initialized = true;
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
/**
 * This method is called by generateKeyPair() in case that no other
 * initialization method has been called by the user
 */
private void initializeDefault()
{
    int[] defh = {10, 10, 10, 10};
    int[] defw = {3, 3, 3, 3};
    int[] defk = {2, 2, 2, 2};

    KeyGenerationParameters kgp = new GMSSKeyGenerationParameters(new SecureRandom(), new GMSSParameters(defh.length, defh, defw, defk));
    this.initialize(kgp);

}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
public void initialize(
    KeyGenerationParameters param)
{
    this.rainbowParams = (RainbowKeyGenerationParameters)param;

    // set source of randomness
    this.sr = new SecureRandom();

    // unmarshalling:
    this.vi = this.rainbowParams.getParameters().getVi();
    this.numOfLayers = this.rainbowParams.getParameters().getNumOfLayers();

    this.initialized = true;
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
private void initialize(
    KeyGenerationParameters param)
{
    this.mcElieceParams = (McElieceKeyGenerationParameters)param;

    // set source of randomness
    this.random = new SecureRandom();

    this.m = this.mcElieceParams.getParameters().getM();
    this.n = this.mcElieceParams.getParameters().getN();
    this.t = this.mcElieceParams.getParameters().getT();
    this.fieldPoly = this.mcElieceParams.getParameters().getFieldPoly();
    this.initialized = true;
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
public void init(
    KeyGenerationParameters param)
{
    this.mcElieceCCA2Params = (McElieceCCA2KeyGenerationParameters)param;

    // set source of randomness
    this.random = new SecureRandom();

    this.m = this.mcElieceCCA2Params.getParameters().getM();
    this.n = this.mcElieceCCA2Params.getParameters().getN();
    this.t = this.mcElieceCCA2Params.getParameters().getT();
    this.fieldPoly = this.mcElieceCCA2Params.getParameters().getFieldPoly();
    this.initialized = true;
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
public void init(
    KeyGenerationParameters param)
{
    ECKeyGenerationParameters  ecP = (ECKeyGenerationParameters)param;

    this.random = ecP.getRandom();
    this.params = ecP.getDomainParameters();
}
 

import org.bouncycastle.crypto.KeyGenerationParameters; //导入依赖的package包/类
protected SecretKey engineGenerateKey()
{
    if (uninitialised)
    {
        engine.init(new KeyGenerationParameters(new SecureRandom(), defaultKeySize));
        uninitialised = false;
    }

    return new SecretKeySpec(engine.generateKey(), algName);
}