gwenhywfar  4.8.0beta
cryptkeysym.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Wed Mar 16 2005
3  copyright : (C) 2005 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * Please see toplevel file COPYING for license details *
8  ***************************************************************************/
9 
10 #ifdef HAVE_CONFIG_H
11 # include <config.h>
12 #endif
13 
14 #define DISABLE_DEBUGLOG
15 
16 
17 #include "cryptkeysym_p.h"
18 #include <gwenhywfar/misc.h>
19 #include <gwenhywfar/debug.h>
20 #include <gwenhywfar/cryptdefs.h>
21 #include <gwenhywfar/text.h>
22 
23 
24 
25 GWEN_INHERIT(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM)
26 
27 
28 
29 
30 
31 
33  const uint8_t *pInData,
34  uint32_t inLen,
35  uint8_t *pOutData,
36  uint32_t *pOutLen) {
37  GWEN_CRYPT_KEY_SYM *xk;
38  gcry_error_t err;
39 
40  assert(k);
41  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
42  assert(xk);
43 
44  err=gcry_cipher_encrypt(xk->algoHandle, pOutData, inLen, pInData, inLen);
45  if (err) {
46  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_encrypt(): %s", gcry_strerror(err));
47  return GWEN_ERROR_GENERIC;
48  }
49  *pOutLen=inLen;
50 
51  return 0;
52 }
53 
54 
55 
57  const uint8_t *pInData,
58  uint32_t inLen,
59  uint8_t *pOutData,
60  uint32_t *pOutLen) {
61  GWEN_CRYPT_KEY_SYM *xk;
62  gcry_error_t err;
63 
64  assert(k);
65  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
66  assert(xk);
67 
68  err=gcry_cipher_decrypt(xk->algoHandle, pOutData, inLen, pInData, inLen);
69  if (err) {
70  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_decrypt(): %s", gcry_strerror(err));
71  return GWEN_ERROR_GENERIC;
72  }
73  *pOutLen=inLen;
74 
75  return 0;
76 }
77 
78 
79 
81 void GWEN_Crypt_KeySym_freeData(GWEN_UNUSED void *bp, void *p) {
82  GWEN_CRYPT_KEY_SYM *xk;
83 
84  xk=(GWEN_CRYPT_KEY_SYM*) p;
85  if (xk->keyData && xk->keyLen) {
86  memset(xk->keyData, 0, xk->keyLen);
87  free(xk->keyData);
88  }
89  xk->keyData=NULL;
90  xk->keyLen=0;
91  if (xk->algoValid)
92  gcry_cipher_close(xk->algoHandle);
93  GWEN_FREE_OBJECT(xk);
94 }
95 
96 
97 
99  GWEN_CRYPT_KEY *nk;
100  GWEN_CRYPT_KEY_SYM *xk;
101 
102  assert(k);
103  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
104  assert(xk);
105 
108  xk->mode,
109  xk->algo,
110  GCRY_CIPHER_SECURE,
111  xk->keyData,
112  xk->keyLen);
113  return nk;
114 }
115 
116 
117 
119  switch(mode) {
120  case GWEN_Crypt_CryptMode_Unknown: return GCRY_CIPHER_MODE_NONE;
121  case GWEN_Crypt_CryptMode_None: return GCRY_CIPHER_MODE_NONE;
122  case GWEN_Crypt_CryptMode_Ecb: return GCRY_CIPHER_MODE_ECB;
123  case GWEN_Crypt_CryptMode_Cfb: return GCRY_CIPHER_MODE_CFB;
124  case GWEN_Crypt_CryptMode_Cbc: return GCRY_CIPHER_MODE_CBC;
125  }
126 
127  return GCRY_CIPHER_MODE_NONE;
128 }
129 
130 
131 
134  int algo,
135  unsigned int flags,
136  int quality) {
137  GWEN_CRYPT_KEY *k;
138  GWEN_CRYPT_KEY_SYM *xk;
139  int kbytes;
140  uint8_t *keyData;
141  gcry_error_t err;
142  enum gcry_random_level q;
143 
144  k=GWEN_Crypt_Key_new(cryptAlgoId, keySize);
145  assert(k);
146  GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
150 
151  switch(quality) {
152  case 0: q=GCRY_WEAK_RANDOM; break;
153  case 1: q=GCRY_STRONG_RANDOM; break;
154  case 2:
155  default: q=GCRY_VERY_STRONG_RANDOM; break;
156  }
157 
158  /* open algo */
159  err=gcry_cipher_open(&xk->algoHandle, algo, GWEN_Crypt_KeySym__MyMode2GMode(mode), flags);
160  if (err) {
161  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
163  return NULL;
164  }
165  xk->algoValid=1;
166  xk->mode=mode;
167 
168  while(1) {
169  kbytes=keySize;
170  keyData=gcry_random_bytes(kbytes, q);
171 
172  /* store key data */
173  xk->keyData=keyData;
174  xk->keyLen=kbytes;
175 
176  /* set key in algo */
177  err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
178  if (err) {
179  if ((err & GPG_ERR_CODE_MASK)==GPG_ERR_WEAK_KEY) {
180  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): weak key, will try again");
181  }
182  else {
183  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %d [%s]", err, gcry_strerror(err));
185  return NULL;
186  }
187  }
188  else
189  break;
190 
191  /* try it again */
192  memset(xk->keyData, 0, xk->keyLen);
193  free(xk->keyData);
194  xk->keyData=NULL;
195  xk->keyLen=0;
196  }
197 
198  return k;
199 }
200 
201 
202 
205  int algo,
206  unsigned int flags,
207  const uint8_t *kd, uint32_t kl) {
208  GWEN_CRYPT_KEY *k;
209  GWEN_CRYPT_KEY_SYM *xk;
210  gcry_error_t err;
211 
212 #if 0
213  if (kl!=gcry_cipher_get_algo_keylen(algo)) {
214  DBG_ERROR(GWEN_LOGDOMAIN, "Invalid key length (is %d, should be %d)",
215  (int)kl, (int)gcry_cipher_get_algo_keylen(algo));
216  return NULL;
217  }
218 #endif
219 
220  k=GWEN_Crypt_Key_new(cryptAlgoId, keySize);
221  assert(k);
222  GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
226 
227  /* open algo */
228  err=gcry_cipher_open(&xk->algoHandle, algo, GWEN_Crypt_KeySym__MyMode2GMode(mode), flags);
229  if (err) {
230  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
232  return NULL;
233  }
234  xk->algoValid=1;
235  xk->mode=mode;
236  xk->algo=algo;
237 
238  /* read key data */
239  if (kd==NULL || kl==0) {
240  DBG_INFO(GWEN_LOGDOMAIN, "No key data");
242  return NULL;
243  }
244 
245  /* store key data */
246  xk->keyData=(uint8_t*) malloc(kl);
247  assert(xk->keyData);
248  memmove(xk->keyData, kd, kl);
249  xk->keyLen=kl;
250 
251  /* set key in algo */
252  err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
253  if (err) {
254  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
256  return NULL;
257  }
258 
259  return k;
260 }
261 
262 
263 
266  int algo,
267  unsigned int flags,
268  const char *gname,
269  GWEN_DB_NODE *db) {
270  gcry_error_t err;
271  GWEN_CRYPT_KEY *k;
272  GWEN_CRYPT_KEY_SYM *xk;
273  unsigned int nbits;
274  GWEN_DB_NODE *dbR;
275  unsigned int len;
276  const char *p;
277 
279  if (dbR==NULL) {
280  DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an %s key (no %s group)",
281  gname, gname);
282  return NULL;
283  }
284 
285  k=GWEN_Crypt_Key_fromDb(db);
286  if (k==NULL) {
287  DBG_INFO(GWEN_LOGDOMAIN, "here");
288  return NULL;
289  }
290  if (GWEN_Crypt_Key_GetCryptAlgoId(k)!=cryptAlgoId) {
291  DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an RSA key");
293  return NULL;
294  }
295  nbits=GWEN_Crypt_Key_GetKeySize(k)*8;
296 
297  /* extend key */
298  GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
302 
303  /* open algo */
304  err=gcry_cipher_open(&xk->algoHandle, algo, GWEN_Crypt_KeySym__MyMode2GMode(mode), flags);
305  if (err) {
306  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
308  return NULL;
309  }
310  xk->algoValid=1;
311  xk->mode=mode;
312  xk->algo=algo;
313 
314  /* read key data */
315  p=GWEN_DB_GetBinValue(dbR, "keyData", 0, NULL, 0, &len);
316  if (p==NULL || len==0) {
317  DBG_INFO(GWEN_LOGDOMAIN, "No key data");
319  return NULL;
320  }
321 
322  /* store key data */
323  xk->keyData=(uint8_t*) malloc(len);
324  assert(xk->keyData);
325  memmove(xk->keyData, p, len);
326  xk->keyLen=len;
327 
328  /* set key in algo */
329  err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
330  if (err) {
331  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
333  return NULL;
334  }
335 
336  return k;
337 }
338 
339 
340 
341 int GWEN_Crypt_KeySym__toDb(const GWEN_CRYPT_KEY *k, GWEN_DB_NODE *db, const char *gname) {
342  GWEN_CRYPT_KEY_SYM *xk;
343  GWEN_DB_NODE *dbR;
344  int rv;
345 
346  assert(k);
347  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
348  assert(xk);
349 
350  /* let key module wirte basic key info */
351  rv=GWEN_Crypt_Key_toDb(k, db);
352  if (rv)
353  return rv;
354 
355  /* write sym stuff into our own group */
357  assert(dbR);
358 
360  "keyData", xk->keyData, xk->keyLen);
361 
362  return 0;
363 }
364 
365 
366 
368  gcry_error_t err;
369  GWEN_CRYPT_KEY *k;
370  GWEN_CRYPT_KEY_SYM *xk;
371  unsigned int nbits;
372  GWEN_DB_NODE *dbR;
373  unsigned int len;
374  const char *gname;
375  const char *p;
376 
377  k=GWEN_Crypt_Key_fromDb(db);
378  if (k==NULL) {
379  DBG_INFO(GWEN_LOGDOMAIN, "here");
380  return NULL;
381  }
382 
384 
386  if (dbR==NULL) {
387  DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an %s key (no %s group)",
388  gname, gname);
390  return NULL;
391  }
392 
393  nbits=GWEN_Crypt_Key_GetKeySize(k)*8;
394 
395  /* extend key */
396  GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_SYM, xk);
400 
401  /* open algo */
402  err=gcry_cipher_open(&xk->algoHandle,
405  GCRY_CIPHER_SECURE);
406  if (err) {
407  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_open(): %s", gcry_strerror(err));
409  return NULL;
410  }
411  xk->algoValid=1;
412  xk->mode=mode;
413  xk->algo=GWEN_Crypt_Key_GetCryptAlgoId(k);
414 
415  /* read key data */
416  p=GWEN_DB_GetBinValue(dbR, "keyData", 0, NULL, 0, &len);
417  if (p==NULL || len==0) {
418  DBG_INFO(GWEN_LOGDOMAIN, "No key data");
420  return NULL;
421  }
422 
423  /* store key data */
424  xk->keyData=(uint8_t*) malloc(len);
425  assert(xk->keyData);
426  memmove(xk->keyData, p, len);
427  xk->keyLen=len;
428 
429  /* set key in algo */
430  err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
431  if (err) {
432  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
434  return NULL;
435  }
436 
437  return k;
438 }
439 
440 
441 
443  GWEN_CRYPT_KEY_SYM *xk;
444  GWEN_DB_NODE *dbR;
445  int rv;
446  const char *gname;
447 
448  assert(k);
449  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
450  assert(xk);
451 
452  /* let key module wirte basic key info */
453  rv=GWEN_Crypt_Key_toDb(k, db);
454  if (rv)
455  return rv;
456 
458 
459  /* write sym stuff into our own group */
461  assert(dbR);
462 
464  "keyData", xk->keyData, xk->keyLen);
465 
466  return 0;
467 }
468 
469 
470 
471 int GWEN_Crypt_KeySym_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
472  GWEN_CRYPT_KEY_SYM *xk;
473  gcry_error_t err;
474 
475  if (!kd || !kl) {
476  DBG_ERROR(GWEN_LOGDOMAIN, "Empty keydata not allowed");
477  return GWEN_ERROR_INVALID;
478  }
479 
480  assert(k);
481  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
482  assert(xk);
483 
484  if (xk->keyData && xk->keyLen) {
485  memset(xk->keyData, 0, xk->keyLen);
486  free(xk->keyData);
487  }
488 
489  /* store key data */
490  xk->keyData=(uint8_t*)malloc(kl);
491  assert(xk->keyData);
492  memmove(xk->keyData, kd, kl);
493  xk->keyLen=kl;
494 
495  /* set key in algo */
496  err=gcry_cipher_setkey(xk->algoHandle, xk->keyData, xk->keyLen);
497  if (err) {
498  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setkey(): %s", gcry_strerror(err));
500  return GWEN_ERROR_GENERIC;
501  }
502 
503  return 0;
504 }
505 
506 
507 
509  GWEN_CRYPT_KEY_SYM *xk;
510 
511  assert(k);
512  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
513  assert(xk);
514 
515  return xk->keyData;
516 }
517 
518 
519 
521  GWEN_CRYPT_KEY_SYM *xk;
522 
523  assert(k);
524  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
525  assert(xk);
526 
527  return xk->keyLen;
528 }
529 
530 
531 
532 
534  int keySize,
535  int quality){
536  uint8_t kd[16];
537  GWEN_CRYPT_KEY *k;
538 
539  GWEN_Crypt_Random(quality, kd, 16);
540  k=GWEN_Crypt_KeyDes3K_fromData(mode, keySize, kd, 16);
541  memset(kd, 0, 16);
542 
543  return k;
544 }
545 
546 
547 
549  const uint8_t *kd, uint32_t kl) {
550  if (kl==16) {
551  uint8_t new_kd[24];
552  GWEN_CRYPT_KEY *k;
553 
554  /* 3key DES with only two keys, copy key1 as key3 */
555  memmove(new_kd, kd, 16);
556  memmove(new_kd+16, new_kd, 8);
557  k=GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_Des3K, 24,
558  mode, GCRY_CIPHER_3DES, GCRY_CIPHER_SECURE, new_kd, 24);
559  memset(new_kd, 0, 24);
560  return k;
561  }
562  else
563  return GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_Des3K, keySize,
564  mode, GCRY_CIPHER_3DES, GCRY_CIPHER_SECURE, kd, kl);
565 }
566 
567 
568 
570  GWEN_DB_NODE *db) {
571  return GWEN_Crypt_KeySym__fromDb(GWEN_Crypt_CryptAlgoId_Des3K, mode,
572  GCRY_CIPHER_3DES, GCRY_CIPHER_SECURE, "des3k", db);
573 }
574 
575 
576 
578  return GWEN_Crypt_KeySym__toDb(k, db, "des3k");
579 }
580 
581 
582 
583 int GWEN_Crypt_KeyDes3K_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
584  if (kl==16) {
585  uint8_t new_kd[24];
586  int rv;
587 
588  /* 3key DES with only two keys, copy key1 as key3 */
589  memmove(new_kd, kd, 16);
590  memmove(new_kd+16, new_kd, 8);
591  rv=GWEN_Crypt_KeySym_SetKeyData(k, new_kd, 24);
592  memset(new_kd, 0, 24);
593  return rv;
594  }
595  else
596  return GWEN_Crypt_KeySym_SetKeyData(k, kd, kl);
597 }
598 
599 
600 
603 }
604 
605 
606 
609 }
610 
611 
612 
614  const uint8_t *kd,
615  uint32_t kl) {
616  GWEN_CRYPT_KEY_SYM *xk;
617  gcry_error_t err;
618 
619  assert(k);
620  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
621  assert(xk);
622 
623  if (kd==NULL || kl==0) {
624  const uint8_t iv[]={
625  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
626  };
627  err=gcry_cipher_setiv(xk->algoHandle, iv, sizeof(iv));
628  }
629  else
630  err=gcry_cipher_setiv(xk->algoHandle, kd, kl);
631  if (err) {
632  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setiv(): %s", gcry_strerror(err));
633  return GWEN_ERROR_GENERIC;
634  }
635 
636  return 0;
637 }
638 
639 
640 
641 
642 
643 
644 
646  int keySize,
647  int quality){
648  return GWEN_Crypt_KeySym_Generate(GWEN_Crypt_CryptAlgoId_BlowFish, keySize, mode,
649  GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_SECURE, quality);
650 }
651 
652 
653 
655  const uint8_t *kd, uint32_t kl) {
656  return GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_BlowFish, keySize, mode,
657  GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_SECURE,
658  kd, kl);
659 }
660 
661 
662 
664  GWEN_DB_NODE *db) {
665  return GWEN_Crypt_KeySym__fromDb(GWEN_Crypt_CryptAlgoId_BlowFish, mode,
666  GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_SECURE, "blowFish", db);
667 }
668 
669 
670 
672  return GWEN_Crypt_KeySym__toDb(k, db, "blowFish");
673 }
674 
675 
676 
677 int GWEN_Crypt_KeyBlowFish_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
678  return GWEN_Crypt_KeySym_SetKeyData(k, kd, kl);
679 }
680 
681 
682 
685 }
686 
687 
688 
691 }
692 
693 
694 
695 
697  int keySize,
698  int quality){
699  return GWEN_Crypt_KeySym_Generate(GWEN_Crypt_CryptAlgoId_Aes128, keySize, mode,
700  GCRY_CIPHER_AES128, GCRY_CIPHER_SECURE, quality);
701 }
702 
703 
704 
706  const uint8_t *kd, uint32_t kl) {
707  return GWEN_Crypt_KeySym_fromData(GWEN_Crypt_CryptAlgoId_Aes128, keySize, mode,
708  GCRY_CIPHER_AES128, GCRY_CIPHER_SECURE,
709  kd, kl);
710 }
711 
712 
713 
715  GWEN_DB_NODE *db) {
716  return GWEN_Crypt_KeySym__fromDb(GWEN_Crypt_CryptAlgoId_Aes128, mode,
717  GCRY_CIPHER_AES128, GCRY_CIPHER_SECURE, "aes128", db);
718 }
719 
720 
721 
723  return GWEN_Crypt_KeySym__toDb(k, db, "aes128");
724 }
725 
726 
727 
728 int GWEN_Crypt_KeyAes128_SetKeyData(GWEN_CRYPT_KEY *k, const uint8_t *kd, uint32_t kl) {
729  return GWEN_Crypt_KeySym_SetKeyData(k, kd, kl);
730 }
731 
732 
733 
736 }
737 
738 
739 
742 }
743 
744 
745 
747  const uint8_t *kd,
748  uint32_t kl) {
749  GWEN_CRYPT_KEY_SYM *xk;
750  gcry_error_t err;
751 
752  assert(k);
753  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_SYM, k);
754  assert(xk);
755 
756  if (kd==NULL || kl==0) {
757  const uint8_t iv[]={
758  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
759  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
760  };
761  err=gcry_cipher_setiv(xk->algoHandle, iv, sizeof(iv));
762  }
763  else
764  err=gcry_cipher_setiv(xk->algoHandle, kd, kl);
765  if (err) {
766  DBG_INFO(GWEN_LOGDOMAIN, "gcry_cipher_setiv(): %s", gcry_strerror(err));
767  return GWEN_ERROR_GENERIC;
768  }
769 
770  return 0;
771 }
772 
773 
774 
775 
776 
777 
778 
779 
780 
781