gwenhywfar 4.0.3
|
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