gwenhywfar  4.3.1
cryptkeyrsa.c
Go to the documentation of this file.
00001 /***************************************************************************
00002     begin       : Wed Mar 16 2005
00003     copyright   : (C) 2005 by Martin Preuss
00004     email       : martin@libchipcard.de
00005 
00006  ***************************************************************************
00007  *          Please see toplevel file COPYING for license details           *
00008  ***************************************************************************/
00009 
00010 #ifdef HAVE_CONFIG_H
00011 # include <config.h>
00012 #endif
00013 
00014 #define DISABLE_DEBUGLOG
00015 
00016 
00017 #include "cryptkeyrsa_p.h"
00018 #include <gwenhywfar/misc.h>
00019 #include <gwenhywfar/debug.h>
00020 #include <gwenhywfar/text.h>
00021 
00022 
00023 
00024 
00025 GWEN_INHERIT(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA)
00026 
00027 
00028 
00029 
00030 #if 0
00031 static void dumpKeyData(gcry_ac_data_t data) {
00032   int i;
00033   unsigned int l;
00034 
00035   l=gcry_ac_data_length(data);
00036   for (i=0; i<l; i++) {
00037     const char *dname;
00038     gcry_mpi_t mpi;
00039     gcry_error_t err;
00040     unsigned char *buf;
00041     size_t nbytes;
00042 
00043     gcry_ac_data_get_index(data, 0, i, &dname, &mpi);
00044     fprintf(stderr, "%3d: [%s]\n", i, dname);
00045 
00046     /* write mpi as bin into a buffer which will be allocates by this function */
00047     err=gcry_mpi_aprint(GCRYMPI_FMT_USG, &buf, &nbytes, mpi);
00048     if (err) {
00049       DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_aprint(): %d", err);
00050     }
00051     else {
00052       GWEN_Text_DumpString((const char*)buf, nbytes, stderr, 6);
00053       gcry_free(buf);
00054     }
00055   }
00056 }
00057 #endif
00058 
00059 
00060 
00061 
00062 int GWEN_Crypt_KeyRsa_Sign(GWEN_CRYPT_KEY *k,
00063                            const uint8_t *pInData,
00064                            uint32_t inLen,
00065                            uint8_t *pSignatureData,
00066                            uint32_t *pSignatureLen) {
00067   GWEN_CRYPT_KEY_RSA *xk;
00068   gcry_error_t err;
00069   size_t nscanned;
00070   gcry_ac_data_t dsKey;
00071   gcry_mpi_t mpi_d;
00072   gcry_mpi_t mpi_n;
00073   gcry_mpi_t mpi_in;
00074   gcry_mpi_t mpi_sigout1;
00075   gcry_mpi_t mpi_sigout2=NULL;
00076   size_t nwritten;
00077 
00078   assert(k);
00079   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
00080   assert(xk);
00081 
00082   dsKey=gcry_ac_key_data_get(xk->key);
00083 
00084   /* get modulus */
00085   err=gcry_ac_data_get_name(dsKey, 0, "n", &mpi_n);
00086   if (err) {
00087     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00088              gcry_strerror(err));
00089     return GWEN_ERROR_BAD_DATA;
00090   }
00091 
00092   /* get private exponent */
00093   err=gcry_ac_data_get_name(dsKey, 0, "d", &mpi_d);
00094   if (err) {
00095     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00096              gcry_strerror(err));
00097     return GWEN_ERROR_BAD_DATA;
00098   }
00099 
00100   /* convert input to MPI */
00101   mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00102   err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
00103   if (err) {
00104     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
00105     gcry_mpi_release(mpi_in);
00106     return GWEN_ERROR_BAD_DATA;
00107   }
00108 
00109   /* create first signature */
00110   mpi_sigout1=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00111   gcry_mpi_powm(mpi_sigout1, mpi_in, mpi_d, mpi_n);
00112 
00113   if (!(xk->flags & GWEN_CRYPT_KEYRSA_FLAGS_DIRECTSIGN)) {
00114     /* create second signature */
00115     mpi_sigout2=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00116     gcry_mpi_sub(mpi_sigout2, mpi_n, mpi_sigout1);
00117 
00118     if (gcry_mpi_cmp(mpi_sigout2, mpi_sigout1)<0) {
00119       DBG_DEBUG(GWEN_LOGDOMAIN, "Choosing 2nd variant");
00120       gcry_mpi_set(mpi_sigout1, mpi_sigout2);
00121     }
00122   }
00123 
00124   /* release unneeded objects */
00125   gcry_mpi_release(mpi_sigout2);
00126   gcry_mpi_release(mpi_in);
00127 
00128   /* convert signature MPI */
00129   err=gcry_mpi_print(GCRYMPI_FMT_USG,
00130                      pSignatureData, *pSignatureLen,
00131                      &nwritten, mpi_sigout1);
00132   gcry_mpi_release(mpi_sigout1);
00133   if (err) {
00134     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_print(): %s", gcry_strerror(err));
00135     return GWEN_ERROR_BAD_DATA;
00136   }
00137   *pSignatureLen=nwritten;
00138 
00139   return 0;
00140 }
00141 
00142 
00143 
00144 int GWEN_Crypt_KeyRsa_Verify(GWEN_CRYPT_KEY *k,
00145                              const uint8_t *pInData,
00146                              uint32_t inLen,
00147                              const uint8_t *pSignatureData,
00148                              uint32_t signatureLen) {
00149   GWEN_CRYPT_KEY_RSA *xk;
00150   gcry_error_t err;
00151   size_t nscanned;
00152   gcry_ac_data_t dsKey;
00153   gcry_mpi_t mpi_e;
00154   gcry_mpi_t mpi_n;
00155   gcry_mpi_t mpi_in;
00156   gcry_mpi_t mpi_sigin1;
00157   gcry_mpi_t mpi_sigout;
00158 
00159   assert(k);
00160   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
00161   assert(xk);
00162 
00163   dsKey=gcry_ac_key_data_get(xk->key);
00164 
00165   /* get modulus */
00166   err=gcry_ac_data_get_name(dsKey, 0, "n", &mpi_n);
00167   if (err) {
00168     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00169              gcry_strerror(err));
00170     return GWEN_ERROR_BAD_DATA;
00171   }
00172 
00173   /* get public exponent */
00174   err=gcry_ac_data_get_name(dsKey, 0, "e", &mpi_e);
00175   if (err) {
00176     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00177              gcry_strerror(err));
00178     return GWEN_ERROR_BAD_DATA;
00179   }
00180 
00181   /* convert input to MPI */
00182   mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00183   err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
00184   if (err) {
00185     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
00186     gcry_mpi_release(mpi_in);
00187     return GWEN_ERROR_BAD_DATA;
00188   }
00189 
00190   /* convert signature to MPI */
00191   mpi_sigin1=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00192   err=gcry_mpi_scan(&mpi_sigin1, GCRYMPI_FMT_USG,
00193                     pSignatureData, signatureLen,
00194                     &nscanned);
00195   if (err) {
00196     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
00197     gcry_mpi_release(mpi_sigin1);
00198     gcry_mpi_release(mpi_in);
00199     return GWEN_ERROR_BAD_DATA;
00200   }
00201 
00202   /* create signature */
00203   mpi_sigout=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00204   gcry_mpi_powm(mpi_sigout, mpi_sigin1, mpi_e, mpi_n);
00205   /* compare */
00206   if (gcry_mpi_cmp(mpi_sigout, mpi_in)) {
00207     gcry_mpi_t mpi_sigin2;
00208 
00209     mpi_sigin2=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00210 
00211     DBG_DEBUG(GWEN_LOGDOMAIN, "Trying 2nd variant");
00212     gcry_mpi_sub(mpi_sigin2, mpi_n, mpi_sigin1);
00213     gcry_mpi_powm(mpi_sigout, mpi_sigin2, mpi_e, mpi_n);
00214     if (gcry_mpi_cmp(mpi_sigout, mpi_in)) {
00215       DBG_ERROR(GWEN_LOGDOMAIN, "Bad signature");
00216       gcry_mpi_release(mpi_sigin2);
00217       gcry_mpi_release(mpi_sigout);
00218       gcry_mpi_release(mpi_sigin1);
00219       gcry_mpi_release(mpi_in);
00220       return GWEN_ERROR_VERIFY;
00221     }
00222     gcry_mpi_release(mpi_sigin2);
00223   }
00224 
00225   gcry_mpi_release(mpi_sigout);
00226   gcry_mpi_release(mpi_sigin1);
00227   gcry_mpi_release(mpi_in);
00228 
00229   return 0;
00230 }
00231 
00232 
00233 
00234 int GWEN_Crypt_KeyRsa_Encipher(GWEN_CRYPT_KEY *k,
00235                                const uint8_t *pInData,
00236                                uint32_t inLen,
00237                                uint8_t *pOutData,
00238                                uint32_t *pOutLen) {
00239   GWEN_CRYPT_KEY_RSA *xk;
00240   gcry_error_t err;
00241   size_t nscanned;
00242   gcry_ac_data_t dsKey;
00243   gcry_mpi_t mpi_e;
00244   gcry_mpi_t mpi_n;
00245   gcry_mpi_t mpi_in;
00246   gcry_mpi_t mpi_out;
00247   size_t nwritten;
00248 
00249   assert(k);
00250   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
00251   assert(xk);
00252 
00253   dsKey=gcry_ac_key_data_get(xk->key);
00254 
00255   /* get modulus */
00256   err=gcry_ac_data_get_name(dsKey, 0, "n", &mpi_n);
00257   if (err) {
00258     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00259              gcry_strerror(err));
00260     return GWEN_ERROR_BAD_DATA;
00261   }
00262 
00263   /* get private exponent */
00264   err=gcry_ac_data_get_name(dsKey, 0, "e", &mpi_e);
00265   if (err) {
00266     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00267              gcry_strerror(err));
00268     return GWEN_ERROR_BAD_DATA;
00269   }
00270 
00271   /* convert input to MPI */
00272   mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00273   err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
00274   if (err) {
00275     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
00276     gcry_mpi_release(mpi_in);
00277     return GWEN_ERROR_BAD_DATA;
00278   }
00279 
00280   /* encrypt */
00281   mpi_out=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00282   gcry_mpi_powm(mpi_out, mpi_in, mpi_e, mpi_n);
00283 
00284   /* release unneeded objects */
00285   gcry_mpi_release(mpi_in);
00286 
00287   /* convert result MPI */
00288   err=gcry_mpi_print(GCRYMPI_FMT_USG,
00289                      pOutData, *pOutLen,
00290                      &nwritten, mpi_out);
00291   gcry_mpi_release(mpi_out);
00292   if (err) {
00293     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_print(): %s", gcry_strerror(err));
00294     return GWEN_ERROR_BAD_DATA;
00295   }
00296   *pOutLen=nwritten;
00297 
00298   return 0;
00299 }
00300 
00301 
00302 
00303 int GWEN_Crypt_KeyRsa_Decipher(GWEN_CRYPT_KEY *k,
00304                                const uint8_t *pInData,
00305                                uint32_t inLen,
00306                                uint8_t *pOutData,
00307                                uint32_t *pOutLen) {
00308   GWEN_CRYPT_KEY_RSA *xk;
00309   gcry_error_t err;
00310   size_t nscanned;
00311   gcry_ac_data_t dsKey;
00312   gcry_mpi_t mpi_d;
00313   gcry_mpi_t mpi_n;
00314   gcry_mpi_t mpi_in;
00315   gcry_mpi_t mpi_out;
00316   size_t nwritten;
00317 
00318   assert(k);
00319   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
00320   assert(xk);
00321 
00322   dsKey=gcry_ac_key_data_get(xk->key);
00323 
00324   /* get modulus */
00325   err=gcry_ac_data_get_name(dsKey, 0, "n", &mpi_n);
00326   if (err) {
00327     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00328              gcry_strerror(err));
00329     return GWEN_ERROR_BAD_DATA;
00330   }
00331 
00332   /* get private exponent */
00333   err=gcry_ac_data_get_name(dsKey, 0, "d", &mpi_d);
00334   if (err) {
00335     DBG_INFO(GWEN_LOGDOMAIN, "gcry_data_get_name(): %s",
00336              gcry_strerror(err));
00337     return GWEN_ERROR_BAD_DATA;
00338   }
00339 
00340   /* convert input to MPI */
00341   mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00342   err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
00343   if (err) {
00344     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
00345     gcry_mpi_release(mpi_in);
00346     return GWEN_ERROR_BAD_DATA;
00347   }
00348 
00349   /* decrypt */
00350   mpi_out=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00351   gcry_mpi_powm(mpi_out, mpi_in, mpi_d, mpi_n);
00352 
00353   /* release unneeded objects */
00354   gcry_mpi_release(mpi_in);
00355 
00356   /* convert result MPI */
00357   err=gcry_mpi_print(GCRYMPI_FMT_USG,
00358                      pOutData, *pOutLen,
00359                      &nwritten, mpi_out);
00360   gcry_mpi_release(mpi_out);
00361   if (err) {
00362     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_print(): %s", gcry_strerror(err));
00363     return GWEN_ERROR_BAD_DATA;
00364   }
00365   *pOutLen=nwritten;
00366 
00367   return 0;
00368 }
00369 
00370 
00371 
00372 int GWEN_Crypt_KeyRsa__ReadMpi(GWEN_DB_NODE *db,
00373                                const char *dbName,
00374                                gcry_ac_data_t ds,
00375                                const char *dsName) {
00376   gcry_error_t err;
00377   const void *p;
00378   unsigned int len;
00379   gcry_mpi_t mpi=NULL;
00380   size_t nscanned;
00381 
00382   /* read n */
00383   p=GWEN_DB_GetBinValue(db, dbName, 0, NULL, 0, &len);
00384   if (p==NULL || len<1) {
00385     DBG_INFO(GWEN_LOGDOMAIN, "Missing %s", dbName);
00386     return GWEN_ERROR_NO_DATA;
00387   }
00388 
00389   err=gcry_mpi_scan(&mpi, GCRYMPI_FMT_USG, p, len, &nscanned);
00390   if (err) {
00391     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
00392     if (mpi)
00393       gcry_mpi_release(mpi);
00394     return GWEN_ERROR_GENERIC;
00395   }
00396   if (nscanned<1) {
00397     DBG_INFO(GWEN_LOGDOMAIN, "Empty %s (%d)", dbName, (int)nscanned);
00398 #if 0
00399     if (mpi)
00400       gcry_mpi_release(mpi);
00401     return GWEN_ERROR_BAD_DATA;
00402 #endif
00403   }
00404   err=gcry_ac_data_set(ds, GCRY_AC_FLAG_COPY, (char*)dsName, mpi);
00405   if (err) {
00406     DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_data_set(): %s", gcry_strerror(err));
00407     gcry_mpi_release(mpi);
00408     return GWEN_ERROR_GENERIC;
00409   }
00410   gcry_mpi_release(mpi);
00411 
00412   return 0;
00413 }
00414 
00415 
00416 
00417 
00418 int GWEN_Crypt_KeyRsa__WriteMpi(GWEN_DB_NODE *db,
00419                                 const char *dbName,
00420                                 gcry_ac_data_t ds,
00421                                 const char *dsName) {
00422   gcry_mpi_t mpi;
00423   gcry_error_t err;
00424   unsigned char *buf;
00425   size_t nbytes;
00426 
00427   /* read n (don't copy) */
00428   err=gcry_ac_data_get_name(ds, 0, dsName, &mpi);
00429   if (err) {
00430     DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_data_get_name(%s): %s",
00431              dsName, gcry_strerror(err));
00432     if (err==GPG_ERR_INV_ARG)
00433       return GWEN_ERROR_NO_DATA;
00434     else
00435       return GWEN_ERROR_GENERIC;
00436   }
00437 
00438   /* write mpi as bin into a buffer which will be allocates by this function */
00439   err=gcry_mpi_aprint(GCRYMPI_FMT_USG, &buf, &nbytes, mpi);
00440   if (err) {
00441     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_aprint(%s): %s", dsName, gcry_strerror(err));
00442     return GWEN_ERROR_GENERIC;
00443   }
00444   GWEN_DB_SetBinValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00445                       dbName,
00446                       buf, nbytes);
00447   gcry_free(buf);
00448 
00449   return 0;
00450 }
00451 
00452 
00453 
00454 int GWEN_Crypt_KeyRsa__DataFromDb(GWEN_DB_NODE *db, gcry_ac_data_t *pData,
00455                                   int pub, GWEN_UNUSED unsigned int nbits) {
00456   gcry_ac_data_t ds;
00457   gcry_error_t err;
00458   int rv;
00459 
00460   /* allocate key data */
00461   err=gcry_ac_data_new(&ds);
00462   if (err) {
00463     DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_data_new(): %d", err);
00464     return GWEN_ERROR_GENERIC;
00465   }
00466 
00467   /* read n */
00468   rv=GWEN_Crypt_KeyRsa__ReadMpi(db, "n", ds, "n");
00469   if (rv) {
00470     gcry_ac_data_destroy(ds);
00471     return rv;
00472   }
00473 
00474   /* read e */
00475   rv=GWEN_Crypt_KeyRsa__ReadMpi(db, "e", ds, "e");
00476   if (rv) {
00477     gcry_ac_data_destroy(ds);
00478     return rv;
00479   }
00480 
00481   if (!pub) {
00482     /* read d */
00483     rv=GWEN_Crypt_KeyRsa__ReadMpi(db, "d", ds, "d");
00484     if (rv) {
00485       gcry_ac_data_destroy(ds);
00486       return rv;
00487     }
00488 
00489     /* read p */
00490     if (GWEN_DB_VariableExists(db, "p") &&
00491         GWEN_DB_VariableExists(db, "q")) {
00492       rv=GWEN_Crypt_KeyRsa__ReadMpi(db, "p", ds, "p");
00493       if (rv) {
00494         gcry_ac_data_destroy(ds);
00495         return rv;
00496       }
00497 
00498       /* read q */
00499       rv=GWEN_Crypt_KeyRsa__ReadMpi(db, "q", ds, "q");
00500       if (rv) {
00501         gcry_ac_data_destroy(ds);
00502         return rv;
00503       }
00504     }
00505   }
00506 
00507   *pData=ds;
00508   return 0;
00509 }
00510 
00511 
00512 
00513 GWENHYWFAR_CB
00514 void GWEN_Crypt_KeyRsa_freeData(GWEN_UNUSED void *bp, void *p) {
00515   GWEN_CRYPT_KEY_RSA *xk;
00516 
00517   xk=(GWEN_CRYPT_KEY_RSA*) p;
00518   if (xk->keyValid)
00519     gcry_ac_key_destroy(xk->key);
00520   if (xk->algoValid)
00521     gcry_ac_close(xk->algoHandle);
00522   GWEN_FREE_OBJECT(xk);
00523 }
00524 
00525 
00526 
00527 GWEN_CRYPT_KEY *GWEN_Crypt_KeyRsa_fromDb(GWEN_DB_NODE *db) {
00528   gcry_error_t err;
00529   gcry_ac_data_t data;
00530   int rv;
00531   int isPublic;
00532   GWEN_CRYPT_KEY *k;
00533   GWEN_CRYPT_KEY_RSA *xk;
00534   unsigned int nbits;
00535   GWEN_DB_NODE *dbR;
00536 
00537   dbR=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, "rsa");
00538   if (dbR==NULL) {
00539     DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an RSA key (no RSA group)");
00540     return NULL;
00541   }
00542   k=GWEN_Crypt_Key_fromDb(db);
00543   if (k==NULL) {
00544     DBG_INFO(GWEN_LOGDOMAIN, "here");
00545     return NULL;
00546   }
00547   if (GWEN_Crypt_Key_GetCryptAlgoId(k)!=GWEN_Crypt_CryptAlgoId_Rsa) {
00548     DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an RSA key");
00549     GWEN_Crypt_Key_free(k);
00550     return NULL;
00551   }
00552   nbits=GWEN_Crypt_Key_GetKeySize(k)*8;
00553 
00554   /* extend key */
00555   GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_RSA, xk);
00556   GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k, xk,
00557                        GWEN_Crypt_KeyRsa_freeData);
00558   GWEN_Crypt_Key_SetSignFn(k, GWEN_Crypt_KeyRsa_Sign);
00559   GWEN_Crypt_Key_SetVerifyFn(k, GWEN_Crypt_KeyRsa_Verify);
00560   GWEN_Crypt_Key_SetEncipherFn(k, GWEN_Crypt_KeyRsa_Encipher);
00561   GWEN_Crypt_Key_SetDecipherFn(k, GWEN_Crypt_KeyRsa_Decipher);
00562 
00563   isPublic=GWEN_DB_GetIntValue(dbR, "isPublic", 0, 1);
00564   xk->pub=isPublic;
00565 
00566   xk->flags=GWEN_DB_GetIntValue(dbR, "flags", 0, 0);
00567 
00568   /* prepare data */
00569   rv=GWEN_Crypt_KeyRsa__DataFromDb(dbR, &data, isPublic, nbits);
00570   if (rv) {
00571     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00572     GWEN_Crypt_Key_free(k);
00573     return NULL;
00574   }
00575 
00576   err=gcry_ac_open(&xk->algoHandle, GCRY_AC_RSA, 0); /* TODO: lookup flags to use */
00577   if (err) {
00578     DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_open(): %d", err);
00579     gcry_ac_data_destroy(data);
00580     GWEN_Crypt_Key_free(k);
00581     return NULL;
00582   }
00583   xk->algoValid=1;
00584 
00585   err=gcry_ac_key_init(&xk->key, xk->algoHandle,
00586                        isPublic?GCRY_AC_KEY_PUBLIC:GCRY_AC_KEY_SECRET,
00587                        data);
00588   if (err) {
00589     DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_key_init(): %d", err);
00590     gcry_ac_data_destroy(data);
00591     GWEN_Crypt_Key_free(k);
00592     return NULL;
00593   }
00594   xk->keyValid=1;
00595 
00596 #if 0
00597   DBG_ERROR(0, "fromDb:");
00598   dumpKeyData(data);
00599 #endif
00600 
00601   gcry_ac_data_destroy(data);
00602   return k;
00603 }
00604 
00605 
00606 
00607 int GWEN_Crypt_KeyRsa_toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db, int pub) {
00608   GWEN_CRYPT_KEY_RSA *xk;
00609   GWEN_DB_NODE *dbR;
00610   int rv;
00611   gcry_ac_data_t ds;
00612 
00613   assert(k);
00614   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
00615   assert(xk);
00616 
00617   if (xk->algoValid==0 || xk->keyValid==0) {
00618     /* should not happen */
00619     DBG_ERROR(GWEN_LOGDOMAIN, "Key is not open");
00620     return GWEN_ERROR_NOT_OPEN;
00621   }
00622 
00623   if (xk->pub && !pub) {
00624     DBG_ERROR(GWEN_LOGDOMAIN, "Can't write public key as secret key");
00625     return GWEN_ERROR_INVALID;
00626   }
00627 
00628   ds=gcry_ac_key_data_get(xk->key);
00629 
00630 #if 0
00631   DBG_ERROR(0, "toDb (%s):", pub?"public":"private");
00632   dumpKeyData(ds);
00633 #endif
00634 
00635   /* let key module write basic key info */
00636   rv=GWEN_Crypt_Key_toDb(k, db);
00637   if (rv)
00638     return rv;
00639 
00640   /* write RSA stuff into our own group */
00641   dbR=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "rsa");
00642   assert(dbR);
00643 
00644   GWEN_DB_SetIntValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
00645                       "isPublic", pub);
00646   GWEN_DB_SetIntValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
00647                       "flags", xk->flags);
00648 
00649   /* store n */
00650   rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "n", ds, "n");
00651   if (rv) {
00652     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00653     return rv;
00654   }
00655 
00656   /* store e */
00657   rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "e", ds, "e");
00658   if (rv) {
00659     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00660     return rv;
00661   }
00662   if (!pub) {
00663     gcry_mpi_t mpi;
00664 
00665     /* store d */
00666     rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "d", ds, "d");
00667     if (rv) {
00668       DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00669       return rv;
00670     }
00671 
00672     if (gcry_ac_data_get_name(ds, 0, "p", &mpi)==0 &&
00673         gcry_ac_data_get_name(ds, 0, "q", &mpi)==0) {
00674       /* store p */
00675       rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "p", ds, "p");
00676       if (rv) {
00677         DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00678         return rv;
00679       }
00680       /* store q */
00681       rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "q", ds, "q");
00682       if (rv) {
00683         DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00684         return rv;
00685       }
00686     }
00687   }
00688 
00689   return 0;
00690 }
00691 
00692 
00693 
00694 
00695 int GWEN_Crypt_KeyRsa__sKeyElementToData(gcry_ac_data_t data, gcry_sexp_t sx, const char *name) {
00696   int rc;
00697   gcry_sexp_t list;
00698   gcry_mpi_t mpi=NULL;
00699 
00700   list=gcry_sexp_find_token(sx, name, 0);
00701   if (!list || !(mpi=gcry_sexp_nth_mpi(list, 1, 0)) ) {
00702     DBG_ERROR(GWEN_LOGDOMAIN, "Entry \"%s\" not found", name);
00703     return GWEN_ERROR_GENERIC;
00704   }
00705 
00706   rc=gcry_ac_data_set(data, GCRY_AC_FLAG_COPY, (char*)name, mpi);
00707   if (rc) {
00708     DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_data_set(): %s", gcry_strerror(rc));
00709     gcry_mpi_release(mpi);
00710     return GWEN_ERROR_GENERIC;
00711   }
00712   gcry_mpi_release(mpi);
00713   gcry_sexp_release(list);
00714 
00715   return 0;
00716 }
00717 
00718 
00719 
00720 int GWEN_Crypt_KeyRsa__sKeyToDataPubKey(gcry_ac_data_t data, gcry_sexp_t sx) {
00721   int rv;
00722 
00723   rv=GWEN_Crypt_KeyRsa__sKeyElementToData(data, sx, "n");
00724   if (rv)
00725     return rv;
00726   rv=GWEN_Crypt_KeyRsa__sKeyElementToData(data, sx, "e");
00727   if (rv)
00728     return rv;
00729   return 0;
00730 }
00731 
00732 
00733 
00734 int GWEN_Crypt_KeyRsa__sKeyToDataPrivKey(gcry_ac_data_t data, gcry_sexp_t sx) {
00735   int rv;
00736 
00737   rv=GWEN_Crypt_KeyRsa__sKeyElementToData(data, sx, "n");
00738   if (rv)
00739     return rv;
00740   rv=GWEN_Crypt_KeyRsa__sKeyElementToData(data, sx, "e");
00741   if (rv)
00742     return rv;
00743   rv=GWEN_Crypt_KeyRsa__sKeyElementToData(data, sx, "d");
00744   if (rv)
00745     return rv;
00746   rv=GWEN_Crypt_KeyRsa__sKeyElementToData(data, sx, "p");
00747   if (rv)
00748     return rv;
00749   rv=GWEN_Crypt_KeyRsa__sKeyElementToData(data, sx, "q");
00750   if (rv)
00751     return rv;
00752   return 0;
00753 }
00754 
00755 
00756 
00757 int GWEN_Crypt_KeyRsa_GeneratePair2(unsigned int nbits, int use65537e,
00758                                     GWEN_CRYPT_KEY **pPubKey,
00759                                     GWEN_CRYPT_KEY **pSecretKey) {
00760   gcry_sexp_t keyparm, key;
00761   int rc;
00762   char buffer[256];
00763   char numbuf[32];
00764   gcry_sexp_t skey, pkey;
00765   int nbytes;
00766 
00767   nbytes=nbits/8;
00768   if (nbits%8)
00769     nbytes++;
00770   snprintf(numbuf, sizeof(numbuf)-1, "%d", nbits);
00771   if (use65537e) {
00772     snprintf(buffer, sizeof(buffer)-1,
00773              "(genkey\n"
00774              " (rsa\n"
00775              "  (nbits %zd:%d)\n"
00776              "  (rsa-use-e 5:65537)\n"
00777              " ))",
00778              strlen(numbuf),
00779              nbits);
00780   }
00781   else
00782     snprintf(buffer, sizeof(buffer)-1,
00783              "(genkey\n"
00784              " (rsa\n"
00785              "  (nbits %zd:%d)\n"
00786              "  (rsa-use-e 1:0)\n"
00787              " ))",
00788              strlen(numbuf),
00789              nbits);
00790   buffer[sizeof(buffer)-1]=0;
00791 
00792   /*DBG_ERROR(0, "Genkey string: [%s]", buffer);*/
00793 
00794   rc=gcry_sexp_new(&keyparm, buffer, 0, 1);
00795   if (rc) {
00796     DBG_ERROR(GWEN_LOGDOMAIN,
00797               "Error creating S-expression: %s", gpg_strerror (rc));
00798     return GWEN_ERROR_GENERIC;
00799   }
00800 
00801   rc=gcry_pk_genkey(&key, keyparm);
00802   gcry_sexp_release(keyparm);
00803   if (rc) {
00804     DBG_ERROR(GWEN_LOGDOMAIN, "Error generating RSA key: %s", gpg_strerror (rc));
00805     return GWEN_ERROR_GENERIC;
00806   }
00807 
00808   pkey=gcry_sexp_find_token(key, "public-key", 0);
00809   if (!pkey) {
00810     DBG_ERROR(GWEN_LOGDOMAIN, "Public part missing in return value");
00811     gcry_sexp_release(key);
00812     return GWEN_ERROR_GENERIC;
00813   }
00814   else {
00815     gcry_ac_data_t data;
00816     GWEN_CRYPT_KEY *k;
00817     GWEN_CRYPT_KEY_RSA *xk;
00818 
00819     /* allocate key data */
00820     rc=gcry_ac_data_new(&data);
00821     if (rc) {
00822       DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_data_new(): %s", gcry_strerror(rc));
00823       gcry_sexp_release(key);
00824       return GWEN_ERROR_GENERIC;
00825     }
00826 
00827     rc=GWEN_Crypt_KeyRsa__sKeyToDataPubKey(data, pkey);
00828     if (rc) {
00829       DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rc);
00830       gcry_ac_data_destroy(data);
00831       gcry_sexp_release(key);
00832       return rc;
00833     }
00834     gcry_sexp_release(pkey);
00835 
00836     /* create public key */
00837     k=GWEN_Crypt_Key_new(GWEN_Crypt_CryptAlgoId_Rsa, nbytes);
00838     assert(k);
00839     GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_RSA, xk);
00840     GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k, xk,
00841                          GWEN_Crypt_KeyRsa_freeData);
00842     GWEN_Crypt_Key_SetSignFn(k, GWEN_Crypt_KeyRsa_Sign);
00843     GWEN_Crypt_Key_SetVerifyFn(k, GWEN_Crypt_KeyRsa_Verify);
00844     GWEN_Crypt_Key_SetEncipherFn(k, GWEN_Crypt_KeyRsa_Encipher);
00845     GWEN_Crypt_Key_SetDecipherFn(k, GWEN_Crypt_KeyRsa_Decipher);
00846   
00847     /* open algo for key */
00848     rc=gcry_ac_open(&xk->algoHandle, GCRY_AC_RSA, 0);
00849     if (rc) {
00850       DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_open(): %s", gcry_strerror(rc));
00851       GWEN_Crypt_Key_free(k);
00852       gcry_ac_data_destroy(data);
00853       gcry_sexp_release(key);
00854       return GWEN_ERROR_GENERIC;
00855     }
00856     xk->algoValid=1;
00857     /* copy key */
00858     rc=gcry_ac_key_init(&xk->key, xk->algoHandle, GCRY_AC_KEY_PUBLIC, data);
00859     xk->pub=1;
00860     if (rc) {
00861       DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_key_init(): %s", gcry_strerror(rc));
00862       GWEN_Crypt_Key_free(k);
00863       gcry_ac_data_destroy(data);
00864       gcry_sexp_release(key);
00865       return GWEN_ERROR_GENERIC;
00866     }
00867     xk->keyValid=1;
00868     *pPubKey=k;
00869     gcry_ac_data_destroy(data);
00870   }
00871 
00872   skey=gcry_sexp_find_token(key, "private-key", 0);
00873   if (!skey) {
00874     DBG_ERROR(GWEN_LOGDOMAIN, "Private part missing in return value");
00875     return GWEN_ERROR_GENERIC;
00876   }
00877   else {
00878     gcry_ac_data_t data;
00879     GWEN_CRYPT_KEY *k;
00880     GWEN_CRYPT_KEY_RSA *xk;
00881 
00882     /* allocate key data */
00883     rc=gcry_ac_data_new(&data);
00884     if (rc) {
00885       DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_data_new(): %s", gcry_strerror(rc));
00886       gcry_sexp_release(key);
00887       return GWEN_ERROR_GENERIC;
00888     }
00889 
00890     rc=GWEN_Crypt_KeyRsa__sKeyToDataPrivKey(data, skey);
00891     if (rc) {
00892       DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rc);
00893       gcry_ac_data_destroy(data);
00894       gcry_sexp_release(key);
00895       return rc;
00896     }
00897     gcry_sexp_release(skey);
00898 
00899     /* create public key */
00900     k=GWEN_Crypt_Key_new(GWEN_Crypt_CryptAlgoId_Rsa, nbytes);
00901     assert(k);
00902     GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_RSA, xk);
00903     GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k, xk,
00904                          GWEN_Crypt_KeyRsa_freeData);
00905     GWEN_Crypt_Key_SetSignFn(k, GWEN_Crypt_KeyRsa_Sign);
00906     GWEN_Crypt_Key_SetVerifyFn(k, GWEN_Crypt_KeyRsa_Verify);
00907     GWEN_Crypt_Key_SetEncipherFn(k, GWEN_Crypt_KeyRsa_Encipher);
00908     GWEN_Crypt_Key_SetDecipherFn(k, GWEN_Crypt_KeyRsa_Decipher);
00909   
00910     /* open algo for key */
00911     rc=gcry_ac_open(&xk->algoHandle, GCRY_AC_RSA, 0);
00912     if (rc) {
00913       DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_open(): %s", gcry_strerror(rc));
00914       GWEN_Crypt_Key_free(k);
00915       gcry_ac_data_destroy(data);
00916       gcry_sexp_release(key);
00917       return GWEN_ERROR_GENERIC;
00918     }
00919     xk->algoValid=1;
00920     /* copy key */
00921     rc=gcry_ac_key_init(&xk->key, xk->algoHandle, GCRY_AC_KEY_SECRET, data);
00922     xk->pub=0;
00923     if (rc) {
00924       DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_open(): %s", gcry_strerror(rc));
00925       GWEN_Crypt_Key_free(k);
00926       gcry_ac_data_destroy(data);
00927       gcry_sexp_release(key);
00928       return GWEN_ERROR_GENERIC;
00929     }
00930     xk->keyValid=1;
00931     *pSecretKey=k;
00932     gcry_ac_data_destroy(data);
00933   }
00934 
00935   gcry_sexp_release(key);
00936   return 0;
00937 }
00938 
00939 
00940 
00941 int GWEN_Crypt_KeyRsa_GeneratePair(unsigned int nbytes, int use65537e,
00942                                    GWEN_CRYPT_KEY **pPubKey,
00943                                    GWEN_CRYPT_KEY **pSecretKey) {
00944   return GWEN_Crypt_KeyRsa_GeneratePair2(nbytes*8, use65537e, pPubKey, pSecretKey);
00945 }
00946 
00947 
00948 int GWEN_Crypt_KeyRsa__GetNamedElement(const GWEN_CRYPT_KEY *k,
00949                                        const char *name,
00950                                        uint8_t *buffer,
00951                                        uint32_t *pBufLen) {
00952   gcry_ac_data_t ds;
00953   GWEN_CRYPT_KEY_RSA *xk;
00954   gcry_mpi_t mpi;
00955   gcry_error_t err;
00956   unsigned char *buf;
00957   size_t nbytes;
00958 
00959   assert(k);
00960   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
00961   assert(xk);
00962 
00963   if (xk->algoValid==0 || xk->keyValid==0) {
00964     DBG_INFO(GWEN_LOGDOMAIN, "Invalid key data");
00965     return GWEN_ERROR_GENERIC;
00966   }
00967 
00968   ds=gcry_ac_key_data_get(xk->key);
00969 
00970   /* read n (don't copy) */
00971   err=gcry_ac_data_get_name(ds, 0, name, &mpi);
00972   if (err) {
00973     DBG_INFO(GWEN_LOGDOMAIN, "gcry_ac_data_get_name(): %d", err);
00974     if (err==GPG_ERR_INV_ARG)
00975       return GWEN_ERROR_NO_DATA;
00976     else
00977       return GWEN_ERROR_GENERIC;
00978   }
00979 
00980   /* write mpi as bin into a buffer which will be allocated by this function */
00981   err=gcry_mpi_aprint(GCRYMPI_FMT_USG, &buf, &nbytes, mpi);
00982   if (err) {
00983     DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_aprint(): %d", err);
00984     return GWEN_ERROR_GENERIC;
00985   }
00986   if (nbytes>*pBufLen) {
00987     DBG_INFO(GWEN_LOGDOMAIN, "Buffer too small");
00988     gcry_free(buf);
00989     return GWEN_ERROR_BUFFER_OVERFLOW;
00990   }
00991 
00992   memmove(buffer, buf, nbytes);
00993   *pBufLen=nbytes;
00994   gcry_free(buf);
00995 
00996   return 0;
00997 }
00998 
00999 
01000 
01001 int GWEN_Crypt_KeyRsa_GetModulus(const GWEN_CRYPT_KEY *k, uint8_t *buffer, uint32_t *pBufLen) {
01002   return GWEN_Crypt_KeyRsa__GetNamedElement(k, "n", buffer, pBufLen);
01003 }
01004 
01005 
01006 
01007 int GWEN_Crypt_KeyRsa_GetExponent(const GWEN_CRYPT_KEY *k, uint8_t *buffer, uint32_t *pBufLen) {
01008   return GWEN_Crypt_KeyRsa__GetNamedElement(k, "e", buffer, pBufLen);
01009 }
01010 
01011 
01012 
01013 int GWEN_Crypt_KeyRsa_GetSecretExponent(const GWEN_CRYPT_KEY *k, uint8_t *buffer, uint32_t *pBufLen) {
01014   return GWEN_Crypt_KeyRsa__GetNamedElement(k, "d", buffer, pBufLen);
01015 }
01016 
01017 
01018 
01019 GWEN_CRYPT_KEY *GWEN_Crypt_KeyRsa_fromModExp(unsigned int nbytes,
01020                                              const uint8_t *pModulus,
01021                                              uint32_t lModulus,
01022                                              const uint8_t *pExponent,
01023                                              uint32_t lExponent) {
01024   GWEN_DB_NODE *dbKey;
01025   GWEN_DB_NODE *dbR;
01026   GWEN_CRYPT_KEY *key;
01027 
01028   assert(nbytes);
01029   assert(pModulus);
01030   assert(lModulus);
01031   assert(pExponent);
01032   assert(lExponent);
01033 
01034   dbKey=GWEN_DB_Group_new("key");
01035   dbR=GWEN_DB_GetGroup(dbKey, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "rsa");
01036 
01037   /* basic key stuff */
01038   GWEN_DB_SetCharValue(dbKey, GWEN_DB_FLAGS_OVERWRITE_VARS,
01039                        "cryptAlgoId",
01040                        GWEN_Crypt_CryptAlgoId_toString(GWEN_Crypt_CryptAlgoId_Rsa));
01041   GWEN_DB_SetIntValue(dbKey, GWEN_DB_FLAGS_OVERWRITE_VARS,
01042                       "keySize", nbytes);
01043 
01044   /* RSA stuff */
01045   GWEN_DB_SetIntValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
01046                       "isPublic", 1);
01047   GWEN_DB_SetBinValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
01048                       "n",
01049                       pModulus, lModulus);
01050   GWEN_DB_SetBinValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
01051                       "e",
01052                       pExponent, lExponent);
01053 
01054   /* create key from DB */
01055   key=GWEN_Crypt_KeyRsa_fromDb(dbKey);
01056   if (key==NULL) {
01057     DBG_INFO(GWEN_LOGDOMAIN,
01058              "Internal error: Bad RSA key group");
01059     GWEN_DB_Dump(dbKey, 2);
01060     GWEN_DB_Group_free(dbKey);
01061     return NULL;
01062   }
01063 
01064   GWEN_DB_Group_free(dbKey);
01065   return key;
01066 }
01067 
01068 
01069 
01070 GWEN_CRYPT_KEY *GWEN_Crypt_KeyRsa_fromModPrivExp(unsigned int nbytes,
01071                                                  const uint8_t *pModulus,
01072                                                  uint32_t lModulus,
01073                                                  const uint8_t *pExponent,
01074                                                  uint32_t lExponent,
01075                                                  const uint8_t *pPrivExponent,
01076                                                  uint32_t lPrivExponent) {
01077   GWEN_DB_NODE *dbKey;
01078   GWEN_DB_NODE *dbR;
01079   GWEN_CRYPT_KEY *key;
01080 
01081   assert(nbytes);
01082   assert(pModulus);
01083   assert(lModulus);
01084   assert(pExponent);
01085   assert(lExponent);
01086   assert(pPrivExponent);
01087   assert(lPrivExponent);
01088 
01089   dbKey=GWEN_DB_Group_new("key");
01090   dbR=GWEN_DB_GetGroup(dbKey, GWEN_DB_FLAGS_OVERWRITE_GROUPS, "rsa");
01091 
01092   /* basic key stuff */
01093   GWEN_DB_SetCharValue(dbKey, GWEN_DB_FLAGS_OVERWRITE_VARS,
01094                        "cryptAlgoId",
01095                        GWEN_Crypt_CryptAlgoId_toString(GWEN_Crypt_CryptAlgoId_Rsa));
01096   GWEN_DB_SetIntValue(dbKey, GWEN_DB_FLAGS_OVERWRITE_VARS,
01097                       "keySize", nbytes);
01098 
01099   /* RSA stuff */
01100   GWEN_DB_SetIntValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
01101                       "isPublic", 0);
01102   GWEN_DB_SetBinValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
01103                       "n",
01104                       pModulus, lModulus);
01105   GWEN_DB_SetBinValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
01106                       "e",
01107                       pExponent, lExponent);
01108   GWEN_DB_SetBinValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
01109                       "d",
01110                       pPrivExponent, lPrivExponent);
01111 
01112   /* create key from DB */
01113   key=GWEN_Crypt_KeyRsa_fromDb(dbKey);
01114   if (key==NULL) {
01115     DBG_INFO(GWEN_LOGDOMAIN,
01116              "Internal error: Bad RSA key group");
01117     GWEN_DB_Dump(dbKey, 2);
01118     GWEN_DB_Group_free(dbKey);
01119     return NULL;
01120   }
01121 
01122   GWEN_DB_Group_free(dbKey);
01123   return key;
01124 }
01125 
01126 
01127 
01128 GWEN_CRYPT_KEY *GWEN_Crypt_KeyRsa_dup(const GWEN_CRYPT_KEY *k) {
01129   GWEN_CRYPT_KEY_RSA *xk;
01130   GWEN_DB_NODE *dbKey;
01131   GWEN_CRYPT_KEY *nk;
01132   int rv;
01133 
01134   assert(k);
01135   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
01136   assert(xk);
01137 
01138   dbKey=GWEN_DB_Group_new("dbKey");
01139   rv=GWEN_Crypt_KeyRsa_toDb(k, dbKey, xk->pub);
01140   if (rv<0) {
01141     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
01142     GWEN_DB_Group_free(dbKey);
01143     return NULL;
01144   }
01145 
01146   nk=GWEN_Crypt_KeyRsa_fromDb(dbKey);
01147   GWEN_DB_Group_free(dbKey);
01148   if (nk==NULL) {
01149     DBG_INFO(GWEN_LOGDOMAIN, "Could not create key");
01150   }
01151 
01152   GWEN_Crypt_KeyRsa_SetFlags(nk, xk->flags);
01153 
01154   return nk;
01155 }
01156 
01157 
01158 
01159 uint32_t GWEN_Crypt_KeyRsa_GetFlags(const GWEN_CRYPT_KEY *k) {
01160   GWEN_CRYPT_KEY_RSA *xk;
01161 
01162   assert(k);
01163   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
01164   assert(xk);
01165 
01166   return xk->flags;
01167 }
01168 
01169 
01170 
01171 void GWEN_Crypt_KeyRsa_SetFlags(GWEN_CRYPT_KEY *k, uint32_t fl) {
01172   GWEN_CRYPT_KEY_RSA *xk;
01173 
01174   assert(k);
01175   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
01176   assert(xk);
01177 
01178   xk->flags=fl;
01179 }
01180 
01181 
01182 
01183 void GWEN_Crypt_KeyRsa_AddFlags(GWEN_CRYPT_KEY *k, uint32_t fl) {
01184   GWEN_CRYPT_KEY_RSA *xk;
01185 
01186   assert(k);
01187   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
01188   assert(xk);
01189 
01190   xk->flags|=fl;
01191 }
01192 
01193 
01194 
01195 void GWEN_Crypt_KeyRsa_SubFlags(GWEN_CRYPT_KEY *k, uint32_t fl) {
01196   GWEN_CRYPT_KEY_RSA *xk;
01197 
01198   assert(k);
01199   xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
01200   assert(xk);
01201 
01202   xk->flags&=~fl;
01203 }
01204 
01205 
01206 
01207 
01208 
01209 
01210 
01211