gwenhywfar  4.3.1
cryptkeysym.c
Go to the documentation of this file.
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