00001
00002
00003
00004
00005
00006
00007
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
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
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
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
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
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
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
00125 gcry_mpi_release(mpi_sigout2);
00126 gcry_mpi_release(mpi_in);
00127
00128
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
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
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
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
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
00203 mpi_sigout=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
00204 gcry_mpi_powm(mpi_sigout, mpi_sigin1, mpi_e, mpi_n);
00205
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
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
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
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
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
00285 gcry_mpi_release(mpi_in);
00286
00287
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
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
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
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
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
00354 gcry_mpi_release(mpi_in);
00355
00356
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
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
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
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
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
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
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
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
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
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
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
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);
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
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
00636 rv=GWEN_Crypt_Key_toDb(k, db);
00637 if (rv)
00638 return rv;
00639
00640
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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