Example usage for org.bouncycastle.crypto.params DHParameters DHParameters

Introduction

In this page you can find the example usage for org.bouncycastle.crypto.params DHParameters DHParameters.

Prototype

public DHParameters(BigInteger p, BigInteger g) 

Source Link

Usage

From source file:com.licel.jcardsim.crypto.DHKeyImpl.java

License:Apache License

private static DHParameters fromPG(String hexP, String hexG) {
    BigInteger p = new BigInteger(1, Hex.decode(hexP));
    BigInteger g = new BigInteger(1, Hex.decode(hexG));
    return new DHParameters(p, g);
}

---

From source file:de.rub.nds.tlsattacker.tls.protocol.handshake.DHClientKeyExchangeHandler.java

License:Apache License

@Override
byte[] prepareKeyExchangeMessage() {
    if (tlsContext.getServerDHParameters() == null) {
        // we are probably handling a simple DH ciphersuite, we try to
        // establish server public key parameters from the server
        // certificate message
        Certificate x509Cert = tlsContext.getServerCertificate();

        SubjectPublicKeyInfo keyInfo = x509Cert.getSubjectPublicKeyInfo();
        DHPublicKeyParameters parameters;
        try {/*w w  w  .  j  av a 2  s.  c  o m*/
            parameters = (DHPublicKeyParameters) PublicKeyFactory.createKey(keyInfo);
            tlsContext.setServerDHParameters(new ServerDHParams(parameters));
        } catch (IOException e) {
            throw new WorkflowExecutionException("Problem in parsing public key parameters from certificate",
                    e);
        }
    }

    // generate client's original dh public and private key, based on the
    // server's public parameters
    AsymmetricCipherKeyPair kp = TlsDHUtils.generateDHKeyPair(new SecureRandom(),
            tlsContext.getServerDHParameters().getPublicKey().getParameters());
    DHPublicKeyParameters dhPublic = (DHPublicKeyParameters) kp.getPublic();
    DHPrivateKeyParameters dhPrivate = (DHPrivateKeyParameters) kp.getPrivate();

    protocolMessage.setG(dhPublic.getParameters().getG());
    protocolMessage.setP(dhPublic.getParameters().getP());
    protocolMessage.setY(dhPublic.getY());
    protocolMessage.setX(dhPrivate.getX());

    // set the modified values of client's private and public parameters
    DHParameters newParams = new DHParameters(protocolMessage.getP().getValue(),
            protocolMessage.getG().getValue());
    // DHPublicKeyParameters newDhPublic = new
    // DHPublicKeyParameters(dhMessage.getY().getValue(), newParams);
    DHPrivateKeyParameters newDhPrivate = new DHPrivateKeyParameters(protocolMessage.getX().getValue(),
            newParams);

    byte[] serializedPublicKey = BigIntegers.asUnsignedByteArray(protocolMessage.getY().getValue());
    protocolMessage.setSerializedPublicKey(serializedPublicKey);
    protocolMessage.setSerializedPublicKeyLength(serializedPublicKey.length);

    byte[] result = ArrayConverter
            .concatenate(
                    ArrayConverter.intToBytes(protocolMessage.getSerializedPublicKeyLength().getValue(),
                            HandshakeByteLength.DH_PARAM_LENGTH),
                    protocolMessage.getSerializedPublicKey().getValue());

    byte[] premasterSecret = TlsDHUtils
            .calculateDHBasicAgreement(tlsContext.getServerDHParameters().getPublicKey(), newDhPrivate);
    protocolMessage.setPremasterSecret(premasterSecret);
    LOGGER.debug("Computed PreMaster Secret: {}",
            ArrayConverter.bytesToHexString(protocolMessage.getPremasterSecret().getValue()));

    byte[] random = tlsContext.getClientServerRandom();

    PRFAlgorithm prfAlgorithm = AlgorithmResolver.getPRFAlgorithm(tlsContext.getProtocolVersion(),
            tlsContext.getSelectedCipherSuite());
    byte[] masterSecret = PseudoRandomFunction.compute(prfAlgorithm,
            protocolMessage.getPremasterSecret().getValue(), PseudoRandomFunction.MASTER_SECRET_LABEL, random,
            HandshakeByteLength.MASTER_SECRET);
    LOGGER.debug("Computed Master Secret: {}", ArrayConverter.bytesToHexString(masterSecret));

    protocolMessage.setMasterSecret(masterSecret);
    tlsContext.setMasterSecret(protocolMessage.getMasterSecret().getValue());

    return result;

}

---

From source file:de.rub.nds.tlsattacker.tls.protocol.handshake.DHEServerKeyExchangeHandler.java

License:Apache License

 @Override
 public byte[] prepareMessageAction() {
     // To use true DH ephemeral we need to precompute the prime number P(DH modulus)
/**int defaultPrimeProbability = 30;

DHParametersGenerator generator = new DHParametersGenerator();
     //Genration of a higher bit prime number takes too long (512 bits takes 2 seconds)
generator.init(512, defaultPrimeProbability, new SecureRandom());
DHParameters params = generator.generateParameters();*/
        /*from w w  w. ja  v a2 s  .  co  m*/
     //fixed DH modulus P and DH generator G
     byte [] pArray = ArrayConverter
    .hexStringToByteArray("ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc"
                 + "74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d"
                 + "51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24"
                 + "117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83"
                 + "655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca1821"
                 + "7c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf695"
                 + "5817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff");
     byte [] gArray = {0x02}; 
     BigInteger p = new BigInteger(1, pArray);
     BigInteger g = new BigInteger(1, gArray);
     DHParameters params = new DHParameters( p, g );
        
KeyGenerationParameters kgp = new DHKeyGenerationParameters(new SecureRandom(), params);
DHKeyPairGenerator keyGen = new DHKeyPairGenerator();
keyGen.init(kgp);
AsymmetricCipherKeyPair serverKeyPair = keyGen.generateKeyPair();
        
DHPublicKeyParameters dhPublic = (DHPublicKeyParameters) serverKeyPair.getPublic();
DHPrivateKeyParameters dhPrivate = (DHPrivateKeyParameters) serverKeyPair.getPrivate();

protocolMessage.setG(dhPublic.getParameters().getG());
protocolMessage.setP(dhPublic.getParameters().getP());
protocolMessage.setPublicKey(dhPublic.getY());
protocolMessage.setPrivateKey(dhPrivate.getX());
tlsContext.setServerDHPrivateKeyParameters(dhPrivate);

byte[] serializedP = BigIntegers.asUnsignedByteArray(protocolMessage.getP().getValue());
protocolMessage.setSerializedP(serializedP);
protocolMessage.setSerializedPLength(serializedP.length);

byte[] serializedG = BigIntegers.asUnsignedByteArray(protocolMessage.getG().getValue());
protocolMessage.setSerializedG(serializedG);
protocolMessage.setSerializedGLength(serializedG.length);

byte[] serializedPublicKey = BigIntegers.asUnsignedByteArray(protocolMessage.getPublicKey().getValue());
protocolMessage.setSerializedPublicKey(serializedPublicKey);
protocolMessage.setSerializedPublicKeyLength(serializedPublicKey.length);

byte[] dhParams = ArrayConverter.concatenate(ArrayConverter.intToBytes(protocolMessage.getSerializedPLength()
   .getValue(), HandshakeByteLength.DH_PARAM_LENGTH), protocolMessage.getSerializedP().getValue(),
   ArrayConverter.intToBytes(protocolMessage.getSerializedGLength().getValue(),
      HandshakeByteLength.DH_PARAM_LENGTH), protocolMessage.getSerializedG().getValue(),
   ArrayConverter.intToBytes(protocolMessage.getSerializedPublicKeyLength().getValue(),
      HandshakeByteLength.DH_PARAM_LENGTH), protocolMessage.getSerializedPublicKey().getValue());
InputStream is = new ByteArrayInputStream(dhParams);

try {
    ServerDHParams publicKeyParameters = ServerDHParams.parse(is);

    tlsContext.setServerDHParameters(publicKeyParameters);

    KeyStore ks = tlsContext.getKeyStore();

    SignatureAndHashAlgorithm selectedSignatureHashAlgo = new SignatureAndHashAlgorithm(SignatureAlgorithm.RSA,
       HashAlgorithm.SHA1);
    protocolMessage.setSignatureAlgorithm(selectedSignatureHashAlgo.getSignatureAlgorithm().getValue());
    protocolMessage.setHashAlgorithm(selectedSignatureHashAlgo.getHashAlgorithm().getValue());

    Key key = ks.getKey(tlsContext.getAlias(), tlsContext.getPassword().toCharArray());

    RSAPrivateCrtKey rsaKey = (RSAPrivateCrtKey) key;

    Signature instance = Signature.getInstance(selectedSignatureHashAlgo.getJavaName());
    instance.initSign(rsaKey);
    LOGGER.debug("SignatureAndHashAlgorithm for ServerKeyExchange message: {}",
       selectedSignatureHashAlgo.getJavaName());

    byte[] toBeSignedBytes = ArrayConverter.concatenate(tlsContext.getClientRandom(), tlsContext
       .getServerRandom(), dhParams);

    instance.update(toBeSignedBytes);
    byte[] signature = instance.sign();
    protocolMessage.setSignature(signature);
    protocolMessage.setSignatureLength(signature.length);

    byte[] result = ArrayConverter.concatenate(dhParams,
       new byte[] { protocolMessage.getHashAlgorithm().getValue(),
          protocolMessage.getSignatureAlgorithm().getValue() }, ArrayConverter.intToBytes(
          protocolMessage.getSignatureLength().getValue(), HandshakeByteLength.SIGNATURE_LENGTH),
       protocolMessage.getSignature().getValue());

    protocolMessage.setLength(result.length);

    long header = (HandshakeMessageType.SERVER_KEY_EXCHANGE.getValue() << 24)
       + protocolMessage.getLength().getValue();

    protocolMessage.setCompleteResultingMessage(ArrayConverter.concatenate(
       ArrayConverter.longToUint32Bytes(header), result));

} catch (KeyStoreException | NoSuchAlgorithmException | UnrecoverableKeyException | InvalidKeyException
   | SignatureException | IOException ex) {
    throw new ConfigurationException(ex.getLocalizedMessage(), ex);
}

return protocolMessage.getCompleteResultingMessage().getValue();
 }

---