00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #ifdef HAVE_CONFIG_H
00014 # include <config.h>
00015 #endif
00016
00017
00018 #include "hashalgo_p.h"
00019 #include <gwenhywfar/misc.h>
00020 #include <gwenhywfar/debug.h>
00021
00022
00023
00024 GWEN_LIST2_FUNCTIONS(GWEN_CRYPT_HASHALGO, GWEN_Crypt_HashAlgo)
00025
00026
00027
00028 GWEN_CRYPT_HASHALGOID GWEN_Crypt_HashAlgoId_fromString(const char *s) {
00029 assert(s);
00030 if (strcasecmp(s, "none")==0)
00031 return GWEN_Crypt_HashAlgoId_None;
00032 else if (strcasecmp(s, "sha1")==0)
00033 return GWEN_Crypt_HashAlgoId_Sha1;
00034 else if (strcasecmp(s, "rmd160")==0)
00035 return GWEN_Crypt_HashAlgoId_Rmd160;
00036 else if (strcasecmp(s, "md5")==0)
00037 return GWEN_Crypt_HashAlgoId_Md5;
00038 else if (strcasecmp(s, "any")==0)
00039 return GWEN_Crypt_HashAlgoId_Any;
00040 return GWEN_Crypt_HashAlgoId_Unknown;
00041 }
00042
00043
00044
00045 const char *GWEN_Crypt_HashAlgoId_toString(GWEN_CRYPT_HASHALGOID a) {
00046 switch(a) {
00047 case GWEN_Crypt_HashAlgoId_None:
00048 return "none";
00049 case GWEN_Crypt_HashAlgoId_Sha1:
00050 return "sha1";
00051 case GWEN_Crypt_HashAlgoId_Rmd160:
00052 return "rmd160";
00053 case GWEN_Crypt_HashAlgoId_Md5:
00054 return "md5";
00055 case GWEN_Crypt_HashAlgoId_Any:
00056 return "any";
00057 default:
00058 return "unknown";
00059 }
00060 }
00061
00062
00063
00064 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_new(GWEN_CRYPT_HASHALGOID id) {
00065 GWEN_CRYPT_HASHALGO *a;
00066
00067 GWEN_NEW_OBJECT(GWEN_CRYPT_HASHALGO, a);
00068 a->refCount=1;
00069
00070 a->id=id;
00071
00072 return a;
00073 }
00074
00075
00076
00077 void GWEN_Crypt_HashAlgo_Attach(GWEN_CRYPT_HASHALGO *a) {
00078 assert(a);
00079 assert(a->refCount);
00080 a->refCount++;
00081 }
00082
00083
00084
00085 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_fromDb(GWEN_DB_NODE *db) {
00086 const char *s;
00087
00088 assert(db);
00089 s=GWEN_DB_GetCharValue(db, "id", 0, NULL);
00090 if (s) {
00091 GWEN_CRYPT_HASHALGO *a;
00092 GWEN_CRYPT_HASHALGOID id;
00093 const void *p;
00094 unsigned int len;
00095
00096 id=GWEN_Crypt_HashAlgoId_fromString(s);
00097 if (id==GWEN_Crypt_HashAlgoId_Unknown) {
00098 DBG_INFO(GWEN_LOGDOMAIN, "Unknown hashalgo id [%s]", s);
00099 return NULL;
00100 }
00101 a=GWEN_Crypt_HashAlgo_new(id);
00102 assert(a);
00103 p=GWEN_DB_GetBinValue(db, "initVector", 0, NULL, 0, &len);
00104 if (p && len)
00105 GWEN_Crypt_HashAlgo_SetInitVector(a, p, len);
00106
00107 return a;
00108 }
00109 else {
00110 DBG_INFO(GWEN_LOGDOMAIN, "Missing hashalgo id");
00111 return NULL;
00112 }
00113 }
00114
00115
00116
00117 int GWEN_Crypt_HashAlgo_toDb(const GWEN_CRYPT_HASHALGO *a, GWEN_DB_NODE *db) {
00118 assert(a);
00119 assert(a->refCount);
00120
00121 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00122 "id",
00123 GWEN_Crypt_HashAlgoId_toString(a->id));
00124 if (a->pInitVector && a->lInitVector)
00125 GWEN_DB_SetBinValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00126 "initVector",
00127 a->pInitVector, a->lInitVector);
00128
00129 return 0;
00130 }
00131
00132
00133
00134 GWEN_CRYPT_HASHALGO *GWEN_Crypt_HashAlgo_dup(const GWEN_CRYPT_HASHALGO *na) {
00135 GWEN_CRYPT_HASHALGO *a;
00136
00137 assert(na);
00138 a=GWEN_Crypt_HashAlgo_new(na->id);
00139 if (na->pInitVector && na->lInitVector) {
00140 a->pInitVector=(uint8_t*) malloc(na->lInitVector);
00141 if (a->pInitVector==NULL) {
00142 GWEN_Crypt_HashAlgo_free(a);
00143 return NULL;
00144 }
00145 else
00146 memmove(a->pInitVector, na->pInitVector, na->lInitVector);
00147 a->lInitVector=na->lInitVector;
00148 }
00149
00150 return a;
00151 }
00152
00153
00154
00155 void GWEN_Crypt_HashAlgo_free(GWEN_CRYPT_HASHALGO *a) {
00156 if (a) {
00157 assert(a->refCount);
00158 if (a->refCount==1) {
00159 if (a->pInitVector) {
00160 free(a->pInitVector);
00161 a->pInitVector=NULL;
00162 }
00163 a->refCount--;
00164 GWEN_FREE_OBJECT(a);
00165 }
00166 else {
00167 a->refCount--;
00168 }
00169 }
00170 }
00171
00172
00173
00174 GWEN_CRYPT_HASHALGOID GWEN_Crypt_HashAlgo_GetId(const GWEN_CRYPT_HASHALGO *a){
00175 assert(a);
00176 assert(a->refCount);
00177 return a->id;
00178 }
00179
00180
00181
00182 uint8_t *GWEN_Crypt_HashAlgo_GetInitVectorPtr(const GWEN_CRYPT_HASHALGO *a){
00183 assert(a);
00184 assert(a->refCount);
00185 return a->pInitVector;
00186 }
00187
00188
00189
00190 uint32_t GWEN_Crypt_HashAlgo_GetInitVectorLen(const GWEN_CRYPT_HASHALGO *a){
00191 assert(a);
00192 assert(a->refCount);
00193 return a->lInitVector;
00194 }
00195
00196
00197
00198 int GWEN_Crypt_HashAlgo_SetInitVector(GWEN_CRYPT_HASHALGO *a,
00199 const uint8_t *pv,
00200 uint32_t lv) {
00201 uint8_t *nv=NULL;
00202
00203 assert(a);
00204 assert(a->refCount);
00205
00206 if (pv && lv) {
00207 nv=(uint8_t*) malloc(lv);
00208 if (nv==NULL)
00209 return GWEN_ERROR_MEMORY_FULL;
00210 memmove(nv, pv, lv);
00211 }
00212
00213 if (a->pInitVector && a->lInitVector)
00214 free(a->pInitVector);
00215
00216 a->pInitVector=nv;
00217 a->lInitVector=(nv!=NULL)?lv:0;
00218
00219 return 0;
00220 }
00221
00222
00223
00224