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