/** * 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."); } }
/** * 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."); } }
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); } }
/** * 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."); } }
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()); } }
@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; }
/** * 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; }
/** * 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); }
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; }
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; }
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; }
public void init( KeyGenerationParameters param) { ECKeyGenerationParameters ecP = (ECKeyGenerationParameters)param; this.random = ecP.getRandom(); this.params = ecP.getDomainParameters(); }
protected SecretKey engineGenerateKey() { if (uninitialised) { engine.init(new KeyGenerationParameters(new SecureRandom(), defaultKeySize)); uninitialised = false; } return new SecretKeySpec(engine.generateKey(), algName); }
protected void engineInit( SecureRandom random) { if (random != null) { engine.init(new KeyGenerationParameters(random, defaultKeySize)); uninitialised = false; } }
private CipherKeyGenerator createCipherKeyGenerator(SecureRandom random, int keySize) { CipherKeyGenerator keyGen = new CipherKeyGenerator(); keyGen.init(new KeyGenerationParameters(random, keySize)); return keyGen; }
/** * 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(); }
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); }
