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 "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
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