rpm  5.4.15
rpmltc.c
Go to the documentation of this file.
1 
5 #include "system.h"
6 #include <rpmlog.h>
7 
8 #include <rpmiotypes.h>
9 
10 #define _RPMPGP_INTERNAL
11 #if defined(WITH_TOMCRYPT)
12 #define _RPMLTC_INTERNAL
13 #include <rpmltc.h>
14 #endif
15 
16 #include "debug.h"
17 
18 #if defined(WITH_TOMCRYPT)
19 
20 /*@access pgpDig @*/
21 /*@access pgpDigParams @*/
22 
23 /*@-redecl@*/
24 /*@unchecked@*/
25 extern int _pgp_debug;
26 
27 /*@unchecked@*/
28 extern int _pgp_print;
29 /*@=redecl@*/
30 
31 /*@unchecked@*/
32 static int _rpmltc_debug;
33 
34 /*@unchecked@*/
35 static prng_state prng;
36 
37 #define SPEW(_t, _rc, _dig) \
38  { if ((_t) || _rpmltc_debug || _pgp_debug < 0) \
39  fprintf(stderr, "<-- %s(%p) %s\t%s/%s\n", __FUNCTION__, (_dig), \
40  ((_rc) ? "OK" : "BAD"), (_dig)->pubkey_algoN, (_dig)->hash_algoN); \
41  }
42 
48 static
49 unsigned char nibble(char c)
50  /*@*/
51 {
52  if (c >= '0' && c <= '9')
53  return (unsigned char) (c - '0');
54  if (c >= 'A' && c <= 'F')
55  return (unsigned char)((int)(c - 'A') + 10);
56  if (c >= 'a' && c <= 'f')
57  return (unsigned char)((int)(c - 'a') + 10);
58  return (unsigned char) '\0';
59 }
60 
61 static
62 int rpmltcErr(rpmltc ltc, const char * msg, int rc)
63  /*@*/
64 {
65  /* XXX FIXME: Don't spew on expected failures ... */
66  if (rc != CRYPT_OK) {
67  fprintf (stderr, "rpmltc: %s rc(%d) %s\n",
68  msg, rc, error_to_string(rc));
69  }
70  return rc;
71 }
72 
73 #ifdef DYING
74 #define _spewBN(_N, _BN) \
75  { mp_int * bn = _BN; \
76  int nt = 0; \
77  int err = (bn ? mp_radix_size(bn, 16, &nt) : 0); \
78  char * t = (nt ? xmalloc(nt) : ""); \
79  if (nt) \
80  err = mp_toradix(bn, t, 16); \
81  fprintf(stderr, "\t" _N ": %s\n", t); \
82  if (nt) \
83  t = _free(t); \
84  }
85 
86 static void rpmltcDumpRSA(const char * msg, rpmltc ltc)
87 {
88  if (msg) fprintf(stderr, "========== %s\n", msg);
89 
90  {
91  _spewBN(" n", ltc->rsa.N);
92  _spewBN(" e", ltc->rsa.e);
93  _spewBN(" d", ltc->rsa.d);
94  _spewBN(" p", ltc->rsa.p);
95  _spewBN(" q", ltc->rsa.q);
96  _spewBN("dp", ltc->rsa.dP);
97  _spewBN("dq", ltc->rsa.dQ);
98  _spewBN("qi", ltc->rsa.qP);
99  }
100 
101  _spewBN(" c", ltc->c);
102 }
103 
104 static void rpmltcDumpDSA(const char * msg, rpmltc ltc)
105 {
106  if (msg) fprintf(stderr, "========== %s\n", msg);
107 
108  {
109  _spewBN(" p", ltc->dsa.p);
110  _spewBN(" q", ltc->dsa.q);
111  _spewBN(" g", ltc->dsa.g);
112  _spewBN(" x", ltc->dsa.x);
113  _spewBN(" y", ltc->dsa.y);
114  }
115 
116  _spewBN(" r", ltc->r);
117  _spewBN(" s", ltc->s);
118 
119 }
120 
121 static void rpmltcDumpECDSA(const char * msg, rpmltc ltc)
122 {
123  if (msg) fprintf(stderr, "========== %s\n", msg);
124 
125  {
126  const ltc_ecc_set_type * dp = ltc->ecdsa.idx >= 0
127  ? ltc_ecc_sets + ltc->ecdsa.idx : NULL;
128  if (dp == NULL)
129  dp = ltc->ecdsa.dp;
130 
131  if (dp) {
132  fprintf(stderr, "\tsize: %d\n", dp->size);
133  fprintf(stderr, "\tname: %s\n", dp->name);
134  fprintf(stderr, "\t p: %s\n", dp->prime);
135  fprintf(stderr, "\t n: %s\n", dp->order);
136  fprintf(stderr, "\t b: %s\n", dp->B);
137  fprintf(stderr, "\tGx: %s\n", dp->Gx);
138  fprintf(stderr, "\tGy: %s\n", dp->Gy);
139  }
140 
141  _spewBN("Qx", ltc->ecdsa.pubkey.x);
142  _spewBN("Qy", ltc->ecdsa.pubkey.y);
143 
144  _spewBN(" d", ltc->ecdsa.k);
145 
146  }
147 
148  _spewBN(" r", ltc->r);
149  _spewBN(" s", ltc->s);
150 }
151 #endif /* DYING */
152 
153 #undef _spewBN
154 
155 /*==============================================================*/
156 static int getHashIdx(unsigned hash_algo)
157 {
158  const char * hashN = NULL;
159 
160  switch (hash_algo) {
161  case PGPHASHALGO_MD2: hashN = "md2"; break;
162  case PGPHASHALGO_MD4: hashN = "md4"; break;
163  case PGPHASHALGO_MD5: hashN = "md5"; break;
164  case PGPHASHALGO_SHA1: hashN = "sha1"; break;
165  case PGPHASHALGO_SHA224: hashN = "sha224"; break;
166  case PGPHASHALGO_SHA256: hashN = "sha256"; break;
167  case PGPHASHALGO_SHA384: hashN = "sha384"; break;
168  case PGPHASHALGO_SHA512: hashN = "sha512"; break;
169  case PGPHASHALGO_RIPEMD128: hashN = "rmd128"; break;
170  case PGPHASHALGO_RIPEMD160: hashN = "rmd160"; break;
171  case PGPHASHALGO_RIPEMD256: hashN = "rmd256"; break;
172  case PGPHASHALGO_RIPEMD320: hashN = "rmd320"; break;
173  case PGPHASHALGO_TIGER192: hashN = "tiger"; break;
174 #ifdef NOTYET
175  case PGPHASHALGO_WHIRLPOOL: hashN = "whirlpool"; break;
176 #endif
177  case PGPHASHALGO_HAVAL_5_160: /*@fallthrough@*/
178  default:
179  break;
180  }
181  return (hashN ? find_hash(hashN) : -1);
182 }
183 /*==============================================================*/
184 
185 #define _initBN(_t) \
186  { if (_t == NULL) _t = xmalloc(sizeof(mp_int)); \
187  xx = mp_init(_t); \
188  }
189 
190 static
191 int rpmltcSetRSA(/*@only@*/ DIGEST_CTX ctx, pgpDig dig, pgpDigParams sigp)
192  /*@modifies dig @*/
193 {
194  rpmltc ltc = dig->impl;
195  int rc = 1; /* assume failure */
196  int xx;
197 pgpDigParams pubp = pgpGetPubkey(dig);
198 assert(pubp->pubkey_algo == PGPPUBKEYALGO_RSA);
199 assert(sigp->pubkey_algo == PGPPUBKEYALGO_RSA);
200 dig->pubkey_algoN = pgpPubkeyAlgo2Name(pubp->pubkey_algo);
201 dig->hash_algoN = pgpHashAlgo2Name(sigp->hash_algo);
202 
203 assert(sigp->hash_algo == rpmDigestAlgo(ctx));
204 
205 ltc->digest = _free(ltc->digest);
206 ltc->digestlen = 0;
207  xx = rpmDigestFinal(ctx, (void **)&ltc->digest, &ltc->digestlen, 0);
208 
209  ltc->hashIdx = getHashIdx(sigp->hash_algo);
210  if (ltc->hashIdx < 0)
211  goto exit;
212 
213  /* Compare leading 16 bits of digest for quick check. */
214  rc = memcmp(ltc->digest, sigp->signhash16, sizeof(sigp->signhash16));
215 
216  /* XXX FIXME: avoid spurious "BAD" error msg while signing. */
217  if (rc && sigp->signhash16[0] == 0 && sigp->signhash16[1] == 0)
218  rc = 0;
219 
220 exit:
221 SPEW(0, !rc, dig); /* XXX don't spew on mismatch. */
222  return rc;
223 }
224 
225 static
226 int rpmltcSetDSA(/*@only@*/ DIGEST_CTX ctx, pgpDig dig, pgpDigParams sigp)
227  /*@modifies dig @*/
228 {
229  rpmltc ltc = dig->impl;
230  int rc = 1; /* assume failure */
231  int xx;
232 pgpDigParams pubp = pgpGetPubkey(dig);
233 assert(pubp->pubkey_algo == PGPPUBKEYALGO_DSA);
234 assert(sigp->pubkey_algo == PGPPUBKEYALGO_DSA);
235 dig->pubkey_algoN = pgpPubkeyAlgo2Name(pubp->pubkey_algo);
236 dig->hash_algoN = pgpHashAlgo2Name(sigp->hash_algo);
237 
238 assert(sigp->hash_algo == rpmDigestAlgo(ctx));
239 
240 ltc->digest = _free(ltc->digest);
241 ltc->digestlen = 0;
242  xx = rpmDigestFinal(ctx, (void **)&ltc->digest, &ltc->digestlen, 0);
243 
244  ltc->hashIdx = getHashIdx(sigp->hash_algo);
245  if (ltc->hashIdx < 0)
246  goto exit;
247 
248  /* Compare leading 16 bits of digest for quick check. */
249  rc = memcmp(ltc->digest, sigp->signhash16, sizeof(sigp->signhash16));
250  /* XXX FIXME: avoid spurious "BAD" error msg while signing. */
251  if (rc && sigp->signhash16[0] == 0 && sigp->signhash16[1] == 0)
252  rc = 0;
253 
254 exit:
255 SPEW(0, !rc, dig); /* XXX don't spew on mismatch. */
256  return rc;
257 }
258 
259 static
260 int rpmltcSetELG(/*@only@*/ DIGEST_CTX ctx, /*@unused@*/pgpDig dig, pgpDigParams sigp)
261  /*@*/
262 {
263  rpmltc ltc = dig->impl;
264  int rc = 1; /* assume failure. */
265  int xx;
266 pgpDigParams pubp = pgpGetPubkey(dig);
267 assert(pubp->pubkey_algo == PGPPUBKEYALGO_ELGAMAL);
268 assert(sigp->pubkey_algo == PGPPUBKEYALGO_ELGAMAL);
269 dig->pubkey_algoN = pgpPubkeyAlgo2Name(pubp->pubkey_algo);
270 dig->hash_algoN = pgpHashAlgo2Name(sigp->hash_algo);
271 
272 assert(sigp->hash_algo == rpmDigestAlgo(ctx));
273 
274 ltc->digest = _free(ltc->digest);
275 ltc->digestlen = 0;
276  xx = rpmDigestFinal(ctx, (void **)&ltc->digest, &ltc->digestlen, 0);
277 
278  ltc->hashIdx = getHashIdx(sigp->hash_algo);
279  if (ltc->hashIdx < 0)
280  goto exit;
281 
282  /* Compare leading 16 bits of digest for quick check. */
283  rc = memcmp(ltc->digest, sigp->signhash16, sizeof(sigp->signhash16));
284  /* XXX FIXME: avoid spurious "BAD" error msg while signing. */
285  if (rc && sigp->signhash16[0] == 0 && sigp->signhash16[1] == 0)
286  rc = 0;
287 
288  rc = 1; /* XXX FIXME: always fail (unimplemented). */
289 
290 exit:
291 SPEW(0, !rc, dig); /* XXX don't spew on mismatch. */
292  return rc;
293 }
294 
295 static
296 int rpmltcSetECDSA(/*@only@*/ DIGEST_CTX ctx, /*@unused@*/pgpDig dig, pgpDigParams sigp)
297  /*@*/
298 {
299  rpmltc ltc = dig->impl;
300  int rc = 1; /* assume failure. */
301  int xx;
302 pgpDigParams pubp = pgpGetPubkey(dig);
303 assert(pubp->pubkey_algo == PGPPUBKEYALGO_ECDSA);
304 assert(sigp->pubkey_algo == PGPPUBKEYALGO_ECDSA);
305 dig->pubkey_algoN = pgpPubkeyAlgo2Name(pubp->pubkey_algo);
306 dig->hash_algoN = pgpHashAlgo2Name(sigp->hash_algo);
307 
308 assert(sigp->hash_algo == rpmDigestAlgo(ctx));
309 
310 /* XXX FIXME: should this lazy free be done elsewhere? */
311 ltc->digest = _free(ltc->digest);
312 ltc->digestlen = 0;
313  xx = rpmDigestFinal(ctx, &ltc->digest, &ltc->digestlen, 0);
314 
315  ltc->hashIdx = getHashIdx(sigp->hash_algo);
316  if (ltc->hashIdx < 0)
317  goto exit;
318 
319  /* Compare leading 16 bits of digest for quick check. */
320  rc = memcmp(ltc->digest, sigp->signhash16, sizeof(sigp->signhash16));
321  /* XXX FIXME: avoid spurious "BAD" error msg while signing. */
322  if (rc && sigp->signhash16[0] == 0 && sigp->signhash16[1] == 0)
323  rc = 0;
324 
325 exit:
326 SPEW(0, !rc, dig); /* XXX don't spew on mismatch. */
327  return rc;
328 }
329 
330 static int rpmltcErrChk(pgpDig dig, const char * msg, int rc, unsigned expected)
331 {
332 #ifdef REFERENCE
333 rpmgc gc = dig->impl;
334  /* Was the return code the expected result? */
335  rc = (gcry_err_code(gc->err) != expected);
336  if (rc)
337  fail("%s failed: %s\n", msg, gpg_strerror(gc->err));
338 /* XXX FIXME: rpmltcStrerror */
339 #else
340  rc = (rc == 0); /* XXX impedance match 1 -> 0 on success */
341 #endif
342  return rc; /* XXX 0 on success */
343 }
344 
345 static int rpmltcAvailableCipher(pgpDig dig, int algo)
346 {
347  int rc = 0; /* assume available */
348 #ifdef REFERENCE
349  rc = rpmgcAvailable(dig->impl, algo,
350  (gcry_md_test_algo(algo) || algo == PGPHASHALGO_MD5));
351 #endif
352  return rc;
353 }
354 
355 static int rpmltcAvailableDigest(pgpDig dig, int algo)
356 {
357  int rc = 0; /* assume available */
358 #ifdef REFERENCE
359  rc = rpmgcAvailable(dig->impl, algo,
360  (gcry_md_test_algo(algo) || algo == PGPHASHALGO_MD5));
361 #endif
362  return rc;
363 }
364 
365 static int rpmltcAvailablePubkey(pgpDig dig, int algo)
366 {
367  int rc = 0; /* assume available */
368 #ifdef REFERENCE
369  rc = rpmgcAvailable(dig->impl, algo, gcry_pk_test_algo(algo));
370 #endif
371  return rc;
372 }
373 
374 static int rpmltcVerify(pgpDig dig)
375 {
376  rpmltc ltc = dig->impl;
377  int rc = 0; /* assume failure */
378  unsigned char sig[4096]; /* XXX big enuf */
379  unsigned long siglen = sizeof(sig);
380  unsigned int dlen; /* XXX DSA */
381  int _padding = LTC_LTC_PKCS_1_V1_5; /* XXX RSA */
382  unsigned long saltlen = 0; /* XXX RSA */
383  unsigned nz; /* XXX RSA */
384  int xx;
385 pgpDigParams pubp = pgpGetPubkey(dig);
386 pgpDigParams sigp = pgpGetSignature(dig);
387 dig->pubkey_algoN = pgpPubkeyAlgo2Name(pubp->pubkey_algo);
388 dig->hash_algoN = pgpHashAlgo2Name(sigp->hash_algo);
389 
390 assert(ltc->digest && ltc->digestlen > 0);
391 
392  /* XXX &rc is where valid is returned: return code ususally CRYPT_OK */
393  switch (pubp->pubkey_algo) {
394  default:
395 assert(0);
396  break;
397  case PGPPUBKEYALGO_RSA:
398 assert(ltc->hashIdx >= 0);
399  siglen = ltc->nbits/8;
400  nz = siglen - mp_unsigned_bin_size(ltc->c);
401  if (nz) /* XXX resurrect leading zero bytes. */
402  memset(sig, 0, nz);
403  xx = mp_to_unsigned_bin(ltc->c, sig+nz);
404  xx = rpmltcErr(ltc, "rsa_verify_hash_ex",
405  rsa_verify_hash_ex(sig, siglen,
406  ltc->digest, ltc->digestlen,
407  _padding, ltc->hashIdx, saltlen, &rc, &ltc->rsa));
408  break;
409  case PGPPUBKEYALGO_DSA:
410 assert(ltc->r && ltc->s);
411 assert(ltc->qbits);
412  /* XXX Truncate to qbits (if necessary) */
413  dlen = (ltc->digestlen > ltc->qbits/8 ? ltc->qbits/8 : ltc->digestlen);
414  xx = rpmltcErr(ltc, "dsa_verify_hash_raw",
415  dsa_verify_hash_raw(ltc->r, ltc->s,
416  ltc->digest, dlen, &rc, &ltc->dsa));
417  break;
419 #ifdef NOTYET
420  rc = rpmltcVerifyELG(dig);
421 #endif
422  break;
423  case PGPPUBKEYALGO_ECDSA:
424 assert(ltc->r && ltc->s);
425  xx = der_encode_sequence_multi(sig, &siglen,
426  LTC_ASN1_INTEGER, 1UL, ltc->r,
427  LTC_ASN1_INTEGER, 1UL, ltc->s,
428  LTC_ASN1_EOL, 0UL, NULL);
429  xx = rpmltcErr(ltc, "ecc_verify_hash",
430  ecc_verify_hash(sig, siglen,
431  ltc->digest, ltc->digestlen, &rc, &ltc->ecdsa));
432  break;
433  }
434 
435 SPEW(!rc, rc, dig);
436  return rc;
437 }
438 
439 static int rpmltcSign(pgpDig dig)
440 {
441  rpmltc ltc = dig->impl;
442  int rc = 0; /* assume failure */
443  unsigned char sig[2048];
444  unsigned long siglen = sizeof(sig);
445  unsigned int dlen; /* XXX DSA */
446  int _padding = LTC_LTC_PKCS_1_V1_5; /* XXX RSA */
447  unsigned long saltlen = 0 ; /* XXX RSA */
448  int xx;
449 pgpDigParams pubp = pgpGetPubkey(dig);
450 dig->pubkey_algoN = pgpPubkeyAlgo2Name(pubp->pubkey_algo);
451 
452 assert(ltc->digest && ltc->digestlen > 0);
453 
454  switch (pubp->pubkey_algo) {
455  default:
456  break;
457  case PGPPUBKEYALGO_RSA:
458 assert(ltc->hashIdx >= 0);
459  rc = rpmltcErr(ltc, "rsa_sign_hash_ex",
460  rsa_sign_hash_ex(ltc->digest, ltc->digestlen, sig, &siglen,
461  _padding, &prng, ltc->prngIdx,
462  ltc->hashIdx, saltlen, &ltc->rsa));
463  if (rc == CRYPT_OK) {
464  _initBN(ltc->c);
465  xx = mp_read_unsigned_bin(ltc->c, sig, siglen);
466  }
467  break;
468  case PGPPUBKEYALGO_DSA:
469 assert(ltc->qbits);
470  _initBN(ltc->r);
471  _initBN(ltc->s);
472  /* XXX Truncate to qbits (if necessary) */
473  dlen = (ltc->digestlen > ltc->qbits/8 ? ltc->qbits/8 : ltc->digestlen);
474  rc = rpmltcErr(ltc, "dsa_sign_hash_raw",
475  dsa_sign_hash_raw(ltc->digest, dlen, ltc->r, ltc->s,
476  &prng, ltc->prngIdx, &ltc->dsa));
477  break;
479 #ifdef NOTYET
480  rc = rpmltcSignELG(dig);
481 #endif
482  break;
483  case PGPPUBKEYALGO_ECDSA:
484  rc = rpmltcErr(ltc, "ecc_sign_hash",
485  ecc_sign_hash(ltc->digest, ltc->digestlen, sig, &siglen,
486  &prng, ltc->prngIdx, &ltc->ecdsa));
487  if (rc == CRYPT_OK) {
488  _initBN(ltc->r);
489  _initBN(ltc->s);
490  xx = der_decode_sequence_multi(sig, siglen,
491  LTC_ASN1_INTEGER, 1UL, ltc->r,
492  LTC_ASN1_INTEGER, 1UL, ltc->s,
493  LTC_ASN1_EOL, 0UL, NULL);
494  }
495  break;
496  }
497 
498  rc = (rc == CRYPT_OK);
499 
500 SPEW(!rc, rc, dig);
501  return rc;
502 }
503 
504 static int rpmltcGenerate(pgpDig dig)
505 {
506  rpmltc ltc = dig->impl;
507  int rc = 0; /* assume failure */
508 pgpDigParams pubp = pgpGetPubkey(dig);
509 pgpDigParams sigp = pgpGetSignature(dig);
510 assert(pubp->pubkey_algo);
511 assert(sigp->hash_algo);
512 
513 assert(dig->pubkey_algoN);
514 assert(dig->hash_algoN);
515 
516  switch (pubp->pubkey_algo) {
517  default:
518  break;
519  case PGPPUBKEYALGO_RSA:
520  {
521 static long _e = 0x10001; /* XXX FIXME */
522 if (ltc->nbits == 0) ltc->nbits = 2048; /* XXX FIXME */
523  rc = rpmltcErr(ltc, "rsa_make_key",
524  rsa_make_key(&prng, ltc->prngIdx,
525  ltc->nbits/8, _e, &ltc->rsa));
526  rc = (rc == CRYPT_OK);
527  } break;
528  case PGPPUBKEYALGO_DSA:
529  {
530 int xx;
531 int _group_size;
532 int _modulus_size;
533 
534  /* XXX Set the no. of qbits based on the digest being used. */
535  if (ltc->qbits == 0)
536  switch (sigp->hash_algo) {
537  default: /* XXX default */
538  case PGPHASHALGO_SHA1: ltc->qbits = 160; break;
539  case PGPHASHALGO_SHA224: ltc->qbits = 224; break;
540  case PGPHASHALGO_SHA256: ltc->qbits = 256; break;
541  case PGPHASHALGO_SHA384: ltc->qbits = 384; break;
542  case PGPHASHALGO_SHA512: ltc->qbits = 512; break;
543  }
544 assert(ltc->qbits);
545 
546  /* XXX Set the no. of nbits for non-truncated digest in use. */
547  if (ltc->nbits == 0)
548  switch (ltc->qbits) {
549  default: /* XXX default */
550  case 160: ltc->nbits = 1024; break;
551  case 224: ltc->nbits = 2048; break;
552 #ifdef PAINFUL
553  case 256: ltc->nbits = 3072; break;
554  case 384: ltc->nbits = 7680; break;
555  case 512: ltc->nbits = 15360; break;
556 #else
557  case 256: ltc->nbits = 2048; break;
558  case 384: ltc->nbits = 2048; ltc->qbits = 256; break;
559  case 512: ltc->nbits = 2048; ltc->qbits = 256; break;
560 #endif
561  }
562 assert(ltc->nbits);
563 
564 _group_size = ltc->qbits/8;
565 _modulus_size = ltc->nbits/8;
566 
567  xx = rpmltcErr(ltc, "dsa_make_key",
568  dsa_make_key(&prng, ltc->prngIdx,
569  _group_size, _modulus_size, &ltc->dsa));
570 
571  /* XXX &rc is where valid is returned: return code ususally CRYPT_OK */
572  xx = rpmltcErr(ltc, "dsa_verify_key",
573  dsa_verify_key(&ltc->dsa, &rc));
574  } break;
576 #ifdef NOTYET
577  rc = rpmltcGenerateELG(dig);
578 #endif
579  break;
580  case PGPPUBKEYALGO_ECDSA:
581  /* XXX Set the no. of bits based on the digest being used. */
582  if (ltc->nbits == 0)
583  switch (sigp->hash_algo) {
584  case PGPHASHALGO_MD5: ltc->nbits = 128; break;
585  case PGPHASHALGO_TIGER192: ltc->nbits = 192; break;
586  case PGPHASHALGO_SHA224: ltc->nbits = 224; break;
587  default: /* XXX default */
588  case PGPHASHALGO_SHA256: ltc->nbits = 256; break;
589  case PGPHASHALGO_SHA384: ltc->nbits = 384; break;
590  case PGPHASHALGO_SHA512: ltc->nbits = 521; break;
591  }
592 assert(ltc->nbits);
593 
594  /* XXX use ecc_make_key_ex() instead? */
595  rc = rpmltcErr(ltc, "ecc_make_key",
596  ecc_make_key(&prng, ltc->prngIdx,
597  ltc->nbits/8, &ltc->ecdsa));
598  rc = (rc == CRYPT_OK);
599  break;
600  }
601 
602 SPEW(!rc, rc, dig);
603  return rc;
604 }
605 
606 #define _loadBN(_t, _s, _ns) \
607  { int xx; \
608  _initBN(_t); \
609  xx = mp_read_unsigned_bin(_t, _s, _ns); \
610  }
611 
612 static
613 int rpmltcMpiItem(/*@unused@*/ const char * pre, pgpDig dig, int itemno,
614  const rpmuint8_t * p,
615  /*@unused@*/ /*@null@*/ const rpmuint8_t * pend)
616  /*@*/
617 {
618  rpmltc ltc = dig->impl;
619  unsigned int nb = (pend >= p ? (pend - p) : 0);
620  unsigned int mbits = (((8 * (nb - 2)) + 0x1f) & ~0x1f);
621  int rc = 0;
622 
623  switch (itemno) {
624  default:
625 assert(0);
626  break;
627  case 10: /* RSA m**d */
628  ltc->nbits = mbits;
629  _loadBN(ltc->c, p+2, nb-2);
630  break;
631  case 20: /* DSA r */
632  ltc->qbits = mbits;
633  _loadBN(ltc->r, p+2, nb-2);
634  break;
635  case 21: /* DSA s */
636 assert(mbits == ltc->qbits);
637  _loadBN(ltc->s, p+2, nb-2);
638  break;
639  case 30: /* RSA n */
640  ltc->nbits = mbits;
641  _loadBN(ltc->rsa.N, p+2, nb-2);
642  break;
643  case 31: /* RSA e */
644  _loadBN(ltc->rsa.e, p+2, nb-2);
645  break;
646  case 40: /* DSA p */
647  ltc->nbits = mbits;
648  _loadBN(ltc->dsa.p, p+2, nb-2);
649  break;
650  case 41: /* DSA q */
651  ltc->qbits = mbits;
652  _loadBN(ltc->dsa.q, p+2, nb-2);
653  break;
654  case 42: /* DSA g */
655 assert(mbits == ltc->nbits);
656  _loadBN(ltc->dsa.g, p+2, nb-2);
657  break;
658  case 43: /* DSA y */
659 assert(mbits == ltc->nbits);
660  _loadBN(ltc->dsa.y, p+2, nb-2);
661  break;
662  case 50: /* ECDSA r */
663  ltc->qbits = mbits;
664  _loadBN(ltc->r, p+2, nb-2);
665  break;
666  case 51: /* ECDSA s */
667 assert(mbits == ltc->qbits);
668  _loadBN(ltc->s, p+2, nb-2);
669  break;
670  case 60: /* ECDSA curve OID */
671  { const char * s = xstrdup(pgpHexStr(p, nb));
672  if (!strcasecmp(s, "2a8648ce3d030101"))
673  ltc->nbits = 192;
674  else if (!strcasecmp(s, "2b81040021"))
675  ltc->nbits = 224;
676  else if (!strcasecmp(s, "2a8648ce3d030107"))
677  ltc->nbits = 256;
678  else if (!strcasecmp(s, "2b81040022"))
679  ltc->nbits = 384;
680  else if (!strcasecmp(s, "2b81040023"))
681  ltc->nbits = 521;
682  else
683  ltc->nbits = 256; /* XXX FIXME default? */
684  s = _free(s);
685  }
686 assert(ltc->nbits > 0);
687  break;
688  case 61: /* ECDSA Q */
689  mbits = pgpMpiBits(p);
690  nb = pgpMpiLen(p);
691  rc = ecc_ansi_x963_import(p+2, nb-2, &ltc->ecdsa);
692 assert(rc == CRYPT_OK);
693  break;
694  }
695 
696  return rc;
697 }
698 
699 #undef _loadBN
700 
701 #define _freeBN(_t) \
702  if (_t) { \
703  (void) mp_clear(_t); \
704  _t = _free(_t); \
705  }
706 
707 static
708 void rpmltcClean(void * impl)
709  /*@modifies impl @*/
710 {
711  rpmltc ltc = impl;
712  if (ltc != NULL) {
713  ltc->nbits = 0;
714  ltc->qbits = 0;
715  ltc->err = 0;
716  ltc->badok = 0;
717  ltc->digest = _free(ltc->digest);
718  ltc->digestlen = 0;
719 
720  /* XXX rsa_free(&ltc->rsa); */
721  _freeBN(ltc->rsa.N);
722  _freeBN(ltc->rsa.e);
723  _freeBN(ltc->rsa.d);
724  _freeBN(ltc->rsa.p);
725  _freeBN(ltc->rsa.q);
726  _freeBN(ltc->rsa.dP);
727  _freeBN(ltc->rsa.dQ);
728  _freeBN(ltc->rsa.qP);
729  memset(&ltc->rsa, 0, sizeof(ltc->rsa));
730 
731  _freeBN(ltc->c);
732 
733  /* XXX dsa_free(&ltc->dsa); */
734  _freeBN(ltc->dsa.p);
735  _freeBN(ltc->dsa.q);
736  _freeBN(ltc->dsa.g);
737  _freeBN(ltc->dsa.x);
738  _freeBN(ltc->dsa.y);
739  memset(&ltc->dsa, 0, sizeof(ltc->dsa));
740 
741  _freeBN(ltc->r);
742  _freeBN(ltc->s);
743 
744  ecc_free(&ltc->ecdsa);
745  memset(&ltc->ecdsa, 0, sizeof(ltc->ecdsa));
746 
747  }
748 }
749 
750 #undef _freeBN
751 
752 static /*@null@*/
753 void * rpmltcFree(/*@only@*/ void * impl)
754  /*@modifies impl @*/
755 {
756  rpmltcClean(impl);
757  impl = _free(impl);
758  return NULL;
759 }
760 
761 static void reg_algs(rpmltc ltc)
762 {
763  int err;
764 #ifdef LTC_RIJNDAEL
765  register_cipher (&aes_desc);
766 #endif
767 #ifdef LTC_BLOWFISH
768  register_cipher (&blowfish_desc);
769 #endif
770 #ifdef LTC_XTEA
771  register_cipher (&xtea_desc);
772 #endif
773 #ifdef LTC_RC5
774  register_cipher (&rc5_desc);
775 #endif
776 #ifdef LTC_RC6
777  register_cipher (&rc6_desc);
778 #endif
779 #ifdef LTC_SAFERP
780  register_cipher (&saferp_desc);
781 #endif
782 #ifdef LTC_TWOFISH
783  register_cipher (&twofish_desc);
784 #endif
785 #ifdef LTC_SAFER
786  register_cipher (&safer_k64_desc);
787  register_cipher (&safer_sk64_desc);
788  register_cipher (&safer_k128_desc);
789  register_cipher (&safer_sk128_desc);
790 #endif
791 #ifdef LTC_RC2
792  register_cipher (&rc2_desc);
793 #endif
794 #ifdef LTC_DES
795  register_cipher (&des_desc);
796  register_cipher (&des3_desc);
797 #endif
798 #ifdef LTC_CAST5
799  register_cipher (&cast5_desc);
800 #endif
801 #ifdef LTC_NOEKEON
802  register_cipher (&noekeon_desc);
803 #endif
804 #ifdef LTC_SKIPJACK
805  register_cipher (&skipjack_desc);
806 #endif
807 #ifdef LTC_KHAZAD
808  register_cipher (&khazad_desc);
809 #endif
810 #ifdef LTC_ANUBIS
811  register_cipher (&anubis_desc);
812 #endif
813 #ifdef LTC_KSEED
814  register_cipher (&kseed_desc);
815 #endif
816 #ifdef LTC_KASUMI
817  register_cipher (&kasumi_desc);
818 #endif
819 #ifdef LTC_MULTI2
820  register_cipher (&multi2_desc);
821 #endif
822 
823 #ifdef LTC_TIGER
824  register_hash (&tiger_desc);
825 #endif
826 #ifdef LTC_MD2
827  register_hash (&md2_desc);
828 #endif
829 #ifdef LTC_MD4
830  register_hash (&md4_desc);
831 #endif
832 #ifdef LTC_MD5
833  register_hash (&md5_desc);
834 #endif
835 #ifdef LTC_SHA1
836  register_hash (&sha1_desc);
837 #endif
838 #ifdef LTC_SHA224
839  register_hash (&sha224_desc);
840 #endif
841 #ifdef LTC_SHA256
842  register_hash (&sha256_desc);
843 #endif
844 #ifdef LTC_SHA384
845  register_hash (&sha384_desc);
846 #endif
847 #ifdef LTC_SHA512
848  register_hash (&sha512_desc);
849 #endif
850 #ifdef LTC_RIPEMD128
851  register_hash (&rmd128_desc);
852 #endif
853 #ifdef LTC_RIPEMD160
854  register_hash (&rmd160_desc);
855 #endif
856 #ifdef LTC_RIPEMD256
857  register_hash (&rmd256_desc);
858 #endif
859 #ifdef LTC_RIPEMD320
860  register_hash (&rmd320_desc);
861 #endif
862 #ifdef LTC_WHIRLPOOL
863  register_hash (&whirlpool_desc);
864 #endif
865 #ifdef LTC_CHC_HASH
866  register_hash(&chc_desc);
867  err = rpmltcErr(ltc, "chc_register",
868  chc_register(register_cipher(&aes_desc)));
869  if (err != CRYPT_OK)
870  exit(EXIT_FAILURE);
871 #endif
872 
873 register_prng(&yarrow_desc);
874 #ifdef LTC_FORTUNA
875 register_prng(&fortuna_desc);
876 #endif
877 #ifdef LTC_RC4
878 register_prng(&rc4_desc);
879 #endif
880 #ifdef LTC_SOBER128
881 register_prng(&sober128_desc);
882 #endif
883 
884 #ifdef LTC_FORTUNA
885  err = rpmltcErr(ltc, "rng_make_prng",
886  rng_make_prng(128, find_prng("fortuna"), &prng, NULL));
887 #else
888  err = rpmltcErr(ltc, "rng_make_prng",
889  rng_make_prng(128, find_prng("yarrow"), &prng, NULL));
890 #endif
891  if (err != CRYPT_OK)
892  exit(EXIT_FAILURE);
893 
894 }
895 static
896 void * rpmltcInit(void)
897  /*@*/
898 {
899  static int oneshot;
900  rpmltc ltc = xcalloc(1, sizeof(*ltc));
901  if (!oneshot) {
902  reg_algs(ltc);
903 #if defined(LTM_DESC)
904  ltc_mp = ltm_desc; /* XXX tfm_desc */
905 #endif
906  oneshot++;
907  }
908 
909 #ifdef LTC_FORTUNA
910  ltc->prngIdx = find_prng("fortuna");
911 #else
912  ltc->prngIdx = find_prng("yarrow");
913 #endif
914 
915  return (void *) ltc;
916 }
917 
918 struct pgpImplVecs_s rpmltcImplVecs = {
919  "TomCrypt " SCRYPT,
920  rpmltcSetRSA,
921  rpmltcSetDSA,
922  rpmltcSetELG,
923  rpmltcSetECDSA,
924 
925  rpmltcErrChk,
926  rpmltcAvailableCipher, rpmltcAvailableDigest, rpmltcAvailablePubkey,
927  rpmltcVerify, rpmltcSign, rpmltcGenerate,
928 
929  rpmltcMpiItem, rpmltcClean,
930  rpmltcFree, rpmltcInit
931 };
932 
933 int rpmltcExportPubkey(pgpDig dig)
934 {
935  uint8_t pkt[8192];
936  uint8_t * be = pkt;
937  size_t pktlen;
938  time_t now = time(NULL);
939  uint32_t bt = now;
940  uint16_t bn;
941  pgpDigParams pubp = pgpGetPubkey(dig);
942  rpmltc ltc = (rpmltc) dig->impl;
943  int rc = 0; /* assume failure */
944  int xx;
945 
946  *be++ = 0x80 | (PGPTAG_PUBLIC_KEY << 2) | 0x01;
947  be += 2;
948 
949  *be++ = 0x04;
950  *be++ = (bt >> 24);
951  *be++ = (bt >> 16);
952  *be++ = (bt >> 8);
953  *be++ = (bt );
954  *be++ = pubp->pubkey_algo;
955 
956  switch (pubp->pubkey_algo) {
957  default:
958 assert(0);
959  break;
960  case PGPPUBKEYALGO_RSA:
961  bn = mp_count_bits(ltc->rsa.N);
962  *be++ = (bn >> 8); *be++ = (bn );
963  bn += 7; bn &= ~7;
964  xx = mp_to_unsigned_bin(ltc->rsa.N, be);
965  be += bn/8;
966 
967  bn = mp_count_bits(ltc->rsa.e);
968  *be++ = (bn >> 8); *be++ = (bn );
969  bn += 7; bn &= ~7;
970  xx = mp_to_unsigned_bin(ltc->rsa.e, be);
971  be += bn/8;
972  break;
973  case PGPPUBKEYALGO_DSA:
974  bn = mp_count_bits(ltc->dsa.p);
975  *be++ = (bn >> 8); *be++ = (bn );
976  bn += 7; bn &= ~7;
977  xx = mp_to_unsigned_bin(ltc->dsa.p, be);
978  be += bn/8;
979 
980  bn = mp_count_bits(ltc->dsa.q);
981  *be++ = (bn >> 8); *be++ = (bn );
982  bn += 7; bn &= ~7;
983  xx = mp_to_unsigned_bin(ltc->dsa.q, be);
984  be += bn/8;
985 
986  bn = mp_count_bits(ltc->dsa.g);
987  *be++ = (bn >> 8); *be++ = (bn );
988  bn += 7; bn &= ~7;
989  xx = mp_to_unsigned_bin(ltc->dsa.g, be);
990  be += bn/8;
991 
992  bn = mp_count_bits(ltc->dsa.y);
993  *be++ = (bn >> 8); *be++ = (bn );
994  bn += 7; bn &= ~7;
995  xx = mp_to_unsigned_bin(ltc->dsa.y, be);
996  be += bn/8;
997  break;
998  case PGPPUBKEYALGO_ECDSA:
999  /* OID */
1000  { const char * s;
1001  size_t ns;
1002  size_t i;
1003  switch (ltc->nbits) {
1004  case 192: s = "2a8648ce3d030101"; break;
1005  case 224: s = "2b81040021"; break;
1006  default: /* XXX FIXME: default? */
1007  case 256: s = "2a8648ce3d030107"; break;
1008  case 384: s = "2b81040022"; break;
1009  case 512: /* XXX sanity */
1010  case 521: s = "2b81040023"; break;
1011  }
1012  ns = strlen(s);
1013  *be++ = ns/2;
1014  for (i = 0; i < ns; i += 2)
1015  *be++ = (nibble(s[i]) << 4) | (nibble(s[i+1]));
1016  }
1017  /* Q */
1018  { unsigned long nQ = (sizeof(pkt) - (be+2 - pkt));
1019  xx = ecc_ansi_x963_export(&ltc->ecdsa, be+2, &nQ);
1020 assert(xx == CRYPT_OK);
1021  bn = 8 * nQ;
1022  /* XXX uncompressed {x,y} starts with 0x04 (i.e. 5 leading zero bits) */
1023  bn -= 5;
1024  *be++ = (bn >> 8); *be++ = (bn );
1025  bn += 7; bn &= ~7;
1026  be += bn/8;
1027  }
1028  break;
1029  }
1030 
1031  pktlen = (be - pkt);
1032  bn = pktlen - 3;
1033  pkt[1] = (bn >> 8);
1034  pkt[2] = (bn );
1035 
1036  xx = pgpPubkeyFingerprint(pkt, pktlen, pubp->signid);
1037 
1038  dig->pub = memcpy(xmalloc(pktlen), pkt, pktlen);
1039  dig->publen = pktlen;
1040  rc = 1;
1041 
1042 SPEW(!rc, rc, dig);
1043  return rc;
1044 }
1045 
1046 int rpmltcExportSignature(pgpDig dig, /*@only@*/ DIGEST_CTX ctx)
1047 {
1048  uint8_t pkt[8192];
1049  uint8_t * be = pkt;
1050  uint8_t * h;
1051  size_t pktlen;
1052  time_t now = time(NULL);
1053  uint32_t bt;
1054  uint16_t bn;
1055  pgpDigParams pubp = pgpGetPubkey(dig);
1056  pgpDigParams sigp = pgpGetSignature(dig);
1057  rpmltc ltc = (rpmltc) dig->impl;
1058  int rc = 0; /* assume failure */
1059  int xx;
1060 
1061  sigp->tag = PGPTAG_SIGNATURE;
1062  *be++ = 0x80 | (sigp->tag << 2) | 0x01;
1063  be += 2; /* pktlen */
1064 
1065  sigp->hash = be;
1066  *be++ = sigp->version = 0x04; /* version */
1067  *be++ = sigp->sigtype = PGPSIGTYPE_BINARY; /* sigtype */
1068  *be++ = sigp->pubkey_algo = pubp->pubkey_algo; /* pubkey_algo */
1069  *be++ = sigp->hash_algo; /* hash_algo */
1070 
1071  be += 2; /* skip hashd length */
1072  h = (uint8_t *) be;
1073 
1074  *be++ = 1 + 4; /* signature creation time */
1076  bt = now;
1077  *be++ = sigp->time[0] = (bt >> 24);
1078  *be++ = sigp->time[1] = (bt >> 16);
1079  *be++ = sigp->time[2] = (bt >> 8);
1080  *be++ = sigp->time[3] = (bt );
1081 
1082  *be++ = 1 + 4; /* signature expiration time */
1084  bt = 30 * 24 * 60 * 60; /* XXX 30 days from creation */
1085  *be++ = sigp->expire[0] = (bt >> 24);
1086  *be++ = sigp->expire[1] = (bt >> 16);
1087  *be++ = sigp->expire[2] = (bt >> 8);
1088  *be++ = sigp->expire[3] = (bt );
1089 
1090 /* key expiration time (only on a self-signature) */
1091 
1092  *be++ = 1 + 1; /* exportable certification */
1094  *be++ = 0;
1095 
1096  *be++ = 1 + 1; /* revocable */
1097  *be++ = PGPSUBTYPE_REVOCABLE;
1098  *be++ = 0;
1099 
1100 /* notation data */
1101 
1102  sigp->hashlen = (be - h); /* set hashed length */
1103  h[-2] = (sigp->hashlen >> 8);
1104  h[-1] = (sigp->hashlen );
1105  sigp->hashlen += sizeof(struct pgpPktSigV4_s);
1106 
1107  if (sigp->hash != NULL)
1108  xx = rpmDigestUpdate(ctx, sigp->hash, sigp->hashlen);
1109 
1110  if (sigp->version == (rpmuint8_t) 4) {
1111  uint8_t trailer[6];
1112  trailer[0] = sigp->version;
1113  trailer[1] = (rpmuint8_t)0xff;
1114  trailer[2] = (sigp->hashlen >> 24);
1115  trailer[3] = (sigp->hashlen >> 16);
1116  trailer[4] = (sigp->hashlen >> 8);
1117  trailer[5] = (sigp->hashlen );
1118  xx = rpmDigestUpdate(ctx, trailer, sizeof(trailer));
1119  }
1120 
1121  sigp->signhash16[0] = 0x00;
1122  sigp->signhash16[1] = 0x00;
1123  switch (pubp->pubkey_algo) {
1124  default:
1125 assert(0);
1126  break;
1127  case PGPPUBKEYALGO_RSA:
1128  xx = pgpImplSetRSA(ctx, dig, sigp); /* XXX signhash16 check fails */
1129  break;
1130  case PGPPUBKEYALGO_DSA:
1131  xx = pgpImplSetDSA(ctx, dig, sigp); /* XXX signhash16 check fails */
1132  break;
1133  case PGPPUBKEYALGO_ECDSA:
1134  xx = pgpImplSetECDSA(ctx, dig, sigp); /* XXX signhash16 check fails */
1135  break;
1136  }
1137  h = (uint8_t *) ltc->digest;
1138  sigp->signhash16[0] = h[0];
1139  sigp->signhash16[1] = h[1];
1140 
1141  /* XXX pgpImplVec forces "--usecrypto foo" to also be used */
1142  xx = pgpImplSign(dig);
1143 assert(xx == 1);
1144 
1145  be += 2; /* skip unhashed length. */
1146  h = be;
1147 
1148  *be++ = 1 + 8; /* issuer key ID */
1149  *be++ = PGPSUBTYPE_ISSUER_KEYID;
1150  *be++ = pubp->signid[0];
1151  *be++ = pubp->signid[1];
1152  *be++ = pubp->signid[2];
1153  *be++ = pubp->signid[3];
1154  *be++ = pubp->signid[4];
1155  *be++ = pubp->signid[5];
1156  *be++ = pubp->signid[6];
1157  *be++ = pubp->signid[7];
1158 
1159  bt = (be - h); /* set unhashed length */
1160  h[-2] = (bt >> 8);
1161  h[-1] = (bt );
1162 
1163  *be++ = sigp->signhash16[0]; /* signhash16 */
1164  *be++ = sigp->signhash16[1];
1165 
1166  switch (pubp->pubkey_algo) {
1167  default:
1168 assert(0);
1169  break;
1170  case PGPPUBKEYALGO_RSA:
1171  bn = mp_count_bits(ltc->c);
1172  *be++ = (bn >> 8);
1173  *be++ = (bn );
1174  bn += 7; bn &= ~7;
1175  xx = mp_to_unsigned_bin(ltc->c, be);
1176  be += bn/8;
1177  break;
1178  case PGPPUBKEYALGO_DSA:
1179  bn = mp_count_bits(ltc->r);
1180  *be++ = (bn >> 8);
1181  *be++ = (bn );
1182  bn += 7; bn &= ~7;
1183  xx = mp_to_unsigned_bin(ltc->r, be);
1184  be += bn/8;
1185 
1186  bn = mp_count_bits(ltc->s);
1187  *be++ = (bn >> 8);
1188  *be++ = (bn );
1189  bn += 7; bn &= ~7;
1190  xx = mp_to_unsigned_bin(ltc->s, be);
1191  be += bn/8;
1192  break;
1193  case PGPPUBKEYALGO_ECDSA:
1194  bn = mp_count_bits(ltc->r);
1195  *be++ = (bn >> 8);
1196  *be++ = (bn );
1197  bn += 7; bn &= ~7;
1198  xx = mp_to_unsigned_bin(ltc->r, be);
1199  be += bn/8;
1200 
1201  bn = mp_count_bits(ltc->s);
1202  *be++ = (bn >> 8);
1203  *be++ = (bn );
1204  bn += 7; bn &= ~7;
1205  xx = mp_to_unsigned_bin(ltc->s, be);
1206  be += bn/8;
1207  break;
1208  }
1209 
1210  pktlen = (be - pkt); /* packet length */
1211  bn = pktlen - 3;
1212  pkt[1] = (bn >> 8);
1213  pkt[2] = (bn );
1214 
1215  dig->sig = memcpy(xmalloc(pktlen), pkt, pktlen);
1216  dig->siglen = pktlen;
1217  rc = 1;
1218 
1219 SPEW(!rc, rc, dig);
1220  return rc;
1221 }
1222 
1223 #endif /* WITH_TOMCRYPT */
pgpDigParams pgpGetPubkey(pgpDig dig)
Return OpenPGP pubkey parameters.
Definition: rpmpgp.c:1397
struct rpmgc_s * rpmgc
Definition: rpmgc.h:22
#define EXIT_FAILURE
char * xstrdup(const char *str)
Definition: rpmmalloc.c:321
struct pgpDigParams_s * pgpDigParams
Definition: rpmiotypes.h:101
const char int time
Definition: bson.h:1005
pgpImplVecs_t rpmltcImplVecs
Implementation specific parameter storage.
static unsigned char nibble(char c)
Convert hex to binary nibble.
Definition: pack.c:628
5.2.3.
Definition: rpmpgp.h:376
static int pgpImplSign(pgpDig dig)
Definition: rpmpgp.h:1867
const char * pgpPubkeyAlgo2Name(uint32_t algo)
Definition: rpmpgp.c:1193
int rpmltcExportPubkey(pgpDig dig)
static int pgpImplSetDSA(DIGEST_CTX ctx, pgpDig dig, pgpDigParams sigp)
Definition: rpmpgp.h:1785
Yet Another syslog(3) API clone.
void * xcalloc(size_t nmemb, size_t size)
Definition: rpmmalloc.c:300
int rpmDigestUpdate(DIGEST_CTX ctx, const void *data, size_t len)
Update context with next plain text buffer.
Definition: digest.c:986
unsigned char rpmuint8_t
Private int typedefs to avoid C99 portability issues.
Definition: rpmiotypes.h:26
mongo_error_t err
Definition: mongo.h:922
#define SPEW(_list)
Definition: rpmns.c:45
static unsigned int pgpMpiBits(const rpmuint8_t *p)
Return no.
Definition: rpmpgp.h:1074
pgpHashAlgo rpmDigestAlgo(DIGEST_CTX ctx)
Return digest algorithm identifier.
Definition: digest.c:191
pgpDigParams pgpGetSignature(pgpDig dig)
Return OpenPGP signature parameters.
Definition: rpmpgp.c:1392
#define fail(_err)
Definition: yarn.c:199
Digest private data.
Definition: digest.c:130
struct pgpDig_s * pgpDig
Definition: rpmiotypes.h:97
static int pgpImplSetECDSA(DIGEST_CTX ctx, pgpDig dig, pgpDigParams sigp)
Definition: rpmpgp.h:1803
static int pgpImplSetRSA(DIGEST_CTX ctx, pgpDig dig, pgpDigParams sigp)
Definition: rpmpgp.h:1776
static unsigned int pgpMpiLen(const rpmuint8_t *p)
Return no.
Definition: rpmpgp.h:1087
const char const int i
Definition: bson.h:778
int pgpPubkeyFingerprint(const rpmuint8_t *pkt, size_t pktlen, rpmuint8_t *keyid)
Print/parse an OpenPGP subtype packet.
Definition: rpmpgp.c:1029
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:756
const char * pgpHashAlgo2Name(uint32_t algo)
Definition: rpmpgp.c:1188
int rpmDigestFinal(DIGEST_CTX ctx, void *datap, size_t *lenp, int asAscii)
Return digest and destroy context.
Definition: digest.c:1000
#define xmalloc
Definition: system.h:32
struct rpmltc_s * rpmltc
Definition: rpmltc.h:20
int rpmltcExportSignature(pgpDig dig, DIGEST_CTX ctx)
static char * pgpHexStr(const rpmuint8_t *p, size_t plen)
Return hex formatted representation of bytes.
Definition: rpmpgp.h:1124
int _pgp_print
Definition: rpmpgp.c:45
int _pgp_debug
Definition: rpmpgp.c:42
const char * ns
Definition: mongo.h:326