3dffa20e5b34ccfea01309751c8c7608b65d3a62
[platform/upstream/libsolv.git] / ext / repo_pubkey.c
1 /*
2  * Copyright (c) 2007-2013, Novell Inc.
3  *
4  * This program is licensed under the BSD license, read LICENSE.BSD
5  * for further information
6  */
7
8 /*
9  * repo_pubkey
10  *
11  * support for pubkey reading
12  *
13  */
14
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <limits.h>
18 #include <fcntl.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <unistd.h>
23 #include <assert.h>
24 #include <stdint.h>
25 #include <errno.h>
26
27 #include <rpm/rpmio.h>
28 #include <rpm/rpmpgp.h>
29 #ifndef RPM5
30 #include <rpm/header.h>
31 #endif
32 #include <rpm/rpmdb.h>
33
34 #include "pool.h"
35 #include "repo.h"
36 #include "hash.h"
37 #include "util.h"
38 #include "queue.h"
39 #include "chksum.h"
40 #include "repo_rpmdb.h"
41 #include "repo_pubkey.h"
42 #ifdef ENABLE_PGPVRFY
43 #include "solv_pgpvrfy.h"
44 #endif
45
46 static void
47 setutf8string(Repodata *repodata, Id handle, Id tag, const char *str)
48 {
49   if (str[solv_validutf8(str)])
50     {
51       char *ustr = solv_latin1toutf8(str);      /* not utf8, assume latin1 */
52       repodata_set_str(repodata, handle, tag, ustr);
53       solv_free(ustr);
54     }
55   else
56     repodata_set_str(repodata, handle, tag, str);
57 }
58
59 static char *
60 r64dec1(char *p, unsigned int *vp, int *eofp)
61 {
62   int i, x;
63   unsigned int v = 0;
64
65   for (i = 0; i < 4; )
66     {
67       x = *p++;
68       if (!x)
69         return 0;
70       if (x >= 'A' && x <= 'Z')
71         x -= 'A';
72       else if (x >= 'a' && x <= 'z')
73         x -= 'a' - 26;
74       else if (x >= '0' && x <= '9')
75         x -= '0' - 52;
76       else if (x == '+')
77         x = 62;
78       else if (x == '/')
79         x = 63;
80       else if (x == '=')
81         {
82           x = 0;
83           if (i == 0)
84             {
85               *eofp = 3;
86               *vp = 0;
87               return p - 1;
88             }
89           *eofp += 1;
90         }
91       else
92         continue;
93       v = v << 6 | x;
94       i++;
95     }
96   *vp = v;
97   return p;
98 }
99
100 static unsigned int
101 crc24(unsigned char *p, int len)
102 {
103   unsigned int crc = 0xb704ceL;
104   int i;
105
106   while (len--)
107     {
108       crc ^= (*p++) << 16;
109       for (i = 0; i < 8; i++)
110         if ((crc <<= 1) & 0x1000000)
111           crc ^= 0x1864cfbL;
112     }
113   return crc & 0xffffffL;
114 }
115
116 static unsigned char *
117 unarmor(char *pubkey, int *pktlp, char *startstr, char *endstr)
118 {
119   char *p;
120   int l, eof;
121   unsigned char *buf, *bp;
122   unsigned int v;
123
124   *pktlp = 0;
125   if (!pubkey)
126     return 0;
127   l = strlen(startstr);
128   while (strncmp(pubkey, startstr, l) != 0)
129     {
130       pubkey = strchr(pubkey, '\n');
131       if (!pubkey)
132         return 0;
133       pubkey++;
134     }
135   pubkey = strchr(pubkey, '\n');
136   if (!pubkey++)
137     return 0;
138   /* skip header lines */
139   for (;;)
140     {
141       while (*pubkey == ' ' || *pubkey == '\t')
142         pubkey++;
143       if (*pubkey == '\n')
144         break;
145       pubkey = strchr(pubkey, '\n');
146       if (!pubkey++)
147         return 0;
148     }
149   pubkey++;
150   p = strchr(pubkey, '=');
151   if (!p)
152     return 0;
153   l = p - pubkey;
154   bp = buf = solv_malloc(l * 3 / 4 + 4);
155   eof = 0;
156   while (!eof)
157     {
158       pubkey = r64dec1(pubkey, &v, &eof);
159       if (!pubkey)
160         {
161           solv_free(buf);
162           return 0;
163         }
164       *bp++ = v >> 16;
165       *bp++ = v >> 8;
166       *bp++ = v;
167     }
168   while (*pubkey == ' ' || *pubkey == '\t' || *pubkey == '\n' || *pubkey == '\r')
169     pubkey++;
170   bp -= eof;
171   if (*pubkey != '=' || (pubkey = r64dec1(pubkey + 1, &v, &eof)) == 0)
172     {
173       solv_free(buf);
174       return 0;
175     }
176   if (v != crc24(buf, bp - buf))
177     {
178       solv_free(buf);
179       return 0;
180     }
181   while (*pubkey == ' ' || *pubkey == '\t' || *pubkey == '\n' || *pubkey == '\r')
182     pubkey++;
183   if (strncmp(pubkey, endstr, strlen(endstr)) != 0)
184     {
185       solv_free(buf);
186       return 0;
187     }
188   *pktlp = bp - buf;
189   return buf;
190 }
191
192 struct pgpsig {
193   int type;
194   Id hashalgo;
195   unsigned char issuer[8];
196   int haveissuer;
197   unsigned int created;
198   unsigned int expires;
199   unsigned int keyexpires;
200   unsigned char *sigdata;
201   int sigdatal;
202   int mpioff;
203 };
204
205 static Id
206 pgphashalgo2type(int algo)
207 {
208   if (algo == 1)
209     return REPOKEY_TYPE_MD5;
210   if (algo == 2)
211     return REPOKEY_TYPE_SHA1;
212   if (algo == 8)
213     return REPOKEY_TYPE_SHA256;
214   return 0;
215 }
216
217 static void
218 createsigdata(struct pgpsig *sig, unsigned char *p, int l, unsigned char *pubkey, int pubkeyl, unsigned char *userid, int useridl, void *h)
219 {
220   int type = sig->type;
221   unsigned char b[6];
222   const unsigned char *cs;
223   int csl;
224
225   if (sig->mpioff < 2 || l <= sig->mpioff)
226     return;
227   if ((type >= 0x10 && type <= 0x13) || type == 0x1f || type == 0x18 || type == 0x20 || type == 0x28)
228     {
229       b[0] = 0x99;
230       b[1] = pubkeyl >> 8;
231       b[2] = pubkeyl;
232       solv_chksum_add(h, b, 3);
233       solv_chksum_add(h, pubkey, pubkeyl);
234     }
235   if ((type >= 0x10 && type <= 0x13))
236     {
237       if (p[0] != 3)
238         {
239           b[0] = 0xb4;
240           b[1] = useridl >> 24;
241           b[2] = useridl >> 16;
242           b[3] = useridl >> 8;
243           b[4] = useridl;
244           solv_chksum_add(h, b, 5);
245         }
246       solv_chksum_add(h, userid, useridl);
247     }
248   /* add trailer */
249   if (p[0] == 3)
250     solv_chksum_add(h, p + 2, 5);
251   else
252     {
253       int hl = 6 + (p[4] << 8 | p[5]);
254       solv_chksum_add(h, p, hl);
255       b[0] = 4;
256       b[1] = 0xff;
257       b[2] = hl >> 24;
258       b[3] = hl >> 16;
259       b[4] = hl >> 8;
260       b[5] = hl;
261       solv_chksum_add(h, b, 6);
262     }
263   cs = solv_chksum_get(h, &csl);
264   if (cs[0] == p[sig->mpioff - 2] && cs[1] == p[sig->mpioff - 1])
265     {
266       int ml = l - sig->mpioff;
267       sig->sigdata = solv_malloc(2 + csl + ml);
268       sig->sigdatal = 2 + csl + ml;
269       sig->sigdata[0] = p[0] == 3 ? p[15] : p[2];
270       sig->sigdata[1] = p[0] == 3 ? p[16] : p[3];
271       memcpy(sig->sigdata + 2, cs, csl);
272       memcpy(sig->sigdata + 2 + csl, p + sig->mpioff, ml);
273     }
274 }
275
276 static inline int
277 parsesubpkglength(unsigned char *q, int ql, int *pktlp)
278 {
279   int x, sl, hl;
280   /* decode sub-packet length, ql must be > 0 */
281   x = *q++;
282   if (x < 192)
283     {
284       sl = x;
285       hl = 1;
286     }
287   else if (x == 255)
288     {
289       if (ql < 5 || q[0] != 0)
290         return 0;
291       sl = q[1] << 16 | q[2] << 8 | q[3];
292       hl = 5;
293     }
294   else
295     {
296       if (ql < 2)
297         return 0;
298       sl = ((x - 192) << 8) + q[0] + 192;
299       hl = 2;
300     }
301   if (!sl || ql < sl + hl)      /* sub pkg tag is included in length, i.e. sl must not be zero */
302     return 0;
303   *pktlp = sl;
304   return hl;
305 }
306
307 static void
308 parsesigpacket(struct pgpsig *sig, unsigned char *p, int l)
309 {
310   sig->type = -1;
311   if (p[0] == 3)
312     {
313       /* printf("V3 signature packet\n"); */
314       if (l <= 19 || p[1] != 5)
315         return;
316       sig->type = p[2];
317       sig->haveissuer = 1;
318       memcpy(sig->issuer, p + 7, 8);
319       sig->created = p[3] << 24 | p[4] << 16 | p[5] << 8 | p[6];
320       sig->hashalgo = p[16];
321       sig->mpioff = 19;
322     }
323   else if (p[0] == 4)
324     {
325       int j, ql, x;
326       unsigned char *q;
327
328       /* printf("V4 signature packet\n"); */
329       if (l < 6)
330         return;
331       sig->type = p[1];
332       sig->hashalgo = p[3];
333       q = p + 4;
334       sig->keyexpires = -1;
335       for (j = 0; q && j < 2; j++)
336         {
337           if (q + 2 > p + l)
338             {
339               q = 0;
340               break;
341             }
342           ql = q[0] << 8 | q[1];
343           q += 2;
344           if (q + ql > p + l)
345             {
346               q = 0;
347               break;
348             }
349           while (ql > 0)
350             {
351               int sl, hl;
352               hl = parsesubpkglength(q, ql, &sl);
353               if (!hl)
354                 {
355                   q = 0;
356                   break;
357                 }
358               q += hl;
359               ql -= hl;
360               x = q[0] & 127;   /* strip critical bit */
361               /* printf("%d SIGSUB %d %d\n", j, x, sl); */
362               if (x == 16 && sl == 9 && !sig->haveissuer)
363                 {
364                   sig->haveissuer = 1;
365                   memcpy(sig->issuer, q + 1, 8);
366                 }
367               if (x == 2 && j == 0)
368                 sig->created = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
369               if (x == 3 && j == 0)
370                 sig->expires = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
371               if (x == 9 && j == 0)
372                 sig->keyexpires = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
373               q += sl;
374               ql -= sl;
375             }
376         }
377       if (q && q - p + 2 < l)
378         sig->mpioff = q - p + 2;
379     }
380 }
381
382 static int
383 parsepkgheader(unsigned char *p, int pl, int *tagp, int *pktlp)
384 {
385   unsigned char *op = p;
386   int x, l;
387
388   if (!pl)
389     return 0;
390   x = *p++;
391   pl--;
392   if (!(x & 128) || pl <= 0)
393     return 0;
394   if ((x & 64) == 0)
395     {
396       *tagp = (x & 0x3c) >> 2;          /* old format */
397       x = 1 << (x & 3);
398       if (x > 4 || pl < x || (x == 4 && p[0]))
399         return 0;
400       pl -= x;
401       for (l = 0; x--;)
402         l = l << 8 | *p++;
403     }
404   else
405     {
406       *tagp = (x & 0x3f);               /* new format */
407       x = *p++;
408       pl--;
409       if (x < 192)
410         l = x;
411       else if (x >= 192 && x < 224)
412         {
413           if (pl <= 0)
414             return 0;
415           l = ((x - 192) << 8) + *p++ + 192;
416           pl--;
417         }
418       else if (x == 255)
419         {
420           if (pl <= 4 || p[0] != 0)     /* sanity: p[0] must be zero */
421             return 0;
422           l = p[1] << 16 | p[2] << 8 | p[3];
423           p += 4;
424           pl -= 4;
425         }
426       else
427         return 0;
428     }
429   if (l > pl)
430     return 0;
431   *pktlp = l;
432   return p - op;
433 }
434
435
436 static void
437 parsekeydata(Solvable *s, Repodata *data, unsigned char *p, int pl)
438 {
439   int tag, l;
440   unsigned char keyid[8];
441   unsigned int kcr = 0, maxex = 0, maxsigcr = 0;
442   unsigned char *pubkey = 0;
443   int pubkeyl = 0;
444   unsigned char *userid = 0;
445   int useridl = 0;
446   unsigned char *pubdata = 0;
447   int pubdatal = 0;
448
449   for (; pl; p += l, pl -= l)
450     {
451       int hl = parsepkgheader(p, pl, &tag, &l);
452       if (!hl)
453         break;
454       p += hl;
455       pl -= hl;
456       if (tag == 6)
457         {
458           if (pubkey)
459             break;      /* one key at a time, please */
460           pubkey = solv_malloc(l);
461           if (l)
462             memcpy(pubkey, p, l);
463           pubkeyl = l;
464           if (p[0] == 3 && l >= 10)
465             {
466               unsigned int ex;
467               void *h;
468               maxsigcr = kcr = p[1] << 24 | p[2] << 16 | p[3] << 8 | p[4];
469               ex = 0;
470               if (p[5] || p[6])
471                 {
472                   ex = kcr + 24*3600 * (p[5] << 8 | p[6]);
473                   if (ex > maxex)
474                     maxex = ex;
475                 }
476               memset(keyid, 0, 8);
477               if (p[7] == 1)    /* RSA */
478                 {
479                   int ql, ql2;
480                   unsigned char fp[16];
481                   char fpx[32 + 1];
482                   unsigned char *q;
483
484                   ql = ((p[8] << 8 | p[9]) + 7) / 8;            /* length of public modulus */
485                   if (ql >= 8 && 10 + ql + 2 <= l)
486                     {
487                       memcpy(keyid, p + 10 + ql - 8, 8);        /* keyid is last 64 bits of public modulus */
488                       q = p + 10 + ql;
489                       ql2 = ((q[0] << 8 | q[1]) + 7) / 8;       /* length of encryption exponent */
490                       if (10 + ql + 2 + ql2 <= l)
491                         {
492                           /* fingerprint is the md5 over the two MPI bodies */
493                           h = solv_chksum_create(REPOKEY_TYPE_MD5);
494                           solv_chksum_add(h, p + 10, ql);
495                           solv_chksum_add(h, q + 2, ql2);
496                           solv_chksum_free(h, fp);
497                           solv_bin2hex(fp, 16, fpx);
498                           repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
499                         }
500                     }
501                   pubdata = p + 7;
502                   pubdatal = l - 7;
503                 }
504             }
505           else if (p[0] == 4 && l >= 6)
506             {
507               void *h;
508               unsigned char hdr[3];
509               unsigned char fp[20];
510               char fpx[40 + 1];
511
512               maxsigcr = kcr = p[1] << 24 | p[2] << 16 | p[3] << 8 | p[4];
513               hdr[0] = 0x99;
514               hdr[1] = l >> 8;
515               hdr[2] = l;
516               /* fingerprint is the sha1 over the packet */
517               h = solv_chksum_create(REPOKEY_TYPE_SHA1);
518               solv_chksum_add(h, hdr, 3);
519               solv_chksum_add(h, p, l);
520               solv_chksum_free(h, fp);
521               solv_bin2hex(fp, 20, fpx);
522               repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
523               memcpy(keyid, fp + 12, 8);        /* keyid is last 64 bits of fingerprint */
524               pubdata = p + 5;
525               pubdatal = l - 5;
526             }
527         }
528       if (tag == 2)
529         {
530           struct pgpsig sig;
531           Id htype;
532           if (!pubdata)
533             continue;
534           memset(&sig, 0, sizeof(sig));
535           parsesigpacket(&sig, p, l);
536           if (!sig.haveissuer || !((sig.type >= 0x10 && sig.type <= 0x13) || sig.type == 0x1f))
537             continue;
538           if (sig.type >= 0x10 && sig.type <= 0x13 && !userid)
539             continue;
540           htype = pgphashalgo2type(sig.hashalgo);
541           if (htype && sig.mpioff)
542             {
543               void *h = solv_chksum_create(htype);
544               createsigdata(&sig, p, l, pubkey, pubkeyl, userid, useridl, h);
545               solv_chksum_free(h, 0);
546             }
547           if (!memcmp(keyid, sig.issuer, 8))
548             {
549 #ifdef ENABLE_PGPVRFY
550               /* found self sig, verify */
551               if (solv_pgpvrfy(pubdata, pubdatal, sig.sigdata, sig.sigdatal))
552 #endif
553                 {
554                   if (sig.keyexpires && maxex != -1)
555                     {
556                       if (sig.keyexpires == -1)
557                         maxex = -1;
558                       else if (sig.keyexpires + kcr > maxex)
559                         maxex = sig.keyexpires + kcr;
560                     }
561                   if (sig.created > maxsigcr)
562                     maxsigcr = sig.created;
563                 }
564             }
565           else
566             {
567               char issuerstr[17];
568               Id shandle = repodata_new_handle(data);
569               solv_bin2hex(sig.issuer, 8, issuerstr);
570               repodata_set_str(data, shandle, SIGNATURE_ISSUER, issuerstr);
571               if (sig.created)
572                 repodata_set_num(data, shandle, SIGNATURE_TIME, sig.created);
573               if (sig.expires)
574                 repodata_set_num(data, shandle, SIGNATURE_EXPIRES, sig.created + sig.expires);
575               if (sig.sigdata)
576                 repodata_set_binary(data, shandle, SIGNATURE_DATA, sig.sigdata, sig.sigdatal);
577               repodata_add_flexarray(data, s - s->repo->pool->solvables, PUBKEY_SIGNATURES, shandle);
578             }
579           solv_free(sig.sigdata);
580         }
581       if (tag == 13)
582         {
583           userid = solv_realloc(userid, l);
584           if (l)
585             memcpy(userid, p, l);
586           useridl = l;
587         }
588     }
589   if (kcr)
590     repodata_set_num(data, s - s->repo->pool->solvables, SOLVABLE_BUILDTIME, kcr);
591   if (maxex && maxex != -1)
592     repodata_set_num(data, s - s->repo->pool->solvables, PUBKEY_EXPIRES, maxex);
593   s->name = pool_str2id(s->repo->pool, "gpg-pubkey", 1);
594   s->evr = 1;
595   s->arch = 1;
596   if (userid && useridl)
597     {
598       char *useridstr = solv_malloc(useridl + 1);
599       memcpy(useridstr, userid, useridl);
600       useridstr[useridl] = 0;
601       setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_SUMMARY, useridstr);
602       free(useridstr);
603     }
604   if (pubdata)
605     {
606       char keyidstr[17];
607       solv_bin2hex(keyid, 8, keyidstr);
608       repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_KEYID, keyidstr);
609     }
610   if (pubdata)
611     {
612       /* build rpm-style evr */
613       char evr[8 + 1 + 8 + 1];
614       solv_bin2hex(keyid + 4, 4, evr);
615       sprintf(evr + 8, "-%08x", maxsigcr);
616       s->evr = pool_str2id(s->repo->pool, evr, 1);
617       /* set data blob */
618       repodata_set_binary(data, s - s->repo->pool->solvables, PUBKEY_DATA, pubdata, pubdatal);
619     }
620   solv_free(pubkey);
621   solv_free(userid);
622 }
623
624
625 #ifdef ENABLE_RPMDB
626
627 /* this is private to rpm, but rpm lacks an interface to retrieve
628  * the values. Sigh. */
629 struct pgpDigParams_s {
630     const char * userid;
631     const unsigned char * hash;
632 #ifndef HAVE_PGPDIGGETPARAMS
633     const char * params[4];
634 #endif
635     unsigned char tag;
636     unsigned char version;               /*!< version number. */
637     unsigned char time[4];               /*!< time that the key was created. */
638     unsigned char pubkey_algo;           /*!< public key algorithm. */
639     unsigned char hash_algo;
640     unsigned char sigtype;
641     unsigned char hashlen;
642     unsigned char signhash16[2];
643     unsigned char signid[8];
644     unsigned char saved;
645 };
646
647 #ifndef HAVE_PGPDIGGETPARAMS
648 struct pgpDig_s {
649     struct pgpDigParams_s signature;
650     struct pgpDigParams_s pubkey;
651 };
652 #endif
653
654
655 /* only rpm knows how to do the release calculation, we don't dare
656  * to recreate all the bugs in libsolv */
657 static void
658 parsekeydata_rpm(Solvable *s, Repodata *data, unsigned char *pkts, int pktsl)
659 {
660   Pool *pool = s->repo->pool;
661   struct pgpDigParams_s *digpubkey;
662   pgpDig dig = 0;
663   char keyid[16 + 1];
664   char evrbuf[8 + 1 + 8 + 1];
665   unsigned int btime;
666
667 #ifndef RPM5
668   dig = pgpNewDig();
669 #else
670   dig = pgpDigNew(RPMVSF_DEFAULT, 0);
671 #endif
672   (void) pgpPrtPkts(pkts, pktsl, dig, 0);
673 #ifdef HAVE_PGPDIGGETPARAMS
674   digpubkey = pgpDigGetParams(dig, PGPTAG_PUBLIC_KEY);
675 #else
676   digpubkey = &dig->pubkey;
677 #endif
678   if (digpubkey)
679     {
680       btime = digpubkey->time[0] << 24 | digpubkey->time[1] << 16 | digpubkey->time[2] << 8 | digpubkey->time[3];
681       solv_bin2hex(digpubkey->signid, 8, keyid);
682       solv_bin2hex(digpubkey->signid + 4, 4, evrbuf);
683       evrbuf[8] = '-';
684       solv_bin2hex(digpubkey->time, 4, evrbuf + 9);
685       s->evr = pool_str2id(pool, evrbuf, 1);
686       repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_KEYID, keyid);
687       if (digpubkey->userid)
688         setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_SUMMARY, digpubkey->userid);
689       if (btime)
690         repodata_set_num(data, s - s->repo->pool->solvables, SOLVABLE_BUILDTIME, btime);
691     }
692 #ifndef RPM5
693   (void)pgpFreeDig(dig);
694 #else
695   (void)pgpDigFree(dig);
696 #endif
697 }
698
699 #endif  /* ENABLE_RPMDB */
700
701 static int
702 pubkey2solvable(Solvable *s, Repodata *data, char *pubkey)
703 {
704   unsigned char *pkts;
705   int pktsl;
706
707   pkts = unarmor(pubkey, &pktsl, "-----BEGIN PGP PUBLIC KEY BLOCK-----", "-----END PGP PUBLIC KEY BLOCK-----");
708   if (!pkts)
709     {
710       pool_error(s->repo->pool, 0, "unarmor failure");
711       return 0;
712     }
713   setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_DESCRIPTION, pubkey);
714   parsekeydata(s, data, pkts, pktsl);
715 #ifdef ENABLE_RPMDB
716   parsekeydata_rpm(s, data, pkts, pktsl);
717 #endif
718   solv_free((void *)pkts);
719   return 1;
720 }
721
722 #ifdef ENABLE_RPMDB
723
724 int
725 repo_add_rpmdb_pubkeys(Repo *repo, int flags)
726 {
727   Pool *pool = repo->pool;
728   Queue q;
729   int i;
730   char *str;
731   Repodata *data;
732   Solvable *s;
733   const char *rootdir = 0;
734   void *state;
735
736   data = repo_add_repodata(repo, flags);
737   if (flags & REPO_USE_ROOTDIR)
738     rootdir = pool_get_rootdir(pool);
739   state = rpm_state_create(repo->pool, rootdir);
740   queue_init(&q);
741   rpm_installedrpmdbids(state, "Name", "gpg-pubkey", &q);
742   for (i = 0; i < q.count; i++)
743     {
744       void *handle;
745       unsigned long long itime;
746
747       handle = rpm_byrpmdbid(state, q.elements[i]);
748       if (!handle)
749         continue;
750       str = rpm_query(handle, SOLVABLE_DESCRIPTION);
751       if (!str)
752         continue;
753       s = pool_id2solvable(pool, repo_add_solvable(repo));
754       pubkey2solvable(s, data, str);
755       solv_free(str);
756       itime = rpm_query_num(handle, SOLVABLE_INSTALLTIME, 0);
757       if (itime)
758         repodata_set_num(data, s - pool->solvables, SOLVABLE_INSTALLTIME, itime);
759       if (!repo->rpmdbid)
760         repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
761       repo->rpmdbid[s - pool->solvables - repo->start] = q.elements[i];
762     }
763   queue_free(&q);
764   rpm_state_free(state);
765   if (!(flags & REPO_NO_INTERNALIZE))
766     repodata_internalize(data);
767   return 0;
768 }
769
770 #endif
771
772 static char *
773 solv_slurp(FILE *fp, int *lenp)
774 {
775   int l, ll;
776   char *buf = 0;
777   int bufl = 0;
778
779   for (l = 0; ; l += ll)
780     {
781       if (bufl - l < 4096)
782         {
783           bufl += 4096;
784           buf = solv_realloc(buf, bufl);
785         }
786       ll = fread(buf + l, 1, bufl - l, fp);
787       if (ll < 0)
788         {
789           buf = solv_free(buf);
790           l = 0;
791           break;
792         }
793       if (ll == 0)
794         {
795           buf[l] = 0;   /* always zero-terminate */
796           break;
797         }
798     }
799   if (lenp)
800     *lenp = l;
801   return buf;
802 }
803
804 Id
805 repo_add_pubkey(Repo *repo, const char *key, int flags)
806 {
807   Pool *pool = repo->pool;
808   Repodata *data;
809   Solvable *s;
810   char *buf;
811   FILE *fp;
812
813   data = repo_add_repodata(repo, flags);
814   buf = 0;
815   if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, key) : key, "r")) == 0)
816     {
817       pool_error(pool, -1, "%s: %s", key, strerror(errno));
818       return 0;
819     }
820   if ((buf = solv_slurp(fp, 0)) == 0)
821     {
822       pool_error(pool, -1, "%s: %s", key, strerror(errno));
823       fclose(fp);
824       return 0;
825     }
826   fclose(fp);
827   s = pool_id2solvable(pool, repo_add_solvable(repo));
828   if (!pubkey2solvable(s, data, buf))
829     {
830       repo_free_solvable(repo, s - pool->solvables, 1);
831       solv_free(buf);
832       return 0;
833     }
834   solv_free(buf);
835   if (!(flags & REPO_NO_INTERNALIZE))
836     repodata_internalize(data);
837   return s - pool->solvables;
838 }
839
840 static int
841 is_sig_packet(unsigned char *sig, int sigl)
842 {
843   if (!sigl)
844     return 0;
845   if ((sig[0] & 0x80) == 0 || (sig[0] & 0x40 ? sig[0] & 0x3f : sig[0] >> 2 & 0x0f) != 2)
846     return 0;
847   return 1;
848 }
849
850 Id
851 solv_parse_sig(FILE *fp, unsigned char **sigpktp, int *sigpktlp, char *keyidstr)
852 {
853   unsigned char *sig;
854   int sigl, hl, tag, pktl;
855   struct pgpsig pgpsig;
856   Id htype;
857
858   if (sigpktp)
859     {
860       *sigpktp = 0;
861       *sigpktlp = 0;
862     }
863   if ((sig = (unsigned char *)solv_slurp(fp, &sigl)) == 0)
864     return 0;
865   if (!is_sig_packet(sig, sigl))
866     {
867       /* not a raw sig, check armored */
868       unsigned char *nsig;
869       nsig = unarmor((char *)sig, &sigl, "-----BEGIN PGP SIGNATURE-----", "-----END PGP SIGNATURE-----");
870       solv_free(sig);
871       if (!nsig)
872         return 0;
873       sig = nsig;
874       if (!is_sig_packet(sig, sigl))
875         {
876           solv_free(sig);
877           return 0;
878         }
879     }
880   hl = parsepkgheader(sig, sigl, &tag, &pktl);
881   if (!hl || tag != 2 || !pktl)
882     {
883       solv_free(sig);
884       return 0;
885     }
886   memset(&pgpsig, 0, sizeof(pgpsig));
887   parsesigpacket(&pgpsig, sig + hl, pktl);
888   htype = pgphashalgo2type(pgpsig.hashalgo);
889   if (pgpsig.type != 0 || !htype || !pgpsig.haveissuer)
890     {
891       solv_free(sig);
892       return 0;
893     }
894   if (sigpktp)
895     {
896       *sigpktp = solv_malloc(pktl);
897       memcpy(*sigpktp, sig + hl, pktl);
898       *sigpktlp = pktl;
899     }
900   solv_free(sig);
901   if (keyidstr)
902     solv_bin2hex(pgpsig.issuer, 8, keyidstr);
903   return htype;
904 }
905
906 #ifdef ENABLE_PGPVRFY
907
908 int
909 solv_verify_sig(const unsigned char *pubdata, int pubdatal, unsigned char *sigpkt, int sigpktl, void *chk)
910 {
911   struct pgpsig pgpsig;
912   int res;
913   Id htype;
914   void *chk2;
915
916   memset(&pgpsig, 0, sizeof(pgpsig));
917   parsesigpacket(&pgpsig, sigpkt, sigpktl);
918   if (pgpsig.type != 0)
919     return 0;
920   htype = pgphashalgo2type(pgpsig.hashalgo);
921   if (htype != solv_chksum_get_type(chk))
922      return 0;  /* wrong hash type? */
923   chk2 = solv_chksum_create_clone(chk);
924   createsigdata(&pgpsig, sigpkt, sigpktl, 0, 0, 0, 0, chk2);
925   solv_chksum_free(chk2, 0);
926   if (!pgpsig.sigdata)
927     return 0;
928   res = solv_pgpvrfy(pubdata, pubdatal, pgpsig.sigdata, pgpsig.sigdatal);
929   solv_free(pgpsig.sigdata);
930   return res;
931 }
932
933 #endif
934