private KeyPair generateKeyPair() { try { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(keyAlgorithm); keyPairGenerator.initialize(keySize, new SecureRandom()); return keyPairGenerator.generateKeyPair(); } catch (GeneralSecurityException e) { throw new AssertionError(e); } } }
/** * Generates a self-signed certificate. These are used to identify servers. * * @return A matched pair of public and private certificates. */ public CertificatePair generateSelfSigned() { keyPairGenerator.initialize(KEY_SIZE); KeyPair kp = keyPairGenerator.genKeyPair(); try { RSAPublicKeySpec pub = keyFactory.getKeySpec(kp.getPublic(), RSAPublicKeySpec.class); RSAPrivateKeySpec priv = keyFactory.getKeySpec(kp.getPrivate(), RSAPrivateKeySpec.class); String uuid = UUID.randomUUID().toString(); signer.initSign(kp.getPrivate(), new SecureRandom()); signer.update(uuid.getBytes(Charsets.UTF_8)); signer.update(pub.getModulus().toByteArray()); signer.update(pub.getPublicExponent().toByteArray()); byte[] rawSig = signer.sign(); BigInteger signature = new BigInteger(rawSig); PublicIdentityCertificate publicCert = new PublicIdentityCertificate(uuid, pub.getModulus(), pub.getPublicExponent(), signature); PrivateIdentityCertificate privateCert = new PrivateIdentityCertificate(priv.getModulus(), priv.getPrivateExponent()); return new CertificatePair(publicCert, privateCert); } catch (InvalidKeySpecException | SignatureException | InvalidKeyException e) { throw new RuntimeException("Unexpected exception generating certificate", e); } }
public static KeyPair generateKeyPair(String algorithm) throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance(algorithm); keyGen.initialize(1024); return keyGen.genKeyPair(); }
public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException, NoSuchProviderException { KeyPairGenerator generator = KeyPairGenerator .getInstance(KEYGEN_ALGORITHM/* , PROVIDER_NAME */); SecureRandom secureRandom = SecureRandom .getInstance(SECURE_RANDOM_ALGORITHM/* , PROVIDER_NAME */); generator.initialize(keySize, secureRandom); return generator.generateKeyPair(); }
/** Generates the public/private key pair from the init params */ protected void initKeyPair() throws Exception { if (this.key_pair == null) { // generate keys according to the specified algorithms // generate publicKey and Private Key KeyPairGenerator KpairGen=null; if(provider != null && !provider.trim().isEmpty()) KpairGen=KeyPairGenerator.getInstance(getAlgorithm(asym_algorithm), provider); else KpairGen=KeyPairGenerator.getInstance(getAlgorithm(asym_algorithm)); KpairGen.initialize(asym_keylength,new SecureRandom()); key_pair=KpairGen.generateKeyPair(); } // set up the Cipher to decrypt secret key responses encrypted with our key if(provider != null && !provider.trim().isEmpty()) asym_cipher=Cipher.getInstance(asym_algorithm, provider); else asym_cipher=Cipher.getInstance(asym_algorithm); asym_cipher.init(Cipher.DECRYPT_MODE, key_pair.getPrivate()); }
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(1024); KeyPair keyPair = keyPairGenerator.genKeyPair(); byte[] encodedprivkey = keyPair.getPrivate().getEncoded(); SecureRandom random = new SecureRandom(); byte[] salt = new byte[8]; random.nextBytes(salt); pbeCipher.init(Cipher.ENCRYPT_MODE, pbeKey, pbeParamSpec); byte[] ciphertext = pbeCipher.doFinal(encodedprivkey);
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC"); SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); keyGen.initialize(256, random); KeyPair pair = keyGen.generateKeyPair(); PrivateKey priv = pair.getPrivate(); PublicKey pub = pair.getPublic(); System.out.println("Signature: " + new BigInteger(1, realSig).toString(16));
byte[] payload = load(); if (payload == null) { KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA"); gen.initialize(2048, new SecureRandom()); // going beyond 2048 requires crypto extension KeyPair keys = gen.generateKeyPair(); priv = (RSAPrivateKey) keys.getPrivate(); pub = (RSAPublicKey) keys.getPublic(); store(priv.getEncoded()); } else { KeyFactory keyFactory = KeyFactory.getInstance("RSA"); priv = (RSAPrivateKey) keyFactory.generatePrivate(new PKCS8EncodedKeySpec(payload)); pub = (RSAPublicKey) keyFactory.generatePublic( new RSAPublicKeySpec(pks.getModulus(), pks.getPublicExponent()));
public static void main(String[] args) throws Exception { Security.addProvider(new BouncyCastleProvider()); KeyPairGenerator kpg = KeyPairGenerator.getInstance("ECIES"); ECGenParameterSpec brainpoolP256R1 = new ECGenParameterSpec( "brainpoolP256R1"); kpg.initialize(brainpoolP256R1); KeyPair kp = kpg.generateKeyPair(); Cipher c = Cipher.getInstance("ECIES"); c.init(Cipher.ENCRYPT_MODE, kp.getPublic()); final byte[] aesKeyData = new byte[16]; SecureRandom rng = new SecureRandom(); rng.nextBytes(aesKeyData); byte[] wrappedKey = c.doFinal(aesKeyData); SecretKey aesKey = new SecretKeySpec(aesKeyData, "AES"); Arrays.fill(aesKeyData, (byte) 0); }
byte[] data = "test".getBytes("UTF8"); KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(512); KeyPair keyPair = kpg.genKeyPair(); byte[] pk = keyPair.getPublic().getEncoded(); X509EncodedKeySpec spec = new X509EncodedKeySpec(pk); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey pubKey = keyFactory.generatePublic(spec); Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); cipher.init(Cipher.ENCRYPT_MODE, pubKey); byte[] encrypted = cipher.doFinal(data); byte[] priv = keyPair.getPrivate().getEncoded(); PKCS8EncodedKeySpec spec2 = new PKCS8EncodedKeySpec(priv); PrivateKey privKey = keyFactory.generatePrivate(spec2); cipher.init(Cipher.DECRYPT_MODE, privKey); byte[] plain = cipher.doFinal(encrypted); System.out.println(new String(plain, "UTF8")); //=> "test"
public int initAll() { try { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); SecureRandom secureRandom = new SecureRandom(new Date().toString().getBytes()); keyPairGenerator.initialize(RSA_MAX_KEYLEN, secureRandom); KeyPair keyPair = keyPairGenerator.genKeyPair(); rsaPrivateKey = keyPair.getPrivate(); rsaPublicKey = keyPair.getPublic(); encryptCipher = Cipher.getInstance("RSA/ECB/OAEPWITHSHA1ANDMGF1PADDING"); decryptCipher = Cipher.getInstance("RSA/ECB/OAEPWITHSHA1ANDMGF1PADDING"); encryptCipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey); decryptCipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey); } catch (Exception e) { log.error(e.toString()); return -1; } return 0; }
DHParameterSpec dhSkipParamSpec = new DHParameterSpec(skip1024Modulus, skip1024Base); KeyPairGenerator aliceKpairGen = KeyPairGenerator.getInstance("DH", "BC"); aliceKpairGen.initialize(dhSkipParamSpec); KeyPair aliceKpair = aliceKpairGen.generateKeyPair(); byte[] alicePubKeyEnc = aliceKpair.getPublic().getEncoded(); aliceKeyAgree = KeyAgreement.getInstance("DH", "BC"); aliceKeyAgree.init(aliceKpair.getPrivate()); //... obtaining Bob's Public Key aliceKeyFac = KeyFactory.getInstance("DH", "BC"); X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(bobPubKeyEnc); bobPubKey = aliceKeyFac.generatePublic(x509KeySpec); aliceKeyAgree.doPhase(bobPubKey, true); SecretKey aliceAesKey = aliceKeyAgree.generateSecret("AES"); Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding", "BC"); cipher.init(Cipher.ENCRYPT_MODE, aliceAesKey); byte[] cipherText = cipher.doFinal(plaintext.getBytes());
KeyPair keyPair; try { keyGen = KeyPairGenerator.getInstance(algorithm); keyGen.initialize(keySize); keyPair = keyGen.genKeyPair(); } catch (NoSuchAlgorithmException e) { throw new APIException(500, "Server error"); registerKey(authorization.getIdentity(), keyPair.getPublic()); StringWriter writer = new StringWriter(); PemWriter pemWriter = new PemWriter(writer); pemWriter.writeObject(new PemObject("PUBLIC KEY", keyPair.getPublic().getEncoded())); pemWriter.flush(); pemWriter.close(); X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(encodedKey)); pub = (RSAPublicKey) KeyFactory.getInstance(algorithm).generatePublic(keySpec); } catch (Throwable e) { throw new APIException(400, "Public key not readable (DER)"); int bitLength = pub.getModulus().bitLength(); if (bitLength <= 512) { keySize = 512;
@Test public void testPadding() throws Exception { SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(1024, random); KeyPair keyPair = keyGen.generateKeyPair(); /* constant 117 is a public key size - 11 */ byte[] plaintext = new byte[117]; random.nextBytes(plaintext); Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic()); byte[] ciphertext = cipher.doFinal(plaintext); System.out.println(plaintext.length + " becomes " + ciphertext.length); }
@Before public void generateKeys() throws NoSuchAlgorithmException { KeyPairGenerator clientKeyGen = KeyPairGenerator.getInstance("RSA"); clientKeyGen.initialize(2048); KeyPair kp = clientKeyGen.genKeyPair(); clientPublic = kp.getPublic(); clientPrivate = kp.getPrivate(); KeyPairGenerator serverKeyGen = KeyPairGenerator.getInstance("RSA"); serverKeyGen.initialize(2048); kp = serverKeyGen.genKeyPair(); serverPublic = kp.getPublic(); serverPrivate = kp.getPrivate(); KeyPairGenerator otherKeyGen = KeyPairGenerator.getInstance("RSA"); otherKeyGen.initialize(2048); kp = otherKeyGen.genKeyPair(); theifPublic = kp.getPublic(); theifPrivate = kp.getPrivate(); }
protected void handleSecretKeyRequest(PublicKey dh_public_key, Address sender) throws Exception { KeyPair kp=key_pair_gen.generateKeyPair(); PrivateKey private_key=kp.getPrivate(); PublicKey public_key_rsp=kp.getPublic(); // sent back as part of the response byte[] version; byte[] encrypted_secret_key; log.debug("%s: received public key %s.. from %s", local_addr, print16(dh_public_key), sender); synchronized(this) { key_agreement.init(private_key); key_agreement.doPhase(dh_public_key, true); // Diffie-Hellman secret session key, to encrypt secret key byte[] secret_session_key=key_agreement.generateSecret(); SecretKey hashed_session_key=hash(secret_session_key); Cipher encrypter=Cipher.getInstance(secret_key_algorithm); encrypter.init(Cipher.ENCRYPT_MODE, hashed_session_key); Tuple<SecretKey,byte[]> tuple=(Tuple<SecretKey,byte[]>)up_prot.up(new Event(Event.GET_SECRET_KEY)); SecretKey secret_key=tuple.getVal1(); version=tuple.getVal2(); encrypted_secret_key=encrypter.doFinal(secret_key.getEncoded()); } log.debug("%s: sending public key rsp %s.. to %s", local_addr, print16(public_key_rsp), sender); // send response to sender with public_key_rsp, encrypted secret key and secret key version Message rsp=new Message(sender) .putHeader(id, DhHeader.createSecretKeyResponse(public_key_rsp.getEncoded(), encrypted_secret_key, version)); down_prot.down(rsp); }
KeyGenerator kgenerator = KeyGenerator.getInstance("AES"); SecureRandom random = new SecureRandom(); kgenerator.init(128, random); Key aeskey = kgenerator.generateKey(); KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(1024, random); KeyPair kpa = kpg.genKeyPair(); PublicKey pubKey = kpa.getPublic(); PrivateKey privKey = kpa.getPrivate(); // Encrypt the generated Symmetric AES Key using RSA cipher Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); rsaCipher.init(Cipher.WRAP_MODE, pubKey); byte[] encryptedSymmKey = rsaCipher.wrap(aeskey); // RSA Decryption of Encrypted Symmetric AES key rsaCipher.init(Cipher.UNWRAP_MODE, privKey); Key decryptedKey = rsaCipher.unwrap(encryptedSymmKey, "AES", Cipher.SECRET_KEY); System.out.println("Decrypted Key Length: " + decryptedKey.getEncoded().length * 8); // -> 128
KeyPairGenerator mcElieceKeyPairGenerator = KeyPairGenerator.getInstance("McEliece"); mcElieceKeyPairGenerator.initialize(keysize, new SecureRandom()); kp = mcElieceKeyPairGenerator.generateKeyPair(); final byte[] publicKeyData = kp.getPublic().getEncoded(); X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyData); KeyFactory mcElieceKeyFactory = KeyFactory.getInstance("McEliece"); PublicKey regeneratedPublicKey = mcElieceKeyFactory.generatePublic(publicKeySpec); final byte[] privateKeyData = kp.getPrivate().getEncoded(); PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKeyData); PrivateKey regeneratedPrivateKey = mcElieceKeyFactory.generatePrivate(privateKeySpec);
KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", "SunJSSE"); generator.initialize(2048); KeyPair keyPair = generator.generateKeyPair(); SecretKey sessionKey = new SecretKeySpec(new byte[16], "AES"); Cipher c = Cipher.getInstance("RSA", "SunJCE"); c.init(Cipher.ENCRYPT_MODE, keyPair.getPublic()); byte[] result1 = c.doFinal(sessionKey.getEncoded()); c.init(Cipher.WRAP_MODE, keyPair.getPublic()); byte[] result2 = c.wrap(sessionKey); c.init(Cipher.UNWRAP_MODE, keyPair.getPrivate()); SecretKey sessionKey1 = (SecretKey) c.unwrap(result1, "AES", Cipher.SECRET_KEY); c.init(Cipher.DECRYPT_MODE, keyPair.getPrivate()); SecretKey sessionKey2 = new SecretKeySpec(c.doFinal(result2), "AES"); System.out.println(Arrays.equals(sessionKey1.getEncoded(), sessionKey2.getEncoded()));
KeyPair keys = KeyPairGenerator.getInstance("RSA").generateKeyPair(); Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, keys.getPublic()); byte[] encrypted = cipher.doFinal(rawData);