Refine search
public KeyAgreement diffieHellman(boolean side, int keySize) throws IOException, GeneralSecurityException { KeyPair keyPair; PublicKey otherHalf; if (side) { AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance("DH"); paramGen.init(keySize); KeyPairGenerator dh = KeyPairGenerator.getInstance("DH"); dh.initialize(paramGen.generateParameters().getParameterSpec(DHParameterSpec.class)); keyPair = dh.generateKeyPair(); // send a half and get a half writeKey(keyPair.getPublic()); otherHalf = KeyFactory.getInstance("DH").generatePublic(readKey()); } else { otherHalf = KeyFactory.getInstance("DH").generatePublic(readKey()); KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("DH"); keyPairGen.initialize(((DHPublicKey) otherHalf).getParams()); keyPair = keyPairGen.generateKeyPair(); // send a half and get a half writeKey(keyPair.getPublic()); } KeyAgreement ka = KeyAgreement.getInstance("DH"); ka.init(keyPair.getPrivate()); ka.doPhase(otherHalf, true); return ka; }
private static byte[] generateSecret(String dhSKAlgo, PrivateKey privateKey, PublicKey otherPublicKey) throws Exception { KeyAgreement ka = KeyAgreement.getInstance("DH"); ka.init(privateKey); ka.doPhase(otherPublicKey, true); int keysize = getKeySize(dhSKAlgo); int blocksize = getBlockSize(dhSKAlgo); if (keysize == -1 || blocksize == -1) { SecretKey sKey = ka.generateSecret(dhSKAlgo); return sKey.getEncoded(); } else { return ka.generateSecret(); } } }
@Override void computeK(byte[] f) throws GeneralSecurityException { final KeyFactory keyFactory = SecurityUtils.getKeyFactory("DH"); final PublicKey yourPubKey = keyFactory.generatePublic(new DHPublicKeySpec(new BigInteger(f), p, g)); agreement.doPhase(yourPubKey, true); setK(new BigInteger(1, agreement.generateSecret())); }
@Override public void init(AlgorithmParameterSpec params, Factory<Random> randomFactory) throws GeneralSecurityException { if (!(params instanceof DHParameterSpec)) { throw new SSHRuntimeException("Wrong algorithm parameters for Diffie Hellman"); } this.p = ((DHParameterSpec) params).getP(); this.g = ((DHParameterSpec) params).getG(); generator.initialize(params); final KeyPair kp = generator.generateKeyPair(); agreement.init(kp.getPrivate()); setE(((javax.crypto.interfaces.DHPublicKey) kp.getPublic()).getY().toByteArray()); }
public DHPublicKey init(DHParameterSpec dhParamSpec) throws Exception { dhParameterSpec = dhParamSpec; // The client creates its own DH key pair, using the DH parameters from above. KeyPairGenerator clientKpairGen = KeyPairGenerator.getInstance("DH"); clientKpairGen.initialize(dhParamSpec); KeyPair clientKpair = clientKpairGen.generateKeyPair(); // The client creates and initializes its DH KeyAgreement object. clientKeyAgree = KeyAgreement.getInstance("DH"); clientKeyAgree.init(clientKpair.getPrivate()); // The client encodes its public key, and sends it over to the server. return (DHPublicKey) clientKpair.getPublic(); }
@Override public byte[] getK() throws Exception { if( _K == null ) { KeyFactory myKeyFac = KeyFactory.getInstance("DH"); PublicKey yourPubKey = myKeyFac.generatePublic(new DHPublicKeySpec(_f, _p, _g)); _keyAgreement.doPhase(yourPubKey, true); byte[] mySharedSecret = _keyAgreement.generateSecret(); _K = new BigInteger(mySharedSecret); //_KArray = _K.toByteArray(); // TODO Why assign twice? _KArray = mySharedSecret; } return _KArray; }
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); }
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM); PublicKey pubKey = keyFactory.generatePublic(x509KeySpec); PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec); KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory.getAlgorithm()); keyAgree.init(priKey); keyAgree.doPhase(pubKey, true); SecretKey secretKey = keyAgree.generateSecret(SECRET_KEY_ALGORITHM);
KeyPairGenerator eckpg = KeyPairGenerator.getInstance("EC"); ECGenParameterSpec p256 = new ECGenParameterSpec("secp256r1"); eckpg.initialize(p256); KeyPair doubleUseKeyPair = eckpg.generateKeyPair(); KeyAgreement ecdh = KeyAgreement.getInstance("ECDH"); ecdh.init(doubleUseKeyPair.getPrivate()); // ... Signature ecdsa = Signature.getInstance("SHA256withECDSA"); ecdsa.initSign(doubleUseKeyPair.getPrivate()); // ... System.out.println(eckpg.getProvider()); System.out.println(ecdh.getProvider()); System.out.println(ecdsa.getProvider());
KeyFactory keyFact = KeyFactory.getInstance("DH"); pubKey = keyFact.generatePublic(x509KeySpec); KeyAgreement ka = KeyAgreement.getInstance("DH"); ka.init(dhPrivateKey); ka.doPhase(pubKey, true); SecretKey sKey = ka.generateSecret(skAlgo); decrypt = Cipher.getInstance(skAlgo); decrypt.init(Cipher.DECRYPT_MODE, sKey); String algoStr = getDhAlgoStr(skAlgo); byte[] sKeyBytes = ka.generateSecret(); SecretKeySpec sks = new SecretKeySpec(sKeyBytes, 0, keysize, algoStr); IvParameterSpec ivps = new IvParameterSpec(sKeyBytes, keysize, blocksize);
public void doPhase(byte[] serverPubKeyEnc) throws Exception { /* * The client uses the server's public key for the first (and only) phase * of its version of the DH protocol. Before it can do so, it has to * instantiate a DH public key from the server's encoded key material. */ KeyFactory clientKeyFac = KeyFactory.getInstance("DH"); X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(serverPubKeyEnc); PublicKey serverPubKey = clientKeyFac.generatePublic(x509KeySpec); clientKeyAgree.doPhase(serverPubKey, true); }
public void init() throws Exception{ myKpairGen=KeyPairGenerator.getInstance("DH"); myKeyAgree=KeyAgreement.getInstance("DH"); } public byte[] getE() throws Exception{
public static ECDHKeySet getSharedSecret (ECKey keyServer, ECKey keyClient) { try { ECPrivateKeySpec specPrivate = new ECPrivateKeySpec(keyServer.getPrivKey(), ecParameters); ECPublicKeySpec specPublic = new ECPublicKeySpec(new ECPoint(keyClient.getPubKeyPoint().getXCoord().toBigInteger(), keyClient.getPubKeyPoint() .getYCoord().toBigInteger()), ecParameters); ECPrivateKey privateKey = (ECPrivateKey) kf.generatePrivate(specPrivate); ECPublicKey publicKey = (ECPublicKey) kf.generatePublic(specPublic); JCEECPrivateKey ecPrivKey = new JCEECPrivateKey(privateKey); JCEECPublicKey ecPubKey = new JCEECPublicKey(publicKey); KeyAgreement aKeyAgree = KeyAgreement.getInstance("ECDH"); aKeyAgree.init(ecPrivKey); aKeyAgree.doPhase(ecPubKey, true); return new ECDHKeySet(aKeyAgree.generateSecret(), keyServer.getPubKey(), keyClient.getPubKey()); } catch (Exception e) { throw new RuntimeException(e); } }
public static KeyAgreement getInitializedKeyAgreement(KeyPair keyPair) { KeyAgreement keyAgreement = null; try { keyAgreement = KeyAgreement.getInstance(DIFFIE_HELLMAN); keyAgreement.init(keyPair.getPrivate()); return keyAgreement; } catch (NoSuchAlgorithmException e) { throw new RuntimeException(e); } catch (InvalidKeyException e) { throw new RuntimeException(e); } }
public BigInteger keyAgreement(ECPoint otherParty) { if (privKey == null) { throw new MissingPrivateKeyException(); } else if (privKey instanceof BCECPrivateKey) { final ECDHBasicAgreement agreement = new ECDHBasicAgreement(); agreement.init(new ECPrivateKeyParameters(((BCECPrivateKey) privKey).getD(), CURVE)); return agreement.calculateAgreement(new ECPublicKeyParameters(otherParty, CURVE)); } else { try { final KeyAgreement agreement = ECKeyAgreement.getInstance(this.provider); agreement.init(this.privKey); agreement.doPhase( ECKeyFactory.getInstance(this.provider) .generatePublic(new ECPublicKeySpec(otherParty, CURVE_SPEC)), /* lastPhase */ true); return new BigInteger(1, agreement.generateSecret()); } catch (IllegalStateException | InvalidKeyException | InvalidKeySpecException ex) { throw new RuntimeException("ECDH key agreement failure", ex); } } }
public void init(int size) throws Exception{ myKeyAgree = KeyAgreement.getInstance("ECDH"); KeyPairGenECDSA kpair = new KeyPairGenECDSA(); kpair.init(size); publicKey = kpair.getPublicKey(); byte[] r = kpair.getR(); byte[] s = kpair.getS(); Q_array = toPoint(r, s); myKeyAgree.init(kpair.getPrivateKey()); }
public static KeyAgreement getInstance(final String provider) throws NoSuchProviderException { try { return KeyAgreement.getInstance(ALGORITHM, provider); } catch (NoSuchAlgorithmException ex) { throw new AssertionError(algorithmAssertionMsg, ex); } }
public static KeyAgreement generateKeyAgreement(PrivateKey privateKey, PublicKey publicKey) throws NoSuchAlgorithmException, InvalidKeyException { KeyAgreement keyAgreement = KeyAgreement.getInstance(AlgorithmName.DH); keyAgreement.init(privateKey); keyAgreement.doPhase(publicKey, true); return keyAgreement; }
public SecretKey calculateKeyAgreement(String agreementAlgorithm, PrivateKey privateKey, PublicKey publicKey, String secretAlgorithm) throws GeneralSecurityException { KeyAgreement agreement = helper.createKeyAgreement(agreementAlgorithm); agreement.init(privateKey); agreement.doPhase(publicKey, true); return agreement.generateSecret(secretAlgorithm); }
protected void handleSecretKeyResponse(PublicKey dh_public_key, byte[] encrypted_secret_key, byte[] version, Address sender) throws Exception { Tuple<SecretKey,byte[]> tuple=null; log.debug("%s: received public key rsp %s.. from %s", local_addr, print16(dh_public_key), sender); synchronized(this) { key_agreement.doPhase(dh_public_key, true); // Diffie-Hellman secret session key, to decrypt 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.DECRYPT_MODE, hashed_session_key); byte[] secret_key=encrypter.doFinal(encrypted_secret_key); // <-- this is the shared group key SecretKey sk=new SecretKeySpec(secret_key, secret_key_algorithm); tuple=new Tuple<>(sk, version); dh_key=null; } log.debug("%s: sending up secret key (version: %s)", local_addr, Util.byteArrayToHexString(version)); up_prot.up(new Event(Event.SET_SECRET_KEY, tuple)); }