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