Optimized (a bit) the rsa_parameter copying. I don't like it.

diff --git a/lib/gnutls_rsa_export.c b/lib/gnutls_rsa_export.c
index fa1ed8b853ad4303e42a4514a553a0e701657400..57e15ebb12eda8fb289383bdff2162a60b86e724 100644 (file)
--- a/lib/gnutls_rsa_export.c
+++ b/lib/gnutls_rsa_export.c
@@ -186,8 +186,17 @@ int gnutls_rsa_params_import_raw(gnutls_rsa_params rsa_params,
   **/
 int gnutls_rsa_params_init(gnutls_rsa_params * rsa_params)
 {
+int ret;
 
-       return gnutls_x509_privkey_init( rsa_params);
+       ret = gnutls_x509_privkey_init( rsa_params);
+       if (ret < 0) {
+               gnutls_assert();
+               return ret;
+       }
+       
+       (*rsa_params)->crippled = 1;
+       
+       return 0;
 }
 
 /**

diff --git a/lib/x509/privkey.c b/lib/x509/privkey.c
index 70fe0ddc64ac62f9eaad1ec51e206a02dddf7c65..b38ea376df28c936120e1bef1b148293320901d0 100644 (file)
--- a/lib/x509/privkey.c
+++ b/lib/x509/privkey.c
@@ -103,25 +103,28 @@ int i, ret;
 
        dst->params_size = src->params_size;
        dst->pk_algorithm = src->pk_algorithm;
-
-       switch( dst->pk_algorithm) {
-               case GNUTLS_PK_DSA:
-                       ret = _encode_dsa( &dst->key, dst->params);
-                       if (ret < 0) {
-                               gnutls_assert();
-                               return ret;
-                       }
-                       break;
-               case GNUTLS_PK_RSA:
-                       ret = _encode_rsa( &dst->key, dst->params);
-                       if (ret < 0) {
+       dst->crippled = src->crippled;
+
+       if (!src->crippled) {
+               switch( dst->pk_algorithm) {
+                       case GNUTLS_PK_DSA:
+                               ret = _encode_dsa( &dst->key, dst->params);
+                               if (ret < 0) {
+                                       gnutls_assert();
+                                       return ret;
+                               }
+                               break;
+                       case GNUTLS_PK_RSA:
+                               ret = _encode_rsa( &dst->key, dst->params);
+                               if (ret < 0) {
+                                       gnutls_assert();
+                                       return ret;
+                               }
+                               break;
+                       default:
                                gnutls_assert();
-                               return ret;
-                       }
-                       break;
-               default:
-                       gnutls_assert();
-                       return GNUTLS_E_INVALID_REQUEST;
+                               return GNUTLS_E_INVALID_REQUEST;
+               }
        }
 
        return 0;
@@ -478,11 +481,13 @@ int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey key,
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
-       ret = _encode_rsa( &key->key, key->params);
-       if (ret < 0) {
-               gnutls_assert();
-               FREE_RSA_PRIVATE_PARAMS;
-               return ret;
+       if (!key->crippled) {
+               ret = _encode_rsa( &key->key, key->params);
+               if (ret < 0) {
+                       gnutls_assert();
+                       FREE_RSA_PRIVATE_PARAMS;
+                       return ret;
+               }
        }
 
        key->params_size = RSA_PRIVATE_PARAMS;
@@ -553,11 +558,13 @@ int gnutls_x509_privkey_import_dsa_raw(gnutls_x509_privkey key,
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
-       ret = _encode_dsa( &key->key, key->params);
-       if (ret < 0) {
-               gnutls_assert();
-               FREE_DSA_PRIVATE_PARAMS;
-               return ret;
+       if (!key->crippled) {
+               ret = _encode_dsa( &key->key, key->params);
+               if (ret < 0) {
+                       gnutls_assert();
+                       FREE_DSA_PRIVATE_PARAMS;
+                       return ret;
+               }
        }
 
        key->params_size = DSA_PRIVATE_PARAMS;
@@ -615,6 +622,7 @@ int gnutls_x509_privkey_export( gnutls_x509_privkey key,
        gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size)
 {
        char * msg;
+       int ret;
 
        if (key == NULL) {
                gnutls_assert();
@@ -627,6 +635,29 @@ int gnutls_x509_privkey_export( gnutls_x509_privkey key,
                msg = PEM_KEY_DSA;
        else msg = NULL;
 
+       if (key->crippled) { /* encode the parameters on the fly.
+                             */
+               switch( key->pk_algorithm) {
+                       case GNUTLS_PK_DSA:
+                               ret = _encode_dsa( &key->key, key->params);
+                               if (ret < 0) {
+                                       gnutls_assert();
+                                       return ret;
+                               }
+                       break;
+                       case GNUTLS_PK_RSA:
+                               ret = _encode_rsa( &key->key, key->params);
+                               if (ret < 0) {
+                                       gnutls_assert();
+                                       return ret;
+                               }
+                       break;
+                       default:
+                               gnutls_assert();
+                               return GNUTLS_E_INVALID_REQUEST;
+               }
+       }
+
        return _gnutls_x509_export_int( key->key, format, msg, *output_data_size,
                output_data, output_data_size);
 }
@@ -1190,10 +1221,12 @@ int i;
                                return ret;
                        }
                        
-                       ret = _encode_dsa( &key->key, key->params);
-                       if (ret < 0) {
-                               gnutls_assert();
-                               goto cleanup;
+                       if (!key->crippled) {
+                               ret = _encode_dsa( &key->key, key->params);
+                               if (ret < 0) {
+                                       gnutls_assert();
+                                       goto cleanup;
+                               }
                        }
                        key->params_size = params_len;
                        key->pk_algorithm = GNUTLS_PK_DSA;
@@ -1206,11 +1239,14 @@ int i;
                                return ret;
                        }
                        
-                       ret = _encode_rsa( &key->key, key->params);
-                       if (ret < 0) {
-                               gnutls_assert();
-                               goto cleanup;
+                       if (!key->crippled) {
+                               ret = _encode_rsa( &key->key, key->params);
+                               if (ret < 0) {
+                                       gnutls_assert();
+                                       goto cleanup;
+                               }
                        }
+
                        key->params_size = params_len;
                        key->pk_algorithm = GNUTLS_PK_RSA;
                        
@@ -1257,7 +1293,7 @@ int result;
 GNUTLS_HASH_HANDLE hd;
 gnutls_datum der = { NULL, 0 };
 
-       if (key == NULL) {
+       if (key == NULL || key->crippled) {
                gnutls_assert();
                return GNUTLS_E_INVALID_REQUEST;
        }

diff --git a/lib/x509/x509.h b/lib/x509/x509.h
index ee5c949e1ad8b5dcc3a17901b6d14f3408a50af3..3d2052cbd4ec4df0896c95bf194f82de71166450 100644 (file)
--- a/lib/x509/x509.h
+++ b/lib/x509/x509.h
@@ -51,6 +51,11 @@ typedef struct gnutls_x509_privkey_int {
 
        gnutls_pk_algorithm pk_algorithm;
 
+       int crippled; /* The crippled keys will not use the ASN1_TYPE key.
+                      * The encoding will only be performed at the export
+                      * phase, to optimize copying etc. Cannot be used with
+                      * the exported API (used internally only).
+                      */
        ASN1_TYPE key;
 } gnutls_x509_privkey_int;