cryptkey.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 "cryptkey_p.h"
00019 #include <gwenhywfar/misc.h>
00020 #include <gwenhywfar/debug.h>
00021 
00022 #include <gcrypt.h>
00023 
00024 
00025 
00026 
00027 GWEN_INHERIT_FUNCTIONS(GWEN_CRYPT_KEY)
00028 GWEN_LIST_FUNCTIONS(GWEN_CRYPT_KEY, GWEN_Crypt_Key)
00029 GWEN_LIST2_FUNCTIONS(GWEN_CRYPT_KEY, GWEN_Crypt_Key)
00030 
00031 
00032 
00033 
00034 int GWEN_Crypt3_ModuleInit() {
00035   gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
00036   if (!gcry_check_version (GCRYPT_VERSION)) {
00037     DBG_ERROR(GWEN_LOGDOMAIN, "Libgcrypt version mismatch");
00038     return GWEN_ERROR_GENERIC;
00039   }
00040   /*gcry_control(GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);*/
00041 
00042   gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
00043   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
00044 
00045   return 0;
00046 }
00047 
00048 
00049 
00050 int GWEN_Crypt3_ModuleFini() {
00051   return 0;
00052 }
00053 
00054 
00055 
00056 
00057 
00058 GWEN_CRYPT_KEY *GWEN_Crypt_Key_new(GWEN_CRYPT_CRYPTALGOID cryptAlgoId, int keySize) {
00059   GWEN_CRYPT_KEY *k;
00060 
00061   GWEN_NEW_OBJECT(GWEN_CRYPT_KEY, k)
00062   k->refCount=1;
00063   GWEN_INHERIT_INIT(GWEN_CRYPT_KEY, k)
00064   GWEN_LIST_INIT(GWEN_CRYPT_KEY, k)
00065 
00066   k->cryptAlgoId=cryptAlgoId;
00067   k->keySize=keySize;
00068 
00069   return k;
00070 }
00071 
00072 
00073 
00074 GWEN_CRYPT_KEY *GWEN_Crypt_Key_fromDb(GWEN_DB_NODE *db) {
00075   GWEN_CRYPT_KEY *k;
00076   GWEN_CRYPT_CRYPTALGOID cryptAlgoId;
00077   int keySize;
00078   const char *s;
00079 
00080   s=GWEN_DB_GetCharValue(db, "cryptAlgoId", 0, NULL);
00081   if (s)
00082     cryptAlgoId=GWEN_Crypt_CryptAlgoId_fromString(s);
00083   else
00084     cryptAlgoId=GWEN_Crypt_CryptAlgoId_Unknown;
00085 
00086   if (cryptAlgoId==GWEN_Crypt_CryptAlgoId_Unknown) {
00087     DBG_ERROR(GWEN_LOGDOMAIN, "Unknown crypt algo id [%s]",
00088               s?s:"---");
00089     return NULL;
00090   }
00091 
00092   keySize=GWEN_DB_GetIntValue(db, "keySize", 0, -1);
00093   if (keySize==-1) {
00094     DBG_ERROR(GWEN_LOGDOMAIN, "Missing keysize");
00095     return NULL;
00096   }
00097 
00098   k=GWEN_Crypt_Key_new(cryptAlgoId, keySize);
00099   if (k==NULL)
00100     return NULL;
00101 
00102   k->keyNumber=GWEN_DB_GetIntValue(db, "keyNumber", 0, 0);
00103   k->keyVersion=GWEN_DB_GetIntValue(db, "keyVersion", 0, 0);
00104 
00105   return k;
00106 }
00107 
00108 
00109 
00110 int GWEN_Crypt_Key_toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db) {
00111   assert(k);
00112   assert(db);
00113 
00114   GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00115                        "cryptAlgoId",
00116                        GWEN_Crypt_CryptAlgoId_toString(k->cryptAlgoId));
00117   GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00118                       "keySize", k->keySize);
00119   GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00120                       "keyNumber", k->keyNumber);
00121   GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
00122                       "keyVersion", k->keyVersion);
00123 
00124   return 0;
00125 }
00126 
00127 
00128 
00129 GWEN_CRYPT_KEY *GWEN_Crypt_Key_dup(const GWEN_CRYPT_KEY *k) {
00130   GWEN_CRYPT_KEY *nk;
00131 
00132   assert(k);
00133   nk=GWEN_Crypt_Key_new(k->cryptAlgoId, k->keySize);
00134   if (nk==NULL)
00135     return NULL;
00136 
00137   nk->keyNumber=k->keyNumber;
00138   nk->keyVersion=k->keyVersion;
00139 
00140   return nk;
00141 }
00142 
00143 
00144 
00145 void GWEN_Crypt_Key_free(GWEN_CRYPT_KEY *k) {
00146   if (k) {
00147     assert(k->refCount);
00148     if (k->refCount==1) {
00149       GWEN_INHERIT_FINI(GWEN_CRYPT_KEY, k)
00150       GWEN_LIST_FINI(GWEN_CRYPT_KEY, k)
00151       k->refCount=0;
00152       GWEN_FREE_OBJECT(k);
00153     }
00154     else
00155       k->refCount--;
00156   }
00157 }
00158 
00159 
00160 
00161 GWEN_CRYPT_CRYPTALGOID GWEN_Crypt_Key_GetCryptAlgoId(const GWEN_CRYPT_KEY *k) {
00162   assert(k);
00163   return k->cryptAlgoId;
00164 }
00165 
00166 
00167 
00168 int GWEN_Crypt_Key_GetKeySize(const GWEN_CRYPT_KEY *k) {
00169   assert(k);
00170   return k->keySize;
00171 }
00172 
00173 
00174 
00175 int GWEN_Crypt_Key_GetKeyNumber(const GWEN_CRYPT_KEY *k) {
00176   assert(k);
00177   return k->keyNumber;
00178 }
00179 
00180 
00181 
00182 void GWEN_Crypt_Key_SetKeyNumber(GWEN_CRYPT_KEY *k, int i) {
00183   assert(k);
00184   k->keyNumber=i;
00185 }
00186 
00187 
00188 
00189 int GWEN_Crypt_Key_GetKeyVersion(const GWEN_CRYPT_KEY *k) {
00190   assert(k);
00191   return k->keyVersion;
00192 }
00193 
00194 
00195 
00196 void GWEN_Crypt_Key_SetKeyVersion(GWEN_CRYPT_KEY *k, int i) {
00197   assert(k);
00198   k->keyVersion=i;
00199 }
00200 
00201 
00202 
00203 GWEN_CRYPT_KEY_SIGN_FN GWEN_Crypt_Key_SetSignFn(GWEN_CRYPT_KEY *k, GWEN_CRYPT_KEY_SIGN_FN f) {
00204   GWEN_CRYPT_KEY_SIGN_FN of;
00205 
00206   assert(k);
00207   of=k->signFn;
00208   k->signFn=f;
00209 
00210   return of;
00211 }
00212 
00213 
00214 
00215 GWEN_CRYPT_KEY_VERIFY_FN GWEN_Crypt_Key_SetVerifyFn(GWEN_CRYPT_KEY *k, GWEN_CRYPT_KEY_VERIFY_FN f){
00216   GWEN_CRYPT_KEY_VERIFY_FN of;
00217 
00218   assert(k);
00219   of=k->verifyFn;
00220   k->verifyFn=f;
00221 
00222   return of;
00223 }
00224 
00225 
00226 
00227 GWEN_CRYPT_KEY_ENCIPHER_FN GWEN_Crypt_Key_SetEncipherFn(GWEN_CRYPT_KEY *k,
00228                                                         GWEN_CRYPT_KEY_ENCIPHER_FN f) {
00229   GWEN_CRYPT_KEY_ENCIPHER_FN of;
00230 
00231   assert(k);
00232   of=k->encipherFn;
00233   k->encipherFn=f;
00234 
00235   return of;
00236 }
00237 
00238 
00239 
00240 GWEN_CRYPT_KEY_DECIPHER_FN GWEN_Crypt_Key_SetDecipherFn(GWEN_CRYPT_KEY *k,
00241                                                         GWEN_CRYPT_KEY_DECIPHER_FN f) {
00242   GWEN_CRYPT_KEY_DECIPHER_FN of;
00243 
00244   assert(k);
00245   of=k->decipherFn;
00246   k->decipherFn=f;
00247 
00248   return of;
00249 }
00250 
00251 
00252 
00253 int GWEN_Crypt_Key_Sign(GWEN_CRYPT_KEY *k,
00254                         const uint8_t *pInData,
00255                         uint32_t inLen,
00256                         uint8_t *pSignatureData,
00257                         uint32_t *pSignatureLen) {
00258   assert(k);
00259   if (k->signFn)
00260     return k->signFn(k, pInData, inLen, pSignatureData, pSignatureLen);
00261   else
00262     return GWEN_ERROR_NOT_IMPLEMENTED;
00263 }
00264 
00265 
00266 
00267 int GWEN_Crypt_Key_Verify(GWEN_CRYPT_KEY *k,
00268                           const uint8_t *pInData,
00269                           uint32_t inLen,
00270                           const uint8_t *pSignatureData,
00271                           uint32_t signatureLen) {
00272   assert(k);
00273   if (k->verifyFn)
00274     return k->verifyFn(k, pInData, inLen, pSignatureData, signatureLen);
00275   else
00276     return GWEN_ERROR_NOT_IMPLEMENTED;
00277 }
00278 
00279 
00280 
00281 int GWEN_Crypt_Key_Encipher(GWEN_CRYPT_KEY *k,
00282                             const uint8_t *pInData,
00283                             uint32_t inLen,
00284                             uint8_t *pOutData,
00285                             uint32_t *pOutLen) {
00286   assert(k);
00287   if (k->encipherFn)
00288     return k->encipherFn(k, pInData, inLen, pOutData, pOutLen);
00289   else
00290     return GWEN_ERROR_NOT_IMPLEMENTED;
00291 }
00292 
00293 
00294 
00295 int GWEN_Crypt_Key_Decipher(GWEN_CRYPT_KEY *k,
00296                             const uint8_t *pInData,
00297                             uint32_t inLen,
00298                             uint8_t *pOutData,
00299                             uint32_t *pOutLen) {
00300   assert(k);
00301   if (k->decipherFn)
00302     return k->decipherFn(k, pInData, inLen, pOutData, pOutLen);
00303   else
00304     return GWEN_ERROR_NOT_IMPLEMENTED;
00305 }
00306 
00307 
00308 
00309 
00310 
00311 
00312 
00313 

Generated on Wed Jul 9 13:12:27 2008 for gwenhywfar by  doxygen 1.5.6