tls-sig: instrument crypto-auditing probes

Signed-off-by: Daiki Ueno <ueno@gnu.org>

diff --git a/lib/tls-sig.c b/lib/tls-sig.c
index ef89ed1110cc453b3067133eaf6f76b7d4fe4687..b6913c456221c04fd0267c2c186674b018abd5b8 100644 (file)
--- a/lib/tls-sig.c
+++ b/lib/tls-sig.c
@@ -39,6 +39,7 @@
 #include "state.h"
 #include "x509/common.h"
 #include "abstract_int.h"
+#include "crau/crau.h"
 
 int _gnutls_check_key_usage_for_sig(gnutls_session_t session,
                                    unsigned key_usage, unsigned our_cert)
@@ -201,12 +202,19 @@ int _gnutls_handshake_sign_data(gnutls_session_t session, gnutls_pcert_st *cert,
 
        se = _gnutls_sign_to_entry(*sign_algo);
 
+       crau_new_context_with_data("name", CRAU_STRING, "tls::sign",
+                                  "tls::signature_algorithm", CRAU_WORD,
+                                  se->aid.id[0] << 8 | se->aid.id[1], NULL);
+
        if (_gnutls_version_has_selectable_sighash(ver))
-               return _gnutls_handshake_sign_data12(session, cert, pkey,
-                                                    params, signature, se);
+               ret = _gnutls_handshake_sign_data12(session, cert, pkey, params,
+                                                   signature, se);
        else
-               return _gnutls_handshake_sign_data10(session, cert, pkey,
-                                                    params, signature, se);
+               ret = _gnutls_handshake_sign_data10(session, cert, pkey, params,
+                                                   signature, se);
+
+       crau_pop_context();
+       return ret;
 }
 
 /* Generates a signature of all the random data and the parameters.
@@ -226,6 +234,7 @@ static int _gnutls_handshake_verify_data10(gnutls_session_t session,
        gnutls_digest_algorithm_t hash_algo;
        const mac_entry_st *me;
        gnutls_pk_algorithm_t pk_algo;
+       const gnutls_sign_entry_st *se;
 
        pk_algo = gnutls_pubkey_get_pk_algorithm(cert->pubkey, NULL);
        if (pk_algo == GNUTLS_PK_RSA) {
@@ -257,6 +266,12 @@ static int _gnutls_handshake_verify_data10(gnutls_session_t session,
        dconcat.data = concat;
        dconcat.size = _gnutls_hash_get_algo_len(me);
 
+       se = _gnutls_sign_to_entry(sign_algo);
+       if (se) {
+               crau_data("tls::signature_algorithm", CRAU_WORD,
+                         se->aid.id[0] << 8 | se->aid.id[1], NULL);
+       }
+
        ret = gnutls_pubkey_verify_hash2(cert->pubkey, sign_algo,
                                         GNUTLS_VERIFY_ALLOW_SIGN_WITH_SHA1 |
                                                 verify_flags,
@@ -279,6 +294,9 @@ static int _gnutls_handshake_verify_data12(gnutls_session_t session,
        const version_entry_st *ver = get_version(session);
        const gnutls_sign_entry_st *se = _gnutls_sign_to_entry(sign_algo);
 
+       if (unlikely(se == NULL))
+               return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
+
        _gnutls_handshake_log(
                "HSK[%p]: verify TLS 1.2 handshake data: using %s\n", session,
                se->name);
@@ -313,6 +331,9 @@ static int _gnutls_handshake_verify_data12(gnutls_session_t session,
        memcpy(dconcat.data + GNUTLS_RANDOM_SIZE * 2, params->data,
               params->size);
 
+       crau_data("tls::signature_algorithm", CRAU_WORD,
+                 se->aid.id[0] << 8 | se->aid.id[1], NULL);
+
        ret = gnutls_pubkey_verify_data2(cert->pubkey, sign_algo, verify_flags,
                                         &dconcat, signature);
        if (ret < 0)
@@ -346,14 +367,19 @@ int _gnutls_handshake_verify_data(gnutls_session_t session,
 
        gnutls_sign_algorithm_set_server(session, sign_algo);
 
+       crau_new_context_with_data("name", CRAU_STRING, "tls::verify", NULL);
+
        if (_gnutls_version_has_selectable_sighash(ver))
-               return _gnutls_handshake_verify_data12(session, verify_flags,
-                                                      cert, params, signature,
-                                                      sign_algo);
+               ret = _gnutls_handshake_verify_data12(session, verify_flags,
+                                                     cert, params, signature,
+                                                     sign_algo);
        else
-               return _gnutls_handshake_verify_data10(session, verify_flags,
-                                                      cert, params, signature,
-                                                      sign_algo);
+               ret = _gnutls_handshake_verify_data10(session, verify_flags,
+                                                     cert, params, signature,
+                                                     sign_algo);
+
+       crau_pop_context();
+       return ret;
 }
 
 /* Client certificate verify calculations
@@ -419,6 +445,9 @@ static int _gnutls_handshake_verify_crt_vrfy12(
        dconcat.data = session->internals.handshake_hash_buffer.data;
        dconcat.size = session->internals.handshake_hash_buffer_prev_len;
 
+       crau_data("tls::signature_algorithm", CRAU_WORD,
+                 se->aid.id[0] << 8 | se->aid.id[1], NULL);
+
        /* Here we intentionally enable flag GNUTLS_VERIFY_ALLOW_BROKEN
         * because we have checked whether the currently used signature
         * algorithm is allowed in the session. */
@@ -449,6 +478,7 @@ static int _gnutls_handshake_verify_crt_vrfy3(gnutls_session_t session,
        gnutls_datum_t dconcat;
        gnutls_pk_algorithm_t pk =
                gnutls_pubkey_get_pk_algorithm(cert->pubkey, NULL);
+       const gnutls_sign_entry_st *se;
 
        ret = _gnutls_generate_master(session, 1);
        if (ret < 0) {
@@ -498,6 +528,12 @@ static int _gnutls_handshake_verify_crt_vrfy3(gnutls_session_t session,
 
        dconcat.size += 20;
 
+       se = _gnutls_sign_to_entry(sign_algo);
+       if (se) {
+               crau_data("tls::signature_algorithm", CRAU_WORD,
+                         se->aid.id[0] << 8 | se->aid.id[1], NULL);
+       }
+
        ret = gnutls_pubkey_verify_hash2(cert->pubkey, GNUTLS_SIGN_UNKNOWN,
                                         GNUTLS_VERIFY_ALLOW_SIGN_WITH_SHA1 |
                                                 verify_flags,
@@ -519,6 +555,7 @@ static int _gnutls_handshake_verify_crt_vrfy10(
        gnutls_datum_t dconcat;
        gnutls_pk_algorithm_t pk_algo;
        const mac_entry_st *me;
+       const gnutls_sign_entry_st *se;
 
        /* TLS 1.0 and TLS 1.1 */
        pk_algo = gnutls_pubkey_get_pk_algorithm(cert->pubkey, NULL);
@@ -544,6 +581,12 @@ static int _gnutls_handshake_verify_crt_vrfy10(
        dconcat.data = concat;
        dconcat.size = _gnutls_hash_get_algo_len(me);
 
+       se = _gnutls_sign_to_entry(sign_algo);
+       if (se) {
+               crau_data("tls::signature_algorithm", CRAU_WORD,
+                         se->aid.id[0] << 8 | se->aid.id[1], NULL);
+       }
+
        ret = gnutls_pubkey_verify_hash2(cert->pubkey, sign_algo,
                                         GNUTLS_VERIFY_ALLOW_SIGN_WITH_SHA1 |
                                                 verify_flags,
@@ -586,19 +629,25 @@ int _gnutls_handshake_verify_crt_vrfy(gnutls_session_t session,
 
        gnutls_sign_algorithm_set_client(session, sign_algo);
 
+       crau_new_context_with_data("name", CRAU_STRING, "tls::verify", NULL);
+
        /* TLS 1.2 */
        if (_gnutls_version_has_selectable_sighash(ver))
-               return _gnutls_handshake_verify_crt_vrfy12(
+               ret = _gnutls_handshake_verify_crt_vrfy12(
                        session, verify_flags, cert, signature, sign_algo);
 #ifdef ENABLE_SSL3
-       if (ver->id == GNUTLS_SSL3)
-               return _gnutls_handshake_verify_crt_vrfy3(
+       else if (ver->id == GNUTLS_SSL3)
+               ret = _gnutls_handshake_verify_crt_vrfy3(
                        session, verify_flags, cert, signature, sign_algo);
 #endif
+       else {
+               /* TLS 1.0 and TLS 1.1 */
+               ret = _gnutls_handshake_verify_crt_vrfy10(
+                       session, verify_flags, cert, signature, sign_algo);
+       }
 
-       /* TLS 1.0 and TLS 1.1 */
-       return _gnutls_handshake_verify_crt_vrfy10(session, verify_flags, cert,
-                                                  signature, sign_algo);
+       crau_pop_context();
+       return ret;
 }
 
 /* the same as _gnutls_handshake_sign_crt_vrfy except that it is made for TLS 1.2.
@@ -625,10 +674,13 @@ static int _gnutls_handshake_sign_crt_vrfy12(gnutls_session_t session,
        if (se == NULL)
                return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 
-       gnutls_sign_algorithm_set_client(session, sign_algo);
+       crau_data("tls::signature_algorithm", CRAU_WORD,
+                 se->aid.id[0] << 8 | se->aid.id[1], NULL);
+
+       gnutls_sign_algorithm_set_client(session, se->id);
 
-       if (unlikely(gnutls_sign_supports_pk_algorithm(
-                            sign_algo, pkey->pk_algorithm) == 0))
+       if (unlikely(sign_supports_priv_pk_algorithm(se, pkey->pk_algorithm) ==
+                    0))
                return gnutls_assert_val(GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER);
 
        _gnutls_debug_log("sign handshake cert vrfy: picked %s\n",
@@ -720,7 +772,7 @@ static int _gnutls_handshake_sign_crt_vrfy3(gnutls_session_t session,
        if (ret < 0)
                return gnutls_assert_val(ret);
 
-       return GNUTLS_SIGN_UNKNOWN;
+       return ret;
 }
 #endif
 
@@ -801,18 +853,24 @@ int _gnutls_handshake_sign_crt_vrfy(gnutls_session_t session,
        if (ret < 0)
                return gnutls_assert_val(ret);
 
+       crau_new_context_with_data("name", CRAU_STRING, "tls::sign", NULL);
+
        /* TLS 1.2 */
        if (_gnutls_version_has_selectable_sighash(ver))
-               return _gnutls_handshake_sign_crt_vrfy12(session, cert, pkey,
-                                                        signature);
+               ret = _gnutls_handshake_sign_crt_vrfy12(session, cert, pkey,
+                                                       signature);
 
        /* TLS 1.1 or earlier */
 #ifdef ENABLE_SSL3
-       if (ver->id == GNUTLS_SSL3)
-               return _gnutls_handshake_sign_crt_vrfy3(session, cert, ver,
-                                                       pkey, signature);
+       else if (ver->id == GNUTLS_SSL3)
+               ret = _gnutls_handshake_sign_crt_vrfy3(session, cert, ver, pkey,
+                                                      signature);
 #endif
+       else {
+               ret = _gnutls_handshake_sign_crt_vrfy10(session, cert, ver,
+                                                       pkey, signature);
+       }
 
-       return _gnutls_handshake_sign_crt_vrfy10(session, cert, ver, pkey,
-                                                signature);
+       crau_pop_context();
+       return ret;
 }

diff --git a/lib/tls13-sig.c b/lib/tls13-sig.c
index c781e045b2739aca5c41d79a4a6cacdc945b9fab..02de5c5fb8128ae085cb4122c142aef6b1b320cf 100644 (file)
--- a/lib/tls13-sig.c
+++ b/lib/tls13-sig.c
@@ -29,6 +29,7 @@
 #include "tls13-sig.h"
 #include "tls-sig.h"
 #include "hash_int.h"
+#include "crau/crau.h"
 
 #undef PREFIX_SIZE
 #define PREFIX_SIZE 64
@@ -83,6 +84,10 @@ int _gnutls13_handshake_verify_data(gnutls_session_t session,
        if (ret < 0)
                return gnutls_assert_val(ret);
 
+       crau_new_context_with_data("name", CRAU_STRING, "tls::verify",
+                                  "tls::signature_algorithm", CRAU_WORD,
+                                  se->aid.id[0] << 8 | se->aid.id[1], NULL);
+
        _gnutls_buffer_init(&buf);
 
        memset(prefix, 0x20, sizeof(prefix));
@@ -134,6 +139,7 @@ int _gnutls13_handshake_verify_data(gnutls_session_t session,
        ret = 0;
 cleanup:
        _gnutls_buffer_clear(&buf);
+       crau_pop_context();
 
        return ret;
 }
@@ -162,6 +168,10 @@ int _gnutls13_handshake_sign_data(gnutls_session_t session,
                "HSK[%p]: signing TLS 1.3 handshake data: using %s and PRF: %s\n",
                session, se->name, session->security_parameters.prf->name);
 
+       crau_new_context_with_data("name", CRAU_STRING, "tls::sign",
+                                  "tls::signature_algorithm", CRAU_WORD,
+                                  se->aid.id[0] << 8 | se->aid.id[1], NULL);
+
        _gnutls_buffer_init(&buf);
 
        ret = _gnutls_buffer_resize(&buf, PREFIX_SIZE);
@@ -215,6 +225,7 @@ int _gnutls13_handshake_sign_data(gnutls_session_t session,
        ret = 0;
 cleanup:
        _gnutls_buffer_clear(&buf);
+       crau_pop_context();
 
        return ret;
 }