00001
00002
00003
00004
00005
00006
00007
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