_gnutls_pkcs_raw_{decrypt,encrypt}_data: use public crypto API

These functions previously used the internal crypto
API (_gnutls_cipher_*) which does not have algorithm checks for FIPS.

This change switches the code to use the public crypto
API (gnutls_cipher_*) to trigger proper state transitions under FIPS
mode.

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

diff --git a/lib/x509/pkcs7-crypt.c b/lib/x509/pkcs7-crypt.c
index 4cce52ecf021c94f83d992f9c349dcfc8132991c..2dc5bc4df05bdd3fee5839fb7a928ad0b1bcd8b6 100644 (file)
--- a/lib/x509/pkcs7-crypt.c
+++ b/lib/x509/pkcs7-crypt.c
@@ -1130,8 +1130,7 @@ _gnutls_pkcs_raw_decrypt_data(schema_id schema, asn1_node pkcs8_asn,
        gnutls_datum_t enc = { NULL, 0 };
        uint8_t *key = NULL;
        gnutls_datum_t dkey, d_iv;
-       cipher_hd_st ch;
-       int ch_init = 0;
+       gnutls_cipher_hd_t ch = NULL;
        int key_size, ret;
        unsigned int pass_len = 0;
        const struct pkcs_cipher_schema_st *p;
@@ -1237,8 +1236,7 @@ _gnutls_pkcs_raw_decrypt_data(schema_id schema, asn1_node pkcs8_asn,
        d_iv.data = (uint8_t *) enc_params->iv;
        d_iv.size = enc_params->iv_size;
 
-       ret =
-           _gnutls_cipher_init(&ch, ce, &dkey, &d_iv, 0);
+       ret = gnutls_cipher_init(&ch, ce->id, &dkey, &d_iv);
 
        gnutls_free(key);
 
@@ -1247,9 +1245,7 @@ _gnutls_pkcs_raw_decrypt_data(schema_id schema, asn1_node pkcs8_asn,
                goto error;
        }
 
-       ch_init = 1;
-
-       ret = _gnutls_cipher_decrypt(&ch, enc.data, enc.size);
+       ret = gnutls_cipher_decrypt(ch, enc.data, enc.size);
        if (ret < 0) {
                gnutls_assert();
                ret = GNUTLS_E_DECRYPTION_FAILED;
@@ -1281,7 +1277,7 @@ _gnutls_pkcs_raw_decrypt_data(schema_id schema, asn1_node pkcs8_asn,
                decrypted_data->size = enc.size;
        }
 
-       _gnutls_cipher_deinit(&ch);
+       gnutls_cipher_deinit(ch);
 
        ret = 0;
 
@@ -1294,8 +1290,9 @@ _gnutls_pkcs_raw_decrypt_data(schema_id schema, asn1_node pkcs8_asn,
        gnutls_free(password);
        gnutls_free(enc.data);
        gnutls_free(key);
-       if (ch_init != 0)
-               _gnutls_cipher_deinit(&ch);
+       if (ch) {
+               gnutls_cipher_deinit(ch);
+       }
        return ret;
 }
 
@@ -1725,8 +1722,7 @@ _gnutls_pkcs_raw_encrypt_data(const gnutls_datum_t * plain,
        int data_size;
        uint8_t *data = NULL;
        gnutls_datum_t d_iv;
-       cipher_hd_st ch;
-       int ch_init = 0;
+       gnutls_cipher_hd_t ch = NULL;
        uint8_t pad, pad_size;
        const cipher_entry_st *ce;
 
@@ -1756,18 +1752,13 @@ _gnutls_pkcs_raw_encrypt_data(const gnutls_datum_t * plain,
 
        d_iv.data = (uint8_t *) enc_params->iv;
        d_iv.size = enc_params->iv_size;
-       result =
-           _gnutls_cipher_init(&ch, cipher_to_entry(enc_params->cipher),
-                               key, &d_iv, 1);
-
+       result = gnutls_cipher_init(&ch, enc_params->cipher, key, &d_iv);
        if (result < 0) {
                gnutls_assert();
                goto error;
        }
 
-       ch_init = 1;
-
-       result = _gnutls_cipher_encrypt(&ch, data, data_size);
+       result = gnutls_cipher_encrypt(ch, data, data_size);
        if (result < 0) {
                gnutls_assert();
                goto error;
@@ -1776,13 +1767,14 @@ _gnutls_pkcs_raw_encrypt_data(const gnutls_datum_t * plain,
        encrypted->data = data;
        encrypted->size = data_size;
 
-       _gnutls_cipher_deinit(&ch);
+       gnutls_cipher_deinit(ch);
 
        return 0;
 
  error:
        gnutls_free(data);
-       if (ch_init != 0)
-               _gnutls_cipher_deinit(&ch);
+       if (ch) {
+               gnutls_cipher_deinit(ch);
+       }
        return result;
 }

diff --git a/tests/pkcs12_encode.c b/tests/pkcs12_encode.c
index b8f7d172671423b8935da5ed131415e9e58d0875..78f6f41b480af4f8bcee2e86415b2dd90f25f642 100644 (file)
--- a/tests/pkcs12_encode.c
+++ b/tests/pkcs12_encode.c
@@ -104,9 +104,17 @@ void doit(void)
        int ret, indx;
        char outbuf[10240];
        size_t size;
-       unsigned tests, i;
+       unsigned i;
        gnutls_fips140_context_t fips_context;
        gnutls_fips140_operation_state_t fips_state;
+       size_t n_tests = 0;
+       struct tests {
+               const char *name;
+               gnutls_x509_crt_t crt;
+               const char *friendly_name;
+               unsigned bag_encrypt_flags;
+               int bag_encrypt_expected;
+       } tests[2];
 
        ret = global_init();
        if (ret < 0) {
@@ -157,21 +165,34 @@ void doit(void)
                exit(1);
        }
 
-       /* Generate and add PKCS#12 cert bags. */
-       if (!gnutls_fips140_mode_enabled()) {
-               tests = 2; /* include RC2 */
+       tests[n_tests].name = "3DES";
+       tests[n_tests].crt = client;
+       tests[n_tests].friendly_name = "client";
+       tests[n_tests].bag_encrypt_flags = GNUTLS_PKCS8_USE_PKCS12_3DES;
+       tests[n_tests].bag_encrypt_expected = 0;
+       n_tests++;
+
+       tests[n_tests].name = "RC2-40";
+       tests[n_tests].crt = ca;
+       tests[n_tests].friendly_name = "ca";
+       tests[n_tests].bag_encrypt_flags = GNUTLS_PKCS_USE_PKCS12_RC2_40;
+       if (gnutls_fips140_mode_enabled()) {
+               tests[n_tests].bag_encrypt_expected =
+                       GNUTLS_E_UNWANTED_ALGORITHM;
        } else {
-               tests = 1;
+               tests[n_tests].bag_encrypt_expected = 0;
        }
+       n_tests++;
 
-       for (i = 0; i < tests; i++) {
+       /* Generate and add PKCS#12 cert bags. */
+       for (i = 0; i < n_tests; i++) {
                ret = gnutls_pkcs12_bag_init(&bag);
                if (ret < 0) {
                        fprintf(stderr, "bag_init: %s (%d)\n", gnutls_strerror(ret), ret);
                        exit(1);
                }
 
-               ret = gnutls_pkcs12_bag_set_crt(bag, i == 0 ? client : ca);
+               ret = gnutls_pkcs12_bag_set_crt(bag, tests[i].crt);
                if (ret < 0) {
                        fprintf(stderr, "set_crt: %s (%d)\n", gnutls_strerror(ret), ret);
                        exit(1);
@@ -180,16 +201,14 @@ void doit(void)
                indx = ret;
 
                ret = gnutls_pkcs12_bag_set_friendly_name(bag, indx,
-                                                         i ==
-                                                         0 ? "client" :
-                                                         "ca");
+                                                         tests[i].friendly_name);
                if (ret < 0) {
                        fprintf(stderr, "set_friendly_name: %s (%d)\n", gnutls_strerror(ret), ret);
                        exit(1);
                }
 
                size = sizeof(key_id_buf);
-               ret = gnutls_x509_crt_get_key_id(i == 0 ? client : ca, 0,
+               ret = gnutls_x509_crt_get_key_id(tests[i].crt, 0,
                                                 key_id_buf, &size);
                if (ret < 0) {
                        fprintf(stderr, "get_key_id: %s (%d)\n", gnutls_strerror(ret), ret);
@@ -206,14 +225,11 @@ void doit(void)
                }
 
                ret = gnutls_pkcs12_bag_encrypt(bag, "pass",
-                                               i ==
-                                               0 ?
-                                               GNUTLS_PKCS8_USE_PKCS12_3DES
-                                               :
-                                               GNUTLS_PKCS_USE_PKCS12_RC2_40);
-               if (ret < 0) {
-                       fprintf(stderr, "bag_encrypt: %d: %s", ret,
-                               i == 0 ? "3DES" : "RC2-40");
+                                               tests[i].bag_encrypt_flags);
+               if (ret != tests[i].bag_encrypt_expected) {
+                       fprintf(stderr, "bag_encrypt: returned %d, expected %d: %s", ret,
+                               tests[i].bag_encrypt_expected,
+                               tests[i].name);
                        exit(1);
                }