/** * Creates a public key object from the given encoded key. * * @param encoded The encoded key bytes to generate the key from. * * @return The PublicKey object or null upon failure. */ protected static DHPublicKeyParameters decodeDHPublicKey(byte[] encoded) { BigInteger i = new BigInteger(encoded); return new DHPublicKeyParameters(i, DH_GROUP_PARAMETERS); }
JCEDHPublicKey( DHPublicKeyParameters params) { this.y = params.getY(); this.dhSpec = new DHParameterSpec(params.getParameters().getP(), params.getParameters().getG(), params.getParameters().getL()); }
public DHPublicKeyParameters( BigInteger y, DHParameters params) { super(false, params); this.y = validate(y, params); }
/** * Extracts a byte array representation of a public key given a keypair. * * @param pubkey The keypair from which to get the public key. * * @return The underlying byte array of the public key or null upon failure. */ protected static byte[] encodeDHPublicKey(DHPublicKeyParameters pubkey) { return pubkey.getY().toByteArray(); }
public void generateClientKeyExchange(OutputStream os) throws IOException { /* * RFC 2246 7.4.7.2 If the client certificate already contains a suitable * Diffie-Hellman key, then Yc is implicit and does not need to be sent again. In * this case, the Client Key Exchange message will be sent, but will be empty. */ if (agreementCredentials == null) { generateEphemeralClientKeyExchange(dhAgreeServerPublicKey.getParameters(), os); } }
public boolean equals( Object obj) { if (!(obj instanceof DHPublicKeyParameters)) { return false; } DHPublicKeyParameters other = (DHPublicKeyParameters)obj; return other.getY().equals(y) && super.equals(obj); } }
public void processServerKeyExchange(InputStream input) throws IOException { if (!requiresServerKeyExchange()) { throw new TlsFatalAlert(AlertDescription.unexpected_message); } // DH_anon is handled here, DHE_* in a subclass ServerDHParams dhParams = ServerDHParams.parse(input); this.dhAgreePublicKey = TlsDHUtils.validateDHPublicKey(dhParams.getPublicKey()); this.dhParameters = validateDHParameters(dhAgreePublicKey.getParameters()); }
BCDHPublicKey( DHPublicKeyParameters params) { this.y = params.getY(); this.dhSpec = new DHParameterSpec(params.getParameters().getP(), params.getParameters().getG(), params.getParameters().getL()); }
public AsymmetricKeyParameter readKey(InputStream stream) throws IOException { byte[] V = new byte[(dhParams.getP().bitLength() + 7) / 8]; Streams.readFully(stream, V, 0, V.length); return new DHPublicKeyParameters(new BigInteger(1, V), dhParams); } }
public boolean equals( Object obj) { if (!(obj instanceof DHPublicKeyParameters)) { return false; } DHPublicKeyParameters other = (DHPublicKeyParameters)obj; return other.getY().equals(y) && super.equals(obj); } }
public void processServerKeyExchange(InputStream input) throws IOException { this.psk_identity_hint = TlsUtils.readOpaque16(input); if (this.keyExchange == KeyExchangeAlgorithm.DHE_PSK) { ServerDHParams serverDHParams = ServerDHParams.parse(input); this.dhAgreePublicKey = TlsDHUtils.validateDHPublicKey(serverDHParams.getPublicKey()); this.dhParameters = dhAgreePublicKey.getParameters(); } else if (this.keyExchange == KeyExchangeAlgorithm.ECDHE_PSK) { ECDomainParameters ecParams = TlsECCUtils.readECParameters(namedCurves, clientECPointFormats, input); byte[] point = TlsUtils.readOpaque8(input); this.ecAgreePublicKey = TlsECCUtils.validateECPublicKey(TlsECCUtils.deserializeECPublicKey( clientECPointFormats, ecParams, point)); } }
JCEDHPublicKey( DHPublicKeyParameters params) { this.y = params.getY(); this.dhSpec = new DHParameterSpec(params.getParameters().getP(), params.getParameters().getG(), params.getParameters().getL()); }
public void processClientKeyExchange(InputStream input) throws IOException { if (dhAgreePublicKey != null) { // For dss_fixed_dh and rsa_fixed_dh, the key arrived in the client certificate return; } BigInteger Yc = TlsDHUtils.readDHParameter(input); this.dhAgreePublicKey = TlsDHUtils.validateDHPublicKey(new DHPublicKeyParameters(Yc, dhParameters)); }
public byte[] encodePublicKey(DHPublicKeyParameters publicKey) throws IOException { return encodeParameter(publicKey.getY()); }
public void generateClientKeyExchange(OutputStream os) throws IOException { if (psk_identity_hint == null || psk_identity_hint.length == 0) { pskIdentity.skipIdentityHint(); } else { pskIdentity.notifyIdentityHint(psk_identity_hint); } byte[] psk_identity = pskIdentity.getPSKIdentity(); TlsUtils.writeOpaque16(psk_identity, os); if (this.keyExchange == KeyExchangeAlgorithm.RSA_PSK) { this.premasterSecret = TlsRSAUtils.generateEncryptedPreMasterSecret(context, this.rsaServerPublicKey, os); } else if (this.keyExchange == KeyExchangeAlgorithm.DHE_PSK) { this.dhAgreeClientPrivateKey = TlsDHUtils.generateEphemeralClientKeyExchange( context.getSecureRandom(), dhAgreeServerPublicKey.getParameters(), os); } }
BCDHPublicKey( DHPublicKeyParameters params) { this.y = params.getY(); this.dhSpec = new DHParameterSpec(params.getParameters().getP(), params.getParameters().getG(), params.getParameters().getL()); this.dhPublicKey = params; }
public DHPublicKeyParameters decodePublicKey(byte[] encoding) throws IOException { /* * RFC 7919 3. [..] the client MUST verify that dh_Ys is in the range 1 < dh_Ys < dh_p - 1. * If dh_Ys is not in this range, the client MUST terminate the connection with a fatal * handshake_failure(40) alert. */ try { BigInteger y = decodeParameter(encoding); return new DHPublicKeyParameters(y, dhParameters); } catch (RuntimeException e) { throw new TlsFatalAlert(AlertDescription.handshake_failure, e); } }
public byte[] getEncoded(AsymmetricKeyParameter keyParameter) { byte[] Vloc = new byte[(((DHKeyParameters)keyParameter).getParameters().getP().bitLength() + 7) / 8]; byte[] Vtmp = BigIntegers.asUnsignedByteArray(((DHPublicKeyParameters)keyParameter).getY()); if (Vtmp.length > Vloc.length) { throw new IllegalArgumentException("Senders's public key longer than expected."); } else { System.arraycopy(Vtmp, 0, Vloc, Vloc.length - Vtmp.length, Vtmp.length); } return Vloc; } });
public void processServerKeyExchange(InputStream input) throws IOException { SecurityParameters securityParameters = context.getSecurityParameters(); SignerInputBuffer buf = new SignerInputBuffer(); InputStream teeIn = new TeeInputStream(input, buf); ServerDHParams dhParams = ServerDHParams.parse(teeIn); DigitallySigned signed_params = parseSignature(input); Signer signer = initVerifyer(tlsSigner, signed_params.getAlgorithm(), securityParameters); buf.updateSigner(signer); if (!signer.verifySignature(signed_params.getSignature())) { throw new TlsFatalAlert(AlertDescription.decrypt_error); } this.dhAgreePublicKey = TlsDHUtils.validateDHPublicKey(dhParams.getPublicKey()); this.dhParameters = validateDHParameters(dhAgreePublicKey.getParameters()); }
public static DHPublicKeyParameters validateDHPublicKey(DHPublicKeyParameters key) throws IOException { DHParameters params = validateDHParameters(key.getParameters()); BigInteger Y = key.getY(); if (Y.compareTo(TWO) < 0 || Y.compareTo(params.getP().subtract(TWO)) > 0) { throw new TlsFatalAlert(AlertDescription.illegal_parameter); } // TODO See RFC 2631 for more discussion of Diffie-Hellman validation return key; }