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 "cryptkeysym_p.h"
00018 #include <gwenhywfar/misc.h>
00019 #include <gwenhywfar/debug.h>
00020 #include <gwenhywfar/cryptdefs.h>
00021 #include <gwenhywfar/text.h>
00022
00023
00024
00025 GWEN_INHERIT(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM)
00026
00027
00028
00029
00030
00031
00032 int GWEN_Crypt_KeySym_Encipher(GWEN_CRYPT_KEY *k,
00033 const uint8_t *pInData,
00034 uint32_t inLen,
00035 uint8_t *pOutData,
00036 uint32_t *pOutLen) {
00037 GWEN_CRYPT_KEY_SYM *xk;
00038 gcry_error_t err;
00039
00040 assert(k);
00041 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00042 assert(xk);
00043
00044 err=gcry_cipher_encrypt(xk->algoHandle, pOutData, inLen, pInData, inLen);
00045 if (err) {
00046 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_encrypt(): %s", gcry_strerror(err));
00047 return GWEN_ERROR_GENERIC;
00048 }
00049 *pOutLen=inLen;
00050
00051 return 0;
00052 }
00053
00054
00055
00056 int GWEN_Crypt_KeySym_Decipher(GWEN_CRYPT_KEY *k,
00057 const uint8_t *pInData,
00058 uint32_t inLen,
00059 uint8_t *pOutData,
00060 uint32_t *pOutLen) {
00061 GWEN_CRYPT_KEY_SYM *xk;
00062 gcry_error_t err;
00063
00064 assert(k);
00065 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00066 assert(xk);
00067
00068 err=gcry_cipher_decrypt(xk->algoHandle, pOutData, inLen, pInData, inLen);
00069 if (err) {
00070 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_decrypt(): %s", gcry_strerror(err));
00071 return GWEN_ERROR_GENERIC;
00072 }
00073 *pOutLen=inLen;
00074
00075 return 0;
00076 }
00077
00078
00079
00080 GWENHYWFAR_CB
00081 void GWEN_Crypt_KeySym_freeData(GWEN_UNUSED void *bp, void *p) {
00082 GWEN_CRYPT_KEY_SYM *xk;
00083
00084 xk=(GWEN_CRYPT_KEY_SYM*) p;
00085 if (xk->keyData && xk->keyLen) {
00086 memset(xk->keyData, 0, xk->keyLen);
00087 free(xk->keyData);
00088 }
00089 xk->keyData=NULL;
00090 xk->keyLen=0;
00091 if (xk->algoValid)
00092 gcry_cipher_close(xk->algoHandle);
00093 GWEN_FREE_OBJECT(xk);
00094 }
00095
00096
00097
00098 GWEN_CRYPT_KEY *GWEN_Crypt_KeySym_dup(const GWEN_CRYPT_KEY *k) {
00099 GWEN_CRYPT_KEY *nk;
00100 GWEN_CRYPT_KEY_SYM *xk;
00101
00102 assert(k);
00103 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00104 assert(xk);
00105
00106 nk=GWEN_Crypt_KeySym_fromData(GWEN_Crypt_Key_GetCryptAlgoId(k),
00107 GWEN_Crypt_Key_GetKeySize(k),
00108 xk->mode,
00109 xk->algo,
00110 GCRY_CIPHER_SECURE,
00111 xk->keyData,
00112 xk->keyLen);
00113 return nk;
00114 }
00115
00116
00117
00118 enum gcry_cipher_modes GWEN_Crypt_KeySym__MyMode2GMode(GWEN_CRYPT_CRYPTMODE mode) {
00119 switch(mode) {
00120 case GWEN_Crypt_CryptMode_Unknown: return GCRY_CIPHER_MODE_NONE;
00121 case GWEN_Crypt_CryptMode_None: return GCRY_CIPHER_MODE_NONE;
00122 case GWEN_Crypt_CryptMode_Ecb: return GCRY_CIPHER_MODE_ECB;
00123 case GWEN_Crypt_CryptMode_Cfb: return GCRY_CIPHER_MODE_CFB;
00124 case GWEN_Crypt_CryptMode_Cbc: return GCRY_CIPHER_MODE_CBC;
00125 }
00126
00127 return GCRY_CIPHER_MODE_NONE;
00128 }
00129
00130
00131
00132 GWEN_CRYPT_KEY *GWEN_Crypt_KeySym_Generate(GWEN_CRYPT_CRYPTALGOID cryptAlgoId, int keySize,
00133 GWEN_CRYPT_CRYPTMODE mode,
00134 int algo,
00135 unsigned int flags,
00136 int quality) {
00137 GWEN_CRYPT_KEY *k;
00138 GWEN_CRYPT_KEY_SYM *xk;
00139 int kbytes;
00140 uint8_t *keyData;
00141 gcry_error_t err;
00142 enum gcry_random_level q;
00143
00144 k=GWEN_Crypt_Key_new(cryptAlgoId, keySize);
00145 assert(k);
00146 GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
00147 GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k, xk, GWEN_Crypt_KeySym_freeData);
00148 GWEN_Crypt_Key_SetEncipherFn(k, GWEN_Crypt_KeySym_Encipher);
00149 GWEN_Crypt_Key_SetDecipherFn(k, GWEN_Crypt_KeySym_Decipher);
00150
00151 switch(quality) {
00152 case 0: q=GCRY_WEAK_RANDOM; break;
00153 case 1: q=GCRY_STRONG_RANDOM; break;
00154 case 2:
00155 default: q=GCRY_VERY_STRONG_RANDOM; break;
00156 }
00157
00158
00159 err=gcry_cipher_open(&xk->algoHandle, algo, GWEN_Crypt_KeySym__MyMode2GMode(mode), flags);
00160 if (err) {
00161 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
00162 GWEN_Crypt_Key_free(k);
00163 return NULL;
00164 }
00165 xk->algoValid=1;
00166 xk->mode=mode;
00167
00168 while(1) {
00169 kbytes=keySize;
00170 keyData=gcry_random_bytes(kbytes, q);
00171
00172
00173 xk->keyData=keyData;
00174 xk->keyLen=kbytes;
00175
00176
00177 err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
00178 if (err) {
00179 if ((err & GPG_ERR_CODE_MASK)==GPG_ERR_WEAK_KEY) {
00180 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): weak key, will try again");
00181 }
00182 else {
00183 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %d [%s]", err, gcry_strerror(err));
00184 GWEN_Crypt_Key_free(k);
00185 return NULL;
00186 }
00187 }
00188 else
00189 break;
00190
00191
00192 memset(xk->keyData, 0, xk->keyLen);
00193 free(xk->keyData);
00194 xk->keyData=NULL;
00195 xk->keyLen=0;
00196 }
00197
00198 return k;
00199 }
00200
00201
00202
00203 GWEN_CRYPT_KEY *GWEN_Crypt_KeySym_fromData(GWEN_CRYPT_CRYPTALGOID cryptAlgoId, int keySize,
00204 GWEN_CRYPT_CRYPTMODE mode,
00205 int algo,
00206 unsigned int flags,
00207 const uint8_t *kd, uint32_t kl) {
00208 GWEN_CRYPT_KEY *k;
00209 GWEN_CRYPT_KEY_SYM *xk;
00210 gcry_error_t err;
00211
00212 #if 0
00213 if (kl!=gcry_cipher_get_algo_keylen(algo)) {
00214 DBG_ERROR(GWEN_LOGDOMAIN, "Invalid key length (is %d, should be %d)",
00215 (int)kl, (int)gcry_cipher_get_algo_keylen(algo));
00216 return NULL;
00217 }
00218 #endif
00219
00220 k=GWEN_Crypt_Key_new(cryptAlgoId, keySize);
00221 assert(k);
00222 GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
00223 GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k, xk, GWEN_Crypt_KeySym_freeData);
00224 GWEN_Crypt_Key_SetEncipherFn(k, GWEN_Crypt_KeySym_Encipher);
00225 GWEN_Crypt_Key_SetDecipherFn(k, GWEN_Crypt_KeySym_Decipher);
00226
00227
00228 err=gcry_cipher_open(&xk->algoHandle, algo, GWEN_Crypt_KeySym__MyMode2GMode(mode), flags);
00229 if (err) {
00230 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
00231 GWEN_Crypt_Key_free(k);
00232 return NULL;
00233 }
00234 xk->algoValid=1;
00235 xk->mode=mode;
00236 xk->algo=algo;
00237
00238
00239 if (kd==NULL || kl==0) {
00240 DBG_INFO(GWEN_LOGDOMAIN, "No key data");
00241 GWEN_Crypt_Key_free(k);
00242 return NULL;
00243 }
00244
00245
00246 xk->keyData=(uint8_t*) malloc(kl);
00247 assert(xk->keyData);
00248 memmove(xk->keyData, kd, kl);
00249 xk->keyLen=kl;
00250
00251
00252 err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
00253 if (err) {
00254 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
00255 GWEN_Crypt_Key_free(k);
00256 return NULL;
00257 }
00258
00259 return k;
00260 }
00261
00262
00263
00264 GWEN_CRYPT_KEY *GWEN_Crypt_KeySym__fromDb(GWEN_CRYPT_CRYPTALGOID cryptAlgoId,
00265 GWEN_CRYPT_CRYPTMODE mode,
00266 int algo,
00267 unsigned int flags,
00268 const char *gname,
00269 GWEN_DB_NODE *db) {
00270 gcry_error_t err;
00271 GWEN_CRYPT_KEY *k;
00272 GWEN_CRYPT_KEY_SYM *xk;
00273 unsigned int nbits;
00274 GWEN_DB_NODE *dbR;
00275 unsigned int len;
00276 const char *p;
00277
00278 dbR=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, gname);
00279 if (dbR==NULL) {
00280 DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an %s key (no %s group)",
00281 gname, gname);
00282 return NULL;
00283 }
00284
00285 k=GWEN_Crypt_Key_fromDb(db);
00286 if (k==NULL) {
00287 DBG_INFO(GWEN_LOGDOMAIN, "here");
00288 return NULL;
00289 }
00290 if (GWEN_Crypt_Key_GetCryptAlgoId(k)!=cryptAlgoId) {
00291 DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an RSA key");
00292 GWEN_Crypt_Key_free(k);
00293 return NULL;
00294 }
00295 nbits=GWEN_Crypt_Key_GetKeySize(k)*8;
00296
00297
00298 GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
00299 GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k, xk, GWEN_Crypt_KeySym_freeData);
00300 GWEN_Crypt_Key_SetEncipherFn(k, GWEN_Crypt_KeySym_Encipher);
00301 GWEN_Crypt_Key_SetDecipherFn(k, GWEN_Crypt_KeySym_Decipher);
00302
00303
00304 err=gcry_cipher_open(&xk->algoHandle, algo, GWEN_Crypt_KeySym__MyMode2GMode(mode), flags);
00305 if (err) {
00306 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
00307 GWEN_Crypt_Key_free(k);
00308 return NULL;
00309 }
00310 xk->algoValid=1;
00311 xk->mode=mode;
00312 xk->algo=algo;
00313
00314
00315 p=GWEN_DB_GetBinValue(dbR, "keyData", 0, NULL, 0, &len);
00316 if (p==NULL || len==0) {
00317 DBG_INFO(GWEN_LOGDOMAIN, "No key data");
00318 GWEN_Crypt_Key_free(k);
00319 return NULL;
00320 }
00321
00322
00323 xk->keyData=(uint8_t*) malloc(len);
00324 assert(xk->keyData);
00325 memmove(xk->keyData, p, len);
00326 xk->keyLen=len;
00327
00328
00329 err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
00330 if (err) {
00331 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
00332 GWEN_Crypt_Key_free(k);
00333 return NULL;
00334 }
00335
00336 return k;
00337 }
00338
00339
00340
00341 int GWEN_Crypt_KeySym__toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db, const char *gname) {
00342 GWEN_CRYPT_KEY_SYM *xk;
00343 GWEN_DB_NODE *dbR;
00344 int rv;
00345
00346 assert(k);
00347 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00348 assert(xk);
00349
00350
00351 rv=GWEN_Crypt_Key_toDb(k, db);
00352 if (rv)
00353 return rv;
00354
00355
00356 dbR=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_OVERWRITE_GROUPS, gname);
00357 assert(dbR);
00358
00359 GWEN_DB_SetBinValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
00360 "keyData", xk->keyData, xk->keyLen);
00361
00362 return 0;
00363 }
00364
00365
00366
00367 GWEN_CRYPT_KEY *GWEN_Crypt_KeySym_fromDb(GWEN_CRYPT_CRYPTMODE mode, GWEN_DB_NODE *db) {
00368 gcry_error_t err;
00369 GWEN_CRYPT_KEY *k;
00370 GWEN_CRYPT_KEY_SYM *xk;
00371 unsigned int nbits;
00372 GWEN_DB_NODE *dbR;
00373 unsigned int len;
00374 const char *gname;
00375 const char *p;
00376
00377 k=GWEN_Crypt_Key_fromDb(db);
00378 if (k==NULL) {
00379 DBG_INFO(GWEN_LOGDOMAIN, "here");
00380 return NULL;
00381 }
00382
00383 gname=GWEN_Crypt_CryptAlgoId_toString(GWEN_Crypt_Key_GetCryptAlgoId(k));
00384
00385 dbR=GWEN_DB_GetGroup(db, GWEN_PATH_FLAGS_NAMEMUSTEXIST, gname);
00386 if (dbR==NULL) {
00387 DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an %s key (no %s group)",
00388 gname, gname);
00389 GWEN_Crypt_Key_free(k);
00390 return NULL;
00391 }
00392
00393 nbits=GWEN_Crypt_Key_GetKeySize(k)*8;
00394
00395
00396 GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
00397 GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k, xk, GWEN_Crypt_KeySym_freeData);
00398 GWEN_Crypt_Key_SetEncipherFn(k, GWEN_Crypt_KeySym_Encipher);
00399 GWEN_Crypt_Key_SetDecipherFn(k, GWEN_Crypt_KeySym_Decipher);
00400
00401
00402 err=gcry_cipher_open(&xk->algoHandle,
00403 GWEN_Crypt_Key_GetCryptAlgoId(k),
00404 GWEN_Crypt_KeySym__MyMode2GMode(mode),
00405 GCRY_CIPHER_SECURE);
00406 if (err) {
00407 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
00408 GWEN_Crypt_Key_free(k);
00409 return NULL;
00410 }
00411 xk->algoValid=1;
00412 xk->mode=mode;
00413 xk->algo=GWEN_Crypt_Key_GetCryptAlgoId(k);
00414
00415
00416 p=GWEN_DB_GetBinValue(dbR, "keyData", 0, NULL, 0, &len);
00417 if (p==NULL || len==0) {
00418 DBG_INFO(GWEN_LOGDOMAIN, "No key data");
00419 GWEN_Crypt_Key_free(k);
00420 return NULL;
00421 }
00422
00423
00424 xk->keyData=(uint8_t*) malloc(len);
00425 assert(xk->keyData);
00426 memmove(xk->keyData, p, len);
00427 xk->keyLen=len;
00428
00429
00430 err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
00431 if (err) {
00432 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
00433 GWEN_Crypt_Key_free(k);
00434 return NULL;
00435 }
00436
00437 return k;
00438 }
00439
00440
00441
00442 int GWEN_Crypt_KeySym_toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db) {
00443 GWEN_CRYPT_KEY_SYM *xk;
00444 GWEN_DB_NODE *dbR;
00445 int rv;
00446 const char *gname;
00447
00448 assert(k);
00449 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00450 assert(xk);
00451
00452
00453 rv=GWEN_Crypt_Key_toDb(k, db);
00454 if (rv)
00455 return rv;
00456
00457 gname=GWEN_Crypt_CryptAlgoId_toString(GWEN_Crypt_Key_GetCryptAlgoId(k));
00458
00459
00460 dbR=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_OVERWRITE_GROUPS, gname);
00461 assert(dbR);
00462
00463 GWEN_DB_SetBinValue(dbR, GWEN_DB_FLAGS_OVERWRITE_VARS,
00464 "keyData", xk->keyData, xk->keyLen);
00465
00466 return 0;
00467 }
00468
00469
00470
00471 int GWEN_Crypt_KeySym_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
00472 GWEN_CRYPT_KEY_SYM *xk;
00473 gcry_error_t err;
00474
00475 if (!kd || !kl) {
00476 DBG_ERROR(GWEN_LOGDOMAIN, "Empty keydata not allowed");
00477 return GWEN_ERROR_INVALID;
00478 }
00479
00480 assert(k);
00481 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00482 assert(xk);
00483
00484 if (xk->keyData && xk->keyLen) {
00485 memset(xk->keyData, 0, xk->keyLen);
00486 free(xk->keyData);
00487 }
00488
00489
00490 xk->keyData=(uint8_t*)malloc(kl);
00491 assert(xk->keyData);
00492 memmove(xk->keyData, kd, kl);
00493 xk->keyLen=kl;
00494
00495
00496 err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
00497 if (err) {
00498 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
00499 GWEN_Crypt_Key_free(k);
00500 return GWEN_ERROR_GENERIC;
00501 }
00502
00503 return 0;
00504 }
00505
00506
00507
00508 uint8_t *GWEN_Crypt_KeySym_GetKeyDataPtr(const GWEN_CRYPT_KEY *k) {
00509 GWEN_CRYPT_KEY_SYM *xk;
00510
00511 assert(k);
00512 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00513 assert(xk);
00514
00515 return xk->keyData;
00516 }
00517
00518
00519
00520 uint32_t GWEN_Crypt_KeySym_GetKeyDataLen(const GWEN_CRYPT_KEY *k) {
00521 GWEN_CRYPT_KEY_SYM *xk;
00522
00523 assert(k);
00524 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00525 assert(xk);
00526
00527 return xk->keyLen;
00528 }
00529
00530
00531
00532
00533 GWEN_CRYPT_KEY *GWEN_Crypt_KeyDes3K_Generate(GWEN_CRYPT_CRYPTMODE mode,
00534 int keySize,
00535 int quality){
00536 uint8_t kd[16];
00537 GWEN_CRYPT_KEY *k;
00538
00539 GWEN_Crypt_Random(quality, kd, 16);
00540 k=GWEN_Crypt_KeyDes3K_fromData(mode, keySize, kd, 16);
00541 memset(kd, 0, 16);
00542
00543 return k;
00544 }
00545
00546
00547
00548 GWEN_CRYPT_KEY *GWEN_Crypt_KeyDes3K_fromData(GWEN_CRYPT_CRYPTMODE mode, int keySize,
00549 const uint8_t *kd, uint32_t kl) {
00550 if (kl==16) {
00551 uint8_t new_kd[24];
00552 GWEN_CRYPT_KEY *k;
00553
00554
00555 memmove(new_kd, kd, 16);
00556 memmove(new_kd+16, new_kd, 8);
00557 k=GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_Des3K, 24,
00558 mode, GCRY_CIPHER_3DES, GCRY_CIPHER_SECURE, new_kd, 24);
00559 memset(new_kd, 0, 24);
00560 return k;
00561 }
00562 else
00563 return GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_Des3K, keySize,
00564 mode, GCRY_CIPHER_3DES, GCRY_CIPHER_SECURE, kd, kl);
00565 }
00566
00567
00568
00569 GWEN_CRYPT_KEY *GWEN_Crypt_KeyDes3K_fromDb(GWEN_CRYPT_CRYPTMODE mode,
00570 GWEN_DB_NODE *db) {
00571 return GWEN_Crypt_KeySym__fromDb(GWEN_Crypt_CryptAlgoId_Des3K, mode,
00572 GCRY_CIPHER_3DES, GCRY_CIPHER_SECURE, "des3k", db);
00573 }
00574
00575
00576
00577 int GWEN_Crypt_KeyDes3K_toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db) {
00578 return GWEN_Crypt_KeySym__toDb(k, db, "des3k");
00579 }
00580
00581
00582
00583 int GWEN_Crypt_KeyDes3K_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
00584 if (kl==16) {
00585 uint8_t new_kd[24];
00586 int rv;
00587
00588
00589 memmove(new_kd, kd, 16);
00590 memmove(new_kd+16, new_kd, 8);
00591 rv=GWEN_Crypt_KeySym_SetKeyData(k, new_kd, 24);
00592 memset(new_kd, 0, 24);
00593 return rv;
00594 }
00595 else
00596 return GWEN_Crypt_KeySym_SetKeyData(k, kd, kl);
00597 }
00598
00599
00600
00601 uint8_t *GWEN_Crypt_KeyDes3K_GetKeyDataPtr(const GWEN_CRYPT_KEY *k) {
00602 return GWEN_Crypt_KeySym_GetKeyDataPtr(k);
00603 }
00604
00605
00606
00607 uint32_t GWEN_Crypt_KeyDes3K_GetKeyDataLen(const GWEN_CRYPT_KEY *k) {
00608 return GWEN_Crypt_KeySym_GetKeyDataLen(k);
00609 }
00610
00611
00612
00613 int GWEN_Crypt_KeyDes3K_SetIV(GWEN_CRYPT_KEY *k,
00614 const uint8_t *kd,
00615 uint32_t kl) {
00616 GWEN_CRYPT_KEY_SYM *xk;
00617 gcry_error_t err;
00618
00619 assert(k);
00620 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00621 assert(xk);
00622
00623 if (kd==NULL || kl==0) {
00624 const uint8_t iv[]={
00625 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
00626 };
00627 err=gcry_cipher_setiv(xk->algoHandle, iv, sizeof(iv));
00628 }
00629 else
00630 err=gcry_cipher_setiv(xk->algoHandle, kd, kl);
00631 if (err) {
00632 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setiv(): %s", gcry_strerror(err));
00633 return GWEN_ERROR_GENERIC;
00634 }
00635
00636 return 0;
00637 }
00638
00639
00640
00641
00642
00643
00644
00645 GWEN_CRYPT_KEY *GWEN_Crypt_KeyBlowFish_Generate(GWEN_CRYPT_CRYPTMODE mode,
00646 int keySize,
00647 int quality){
00648 return GWEN_Crypt_KeySym_Generate(GWEN_Crypt_CryptAlgoId_BlowFish, keySize, mode,
00649 GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_SECURE, quality);
00650 }
00651
00652
00653
00654 GWEN_CRYPT_KEY *GWEN_Crypt_KeyBlowFish_fromData(GWEN_CRYPT_CRYPTMODE mode, int keySize,
00655 const uint8_t *kd, uint32_t kl) {
00656 return GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_BlowFish, keySize, mode,
00657 GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_SECURE,
00658 kd, kl);
00659 }
00660
00661
00662
00663 GWEN_CRYPT_KEY *GWEN_Crypt_KeyBlowFish_fromDb(GWEN_CRYPT_CRYPTMODE mode,
00664 GWEN_DB_NODE *db) {
00665 return GWEN_Crypt_KeySym__fromDb(GWEN_Crypt_CryptAlgoId_BlowFish, mode,
00666 GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_SECURE, "blowFish", db);
00667 }
00668
00669
00670
00671 int GWEN_Crypt_KeyBlowFish_toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db) {
00672 return GWEN_Crypt_KeySym__toDb(k, db, "blowFish");
00673 }
00674
00675
00676
00677 int GWEN_Crypt_KeyBlowFish_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
00678 return GWEN_Crypt_KeySym_SetKeyData(k, kd, kl);
00679 }
00680
00681
00682
00683 uint8_t *GWEN_Crypt_KeyBlowFish_GetKeyDataPtr(const GWEN_CRYPT_KEY *k) {
00684 return GWEN_Crypt_KeySym_GetKeyDataPtr(k);
00685 }
00686
00687
00688
00689 uint32_t GWEN_Crypt_KeyBlowFish_GetKeyDataLen(const GWEN_CRYPT_KEY *k) {
00690 return GWEN_Crypt_KeySym_GetKeyDataLen(k);
00691 }
00692
00693
00694
00695
00696 GWEN_CRYPT_KEY *GWEN_Crypt_KeyAes128_Generate(GWEN_CRYPT_CRYPTMODE mode,
00697 int keySize,
00698 int quality){
00699 return GWEN_Crypt_KeySym_Generate(GWEN_Crypt_CryptAlgoId_Aes128, keySize, mode,
00700 GCRY_CIPHER_AES128, GCRY_CIPHER_SECURE, quality);
00701 }
00702
00703
00704
00705 GWEN_CRYPT_KEY *GWEN_Crypt_KeyAes128_fromData(GWEN_CRYPT_CRYPTMODE mode, int keySize,
00706 const uint8_t *kd, uint32_t kl) {
00707 return GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_Aes128, keySize, mode,
00708 GCRY_CIPHER_AES128, GCRY_CIPHER_SECURE,
00709 kd, kl);
00710 }
00711
00712
00713
00714 GWEN_CRYPT_KEY *GWEN_Crypt_KeyAes128_fromDb(GWEN_CRYPT_CRYPTMODE mode,
00715 GWEN_DB_NODE *db) {
00716 return GWEN_Crypt_KeySym__fromDb(GWEN_Crypt_CryptAlgoId_Aes128, mode,
00717 GCRY_CIPHER_AES128, GCRY_CIPHER_SECURE, "aes128", db);
00718 }
00719
00720
00721
00722 int GWEN_Crypt_KeyAes128_toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db) {
00723 return GWEN_Crypt_KeySym__toDb(k, db, "aes128");
00724 }
00725
00726
00727
00728 int GWEN_Crypt_KeyAes128_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
00729 return GWEN_Crypt_KeySym_SetKeyData(k, kd, kl);
00730 }
00731
00732
00733
00734 uint8_t *GWEN_Crypt_KeyAes128_GetKeyDataPtr(const GWEN_CRYPT_KEY *k) {
00735 return GWEN_Crypt_KeySym_GetKeyDataPtr(k);
00736 }
00737
00738
00739
00740 uint32_t GWEN_Crypt_KeyAes128_GetKeyDataLen(const GWEN_CRYPT_KEY *k) {
00741 return GWEN_Crypt_KeySym_GetKeyDataLen(k);
00742 }
00743
00744
00745
00746 int GWEN_Crypt_KeyAes128_SetIV(GWEN_CRYPT_KEY *k,
00747 const uint8_t *kd,
00748 uint32_t kl) {
00749 GWEN_CRYPT_KEY_SYM *xk;
00750 gcry_error_t err;
00751
00752 assert(k);
00753 xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
00754 assert(xk);
00755
00756 if (kd==NULL || kl==0) {
00757 const uint8_t iv[]={
00758 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
00759 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
00760 };
00761 err=gcry_cipher_setiv(xk->algoHandle, iv, sizeof(iv));
00762 }
00763 else
00764 err=gcry_cipher_setiv(xk->algoHandle, kd, kl);
00765 if (err) {
00766 DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setiv(): %s", gcry_strerror(err));
00767 return GWEN_ERROR_GENERIC;
00768 }
00769
00770 return 0;
00771 }
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781