gwenhywfar  4.6.0beta
cryptkeyrsa.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 "cryptkeyrsa_p.h"
18 #include <gwenhywfar/misc.h>
19 #include <gwenhywfar/debug.h>
20 #include <gwenhywfar/text.h>
21 
22 
23 
24 
25 GWEN_INHERIT(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA)
26 
27 
28 
29 
30 #if 0
31 static void dumpKeyData(gcry_ac_data_t data) {
32  int i;
33  unsigned int l;
34 
35  l=gcry_ac_data_length(data);
36  for (i=0; i<l; i++) {
37  const char *dname;
38  gcry_mpi_t mpi;
39  gcry_error_t err;
40  unsigned char *buf;
41  size_t nbytes;
42 
43  gcry_ac_data_get_index(data, 0, i, &dname, &mpi);
44  fprintf(stderr, "%3d: [%s]\n", i, dname);
45 
46  /* write mpi as bin into a buffer which will be allocates by this function */
47  err=gcry_mpi_aprint(GCRYMPI_FMT_USG, &buf, &nbytes, mpi);
48  if (err) {
49  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_aprint(): %d", err);
50  }
51  else {
52  GWEN_Text_DumpString((const char*)buf, nbytes, stderr, 6);
53  gcry_free(buf);
54  }
55  }
56 }
57 #endif
58 
59 
60 
61 static int GWEN_Crypt_KeyRsa__getNamedElement(gcry_sexp_t pkey, const char *name, gcry_mpi_t *pMpi) {
62  gcry_sexp_t list;
63  gcry_mpi_t mpi;
64 
65  /* get public exponent */
66  list=gcry_sexp_find_token(pkey, name, 0);
67  if (!list) {
68  DBG_ERROR(GWEN_LOGDOMAIN, "Missing element \"%s\" in sexp", name);
69  return GWEN_ERROR_GENERIC;
70  }
71 
72  mpi=gcry_sexp_nth_mpi(list, 1, GCRYMPI_FMT_USG);
73  if (!mpi) {
74  DBG_ERROR(GWEN_LOGDOMAIN, "Eror getting value for element \"%s\"", name);
75  gcry_sexp_release(list);
76  return GWEN_ERROR_GENERIC;
77  }
78 
79  *pMpi=mpi;
80  gcry_sexp_release(list);
81 
82  return 0;
83 }
84 
85 
86 
87 int GWEN_Crypt_KeyRsa_GeneratePair2(unsigned int nbits, int use65537e,
88  GWEN_CRYPT_KEY **pPubKey,
89  GWEN_CRYPT_KEY **pSecretKey) {
90  gcry_sexp_t keyparm, key;
91  int rc;
92  char buffer[256];
93  char numbuf[32];
94  gcry_sexp_t pkey;
95  int nbytes;
96  GWEN_CRYPT_KEY *pubKey=NULL;
97  GWEN_CRYPT_KEY *secretKey=NULL;
98 
99  nbytes=nbits/8;
100  if (nbits%8)
101  nbytes++;
102  snprintf(numbuf, sizeof(numbuf)-1, "%d", nbits);
103  if (use65537e) {
104  snprintf(buffer, sizeof(buffer)-1,
105  "(genkey\n"
106  " (rsa\n"
107  " (nbits %zd:%d)\n"
108  " (rsa-use-e 5:65537)\n"
109  " ))",
110  strlen(numbuf),
111  nbits);
112  }
113  else
114  snprintf(buffer, sizeof(buffer)-1,
115  "(genkey\n"
116  " (rsa\n"
117  " (nbits %zd:%d)\n"
118  " (rsa-use-e 1:0)\n"
119  " ))",
120  strlen(numbuf),
121  nbits);
122  buffer[sizeof(buffer)-1]=0;
123 
124  /*DBG_ERROR(0, "Genkey string: [%s]", buffer);*/
125 
126  rc=gcry_sexp_new(&keyparm, buffer, 0, 1);
127  if (rc) {
129  "Error creating S-expression: %s", gpg_strerror (rc));
130  return GWEN_ERROR_GENERIC;
131  }
132 
133  rc=gcry_pk_genkey(&key, keyparm);
134  gcry_sexp_release(keyparm);
135  if (rc) {
136  DBG_ERROR(GWEN_LOGDOMAIN, "Error generating RSA key: %s", gpg_strerror (rc));
137  return GWEN_ERROR_GENERIC;
138  }
139 
140  pkey=gcry_sexp_find_token(key, "public-key", 0);
141  if (!pkey) {
142  DBG_ERROR(GWEN_LOGDOMAIN, "Public part missing in return value");
143  gcry_sexp_release(key);
144  return GWEN_ERROR_GENERIC;
145  }
146  else {
147  int rv;
148  gcry_mpi_t n=NULL;
149  gcry_mpi_t e=NULL;
150  GWEN_CRYPT_KEY *k;
151  GWEN_CRYPT_KEY_RSA *xk;
152 
153  /* get public exponent */
154  rv=GWEN_Crypt_KeyRsa__getNamedElement(pkey, "n", &n);
155  if (rv<0) {
156  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
157  gcry_sexp_release(key);
158  return GWEN_ERROR_GENERIC;
159  }
160 
161  rv=GWEN_Crypt_KeyRsa__getNamedElement(pkey, "e", &e);
162  if (rv<0) {
163  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
164  gcry_mpi_release(n);
165  gcry_sexp_release(key);
166  return GWEN_ERROR_GENERIC;
167  }
168 
169  /* create public key */
170  k=GWEN_Crypt_Key_new(GWEN_Crypt_CryptAlgoId_Rsa, nbits/8);
171  GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_RSA, xk);
177  xk->modulus=gcry_mpi_copy(n);
178  xk->pubExponent=gcry_mpi_copy(e);
179  xk->pub=1;
180  pubKey=k;
181 
182  gcry_mpi_release(e);
183  gcry_mpi_release(n);
184  }
185 
186 
187  pkey=gcry_sexp_find_token(key, "private-key", 0);
188  if (!pkey) {
189  DBG_ERROR(GWEN_LOGDOMAIN, "Private part missing in return value");
190  gcry_sexp_release(key);
191  return GWEN_ERROR_GENERIC;
192  }
193  else {
194  int rv;
195  gcry_mpi_t n=NULL;
196  gcry_mpi_t e=NULL;
197  gcry_mpi_t d=NULL;
198  GWEN_CRYPT_KEY *k;
199  GWEN_CRYPT_KEY_RSA *xk;
200 
201  /* get public exponent */
202  rv=GWEN_Crypt_KeyRsa__getNamedElement(pkey, "n", &n);
203  if (rv<0) {
204  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
205  gcry_sexp_release(key);
206  return GWEN_ERROR_GENERIC;
207  }
208 
209  rv=GWEN_Crypt_KeyRsa__getNamedElement(pkey, "e", &e);
210  if (rv<0) {
211  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
212  gcry_mpi_release(n);
213  gcry_sexp_release(key);
214  return GWEN_ERROR_GENERIC;
215  }
216 
217  rv=GWEN_Crypt_KeyRsa__getNamedElement(pkey, "d", &d);
218  if (rv<0) {
219  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
220  gcry_mpi_release(e);
221  gcry_mpi_release(n);
222  gcry_sexp_release(key);
223  return GWEN_ERROR_GENERIC;
224  }
225 
226  /* create private key */
227  k=GWEN_Crypt_Key_new(GWEN_Crypt_CryptAlgoId_Rsa, nbits/8);
228  GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_RSA, xk);
234  xk->modulus=gcry_mpi_copy(n);
235  xk->pubExponent=gcry_mpi_copy(e);
236  xk->privExponent=gcry_mpi_copy(d);
237  xk->pub=0;
238  secretKey=k;
239 
240  gcry_mpi_release(d);
241  gcry_mpi_release(e);
242  gcry_mpi_release(n);
243  }
244 
245  gcry_sexp_release(key);
246 
247  *pPubKey=pubKey;
248  *pSecretKey=secretKey;
249 
250  return 0;
251 }
252 
253 
254 
255 int GWEN_Crypt_KeyRsa_GeneratePair(unsigned int nbytes, int use65537e,
256  GWEN_CRYPT_KEY **pPubKey,
257  GWEN_CRYPT_KEY **pSecretKey) {
258  return GWEN_Crypt_KeyRsa_GeneratePair2(nbytes*8, use65537e, pPubKey, pSecretKey);
259 }
260 
261 
262 
263 
265  const uint8_t *pInData,
266  uint32_t inLen,
267  uint8_t *pSignatureData,
268  uint32_t *pSignatureLen) {
269  GWEN_CRYPT_KEY_RSA *xk;
270  gcry_error_t err;
271  size_t nscanned;
272  gcry_mpi_t mpi_in;
273  gcry_mpi_t mpi_sigout1;
274  gcry_mpi_t mpi_sigout2=NULL;
275  size_t nwritten;
276 
277  assert(k);
278  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
279  assert(xk);
280 
281  if (xk->modulus==NULL) {
282  DBG_ERROR(GWEN_LOGDOMAIN, "No modulus in key data");
283  return GWEN_ERROR_BAD_DATA;
284  }
285 
286  if (xk->privExponent==NULL) {
287  DBG_ERROR(GWEN_LOGDOMAIN, "No secret exponent in key data");
288  return GWEN_ERROR_BAD_DATA;
289  }
290 
291  /* convert input to MPI */
292  mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
293  err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
294  if (err) {
295  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
296  gcry_mpi_release(mpi_in);
297  return GWEN_ERROR_BAD_DATA;
298  }
299 
300  /* create first signature */
301  mpi_sigout1=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
302  gcry_mpi_powm(mpi_sigout1, mpi_in, xk->privExponent, xk->modulus);
303 
304  if (!(xk->flags & GWEN_CRYPT_KEYRSA_FLAGS_DIRECTSIGN)) {
305  /* create second signature */
306  mpi_sigout2=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
307  gcry_mpi_sub(mpi_sigout2, xk->modulus, mpi_sigout1);
308 
309  if (gcry_mpi_cmp(mpi_sigout2, mpi_sigout1)<0) {
310  DBG_DEBUG(GWEN_LOGDOMAIN, "Choosing 2nd variant");
311  gcry_mpi_set(mpi_sigout1, mpi_sigout2);
312  }
313  }
314 
315  /* release unneeded objects */
316  gcry_mpi_release(mpi_sigout2);
317  gcry_mpi_release(mpi_in);
318 
319  /* convert signature MPI */
320  err=gcry_mpi_print(GCRYMPI_FMT_USG,
321  pSignatureData, *pSignatureLen,
322  &nwritten, mpi_sigout1);
323  gcry_mpi_release(mpi_sigout1);
324  if (err) {
325  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_print(): %s", gcry_strerror(err));
326  return GWEN_ERROR_BAD_DATA;
327  }
328  *pSignatureLen=nwritten;
329 
330  return 0;
331 }
332 
333 
334 
336  const uint8_t *pInData,
337  uint32_t inLen,
338  const uint8_t *pSignatureData,
339  uint32_t signatureLen) {
340  GWEN_CRYPT_KEY_RSA *xk;
341  gcry_error_t err;
342  size_t nscanned;
343  gcry_mpi_t mpi_in;
344  gcry_mpi_t mpi_sigin1;
345  gcry_mpi_t mpi_sigout;
346 
347  assert(k);
348  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
349  assert(xk);
350 
351  if (xk->modulus==NULL) {
352  DBG_ERROR(GWEN_LOGDOMAIN, "No modulus in key data");
353  return GWEN_ERROR_BAD_DATA;
354  }
355 
356  if (xk->pubExponent==NULL) {
357  DBG_ERROR(GWEN_LOGDOMAIN, "No public exponent in key data");
358  return GWEN_ERROR_BAD_DATA;
359  }
360 
361 
362  /* convert input to MPI */
363  mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
364  err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
365  if (err) {
366  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
367  gcry_mpi_release(mpi_in);
368  return GWEN_ERROR_BAD_DATA;
369  }
370 
371  /* convert signature to MPI */
372  mpi_sigin1=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
373  err=gcry_mpi_scan(&mpi_sigin1, GCRYMPI_FMT_USG,
374  pSignatureData, signatureLen,
375  &nscanned);
376  if (err) {
377  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
378  gcry_mpi_release(mpi_sigin1);
379  gcry_mpi_release(mpi_in);
380  return GWEN_ERROR_BAD_DATA;
381  }
382 
383  /* create signature */
384  mpi_sigout=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
385  gcry_mpi_powm(mpi_sigout, mpi_sigin1, xk->pubExponent, xk->modulus);
386  /* compare */
387  if (gcry_mpi_cmp(mpi_sigout, mpi_in)) {
388  gcry_mpi_t mpi_sigin2;
389 
390  mpi_sigin2=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
391 
392  DBG_DEBUG(GWEN_LOGDOMAIN, "Trying 2nd variant");
393  gcry_mpi_sub(mpi_sigin2, xk->modulus, mpi_sigin1);
394  gcry_mpi_powm(mpi_sigout, mpi_sigin2, xk->pubExponent, xk->modulus);
395  if (gcry_mpi_cmp(mpi_sigout, mpi_in)) {
396  DBG_ERROR(GWEN_LOGDOMAIN, "Bad signature");
397  gcry_mpi_release(mpi_sigin2);
398  gcry_mpi_release(mpi_sigout);
399  gcry_mpi_release(mpi_sigin1);
400  gcry_mpi_release(mpi_in);
401  return GWEN_ERROR_VERIFY;
402  }
403  gcry_mpi_release(mpi_sigin2);
404  }
405 
406  gcry_mpi_release(mpi_sigout);
407  gcry_mpi_release(mpi_sigin1);
408  gcry_mpi_release(mpi_in);
409 
410  return 0;
411 }
412 
413 
414 
416  const uint8_t *pInData,
417  uint32_t inLen,
418  uint8_t *pOutData,
419  uint32_t *pOutLen) {
420  GWEN_CRYPT_KEY_RSA *xk;
421  gcry_error_t err;
422  size_t nscanned;
423  gcry_mpi_t mpi_in;
424  gcry_mpi_t mpi_out;
425  size_t nwritten;
426 
427  assert(k);
428  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
429  assert(xk);
430 
431  if (xk->modulus==NULL) {
432  DBG_ERROR(GWEN_LOGDOMAIN, "No modulus in key data");
433  return GWEN_ERROR_BAD_DATA;
434  }
435 
436  if (xk->pubExponent==NULL) {
437  DBG_ERROR(GWEN_LOGDOMAIN, "No public exponent in key data");
438  return GWEN_ERROR_BAD_DATA;
439  }
440 
441 
442  /* convert input to MPI */
443  mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
444  err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
445  if (err) {
446  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
447  gcry_mpi_release(mpi_in);
448  return GWEN_ERROR_BAD_DATA;
449  }
450 
451  /* encrypt */
452  mpi_out=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
453  gcry_mpi_powm(mpi_out, mpi_in, xk->pubExponent, xk->modulus);
454 
455  /* release unneeded objects */
456  gcry_mpi_release(mpi_in);
457 
458  /* convert result MPI */
459  err=gcry_mpi_print(GCRYMPI_FMT_USG,
460  pOutData, *pOutLen,
461  &nwritten, mpi_out);
462  gcry_mpi_release(mpi_out);
463  if (err) {
464  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_print(): %s", gcry_strerror(err));
465  return GWEN_ERROR_BAD_DATA;
466  }
467  *pOutLen=nwritten;
468 
469  return 0;
470 }
471 
472 
473 
475  const uint8_t *pInData,
476  uint32_t inLen,
477  uint8_t *pOutData,
478  uint32_t *pOutLen) {
479  GWEN_CRYPT_KEY_RSA *xk;
480  gcry_error_t err;
481  size_t nscanned;
482  gcry_mpi_t mpi_in;
483  gcry_mpi_t mpi_out;
484  size_t nwritten;
485 
486  assert(k);
487  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
488  assert(xk);
489 
490  if (xk->modulus==NULL) {
491  DBG_ERROR(GWEN_LOGDOMAIN, "No modulus in key data");
492  return GWEN_ERROR_BAD_DATA;
493  }
494 
495  if (xk->privExponent==NULL) {
496  DBG_ERROR(GWEN_LOGDOMAIN, "No secret exponent in key data");
497  return GWEN_ERROR_BAD_DATA;
498  }
499 
500 
501  /* convert input to MPI */
502  mpi_in=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
503  err=gcry_mpi_scan(&mpi_in, GCRYMPI_FMT_USG, pInData, inLen, &nscanned);
504  if (err) {
505  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
506  gcry_mpi_release(mpi_in);
507  return GWEN_ERROR_BAD_DATA;
508  }
509 
510  /* decrypt */
511  mpi_out=gcry_mpi_new(GWEN_Crypt_Key_GetKeySize(k));
512  gcry_mpi_powm(mpi_out, mpi_in, xk->privExponent, xk->modulus);
513 
514  /* release unneeded objects */
515  gcry_mpi_release(mpi_in);
516 
517  /* convert result MPI */
518  err=gcry_mpi_print(GCRYMPI_FMT_USG,
519  pOutData, *pOutLen,
520  &nwritten, mpi_out);
521  gcry_mpi_release(mpi_out);
522  if (err) {
523  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_print(): %s", gcry_strerror(err));
524  return GWEN_ERROR_BAD_DATA;
525  }
526  *pOutLen=nwritten;
527 
528  return 0;
529 }
530 
531 
532 
533 static int GWEN_Crypt_KeyRsa__ReadMpi(GWEN_DB_NODE *db, const char *dbName, gcry_mpi_t *pMpi) {
534  gcry_error_t err;
535  const void *p;
536  unsigned int len;
537  gcry_mpi_t mpi=NULL;
538  size_t nscanned=0;
539 
540  /* read n */
541  p=GWEN_DB_GetBinValue(db, dbName, 0, NULL, 0, &len);
542  if (p==NULL || len<1) {
543  DBG_INFO(GWEN_LOGDOMAIN, "Missing %s", dbName);
544  return GWEN_ERROR_NO_DATA;
545  }
546 
547  err=gcry_mpi_scan(&mpi, GCRYMPI_FMT_USG, p, len, &nscanned);
548  if (err) {
549  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_scan(): %s", gcry_strerror(err));
550  if (mpi)
551  gcry_mpi_release(mpi);
552  return GWEN_ERROR_GENERIC;
553  }
554  if (nscanned<1) {
555  if (mpi==NULL) {
556  DBG_INFO(GWEN_LOGDOMAIN, "Empty %s (%d)", dbName, (int)nscanned);
557  return GWEN_ERROR_BAD_DATA;
558  }
559  }
560  *pMpi=mpi;
561 
562  return 0;
563 }
564 
565 
566 
567 
568 static int GWEN_Crypt_KeyRsa__WriteMpi(GWEN_DB_NODE *db, const char *dbName, const gcry_mpi_t mpi) {
569  gcry_error_t err;
570  unsigned char *buf;
571  size_t nbytes;
572 
573  /* write mpi as bin into a buffer which will be allocates by this function */
574  err=gcry_mpi_aprint(GCRYMPI_FMT_USG, &buf, &nbytes, mpi);
575  if (err) {
576  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_aprint(%s): %s", dbName, gcry_strerror(err));
577  return GWEN_ERROR_GENERIC;
578  }
580  dbName,
581  buf, nbytes);
582  gcry_free(buf);
583 
584  return 0;
585 }
586 
587 
588 
589 static int GWEN_Crypt_KeyRsa__MpiToBuffer(const gcry_mpi_t mpi, unsigned char *buf, size_t nbytes) {
590  gcry_error_t err;
591  size_t nwritten=0;
592 
593  /* write mpi as bin into the given buffer */
594  err=gcry_mpi_print(GCRYMPI_FMT_USG, buf, nbytes, &nwritten, mpi);
595  if (err) {
596  DBG_INFO(GWEN_LOGDOMAIN, "gcry_mpi_print(): %s", gcry_strerror(err));
597  return GWEN_ERROR_GENERIC;
598  }
599 
600  return nwritten;
601 }
602 
603 
604 
605 static GWENHYWFAR_CB
606 void GWEN_Crypt_KeyRsa_freeData(GWEN_UNUSED void *bp, void *p) {
607  GWEN_CRYPT_KEY_RSA *xk;
608 
609  xk=(GWEN_CRYPT_KEY_RSA*) p;
610  if (xk->modulus)
611  gcry_mpi_release(xk->modulus);
612  if (xk->pubExponent)
613  gcry_mpi_release(xk->pubExponent);
614  if (xk->privExponent)
615  gcry_mpi_release(xk->privExponent);
616 
617  GWEN_FREE_OBJECT(xk);
618 }
619 
620 
621 
623  int rv;
624  int isPublic;
625  GWEN_CRYPT_KEY *k;
626  GWEN_CRYPT_KEY_RSA *xk;
627  GWEN_DB_NODE *dbR;
628 
630  if (dbR==NULL) {
631  DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an RSA key (no RSA group)");
632  return NULL;
633  }
634  k=GWEN_Crypt_Key_fromDb(db);
635  if (k==NULL) {
636  DBG_INFO(GWEN_LOGDOMAIN, "here");
637  return NULL;
638  }
639  if (GWEN_Crypt_Key_GetCryptAlgoId(k)!=GWEN_Crypt_CryptAlgoId_Rsa) {
640  DBG_ERROR(GWEN_LOGDOMAIN, "DB does not contain an RSA key");
642  return NULL;
643  }
644 
645  /* extend key */
646  GWEN_NEW_OBJECT(GWEN_CRYPT_KEY_RSA, xk);
647  GWEN_INHERIT_SETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k, xk,
653 
654  isPublic=GWEN_DB_GetIntValue(dbR, "isPublic", 0, 1);
655  xk->pub=isPublic;
656 
657  xk->flags=GWEN_DB_GetIntValue(dbR, "flags", 0, 0);
658 
659  /* read data */
660  rv=GWEN_Crypt_KeyRsa__ReadMpi(dbR, "n", &(xk->modulus));
661  if (rv<0) {
662  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
664  return NULL;
665  }
666 
667  rv=GWEN_Crypt_KeyRsa__ReadMpi(dbR, "e", &(xk->pubExponent));
668  if (rv<0) {
669  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
671  return NULL;
672  }
673 
674  if (!isPublic) {
675  rv=GWEN_Crypt_KeyRsa__ReadMpi(dbR, "d", &(xk->privExponent));
676  if (rv<0) {
677  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
679  return NULL;
680  }
681  }
682 
683 
684  return k;
685 }
686 
687 
688 
690  GWEN_CRYPT_KEY_RSA *xk;
691  GWEN_DB_NODE *dbR;
692  int rv;
693 
694  assert(k);
695  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
696  assert(xk);
697 
698  if (xk->pub && !pub) {
699  DBG_ERROR(GWEN_LOGDOMAIN, "Can't write public key as secret key");
700  return GWEN_ERROR_INVALID;
701  }
702 
703 #if 0
704  DBG_ERROR(0, "toDb (%s):", pub?"public":"private");
705  dumpKeyData(ds);
706 #endif
707 
708  /* let key module write basic key info */
709  rv=GWEN_Crypt_Key_toDb(k, db);
710  if (rv)
711  return rv;
712 
713  /* write RSA stuff into our own group */
715  assert(dbR);
716 
718  "isPublic", pub);
720  "flags", xk->flags);
721 
722  /* store n */
723  rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "n", xk->modulus);
724  if (rv) {
725  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
726  return rv;
727  }
728 
729  /* store e */
730  rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "e", xk->pubExponent);
731  if (rv) {
732  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
733  return rv;
734  }
735 
736 
737  if (!pub) {
738  /* store d */
739  rv=GWEN_Crypt_KeyRsa__WriteMpi(dbR, "d", xk->privExponent);
740  if (rv) {
741  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
742  return rv;
743  }
744  }
745 
746  return 0;
747 }
748 
749 
750 
751 
752 int GWEN_Crypt_KeyRsa_GetModulus(const GWEN_CRYPT_KEY *k, uint8_t *buffer, uint32_t *pBufLen) {
753  GWEN_CRYPT_KEY_RSA *xk;
754  int rv;
755 
756  assert(k);
757  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
758  assert(xk);
759 
760  rv=GWEN_Crypt_KeyRsa__MpiToBuffer(xk->modulus, buffer, *pBufLen);
761  if (rv<1) {
762  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
763  if (rv<0)
764  return rv;
765  return GWEN_ERROR_GENERIC;
766  }
767 
768  *pBufLen=rv;
769  return 0;
770 }
771 
772 
773 
774 int GWEN_Crypt_KeyRsa_GetExponent(const GWEN_CRYPT_KEY *k, uint8_t *buffer, uint32_t *pBufLen) {
775  GWEN_CRYPT_KEY_RSA *xk;
776  int rv;
777 
778  assert(k);
779  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
780  assert(xk);
781 
782  rv=GWEN_Crypt_KeyRsa__MpiToBuffer(xk->pubExponent, buffer, *pBufLen);
783  if (rv<1) {
784  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
785  if (rv<0)
786  return rv;
787  return GWEN_ERROR_GENERIC;
788  }
789 
790  *pBufLen=rv;
791  return 0;
792 }
793 
794 
795 
796 int GWEN_Crypt_KeyRsa_GetSecretExponent(const GWEN_CRYPT_KEY *k, uint8_t *buffer, uint32_t *pBufLen) {
797  GWEN_CRYPT_KEY_RSA *xk;
798  int rv;
799 
800  assert(k);
801  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
802  assert(xk);
803 
804  rv=GWEN_Crypt_KeyRsa__MpiToBuffer(xk->privExponent, buffer, *pBufLen);
805  if (rv<1) {
806  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
807  if (rv<0)
808  return rv;
809  return GWEN_ERROR_GENERIC;
810  }
811 
812  *pBufLen=rv;
813  return 0;
814 }
815 
816 
817 
819  const uint8_t *pModulus,
820  uint32_t lModulus,
821  const uint8_t *pExponent,
822  uint32_t lExponent) {
823  GWEN_DB_NODE *dbKey;
824  GWEN_DB_NODE *dbR;
825  GWEN_CRYPT_KEY *key;
826 
827  assert(nbytes);
828  assert(pModulus);
829  assert(lModulus);
830  assert(pExponent);
831  assert(lExponent);
832 
833  dbKey=GWEN_DB_Group_new("key");
835 
836  /* basic key stuff */
838  "cryptAlgoId",
839  GWEN_Crypt_CryptAlgoId_toString(GWEN_Crypt_CryptAlgoId_Rsa));
841  "keySize", nbytes);
842 
843  /* RSA stuff */
845  "isPublic", 1);
847  "n",
848  pModulus, lModulus);
850  "e",
851  pExponent, lExponent);
852 
853  /* create key from DB */
854  key=GWEN_Crypt_KeyRsa_fromDb(dbKey);
855  if (key==NULL) {
857  "Internal error: Bad RSA key group");
858  GWEN_DB_Dump(dbKey, 2);
859  GWEN_DB_Group_free(dbKey);
860  return NULL;
861  }
862 
863  GWEN_DB_Group_free(dbKey);
864  return key;
865 }
866 
867 
868 
870  const uint8_t *pModulus,
871  uint32_t lModulus,
872  const uint8_t *pExponent,
873  uint32_t lExponent,
874  const uint8_t *pPrivExponent,
875  uint32_t lPrivExponent) {
876  GWEN_DB_NODE *dbKey;
877  GWEN_DB_NODE *dbR;
878  GWEN_CRYPT_KEY *key;
879 
880  assert(nbytes);
881  assert(pModulus);
882  assert(lModulus);
883  assert(pExponent);
884  assert(lExponent);
885  assert(pPrivExponent);
886  assert(lPrivExponent);
887 
888  dbKey=GWEN_DB_Group_new("key");
890 
891  /* basic key stuff */
893  "cryptAlgoId",
894  GWEN_Crypt_CryptAlgoId_toString(GWEN_Crypt_CryptAlgoId_Rsa));
896  "keySize", nbytes);
897 
898  /* RSA stuff */
900  "isPublic", 0);
902  "n",
903  pModulus, lModulus);
905  "e",
906  pExponent, lExponent);
908  "d",
909  pPrivExponent, lPrivExponent);
910 
911  /* create key from DB */
912  key=GWEN_Crypt_KeyRsa_fromDb(dbKey);
913  if (key==NULL) {
915  "Internal error: Bad RSA key group");
916  GWEN_DB_Dump(dbKey, 2);
917  GWEN_DB_Group_free(dbKey);
918  return NULL;
919  }
920 
921  GWEN_DB_Group_free(dbKey);
922  return key;
923 }
924 
925 
926 
928  GWEN_CRYPT_KEY_RSA *xk;
929  GWEN_DB_NODE *dbKey;
930  GWEN_CRYPT_KEY *nk;
931  int rv;
932 
933  assert(k);
934  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
935  assert(xk);
936 
937  dbKey=GWEN_DB_Group_new("dbKey");
938  rv=GWEN_Crypt_KeyRsa_toDb(k, dbKey, xk->pub);
939  if (rv<0) {
940  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
941  GWEN_DB_Group_free(dbKey);
942  return NULL;
943  }
944 
945  nk=GWEN_Crypt_KeyRsa_fromDb(dbKey);
946  GWEN_DB_Group_free(dbKey);
947  if (nk==NULL) {
948  DBG_INFO(GWEN_LOGDOMAIN, "Could not create key");
949  }
950 
951  GWEN_Crypt_KeyRsa_SetFlags(nk, xk->flags);
952 
953  return nk;
954 }
955 
956 
957 
959  GWEN_CRYPT_KEY_RSA *xk;
960 
961  assert(k);
962  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
963  assert(xk);
964 
965  return xk->flags;
966 }
967 
968 
969 
971  GWEN_CRYPT_KEY_RSA *xk;
972 
973  assert(k);
974  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
975  assert(xk);
976 
977  xk->flags=fl;
978 }
979 
980 
981 
983  GWEN_CRYPT_KEY_RSA *xk;
984 
985  assert(k);
986  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
987  assert(xk);
988 
989  xk->flags|=fl;
990 }
991 
992 
993 
995  GWEN_CRYPT_KEY_RSA *xk;
996 
997  assert(k);
998  xk=GWEN_INHERIT_GETDATA(GWEN_CRYPT_KEY, GWEN_CRYPT_KEY_RSA, k);
999  assert(xk);
1000 
1001  xk->flags&=~fl;
1002 }
1003 
1004 
1005 
1006 
1007 
1008 
1009 
1010