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 "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(void) {
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
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(void) {
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