public static void main(String[] args) throws Exception { Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); Misc func = new Misc(); // initialize the key generator (KG) and generate the public/private key pair SecureRandom random = new SecureRandom(); KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", "BC"); generator.initialize(1024, random); KeyPair pair = generator.generateKeyPair(); /* initialize KG for digital signature and generate public/private keys for digital signatures It is generally not recommended to use the same public/private key pair for both encryption and digital signatures */ KeyPairGenerator generatorTwo = KeyPairGenerator.getInstance("RSA"); generatorTwo.initialize(1024); KeyPair sigKeyPair = generatorTwo.generateKeyPair(); byte[] sigPubKey = sigKeyPair.getPublic().getEncoded(); byte[] sigPrivKey = sigKeyPair.getPrivate().getEncoded(); byte[] pubKey = pair.getPublic().getEncoded(); byte[] privKey = pair.getPrivate().getEncoded(); // output the generated keys func.outputText(func.byteToHex(sigPubKey), "alice-dspk.txt"); func.outputText(func.byteToHex(sigPrivKey), "alice-dspvk.txt"); func.outputText(func.byteToHex(pubKey), "bob-pkepk.txt"); func.outputText(func.byteToHex(privKey), "bob-pkepvk.txt"); // clear sensitive data func.clear(sigPubKey); func.clear(sigPrivKey); func.clear(pubKey); func.clear(privKey); }
public static void main(String[] args) { int failCount = 0; // Test key size. int size = Integer.parseInt(args[0]); try { KeyPairGenerator kpg1 = KeyPairGenerator.getInstance(KEYALG, PROVIDER); kpg1.initialize(new RSAKeyGenParameterSpec(size, RSAKeyGenParameterSpec.F4)); if (!specTest(kpg1.generateKeyPair(), RSAKeyGenParameterSpec.F4)) { failCount++; } KeyPairGenerator kpg2 = KeyPairGenerator.getInstance(KEYALG, PROVIDER); kpg2.initialize(new RSAKeyGenParameterSpec(size, RSAKeyGenParameterSpec.F0)); if (!specTest(kpg2.generateKeyPair(), RSAKeyGenParameterSpec.F0)) { failCount++; } } catch (NoSuchAlgorithmException | NoSuchProviderException | InvalidAlgorithmParameterException ex) { ex.printStackTrace(System.err); failCount++; } if (failCount != 0) { throw new RuntimeException("There are " + failCount + " tests failed."); } }
public static void main(String[] args) throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(1024); KeyPair par = keyGen.generateKeyPair(); prk = par.getPrivate(); pbk = par.getPublic(); Registry reg = null; System.out.println("Creando conexion remota"); try { reg = LocateRegistry.createRegistry(5555); } catch (Exception e) { e.printStackTrace(); } System.out.println("Creando objeto servidor"); Servidor s = new Servidor(); try { reg.rebind("Operaciones", (InterfaceRemota) UnicastRemoteObject.exportObject(s, 0)); } catch (Exception e) { e.printStackTrace(); } while (true) { try { Thread.sleep(1000); } catch (InterruptedException ex) { Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex); } } }
public static ECPublicKey PrivateKeytoECPublicKey(byte[] privateKey) throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeySpecException { KeyPairGenerator kpg = null; kpg = KeyPairGenerator.getInstance("EC"); ECGenParameterSpec gps = new ECGenParameterSpec("secp256k1"); // NIST P-256 kpg.initialize(gps); KeyPair apair = kpg.generateKeyPair(); ECPublicKey apub = (ECPublicKey) apair.getPublic(); ECParameterSpec aspec = apub.getParams(); byte[] publicKeyb = Address.privateKeyToPublicKey(Utils.toHex(privateKey), false); byte[] publicKeybx = new byte[32]; byte[] publicKeyby = new byte[32]; System.arraycopy(publicKeyb, 1, publicKeybx, 0, 32); System.arraycopy(publicKeyb, 33, publicKeyby, 0, 32); BigInteger x = new BigInteger(1, publicKeybx); BigInteger y = new BigInteger(1, publicKeyby); java.security.spec.ECPoint cpoint = new java.security.spec.ECPoint(x, y); ECPublicKeySpec cpubs = new ECPublicKeySpec(cpoint, aspec); ECPublicKey cpub = null; KeyFactory kfa = null; kfa = KeyFactory.getInstance("EC"); return cpub = (ECPublicKey) kfa.generatePublic(cpubs); }
public static void main(String[] args) throws Exception { byte[] input = new byte[] {(byte) 0xbe, (byte) 0xef}; Cipher cipher = Cipher.getInstance("ElGamal/None/NoPadding", "BC"); SecureRandom random = Utils.createFixedRandom(); // create the keys KeyPairGenerator generator = KeyPairGenerator.getInstance("ElGamal", "BC"); generator.initialize(256, random); KeyPair pair = generator.generateKeyPair(); Key pubKey = pair.getPublic(); Key privKey = pair.getPrivate(); System.out.println("input : " + Utils.toHex(input)); // encryption step cipher.init(Cipher.ENCRYPT_MODE, pubKey, random); byte[] cipherText = cipher.doFinal(input); System.out.println("cipher: " + Utils.toHex(cipherText)); // decryption step cipher.init(Cipher.DECRYPT_MODE, privKey); byte[] plainText = cipher.doFinal(cipherText); System.out.println("plain : " + Utils.toHex(plainText)); }
@Override protected Boolean doInBackground(String... params) { final String alias = params[0]; try { /* * Generate a new EC key pair entry in the Android Keystore by * using the KeyPairGenerator API. The private key can only be * used for signing or verification and only with SHA-256 or * SHA-512 as the message digest. */ KeyPairGenerator kpg = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore"); kpg.initialize( new KeyGenParameterSpec.Builder( alias, KeyProperties.PURPOSE_SIGN | KeyProperties.PURPOSE_VERIFY) .setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512) .build()); KeyPair kp = kpg.generateKeyPair(); return true; } catch (NoSuchAlgorithmException e) { Log.w(TAG, "Could not generate key", e); return false; } catch (InvalidAlgorithmParameterException e) { Log.w(TAG, "Could not generate key", e); return false; } catch (NoSuchProviderException e) { Log.w(TAG, "Could not generate key", e); return false; } }
/** 生成密钥对 */ public static Map<String, String> generateKeyPair() throws Exception { /** RSA算法要求有一个可信任的随机数源 */ SecureRandom sr = new SecureRandom(); /** 为RSA算法创建一个KeyPairGenerator对象 */ KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */ kpg.initialize(KEYSIZE, sr); /** 生成密匙对 */ KeyPair kp = kpg.generateKeyPair(); /** 得到公钥 */ Key publicKey = kp.getPublic(); byte[] publicKeyBytes = publicKey.getEncoded(); String pub = new String(Base64.encodeBase64(publicKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING); /** 得到私钥 */ Key privateKey = kp.getPrivate(); byte[] privateKeyBytes = privateKey.getEncoded(); String pri = new String(Base64.encodeBase64(privateKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING); Map<String, String> map = new HashMap<String, String>(); map.put("publicKey", pub); map.put("privateKey", pri); RSAPublicKey rsp = (RSAPublicKey) kp.getPublic(); BigInteger bint = rsp.getModulus(); byte[] b = bint.toByteArray(); byte[] deBase64Value = Base64.encodeBase64(b); String retValue = new String(deBase64Value); map.put("modulus", retValue); return map; }
public KeyPair generateKeyPair() throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ds().network.getProperty("PKAlgo", "DSA")); SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); keyGen.initialize(1024, random); return keyGen.generateKeyPair(); }
public void testMacProtectedMessage() throws Exception { KeyPairGenerator kGen = KeyPairGenerator.getInstance("RSA", BC); kGen.initialize(512); KeyPair kp = kGen.generateKeyPair(); X509CertificateHolder cert = makeV3Certificate(kp, "CN=Test", kp, "CN=Test"); GeneralName sender = new GeneralName(new X500Name("CN=Sender")); GeneralName recipient = new GeneralName(new X500Name("CN=Recip")); ProtectedPKIMessage message = new ProtectedPKIMessageBuilder(sender, recipient) .setBody( new PKIBody( PKIBody.TYPE_INIT_REP, CertRepMessage.getInstance(new DERSequence(new DERSequence())))) .addCMPCertificate(cert) .build( new PKMACBuilder(new JcePKMACValuesCalculator().setProvider(BC)) .build("secret".toCharArray())); PKMACBuilder pkMacBuilder = new PKMACBuilder(new JcePKMACValuesCalculator().setProvider(BC)); assertTrue(message.verify(pkMacBuilder, "secret".toCharArray())); assertEquals(sender, message.getHeader().getSender()); assertEquals(recipient, message.getHeader().getRecipient()); }
private void sealedObjectTest() throws Exception { KeyPairGenerator kpg = KeyPairGenerator.getInstance("ECIES"); kpg.initialize(new ECGenParameterSpec("secp256r1")); KeyPair keyPair = kpg.generateKeyPair(); Cipher cipher = Cipher.getInstance("ECIES"); cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic()); String toEncrypt = "Hello"; // Check that cipher works ok cipher.doFinal(toEncrypt.getBytes()); // Using a SealedObject to encrypt the same string fails with a NullPointerException SealedObject sealedObject = new SealedObject(toEncrypt, cipher); cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate()); String result = (String) sealedObject.getObject(cipher); isTrue("result wrong", result.equals(toEncrypt)); result = (String) sealedObject.getObject(keyPair.getPrivate()); isTrue("result wrong", result.equals(toEncrypt)); }
public boolean generateKeys() { PublicKey keyPub; PrivateKey keyPri; SecureRandom rand; Security.addProvider(new ABAProvider()); rand = new SecureRandom(); rand.setSeed(System.currentTimeMillis()); try { KeyPairGenerator fact; KeyPair keyPair; fact = KeyPairGenerator.getInstance("RSA", "ABA"); fact.initialize(1024, rand); keyPair = fact.generateKeyPair(); keyPub = keyPair.getPublic(); keyPri = keyPair.getPrivate(); pubKey = bytesToHexStr(keyPub.getEncoded()); priKey = bytesToHexStr(keyPri.getEncoded()); } catch (Exception e) { return false; } return true; }
public void testProtectedMessage() throws Exception { KeyPairGenerator kGen = KeyPairGenerator.getInstance("RSA", BC); kGen.initialize(512); KeyPair kp = kGen.generateKeyPair(); X509CertificateHolder cert = makeV3Certificate(kp, "CN=Test", kp, "CN=Test"); GeneralName sender = new GeneralName(new X500Name("CN=Sender")); GeneralName recipient = new GeneralName(new X500Name("CN=Recip")); ContentSigner signer = new JcaContentSignerBuilder("MD5WithRSAEncryption").setProvider(BC).build(kp.getPrivate()); ProtectedPKIMessage message = new ProtectedPKIMessageBuilder(sender, recipient) .setBody( new PKIBody( PKIBody.TYPE_INIT_REP, CertRepMessage.getInstance(new DERSequence(new DERSequence())))) .addCMPCertificate(cert) .build(signer); X509Certificate jcaCert = new JcaX509CertificateConverter() .setProvider(BC) .getCertificate(message.getCertificates()[0]); ContentVerifierProvider verifierProvider = new JcaContentVerifierProviderBuilder().setProvider(BC).build(jcaCert.getPublicKey()); assertTrue(message.verify(verifierProvider)); assertEquals(sender, message.getHeader().getSender()); assertEquals(recipient, message.getHeader().getRecipient()); }
private KeyPair generateKeyPair() throws Exception { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); SecureRandom random = new SecureRandom(); keyPairGenerator.initialize( new RSAKeyGenParameterSpec(1024, RSAKeyGenParameterSpec.F4), random); return keyPairGenerator.generateKeyPair(); }
public void main(Provider p) throws Exception { KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", p); kpg.initialize(512); KeyPair kp = kpg.generateKeyPair(); PrivateKey privateKey = kp.getPrivate(); PublicKey publicKey = kp.getPublic(); Signature sig = Signature.getInstance("MD5withRSA", p); byte[] data = new byte[10 * 1024]; new Random().nextBytes(data); sig.initSign(privateKey); sig.initSign(privateKey); sig.update(data); sig.initSign(privateKey); sig.update(data); byte[] signature = sig.sign(); sig.update(data); sig.initSign(privateKey); sig.update(data); sig.sign(); sig.sign(); sig.initSign(privateKey); sig.sign(); System.out.println("All tests passed"); }
/** This method generates public and private keys. */ public static void generateKey() throws Exception { KeyPairGenerator gen = KeyPairGenerator.getInstance(RSA); gen.initialize(512, new SecureRandom()); KeyPair keyPair = gen.generateKeyPair(); pubKey = keyPair.getPublic(); priKey = keyPair.getPrivate(); }
@Test public void testKeygenToFileOutputStream() throws NoSuchAlgorithmException, NoSuchProviderException, IOException { final KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); final SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN"); keyGen.initialize(1024, random); KeyPair pair = keyGen.generateKeyPair(); final PrivateKey priv = pair.getPrivate(); final PublicKey pub = pair.getPublic(); // Write the private key to a file FileOutputStream privOS = new FileOutputStream("RSAPrivateKey.key"); Assert.assertNotNull(privOS); privOS.write(priv.getEncoded()); privOS.close(); // Write the private key to a file FileOutputStream publicOS = new FileOutputStream("RSAPublicKey.key"); Assert.assertNotNull(publicOS); publicOS.write(pub.getEncoded()); publicOS.close(); }
private static String csr() { try { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); keyGen.initialize(2048); KeyPair keyPair = keyGen.generateKeyPair(); X500Principal subject = new X500Principal( "CN = edea87b4-034d-48dc-94dd-e7cdcfdde370/10562468, OU = fgdfgretertgdfg, O = VW, L = US"); ContentSigner signer = new JcaContentSignerBuilder("SHA1withRSA").build(keyPair.getPrivate()); PKCS10CertificationRequestBuilder builder = new JcaPKCS10CertificationRequestBuilder(subject, keyPair.getPublic()); PKCS10CertificationRequest csr = builder.build(signer); String type = "CERTIFICATE REQUEST"; PemObject pem = new PemObject(type, csr.getEncoded()); StringWriter str = new StringWriter(); PEMWriter pemWriter = new PEMWriter(str); pemWriter.writeObject(pem); pemWriter.close(); str.close(); Log.d("Test", "" + str); return Base64Util.getStringAsBase64(str.toString()); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (OperatorCreationException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return ""; }
public static void main(String[] args) { try { AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance("DSA"); paramGen.init(1024); AlgorithmParameters params = paramGen.generateParameters(); DSAParameterSpec dsaParameterSpec = params.getParameterSpec(DSAParameterSpec.class); KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA"); keyPairGenerator.initialize(dsaParameterSpec); KeyPair keyPair = keyPairGenerator.generateKeyPair(); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); saveKey("BpubKey", publicKey); saveKey("BprivKey", privateKey); } catch (NoSuchAlgorithmException | InvalidParameterSpecException | InvalidAlgorithmParameterException e) { e.printStackTrace(); } }
private void testKeyFactory() throws Exception { KeyPairGenerator g = KeyPairGenerator.getInstance("ECDSA", "SC"); ECCurve curve = new ECCurve.Fp( new BigInteger( "883423532389192164791648750360308885314476597252960362792450860609699839"), // q new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a new BigInteger( "6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b ECParameterSpec ecSpec = new ECParameterSpec( curve, curve.decodePoint( Hex.decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G new BigInteger( "883423532389192164791648750360308884807550341691627752275345424702807307")); // n ConfigurableProvider config = (ConfigurableProvider) Security.getProvider("SC"); config.setParameter(ConfigurableProvider.EC_IMPLICITLY_CA, ecSpec); g.initialize(null, new SecureRandom()); KeyPair p = g.generateKeyPair(); ECPrivateKey sKey = (ECPrivateKey) p.getPrivate(); ECPublicKey vKey = (ECPublicKey) p.getPublic(); KeyFactory fact = KeyFactory.getInstance("ECDSA", "SC"); vKey = (ECPublicKey) fact.generatePublic(new ECPublicKeySpec(vKey.getQ(), null)); sKey = (ECPrivateKey) fact.generatePrivate(new ECPrivateKeySpec(sKey.getD(), null)); testECDSA(sKey, vKey); testBCParamsAndQ(sKey, vKey); testEC5Params(sKey, vKey); testEncoding(sKey, vKey); ECPublicKey vKey2 = (ECPublicKey) fact.generatePublic(new ECPublicKeySpec(vKey.getQ(), ecSpec)); ECPrivateKey sKey2 = (ECPrivateKey) fact.generatePrivate(new ECPrivateKeySpec(sKey.getD(), ecSpec)); if (!vKey.equals(vKey2) || vKey.hashCode() != vKey2.hashCode()) { fail("private equals/hashCode failed"); } if (!sKey.equals(sKey2) || sKey.hashCode() != sKey2.hashCode()) { fail("private equals/hashCode failed"); } // check we can get specs. fact.getKeySpec(vKey, java.security.spec.ECPublicKeySpec.class); fact.getKeySpec(sKey, java.security.spec.ECPrivateKeySpec.class); }
public void run() { try { ObjectInputStream ois = new ObjectInputStream(s.getInputStream()); ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream()); BigInteger bg = dhSpec.getG(); BigInteger bp = dhSpec.getP(); oos.writeObject(bg); oos.writeObject(bp); KeyPairGenerator kpg = KeyPairGenerator.getInstance("DH"); kpg.initialize(1024); KeyPair kpa = (KeyPair) ois.readObject(); KeyAgreement dh = KeyAgreement.getInstance("DH"); KeyPair kp = kpg.generateKeyPair(); oos.writeObject(kp); dh.init(kp.getPrivate()); Key pk = dh.doPhase(kpa.getPublic(), true); MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); byte[] rawbits = sha256.digest(dh.generateSecret()); Cipher c = Cipher.getInstance(CIPHER_MODE); SecretKey key = new SecretKeySpec(rawbits, 0, 16, "AES"); byte ivbits[] = (byte[]) ois.readObject(); IvParameterSpec iv = new IvParameterSpec(ivbits); c.init(Cipher.DECRYPT_MODE, key, iv); Mac m = Mac.getInstance("HmacSHA1"); SecretKey mackey = new SecretKeySpec(rawbits, 16, 16, "HmacSHA1"); m.init(mackey); byte ciphertext[], cleartext[], mac[]; try { while (true) { ciphertext = (byte[]) ois.readObject(); mac = (byte[]) ois.readObject(); if (Arrays.equals(mac, m.doFinal(ciphertext))) { cleartext = c.update(ciphertext); System.out.println(ct + " : " + new String(cleartext, "UTF-8")); } else { // System.exit(1); System.out.println(ct + "error"); } } } catch (EOFException e) { cleartext = c.doFinal(); System.out.println(ct + " : " + new String(cleartext, "UTF-8")); System.out.println("[" + ct + "]"); } finally { if (ois != null) ois.close(); if (oos != null) oos.close(); } } catch (Exception e) { e.printStackTrace(); } }
public boolean createSelfSignedKeystore( String cn, String keystoreFile, String keystorePassword, String privateKeyPassword, String privateKeyAlias) { KeyStore ks = null; try { ks = KeyStore.getInstance("JKS"); ks.load(null, null); KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA"); keyGen.initialize(1024, new SecureRandom()); KeyPair keypair = keyGen.generateKeyPair(); PrivateKey privkey = keypair.getPrivate(); PublicKey pubkey = keypair.getPublic(); Hashtable<DERObjectIdentifier, String> attrs = new Hashtable<DERObjectIdentifier, String>(); Vector<DERObjectIdentifier> ordering = new Vector<DERObjectIdentifier>(); ordering.add(X509Name.CN); attrs.put(X509Name.CN, cn); X509Name issuerDN = new X509Name(ordering, attrs); X509Name subjectDN = new X509Name(ordering, attrs); Date validFrom = new Date(); validFrom.setTime(validFrom.getTime() - (10 * 60 * 1000)); Date validTo = new Date(); validTo.setTime(validTo.getTime() + (20 * (24 * 60 * 60 * 1000))); X509V3CertificateGenerator x509 = new X509V3CertificateGenerator(); x509.setSignatureAlgorithm("SHA1withDSA"); x509.setIssuerDN(issuerDN); x509.setSubjectDN(subjectDN); x509.setPublicKey(pubkey); x509.setNotBefore(validFrom); x509.setNotAfter(validTo); x509.setSerialNumber(new BigInteger(128, new Random())); X509Certificate[] cert = new X509Certificate[1]; cert[0] = x509.generate(privkey, "BC"); java.security.cert.Certificate[] chain = new java.security.cert.Certificate[1]; chain[0] = cert[0]; ks.setKeyEntry(privateKeyAlias, privkey, privateKeyPassword.toCharArray(), cert); ks.setKeyEntry(privateKeyAlias, privkey, privateKeyPassword.toCharArray(), chain); ks.store(new FileOutputStream(keystoreFile), keystorePassword.toCharArray()); String IDP_RFC_CERT = "WEB-INF/guanxi_idp/keystore/guanxi_idp_cert.txt"; PEMWriter pemWriter = new PEMWriter(new FileWriter(servletContext.getRealPath(IDP_RFC_CERT))); pemWriter.writeObject(cert[0]); pemWriter.close(); return true; } catch (Exception se) { return false; } }
public static void testcaV3() throws Exception { KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(2048); KeyPair keyPair = kpg.generateKeyPair(); X509Certificate cer = buildCARootCertV3(keyPair); FileUtils.writeByteArrayToFile(new File("d:\\caV3.cer"), cer.getEncoded()); System.out.println(cer); }
private static KeyPair generateKeyPair() throws NoSuchProviderException, NoSuchAlgorithmException { KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "SunRsaSign"); kpg.initialize(512, new SecureRandom()); return kpg.generateKeyPair(); }
public void init(BigInteger p, BigInteger g) throws GeneralSecurityException { this.p = p; this.g = g; generator.initialize(new DHParameterSpec(p, g)); final KeyPair kp = generator.generateKeyPair(); agreement.init(kp.getPrivate()); e = ((javax.crypto.interfaces.DHPublicKey) kp.getPublic()).getY(); }
private final KeyPair generateKeyPair() { try { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DH"); keyGen.initialize(DH_PARAMETER_SPEC); return keyGen.generateKeyPair(); } catch (GeneralSecurityException e) { throw new TorException(e); } }
/** * 获取RSA公私钥 * * @param seedBytes * @return * @throws NoSuchAlgorithmException */ public KeyPair generateRSAKeyPair(byte[] seedBytes) throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA"); int keySize = 1024; // 约定RSA加密采用1024位 // linux下需强制设置RNG算法 SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); random.setSeed(seedBytes); keyGen.initialize(keySize, random); return keyGen.generateKeyPair(); }
public void doTest(String testname, KeyPairGenerator g, String cipher, IESParameterSpec p) throws Exception { byte[] message = Hex.decode("0102030405060708090a0b0c0d0e0f10111213141516"); byte[] out1, out2; // Generate static key pair KeyPair KeyPair = g.generateKeyPair(); ECPublicKey Pub = (ECPublicKey) KeyPair.getPublic(); ECPrivateKey Priv = (ECPrivateKey) KeyPair.getPrivate(); Cipher c1 = Cipher.getInstance(cipher); Cipher c2 = Cipher.getInstance(cipher); // Testing with null parameters and DHAES mode off c1.init(Cipher.ENCRYPT_MODE, Pub, new SecureRandom()); c2.init(Cipher.DECRYPT_MODE, Priv, new SecureRandom()); out1 = c1.doFinal(message, 0, message.length); out2 = c2.doFinal(out1, 0, out1.length); if (!areEqual(out2, message)) fail(testname + " test failed with null parameters, DHAES mode false."); // Testing with given parameters and DHAES mode off c1.init(Cipher.ENCRYPT_MODE, Pub, p, new SecureRandom()); c2.init(Cipher.DECRYPT_MODE, Priv, p, new SecureRandom()); out1 = c1.doFinal(message, 0, message.length); out2 = c2.doFinal(out1, 0, out1.length); if (!areEqual(out2, message)) fail(testname + " test failed with non-null parameters, DHAES mode false."); // TODO: DHAES mode is not currently implemented, perhaps it shouldn't be... // c1 = Cipher.getInstance(cipher + "/DHAES/PKCS7Padding","BC"); // c2 = Cipher.getInstance(cipher + "/DHAES/PKCS7Padding","BC"); // // // Testing with null parameters and DHAES mode on // c1.init(Cipher.ENCRYPT_MODE, Pub, new SecureRandom()); // c2.init(Cipher.DECRYPT_MODE, Priv, new SecureRandom()); // // out1 = c1.doFinal(message, 0, message.length); // out2 = c2.doFinal(out1, 0, out1.length); // if (!areEqual(out2, message)) // fail(testname + " test failed with null parameters, DHAES mode true."); // // c1 = Cipher.getInstance(cipher + "/DHAES/PKCS7Padding"); // c2 = Cipher.getInstance(cipher + "/DHAES/PKCS7Padding"); // // // Testing with given parameters and DHAES mode on // c1.init(Cipher.ENCRYPT_MODE, Pub, p, new SecureRandom()); // c2.init(Cipher.DECRYPT_MODE, Priv, p, new SecureRandom()); // // out1 = c1.doFinal(message, 0, message.length); // out2 = c2.doFinal(out1, 0, out1.length); // if (!areEqual(out2, message)) // fail(testname + " test failed with non-null parameters, DHAES mode true."); }
public static KeyPair generateKeyPair() { KeyPair pair = null; try { KeyPairGenerator key = KeyPairGenerator.getInstance("RSA"); pair = key.generateKeyPair(); } catch (NoSuchAlgorithmException ex) { System.err.println("erreur generation pair de cle :" + ex); } return pair; }
public static Map<String, Object> initKey() throws Exception { KeyPairGenerator localKeyPairGenerator = KeyPairGenerator.getInstance("RSA"); localKeyPairGenerator.initialize(1024); KeyPair localKeyPair = localKeyPairGenerator.generateKeyPair(); RSAPublicKey localRSAPublicKey = (RSAPublicKey) localKeyPair.getPublic(); RSAPrivateKey localRSAPrivateKey = (RSAPrivateKey) localKeyPair.getPrivate(); HashMap localHashMap = new HashMap(2); localHashMap.put("RSAPublicKey", localRSAPublicKey); localHashMap.put("RSAPrivateKey", localRSAPrivateKey); return localHashMap; }
public static KeyPair func_75891_b() { try { KeyPairGenerator keypairgenerator = KeyPairGenerator.getInstance("RSA"); keypairgenerator.initialize(1024); return keypairgenerator.generateKeyPair(); } catch (NoSuchAlgorithmException nosuchalgorithmexception) { nosuchalgorithmexception.printStackTrace(); } System.err.println("Key pair generation failed!"); return null; }