TLS 1.2 ECDHE_RSA-Signatur

Question

Ich arbeite gerade an einem Java-TLS-Server. Ich versuche, die folgende CipherSuite an der Arbeit: TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA

Als ich es testen openssl s_client ich mit dem folgenden Fehler nach der ServerKeyExchange Meldung:

140735242416208:error:1414D172:SSL routines:tls12_check_peer_sigalg:wrong signature type:t1_lib.c:1130:

Hier ist die TLS-Nachricht wie in Wireshark gesehen

Der Handshake schlägt bei einem schwerwiegenden decode_error-Fehler fehl.

Also ich schätze, dass der Client den gewählten Signaturalgorithmus nicht mag.

Aber ich bin nur die Standard-SignatureAndHashAlgorithm mit jetzt per RFC 5246 Section-7.4.1.4.1

If the negotiated key exchange algorithm is one of (RSA, DHE_RSA, DH_RSA, RSA_PSK, ECDH_RSA, ECDHE_RSA), behave as if client had sent the value {sha1,rsa}.

(Ich überprüfe noch, wenn der Kunde es jedoch Standardwerte bieten Thesen)

Da ich ECDHE_RSA mache ich glaube, ich Hash sollte und unterschreiben die serverECDHparams gemäß RFC 4492 Abschnitt 5.4 (erster Beitrag hier so nur 2 Links leid :))

ServerKeyExchange.signed_params.sha_hash 
     SHA(ClientHello.random + ServerHello.random + 
              ServerKeyExchange.params); 
struct { 
    select (KeyExchangeAlgorithm) { 
     case ec_diffie_hellman: 
      ServerECDHParams params; 
      Signature signed_params; 
    }; 
} ServerKeyExchange; 

und ich tun dies gemäß RFC 2246 Abschnitt sollte 7.4.3

select (SignatureAlgorithm) { 
    case rsa: 
     digitally-signed struct { 
      opaque md5_hash[16]; 
      opaque sha_hash[20]; 
     }; 
} Signature; 


md5_hash 
MD5(ClientHello.random + ServerHello.random + ServerParams); 

sha_hash 
SHA(ClientHello.random + ServerHello.random + ServerParams); 

Mein Java-Code in Bezug auf die serverParams Unterzeichnung:

private byte[] getSignedParams(ChannelBuffer params) 
     throws NoSuchAlgorithmException, DigestException, 
     SignatureException, InvalidKeyException { 
    byte[] signedParams = null; 
    ChannelBuffer signAlg = ChannelBuffers.buffer(2); 
    MessageDigest md5 = MessageDigest.getInstance("MD5"); 
    MessageDigest sha = MessageDigest.getInstance("SHA-1"); 
    switch (session.cipherSuite.sign) { 
     case rsa: 
      signAlg.writeByte(2); // 2 for SHA1 
      sha.update(clientRandom); 
      sha.update(serverRandom); 
      sha.update(params.toByteBuffer()); 
      md5.update(clientRandom); 
      md5.update(serverRandom); 
      md5.update(params.toByteBuffer()); 
      signedParams = concat(md5.digest(), sha.digest()); 
     break; 
    } 
    signAlg.writeByte(session.cipherSuite.sign.value); // for RSA he byte is one 
    ChannelBuffer signLength = ChannelBuffers.buffer(2); 
    signLength.writeShort(signedParams.length); 
    return concat(signAlg.array(),concat(signLength.array(),signedParams)); 
} 

Also meine Frage ist im Grunde: Bin ich falsch über alles? und wenn ja, was mache ich falsch?

Vielen Dank für Ihre Zeit! :)

Answer 1

Es ist mir wieder, ich scheine 2 Dinge, die mein besonderes Problem zu haben feste ich gemerkt:

1. In Bezug auf mein Java-Code, nur die Message Klasse nicht Hashing keine Unterzeichnung so dass ich jetzt stattdessen die Signature-Klasse verwenden .
2. Es scheint, dass ich nur unter Verwendung von SHA1 in TLS1.2 unterschreiben muss. Ich brauche MD5 überhaupt nicht zu tun.

Der zweite Punkt ist, was ich in der RFC gefunden habe, sollte aber nicht (vielleicht ist es irgendwo geschrieben, ich weiß es nicht) Ich denke, dies auch für Menschen nützlich sein könnte, wenn sie nicht tun Java;)

Wie mein Code sieht jetzt:

private byte[] getSignedParams(ChannelBuffer params) 
     throws NoSuchAlgorithmException, DigestException, 
     SignatureException, InvalidKeyException { 
    byte[] signedParams = null; 
    Signature signature = Signature.getInstance(selectedSignAndHash.toString()); 
    ChannelBuffer signAlg = ChannelBuffers.buffer(2); 
    signAlg.writeByte(selectedSignAndHash.hash.value); 
    signature.initSign(privateKey); 

    signature.update(clientRandom); 
    signature.update(serverRandom); 
    signature.update(params.toByteBuffer()); 

    signedParams = signature.sign(); 

    signAlg.writeByte(session.cipherSuite.sign.value); 
    ChannelBuffer signLength = ChannelBuffers.buffer(2); 
    signLength.writeShort(signedParams.length); 
    return concat(signAlg.array(), concat(signLength.array(), signedParams)); 
} 

den Code ist anders, weil zwischen mir eine Funktion hinzugefügt, um die SignatureAndHashAlgorithm zu wählen aus der Liste zu verwenden, der Client zur Verfügung stellt. Aber Sie könnten dies ändern, um nur mit SHA1withRSA zu antworten, da dies der Standard-HashAndSignatureAlgorithm zu sein scheint.