gwenhywfar  4.3.3
cryptalgo.c
Go to the documentation of this file.
00001 /***************************************************************************
00002     begin       : Wed Mar 16 2005
00003     copyright   : (C) 2005-2010 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 
00015 #define DISABLE_DEBUGLOG
00016 
00017 
00018 #include "cryptalgo_p.h"
00019 #include <gwenhywfar/misc.h>
00020 #include <gwenhywfar/debug.h>
00021 
00022 
00023 
00024 GWEN_LIST2_FUNCTIONS(GWEN_CRYPT_CRYPTALGO, GWEN_Crypt_CryptAlgo)
00025 
00026 
00027 
00028 GWEN_CRYPT_CRYPTALGOID GWEN_Crypt_CryptAlgoId_fromString(const char *s) {
00029   assert(s);
00030   if (strcasecmp(s, "none")==0)
00031     return GWEN_Crypt_CryptAlgoId_None;
00032   else if (strcasecmp(s, "rsa")==0)
00033     return GWEN_Crypt_CryptAlgoId_Rsa;
00034   else if (strcasecmp(s, "dsa")==0)
00035     return GWEN_Crypt_CryptAlgoId_Dsa;
00036   else if (strcasecmp(s, "des")==0)
00037     return GWEN_Crypt_CryptAlgoId_Des;
00038   else if (strcasecmp(s, "des_3k")==0 ||
00039            strcasecmp(s, "des3k")==0)
00040     return GWEN_Crypt_CryptAlgoId_Des3K;
00041   else if (strcasecmp(s, "blowfish")==0)
00042     return GWEN_Crypt_CryptAlgoId_BlowFish;
00043   else if (strcasecmp(s, "aes128")==0)
00044     return GWEN_Crypt_CryptAlgoId_Aes128;
00045   else if (strcasecmp(s, "any")==0)
00046     return GWEN_Crypt_CryptAlgoId_Any;
00047   return GWEN_Crypt_CryptAlgoId_Unknown;
00048 }
00049 
00050 
00051 
00052 const char *GWEN_Crypt_CryptAlgoId_toString(GWEN_CRYPT_CRYPTALGOID a) {
00053   switch(a) {
00054   case GWEN_Crypt_CryptAlgoId_None:
00055     return "none";
00056   case GWEN_Crypt_CryptAlgoId_Rsa:
00057     return "rsa";
00058   case GWEN_Crypt_CryptAlgoId_Dsa:
00059     return "dsa";
00060   case GWEN_Crypt_CryptAlgoId_Des:
00061     return "des";
00062   case GWEN_Crypt_CryptAlgoId_Des3K:
00063     return "des_3k";
00064   case GWEN_Crypt_CryptAlgoId_BlowFish:
00065     return "blowfish";
00066   case GWEN_Crypt_CryptAlgoId_Aes128:
00067     return "aes128";
00068   case GWEN_Crypt_CryptAlgoId_Any:
00069     return "any";
00070   default:
00071     return "unknown";
00072   }
00073 }
00074 
00075 
00076 
00077 GWEN_CRYPT_CRYPTMODE GWEN_Crypt_CryptMode_fromString(const char *s) {
00078   assert(s);
00079   if (strcasecmp(s, "none")==0)
00080     return GWEN_Crypt_CryptMode_None;
00081   else if (strcasecmp(s, "ecb")==0)
00082     return GWEN_Crypt_CryptMode_Ecb;
00083   else if (strcasecmp(s, "cfb")==0)
00084     return GWEN_Crypt_CryptMode_Cfb;
00085   else if (strcasecmp(s, "cbc")==0)
00086     return GWEN_Crypt_CryptMode_Cbc;
00087   return GWEN_Crypt_CryptMode_Unknown;
00088 }
00089 
00090 
00091 
00092 const char *GWEN_Crypt_CryptMode_toString(GWEN_CRYPT_CRYPTMODE m) {
00093   switch(m) {
00094   case GWEN_Crypt_CryptMode_None:
00095     return "none";
00096   case GWEN_Crypt_CryptMode_Ecb:
00097     return "ecb";
00098   case GWEN_Crypt_CryptMode_Cfb:
00099     return "cfb";
00100   case GWEN_Crypt_CryptMode_Cbc:
00101     return "cbc";
00102   default:
00103     return "unknown";
00104   }
00105 }
00106 
00107 
00108 
00109 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_new(GWEN_CRYPT_CRYPTALGOID id,
00110                                                GWEN_CRYPT_CRYPTMODE m) {
00111   GWEN_CRYPT_CRYPTALGO *a;
00112 
00113   GWEN_NEW_OBJECT(GWEN_CRYPT_CRYPTALGO, a);
00114   a->refCount=1;
00115 
00116   a->id=id;
00117   a->mode=m;
00118 
00119   return a;
00120 }
00121 
00122 
00123 
00124 void GWEN_Crypt_CryptAlgo_Attach(GWEN_CRYPT_CRYPTALGO *a) {
00125   assert(a);
00126   assert(a->refCount);
00127   a->refCount++;
00128 }
00129 
00130 
00131 
00132 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_fromDb(GWEN_DB_NODE *db) {
00133   const char *s;
00134 
00135   assert(db);
00136   s=GWEN_DB_GetCharValue(db, "id", 0, NULL);
00137   if (s) {
00138     GWEN_CRYPT_CRYPTALGO *a;
00139     GWEN_CRYPT_CRYPTALGOID id;
00140     GWEN_CRYPT_CRYPTMODE m;
00141     const void *p;
00142     unsigned int len;
00143 
00144     id=GWEN_Crypt_CryptAlgoId_fromString(s);
00145     if (id==GWEN_Crypt_CryptAlgoId_Unknown) {
00146       DBG_INFO(GWEN_LOGDOMAIN, "Unknown cryptalgo id [%s]", s);
00147       return NULL;
00148     }
00149 
00150     s=GWEN_DB_GetCharValue(db, "mode", 0, NULL);
00151     if (s)
00152       m=GWEN_Crypt_CryptMode_fromString(s);
00153     else {
00154       DBG_INFO(GWEN_LOGDOMAIN, "Missing crypt mode");
00155       return NULL;
00156     }
00157 
00158     a=GWEN_Crypt_CryptAlgo_new(id, m);
00159     assert(a);
00160     p=GWEN_DB_GetBinValue(db, "initVector", 0, NULL, 0, &len);
00161     if (p && len)
00162       GWEN_Crypt_CryptAlgo_SetInitVector(a, p, len);
00163 
00164     a->chunkSize=GWEN_DB_GetIntValue(db, "chunkSize", 0, 0);
00165     a->keySizeInBits=GWEN_DB_GetIntValue(db, "keySizeInBits", 0, 0);
00166 
00167     return a;
00168   }
00169   else {
00170     DBG_INFO(GWEN_LOGDOMAIN, "Missing cryptalgo id");
00171     return NULL;
00172   }
00173 }
00174 
00175 
00176 
00177 int GWEN_Crypt_CryptAlgo_toDb(const GWEN_CRYPT_CRYPTALGO *a, GWEN_DB_NODE *db) {
00178   assert(a);
00179   assert(a->refCount);
00180 
00181   GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00182                        "id",
00183                        GWEN_Crypt_CryptAlgoId_toString(a->id));
00184   GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00185                        "mode",
00186                        GWEN_Crypt_CryptMode_toString(a->id));
00187   if (a->pInitVector && a->lInitVector)
00188     GWEN_DB_SetBinValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00189                         "initVector",
00190                         a->pInitVector, a->lInitVector);
00191   GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00192                       "chunkSize",
00193                       a->chunkSize);
00194   GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00195                       "keySizeInBits",
00196                       a->keySizeInBits);
00197 
00198   return 0;
00199 }
00200 
00201 
00202 
00203 GWEN_CRYPT_CRYPTALGO *GWEN_Crypt_CryptAlgo_dup(const GWEN_CRYPT_CRYPTALGO *na) {
00204   GWEN_CRYPT_CRYPTALGO *a;
00205 
00206   assert(na);
00207   a=GWEN_Crypt_CryptAlgo_new(na->id, na->mode);
00208   if (na->pInitVector && na->lInitVector) {
00209     a->pInitVector=(uint8_t*) malloc(na->lInitVector);
00210     if (a->pInitVector==NULL) {
00211       GWEN_Crypt_CryptAlgo_free(a);
00212       return NULL;
00213     }
00214     else
00215       memmove(a->pInitVector, na->pInitVector, na->lInitVector);
00216     a->lInitVector=na->lInitVector;
00217   }
00218   a->chunkSize=na->chunkSize;
00219   a->keySizeInBits=na->keySizeInBits;
00220   return a;
00221 }
00222 
00223 
00224 
00225 void GWEN_Crypt_CryptAlgo_free(GWEN_CRYPT_CRYPTALGO *a) {
00226   if (a) {
00227     assert(a->refCount);
00228     if (a->refCount==1) {
00229       if (a->pInitVector) {
00230         free(a->pInitVector);
00231         a->pInitVector=NULL;
00232       }
00233       a->refCount--;
00234       GWEN_FREE_OBJECT(a);
00235     }
00236     else {
00237       a->refCount--;
00238     }
00239   }
00240 }
00241 
00242 
00243 
00244 GWEN_CRYPT_CRYPTALGOID GWEN_Crypt_CryptAlgo_GetId(const GWEN_CRYPT_CRYPTALGO *a){
00245   assert(a);
00246   assert(a->refCount);
00247   return a->id;
00248 }
00249 
00250 
00251 
00252 GWEN_CRYPT_CRYPTMODE GWEN_Crypt_CryptAlgo_GetMode(const GWEN_CRYPT_CRYPTALGO *a) {
00253   assert(a);
00254   assert(a->refCount);
00255   return a->mode;
00256 }
00257 
00258 
00259 
00260 uint8_t *GWEN_Crypt_CryptAlgo_GetInitVectorPtr(const GWEN_CRYPT_CRYPTALGO *a){
00261   assert(a);
00262   assert(a->refCount);
00263   return a->pInitVector;
00264 }
00265 
00266 
00267 
00268 uint32_t GWEN_Crypt_CryptAlgo_GetInitVectorLen(const GWEN_CRYPT_CRYPTALGO *a){
00269   assert(a);
00270   assert(a->refCount);
00271   return a->lInitVector;
00272 }
00273 
00274 
00275 
00276 int GWEN_Crypt_CryptAlgo_SetInitVector(GWEN_CRYPT_CRYPTALGO *a,
00277                                        const uint8_t *pv,
00278                                        uint32_t lv) {
00279   uint8_t *nv=NULL;
00280 
00281   assert(a);
00282   assert(a->refCount);
00283 
00284   if (pv && lv) {
00285     nv=(uint8_t*) malloc(lv);
00286     if (nv==NULL)
00287       return GWEN_ERROR_MEMORY_FULL;
00288     memmove(nv, pv, lv);
00289   }
00290 
00291   if (a->pInitVector && a->lInitVector)
00292     free(a->pInitVector);
00293 
00294   a->pInitVector=nv;
00295   a->lInitVector=(nv!=NULL)?lv:0;
00296 
00297   return 0;
00298 }
00299 
00300 
00301 
00302 int GWEN_Crypt_CryptAlgo_GetChunkSize(const GWEN_CRYPT_CRYPTALGO *a) {
00303   assert(a);
00304   assert(a->refCount);
00305 
00306   return a->chunkSize;
00307 }
00308 
00309 
00310 
00311 void GWEN_Crypt_CryptAlgo_SetChunkSize(GWEN_CRYPT_CRYPTALGO *a, int s) {
00312   assert(a);
00313   assert(a->refCount);
00314 
00315   a->chunkSize=s;
00316 }
00317 
00318 
00319 
00320 int GWEN_Crypt_CryptAlgo_GetKeySizeInBits(const GWEN_CRYPT_CRYPTALGO *a) {
00321   assert(a);
00322   assert(a->refCount);
00323 
00324   return a->keySizeInBits;
00325 }
00326 
00327 
00328 
00329 void GWEN_Crypt_CryptAlgo_SetKeySizeInBits(GWEN_CRYPT_CRYPTALGO *a, int s) {
00330   assert(a);
00331   assert(a->refCount);
00332 
00333   a->keySizeInBits=s;
00334 }
00335 
00336 
00337 
00338 
00339 
00340 
00341