gwenhywfar
4.3.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 "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 /* open algo */ 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 /* store key data */ 00173 xk->keyData=keyData; 00174 xk->keyLen=kbytes; 00175 00176 /* set key in algo */ 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 /* try it again */ 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 /* open algo */ 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 /* read key data */ 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 /* store key data */ 00246 xk->keyData=(uint8_t*) malloc(kl); 00247 assert(xk->keyData); 00248 memmove(xk->keyData, kd, kl); 00249 xk->keyLen=kl; 00250 00251 /* set key in algo */ 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 /* extend key */ 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 /* open algo */ 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 /* read key data */ 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 /* store key data */ 00323 xk->keyData=(uint8_t*) malloc(len); 00324 assert(xk->keyData); 00325 memmove(xk->keyData, p, len); 00326 xk->keyLen=len; 00327 00328 /* set key in algo */ 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 /* let key module wirte basic key info */ 00351 rv=GWEN_Crypt_Key_toDb(k, db); 00352 if (rv) 00353 return rv; 00354 00355 /* write sym stuff into our own group */ 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 /* extend key */ 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 /* open algo */ 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 /* read key data */ 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 /* store key data */ 00424 xk->keyData=(uint8_t*) malloc(len); 00425 assert(xk->keyData); 00426 memmove(xk->keyData, p, len); 00427 xk->keyLen=len; 00428 00429 /* set key in algo */ 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 /* let key module wirte basic key info */ 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 /* write sym stuff into our own group */ 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 /* store key data */ 00490 xk->keyData=(uint8_t*)malloc(kl); 00491 assert(xk->keyData); 00492 memmove(xk->keyData, kd, kl); 00493 xk->keyLen=kl; 00494 00495 /* set key in algo */ 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 /* 3key DES with only two keys, copy key1 as key3 */ 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 /* 3key DES with only two keys, copy key1 as key3 */ 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