hashalgo.c

Go to the documentation of this file.
00001 /***************************************************************************
00002  $RCSfile$
00003                              -------------------
00004     cvs         : $Id: crypttoken.h 1113 2007-01-10 09:14:16Z martin $
00005     begin       : Wed Mar 16 2005
00006     copyright   : (C) 2005 by Martin Preuss
00007     email       : martin@libchipcard.de
00008 
00009  ***************************************************************************
00010  *          Please see toplevel file COPYING for license details           *
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 

Generated on Fri Apr 11 01:53:46 2008 for gwenhywfar by  doxygen 1.5.5