Imported Upstream version 0.7.14
[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 <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <unistd.h>
21 #include <assert.h>
22 #include <stdint.h>
23 #include <errno.h>
24 #include <dirent.h>
25
26 #include <rpm/rpmio.h>
27 #include <rpm/rpmpgp.h>
28 #ifndef RPM5
29 #include <rpm/header.h>
30 #endif
31 #include <rpm/rpmdb.h>
32
33 #include "pool.h"
34 #include "repo.h"
35 #include "hash.h"
36 #include "util.h"
37 #include "queue.h"
38 #include "chksum.h"
39 #include "repo_rpmdb.h"
40 #include "repo_pubkey.h"
41 #ifdef ENABLE_PGPVRFY
42 #include "solv_pgpvrfy.h"
43 #endif
44
45 static void
46 setutf8string(Repodata *repodata, Id handle, Id tag, const char *str)
47 {
48   if (str[solv_validutf8(str)])
49     {
50       char *ustr = solv_latin1toutf8(str);      /* not utf8, assume latin1 */
51       repodata_set_str(repodata, handle, tag, ustr);
52       solv_free(ustr);
53     }
54   else
55     repodata_set_str(repodata, handle, tag, str);
56 }
57
58 static char *
59 r64dec1(char *p, unsigned int *vp, int *eofp)
60 {
61   int i, x;
62   unsigned int v = 0;
63
64   for (i = 0; i < 4; )
65     {
66       x = *p++;
67       if (!x)
68         return 0;
69       if (x >= 'A' && x <= 'Z')
70         x -= 'A';
71       else if (x >= 'a' && x <= 'z')
72         x -= 'a' - 26;
73       else if (x >= '0' && x <= '9')
74         x -= '0' - 52;
75       else if (x == '+')
76         x = 62;
77       else if (x == '/')
78         x = 63;
79       else if (x == '=')
80         {
81           x = 0;
82           if (i == 0)
83             {
84               *eofp = 3;
85               *vp = 0;
86               return p - 1;
87             }
88           *eofp += 1;
89         }
90       else
91         continue;
92       v = v << 6 | x;
93       i++;
94     }
95   *vp = v;
96   return p;
97 }
98
99 static unsigned int
100 crc24(unsigned char *p, int len)
101 {
102   unsigned int crc = 0xb704ce;
103   int i;
104
105   while (len--)
106     {
107       crc ^= (*p++) << 16;
108       for (i = 0; i < 8; i++)
109         if ((crc <<= 1) & 0x1000000)
110           crc ^= 0x1864cfb;
111     }
112   return crc & 0xffffff;
113 }
114
115 static int
116 unarmor(char *pubkey, unsigned char **pktp, int *pktlp, const char *startstr, const char *endstr)
117 {
118   char *p, *pubkeystart = pubkey;
119   int l, eof;
120   unsigned char *buf, *bp;
121   unsigned int v;
122
123   *pktp = 0;
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   p = strchr(pubkey, '\n');
189   if (!p)
190     p = pubkey + strlen(pubkey);
191   *pktp = buf;
192   *pktlp = bp - buf;
193   return (p ? p + 1 : pubkey + strlen(pubkey)) - pubkeystart;
194 }
195
196 #define ARMOR_NLAFTER   16
197
198 static char *
199 armor(unsigned char *pkt, int pktl, const char *startstr, const char *endstr, const char *version)
200 {
201   static const char bintoasc[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
202   char *str = solv_malloc(strlen(startstr) + strlen(endstr) + strlen(version) + (pktl / 3) * 4 + (pktl / (ARMOR_NLAFTER * 3)) + 30);
203   char *p = str;
204   int a, b, c, i;
205   unsigned int v;
206
207   v = crc24(pkt, pktl);
208   sprintf(p, "%s\nVersion: %s\n\n", startstr, version);
209   p += strlen(p);
210   for (i = -1; pktl > 0; pktl -= 3)
211     {
212       if (++i == ARMOR_NLAFTER)
213         {
214           i = 0;
215           *p++ = '\n';
216         }
217       a = *pkt++;
218       b = pktl > 1 ? *pkt++ : 0;
219       c = pktl > 2 ? *pkt++ : 0;
220       *p++ = bintoasc[a >> 2];
221       *p++ = bintoasc[(a & 3) << 4 | b >> 4];
222       *p++ = pktl > 1 ? bintoasc[(b & 15) << 2 | c >> 6] : '=';
223       *p++ = pktl > 2 ? bintoasc[c & 63] : '=';
224     }
225   *p++ = '\n';
226   *p++ = '=';
227   *p++ = bintoasc[v >> 18 & 0x3f];
228   *p++ = bintoasc[v >> 12 & 0x3f];
229   *p++ = bintoasc[v >>  6 & 0x3f];
230   *p++ = bintoasc[v       & 0x3f];
231   sprintf(p, "\n%s\n", endstr);
232   return str;
233 }
234
235 /* internal representation of a signature */
236 struct pgpsig {
237   int type;
238   Id hashalgo;
239   unsigned char issuer[8];
240   int haveissuer;
241   unsigned int created;
242   unsigned int expires;
243   unsigned int keyexpires;
244   unsigned char *sigdata;
245   int sigdatal;
246   int mpioff;
247 };
248
249 static Id
250 pgphashalgo2type(int algo)
251 {
252   if (algo == 1)
253     return REPOKEY_TYPE_MD5;
254   if (algo == 2)
255     return REPOKEY_TYPE_SHA1;
256   if (algo == 8)
257     return REPOKEY_TYPE_SHA256;
258   if (algo == 9)
259     return REPOKEY_TYPE_SHA384;
260   if (algo == 10)
261     return REPOKEY_TYPE_SHA512;
262   if (algo == 11)
263     return REPOKEY_TYPE_SHA224;
264   return 0;
265 }
266
267 /* hash the pubkey/userid data for self-sig verification
268  * hash the final trailer
269  * create a "sigdata" block suitable for a call to solv_pgpverify */
270 static void
271 pgpsig_makesigdata(struct pgpsig *sig, unsigned char *p, int l, unsigned char *pubkey, int pubkeyl, unsigned char *userid, int useridl, Chksum *h)
272 {
273   int type = sig->type;
274   unsigned char b[6];
275   const unsigned char *cs;
276   int csl;
277
278   if (!h || sig->mpioff < 2 || l <= sig->mpioff)
279     return;
280   if ((type >= 0x10 && type <= 0x13) || type == 0x1f || type == 0x18 || type == 0x20 || type == 0x28)
281     {
282       b[0] = 0x99;
283       b[1] = pubkeyl >> 8;
284       b[2] = pubkeyl;
285       solv_chksum_add(h, b, 3);
286       solv_chksum_add(h, pubkey, pubkeyl);
287     }
288   if ((type >= 0x10 && type <= 0x13))
289     {
290       if (p[0] != 3)
291         {
292           b[0] = 0xb4;
293           b[1] = useridl >> 24;
294           b[2] = useridl >> 16;
295           b[3] = useridl >> 8;
296           b[4] = useridl;
297           solv_chksum_add(h, b, 5);
298         }
299       solv_chksum_add(h, userid, useridl);
300     }
301   /* add trailer */
302   if (p[0] == 3)
303     solv_chksum_add(h, p + 2, 5);
304   else
305     {
306       int hl = 6 + (p[4] << 8 | p[5]);
307       solv_chksum_add(h, p, hl);
308       b[0] = 4;
309       b[1] = 0xff;
310       b[2] = hl >> 24;
311       b[3] = hl >> 16;
312       b[4] = hl >> 8;
313       b[5] = hl;
314       solv_chksum_add(h, b, 6);
315     }
316   cs = solv_chksum_get(h, &csl);
317   if (cs[0] == p[sig->mpioff - 2] && cs[1] == p[sig->mpioff - 1])
318     {
319       int ml = l - sig->mpioff;
320       sig->sigdata = solv_malloc(2 + csl + ml);
321       sig->sigdatal = 2 + csl + ml;
322       sig->sigdata[0] = p[0] == 3 ? p[15] : p[2];
323       sig->sigdata[1] = p[0] == 3 ? p[16] : p[3];
324       memcpy(sig->sigdata + 2, cs, csl);
325       memcpy(sig->sigdata + 2 + csl, p + sig->mpioff, ml);
326     }
327 }
328
329 /* parse the header of a subpacket contained in a signature packet
330  * returns: length of the packet header, 0 if there was an error
331  * *pktlp is set to the packet length, the tag is the first byte.
332  */
333 static inline int
334 parsesubpkglength(unsigned char *q, int ql, int *pktlp)
335 {
336   int x, sl, hl;
337   /* decode sub-packet length, ql must be > 0 */
338   x = *q++;
339   if (x < 192)
340     {
341       sl = x;
342       hl = 1;
343     }
344   else if (x == 255)
345     {
346       if (ql < 5 || q[0] != 0)
347         return 0;
348       sl = q[1] << 16 | q[2] << 8 | q[3];
349       hl = 5;
350     }
351   else
352     {
353       if (ql < 2)
354         return 0;
355       sl = ((x - 192) << 8) + q[0] + 192;
356       hl = 2;
357     }
358   if (!sl || ql < sl + hl)      /* sub pkg tag is included in length, i.e. sl must not be zero */
359     return 0;
360   *pktlp = sl;
361   return hl;
362 }
363
364 /* parse a signature packet, initializing the pgpsig struct */
365 static void
366 pgpsig_init(struct pgpsig *sig, unsigned char *p, int l)
367 {
368   memset(sig, 0, sizeof(*sig));
369   sig->type = -1;
370   if (p[0] == 3)
371     {
372       /* printf("V3 signature packet\n"); */
373       if (l <= 19 || p[1] != 5)
374         return;
375       sig->type = p[2];
376       sig->haveissuer = 1;
377       memcpy(sig->issuer, p + 7, 8);
378       sig->created = p[3] << 24 | p[4] << 16 | p[5] << 8 | p[6];
379       sig->hashalgo = p[16];
380       sig->mpioff = 19;
381     }
382   else if (p[0] == 4)
383     {
384       int j, ql, x;
385       unsigned char *q;
386
387       /* printf("V4 signature packet\n"); */
388       if (l < 6)
389         return;
390       sig->type = p[1];
391       sig->hashalgo = p[3];
392       q = p + 4;
393       sig->keyexpires = -1;
394       for (j = 0; q && j < 2; j++)
395         {
396           if (q + 2 > p + l)
397             {
398               q = 0;
399               break;
400             }
401           ql = q[0] << 8 | q[1];
402           q += 2;
403           if (q + ql > p + l)
404             {
405               q = 0;
406               break;
407             }
408           while (ql > 0)
409             {
410               int sl, hl;
411               hl = parsesubpkglength(q, ql, &sl);
412               if (!hl)
413                 {
414                   q = 0;
415                   break;
416                 }
417               q += hl;
418               ql -= hl;
419               x = q[0] & 127;   /* strip critical bit */
420               /* printf("%d SIGSUB %d %d\n", j, x, sl); */
421               if (x == 16 && sl == 9 && !sig->haveissuer)
422                 {
423                   sig->haveissuer = 1;
424                   memcpy(sig->issuer, q + 1, 8);
425                 }
426               if (x == 2 && j == 0)
427                 sig->created = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
428               if (x == 3 && j == 0)
429                 sig->expires = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
430               if (x == 9 && j == 0)
431                 sig->keyexpires = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
432               q += sl;
433               ql -= sl;
434             }
435         }
436       if (q && q - p + 2 < l)
437         sig->mpioff = q - p + 2;
438     }
439 }
440
441 /* parse a pgp packet header
442  * returns: length of the packet header, 0 if there was an error
443  * *tagp and *pktlp is set to the packet tag and the packet length
444  */
445 static int
446 parsepkgheader(unsigned char *p, int pl, int *tagp, int *pktlp)
447 {
448   unsigned char *op = p;
449   int x, l;
450
451   if (!pl)
452     return 0;
453   x = *p++;
454   pl--;
455   if (!(x & 128) || pl <= 0)
456     return 0;
457   if ((x & 64) == 0)
458     {
459       *tagp = (x & 0x3c) >> 2;          /* old format */
460       x = 1 << (x & 3);
461       if (x > 4 || pl < x || (x == 4 && p[0]))
462         return 0;
463       pl -= x;
464       for (l = 0; x--;)
465         l = l << 8 | *p++;
466     }
467   else
468     {
469       *tagp = (x & 0x3f);               /* new format */
470       x = *p++;
471       pl--;
472       if (x < 192)
473         l = x;
474       else if (x >= 192 && x < 224)
475         {
476           if (pl <= 0)
477             return 0;
478           l = ((x - 192) << 8) + *p++ + 192;
479           pl--;
480         }
481       else if (x == 255)
482         {
483           if (pl <= 4 || p[0] != 0)     /* sanity: p[0] must be zero */
484             return 0;
485           l = p[1] << 16 | p[2] << 8 | p[3];
486           p += 4;
487           pl -= 4;
488         }
489       else
490         return 0;
491     }
492   if (l > pl)
493     return 0;
494   *pktlp = l;
495   return p - op;
496 }
497
498 /* parse the first pubkey (possible creating new packages for the subkeys)
499  * returns the number of parsed bytes.
500  * if flags contains ADD_WITH_SUBKEYS, all subkeys will be added as new
501  * solvables as well */
502 static int
503 parsepubkey(Solvable *s, Repodata *data, unsigned char *p, int pl, int flags)
504 {
505   Repo *repo = s->repo;
506   Pool *pool = repo->pool;
507   unsigned char *pstart = p;
508   int tag, l;
509   unsigned char keyid[8];
510   char subkeyofstr[17];
511   unsigned int kcr = 0, maxex = 0, maxsigcr = 0, rpmsigcr = 0;
512   unsigned char *pubkey = 0;
513   int pubkeyl = 0;
514   int insubkey = 0;
515   unsigned char *userid = 0;
516   int useridl = 0;
517   unsigned char *pubdata = 0;
518   int pubdatal = 0;
519
520   *subkeyofstr = 0;
521   for (; ; p += l, pl -= l)
522     {
523       int hl = parsepkgheader(p, pl, &tag, &l);
524       if (!hl || (pubkey && (tag == 6 || tag == 14)))
525         {
526           /* finish old key */
527           if (kcr)
528             repodata_set_num(data, s - pool->solvables, SOLVABLE_BUILDTIME, kcr);
529           if (maxex && maxex != -1)
530             repodata_set_num(data, s - pool->solvables, PUBKEY_EXPIRES, maxex);
531           s->name = pool_str2id(pool, insubkey ? "gpg-subkey" : "gpg-pubkey", 1);
532           s->evr = 1;
533           s->arch = 1;
534           if (userid && useridl)
535             {
536               char *useridstr = solv_malloc(useridl + 1);
537               memcpy(useridstr, userid, useridl);
538               useridstr[useridl] = 0;
539               setutf8string(data, s - pool->solvables, SOLVABLE_SUMMARY, useridstr);
540               free(useridstr);
541             }
542           if (pubdata)
543             {
544               char keyidstr[17];
545               char evr[8 + 1 + 8 + 1];
546               solv_bin2hex(keyid, 8, keyidstr);
547               repodata_set_str(data, s - pool->solvables, PUBKEY_KEYID, keyidstr);
548               /* build rpm-style evr */
549               strcpy(evr, keyidstr + 8);
550               sprintf(evr + 8, "-%08x", (flags & USE_RPM_PUBKEY_BUILTTIME) ? rpmsigcr : maxsigcr);
551               s->evr = pool_str2id(pool, evr, 1);
552             }
553           if (insubkey && *subkeyofstr)
554             repodata_set_str(data, s - pool->solvables, PUBKEY_SUBKEYOF, subkeyofstr);
555           if (pubdata)          /* set data blob */
556             repodata_set_binary(data, s - pool->solvables, PUBKEY_DATA, pubdata, pubdatal);
557           if (!pl)
558             break;
559           if (!hl)
560             {
561               p = 0;    /* parse error */
562               break;
563             }
564           if (tag == 6 || (tag == 14 && !(flags & ADD_WITH_SUBKEYS)))
565             break;
566           if (tag == 14 && pubdata && !insubkey)
567             solv_bin2hex(keyid, 8, subkeyofstr);
568           /* create new solvable for subkey */
569           s = pool_id2solvable(pool, repo_add_solvable(repo));
570         }
571       p += hl;
572       pl -= hl;
573       if (!pubkey && tag != 6)
574         continue;
575       if (tag == 6 || (tag == 14 && (flags & ADD_WITH_SUBKEYS) != 0))           /* Public-Key Packet */
576         {
577           if (tag == 6)
578             {
579               pubkey = solv_memdup(p, l);
580               pubkeyl = l;
581             }
582           else
583             insubkey = 1;
584           pubdata = 0;
585           pubdatal = 0;
586           if (p[0] == 3 && l >= 10)
587             {
588               unsigned int ex;
589               Chksum *h;
590               maxsigcr = kcr = p[1] << 24 | p[2] << 16 | p[3] << 8 | p[4];
591               ex = 0;
592               if (p[5] || p[6])
593                 {
594                   ex = kcr + 24*3600 * (p[5] << 8 | p[6]);
595                   if (ex > maxex)
596                     maxex = ex;
597                 }
598               memset(keyid, 0, 8);
599               if (p[7] == 1)    /* RSA */
600                 {
601                   int ql, ql2;
602                   unsigned char fp[16];
603                   char fpx[32 + 1];
604                   unsigned char *q;
605
606                   ql = ((p[8] << 8 | p[9]) + 7) / 8;            /* length of public modulus */
607                   if (ql >= 8 && 10 + ql + 2 <= l)
608                     {
609                       memcpy(keyid, p + 10 + ql - 8, 8);        /* keyid is last 64 bits of public modulus */
610                       q = p + 10 + ql;
611                       ql2 = ((q[0] << 8 | q[1]) + 7) / 8;       /* length of encryption exponent */
612                       if (10 + ql + 2 + ql2 <= l)
613                         {
614                           /* fingerprint is the md5 over the two MPI bodies */
615                           h = solv_chksum_create(REPOKEY_TYPE_MD5);
616                           solv_chksum_add(h, p + 10, ql);
617                           solv_chksum_add(h, q + 2, ql2);
618                           solv_chksum_free(h, fp);
619                           solv_bin2hex(fp, 16, fpx);
620                           repodata_set_str(data, s - pool->solvables, PUBKEY_FINGERPRINT, fpx);
621                         }
622                     }
623                   pubdata = p + 7;
624                   pubdatal = l - 7;
625                 }
626             }
627           else if (p[0] == 4 && l >= 6)
628             {
629               Chksum *h;
630               unsigned char hdr[3];
631               unsigned char fp[20];
632               char fpx[40 + 1];
633
634               maxsigcr = kcr = p[1] << 24 | p[2] << 16 | p[3] << 8 | p[4];
635               hdr[0] = 0x99;
636               hdr[1] = l >> 8;
637               hdr[2] = l;
638               /* fingerprint is the sha1 over the packet */
639               h = solv_chksum_create(REPOKEY_TYPE_SHA1);
640               solv_chksum_add(h, hdr, 3);
641               solv_chksum_add(h, p, l);
642               solv_chksum_free(h, fp);
643               solv_bin2hex(fp, 20, fpx);
644               repodata_set_str(data, s - pool->solvables, PUBKEY_FINGERPRINT, fpx);
645               memcpy(keyid, fp + 12, 8);        /* keyid is last 64 bits of fingerprint */
646               pubdata = p + 5;
647               pubdatal = l - 5;
648             }
649         }
650       if (tag == 2)             /* Signature Packet */
651         {
652           struct pgpsig sig;
653           Id htype;
654           if (!pubdata)
655             continue;
656           pgpsig_init(&sig, p, l);
657           if (!sig.haveissuer || !((sig.type >= 0x10 && sig.type <= 0x13) || sig.type == 0x1f))
658             continue;
659           if (sig.type >= 0x10 && sig.type <= 0x13 && !userid)
660             continue;
661           htype = pgphashalgo2type(sig.hashalgo);
662           if (htype && sig.mpioff)
663             {
664               Chksum *h = solv_chksum_create(htype);
665               pgpsig_makesigdata(&sig, p, l, pubkey, pubkeyl, userid, useridl, h);
666               solv_chksum_free(h, 0);
667             }
668           if (!rpmsigcr)
669             rpmsigcr = sig.created;
670           if (!memcmp(keyid, sig.issuer, 8))
671             {
672 #ifdef ENABLE_PGPVRFY
673               /* found self sig, verify */
674               if (solv_pgpvrfy(pubdata, pubdatal, sig.sigdata, sig.sigdatal))
675 #endif
676                 {
677                   if (sig.keyexpires && maxex != -1)
678                     {
679                       if (sig.keyexpires == -1)
680                         maxex = -1;
681                       else if (sig.keyexpires + kcr > maxex)
682                         maxex = sig.keyexpires + kcr;
683                     }
684                   if (sig.created > maxsigcr)
685                     maxsigcr = sig.created;
686                 }
687             }
688           else if (flags & ADD_WITH_KEYSIGNATURES)
689             {
690               char issuerstr[17];
691               Id shandle = repodata_new_handle(data);
692               solv_bin2hex(sig.issuer, 8, issuerstr);
693               repodata_set_str(data, shandle, SIGNATURE_ISSUER, issuerstr);
694               if (sig.created)
695                 repodata_set_num(data, shandle, SIGNATURE_TIME, sig.created);
696               if (sig.expires)
697                 repodata_set_num(data, shandle, SIGNATURE_EXPIRES, sig.created + sig.expires);
698               if (sig.sigdata)
699                 repodata_set_binary(data, shandle, SIGNATURE_DATA, sig.sigdata, sig.sigdatal);
700               repodata_add_flexarray(data, s - pool->solvables, PUBKEY_SIGNATURES, shandle);
701             }
702           solv_free(sig.sigdata);
703         }
704       if (tag == 13 && !insubkey)               /* User ID Packet */
705         {
706           userid = solv_realloc(userid, l);
707           if (l)
708             memcpy(userid, p, l);
709           useridl = l;
710         }
711     }
712   solv_free(pubkey);
713   solv_free(userid);
714   return p ? p - pstart : 0;
715 }
716
717 /* parse an ascii armored pubkey
718  * adds multiple pubkeys if ADD_MULTIPLE_PUBKEYS is set */
719 static int
720 pubkey2solvable(Pool *pool, Id p, Repodata *data, char *pubkey, int flags)
721 {
722   unsigned char *pkts, *pkts_orig;
723   int pktsl, pl = 0, tag, l, hl;
724
725   if (!unarmor(pubkey, &pkts, &pktsl, "-----BEGIN PGP PUBLIC KEY BLOCK-----", "-----END PGP PUBLIC KEY BLOCK-----"))
726     {
727       pool_error(pool, 0, "unarmor failure");
728       return 0;
729     }
730   pkts_orig = pkts;
731   tag = 6;
732   while (pktsl)
733     {
734       if (tag == 6)
735         {
736           setutf8string(data, p, SOLVABLE_DESCRIPTION, pubkey);
737           pl = parsepubkey(pool->solvables + p, data, pkts, pktsl, flags);
738           if (!pl || !(flags & ADD_MULTIPLE_PUBKEYS))
739             break;
740         }
741       pkts += pl;
742       pktsl -= pl;
743       hl = parsepkgheader(pkts, pktsl, &tag, &l);
744       if (!hl)
745         break;
746       pl = l + hl;
747       if (tag == 6)
748         p = repo_add_solvable(pool->solvables[p].repo);
749     }
750   solv_free((void *)pkts_orig);
751   return 1;
752 }
753
754 #ifdef ENABLE_RPMDB
755
756 int
757 repo_add_rpmdb_pubkeys(Repo *repo, int flags)
758 {
759   Pool *pool = repo->pool;
760   Queue q;
761   int i;
762   char *str;
763   Repodata *data;
764   const char *rootdir = 0;
765   void *state;
766
767   data = repo_add_repodata(repo, flags);
768   if (flags & REPO_USE_ROOTDIR)
769     rootdir = pool_get_rootdir(pool);
770   state = rpm_state_create(repo->pool, rootdir);
771   queue_init(&q);
772   rpm_installedrpmdbids(state, "Name", "gpg-pubkey", &q);
773   for (i = 0; i < q.count; i++)
774     {
775       Id p, p2;
776       void *handle;
777       unsigned long long itime;
778
779       handle = rpm_byrpmdbid(state, q.elements[i]);
780       if (!handle)
781         continue;
782       str = rpm_query(handle, SOLVABLE_DESCRIPTION);
783       if (!str)
784         continue;
785       p = repo_add_solvable(repo);
786       if (!pubkey2solvable(pool, p, data, str, flags))
787         {
788           solv_free(str);
789           repo_free_solvable(repo, p, 1);
790           continue;
791         }
792       solv_free(str);
793       itime = rpm_query_num(handle, SOLVABLE_INSTALLTIME, 0);
794       for (p2 = p; p2 < pool->nsolvables; p2++)
795         {
796           if (itime)
797             repodata_set_num(data, p2, SOLVABLE_INSTALLTIME, itime);
798           if (!repo->rpmdbid)
799             repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
800           repo->rpmdbid[p2 - repo->start] = q.elements[i];
801         }
802     }
803   queue_free(&q);
804   rpm_state_free(state);
805   if (!(flags & REPO_NO_INTERNALIZE))
806     repodata_internalize(data);
807   return 0;
808 }
809
810 #endif
811
812 static char *
813 solv_slurp(FILE *fp, int *lenp)
814 {
815   int l, ll;
816   char *buf = 0;
817   int bufl = 0;
818
819   for (l = 0; ; l += ll)
820     {
821       if (bufl - l < 4096)
822         {
823           bufl += 4096;
824           buf = solv_realloc(buf, bufl);
825         }
826       ll = fread(buf + l, 1, bufl - l, fp);
827       if (ll < 0)
828         {
829           buf = solv_free(buf);
830           l = 0;
831           break;
832         }
833       if (ll == 0)
834         {
835           buf[l] = 0;   /* always zero-terminate */
836           break;
837         }
838     }
839   if (lenp)
840     *lenp = l;
841   return buf;
842 }
843
844 Id
845 repo_add_pubkey(Repo *repo, const char *keyfile, int flags)
846 {
847   Pool *pool = repo->pool;
848   Repodata *data;
849   Id p;
850   char *buf;
851   FILE *fp;
852
853   data = repo_add_repodata(repo, flags);
854   buf = 0;
855   if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, keyfile) : keyfile, "r")) == 0)
856     {
857       pool_error(pool, -1, "%s: %s", keyfile, strerror(errno));
858       return 0;
859     }
860   if ((buf = solv_slurp(fp, 0)) == 0)
861     {
862       pool_error(pool, -1, "%s: %s", keyfile, strerror(errno));
863       fclose(fp);
864       return 0;
865     }
866   fclose(fp);
867   p = repo_add_solvable(repo);
868   if (!pubkey2solvable(pool, p, data, buf, flags))
869     {
870       repo_free_solvable(repo, p, 1);
871       solv_free(buf);
872       return 0;
873     }
874   if (!(flags & REPO_NO_LOCATION))
875     {
876       Id p2;
877       for (p2 = p; p2 < pool->nsolvables; p2++)
878         repodata_set_location(data, p2, 0, 0, keyfile);
879     }
880   solv_free(buf);
881   if (!(flags & REPO_NO_INTERNALIZE))
882     repodata_internalize(data);
883   return p;
884 }
885
886 static int
887 is_sig_packet(unsigned char *sig, int sigl)
888 {
889   if (!sigl)
890     return 0;
891   if ((sig[0] & 0x80) == 0 || (sig[0] & 0x40 ? sig[0] & 0x3f : sig[0] >> 2 & 0x0f) != 2)
892     return 0;
893   return 1;
894 }
895
896 static int
897 is_pubkey_packet(unsigned char *pkt, int pktl)
898 {
899   if (!pktl)
900     return 0;
901   if ((pkt[0] & 0x80) == 0 || (pkt[0] & 0x40 ? pkt[0] & 0x3f : pkt[0] >> 2 & 0x0f) != 6)
902     return 0;
903   return 1;
904 }
905
906 static void
907 add_one_pubkey(Pool *pool, Repo *repo, Repodata *data, unsigned char *pbuf, int pbufl, int flags)
908 {
909   Id p = repo_add_solvable(repo);
910   char *solvversion = pool_tmpjoin(pool, "libsolv-", LIBSOLV_VERSION_STRING, 0);
911   char *descr = armor(pbuf, pbufl, "-----BEGIN PGP PUBLIC KEY BLOCK-----", "-----END PGP PUBLIC KEY BLOCK-----", solvversion);
912   setutf8string(data, p, SOLVABLE_DESCRIPTION, descr);
913   parsepubkey(pool->solvables + p, data, pbuf, pbufl, flags);
914 }
915
916 int
917 repo_add_keyring(Repo *repo, FILE *fp, int flags)
918 {
919   Pool *pool = repo->pool;
920   Repodata *data;
921   unsigned char *buf, *p, *pbuf;
922   int bufl, l, pl, pbufl;
923
924   data = repo_add_repodata(repo, flags);
925   buf = (unsigned char *)solv_slurp(fp, &bufl);
926   if (buf && !is_pubkey_packet(buf, bufl))
927     {
928       /* assume ascii armored */
929       unsigned char *nbuf = 0, *ubuf;
930       int nl, ubufl;
931       bufl = 0;
932       for (l = 0; (nl = unarmor((char *)buf + l, &ubuf, &ubufl, "-----BEGIN PGP PUBLIC KEY BLOCK-----", "-----END PGP PUBLIC KEY BLOCK-----")) != 0; l += nl)
933         {
934           /* found another block. concat. */
935           nbuf = solv_realloc(nbuf, bufl + ubufl);
936           if (ubufl)
937             memcpy(nbuf + bufl, ubuf, ubufl);
938           bufl += ubufl;
939           solv_free(ubuf);
940         }
941       solv_free(buf);
942       buf = nbuf;
943     }
944   /* now split into pubkey parts, ignoring the packets we don't know */
945   pbuf = 0;
946   pbufl = 0;
947   for (p = buf; bufl; p += pl, bufl -= pl)
948     {
949       int tag;
950       int hl = parsepkgheader(p, bufl, &tag, &pl);
951       if (!hl)
952         break;
953       pl += hl;
954       if (tag == 6)
955         {
956           /* found new pubkey! flush old */
957           if (pbufl)
958             {
959               add_one_pubkey(pool, repo, data, pbuf, pbufl, flags);
960               pbuf = solv_free(pbuf);
961               pbufl = 0;
962             }
963         }
964       if (tag != 6 && !pbufl)
965         continue;
966       if (tag != 6 && tag != 2 && tag != 13 && tag != 14 && tag != 17)
967         continue;
968       /* we want that packet. concat. */
969       pbuf = solv_realloc(pbuf, pbufl + pl);
970       memcpy(pbuf + pbufl, p, pl);
971       pbufl += pl;
972     }
973   if (pbufl)
974     add_one_pubkey(pool, repo, data, pbuf, pbufl, flags);
975   solv_free(pbuf);
976   solv_free(buf);
977   if (!(flags & REPO_NO_INTERNALIZE))
978     repodata_internalize(data);
979   return 0;
980 }
981
982 int
983 repo_add_keydir(Repo *repo, const char *keydir, const char *suffix, int flags)
984 {
985   Pool *pool = repo->pool;
986   Repodata *data;
987   int i, nent, sl;
988   struct dirent **namelist;
989   char *rkeydir;
990
991   data = repo_add_repodata(repo, flags);
992   nent = scandir(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, keydir) : keydir, &namelist, 0, alphasort);
993   if (nent == -1)
994     return pool_error(pool, -1, "%s: %s", keydir, strerror(errno));
995   rkeydir = pool_prepend_rootdir(pool, keydir);
996   sl = suffix ? strlen(suffix) : 0;
997   for (i = 0; i < nent; i++)
998     {
999       const char *dn = namelist[i]->d_name;
1000       int l;
1001       if (*dn == '.' && !(flags & ADD_KEYDIR_WITH_DOTFILES))
1002         continue;
1003       l = strlen(dn);
1004       if (sl && (l < sl || strcmp(dn + l - sl, suffix) != 0))
1005         continue;
1006       repo_add_pubkey(repo, pool_tmpjoin(pool, rkeydir, "/", dn), flags | REPO_REUSE_REPODATA);
1007     }
1008   solv_free(rkeydir);
1009   for (i = 0; i < nent; i++)
1010     solv_free(namelist[i]);
1011   solv_free(namelist);
1012   if (!(flags & REPO_NO_INTERNALIZE))
1013     repodata_internalize(data);
1014   return 0;
1015 }
1016
1017 Solvsig *
1018 solvsig_create(FILE *fp)
1019 {
1020   Solvsig *ss;
1021   unsigned char *sig;
1022   int sigl, hl, tag, pktl;
1023   struct pgpsig pgpsig;
1024
1025   if ((sig = (unsigned char *)solv_slurp(fp, &sigl)) == 0)
1026     return 0;
1027   if (!is_sig_packet(sig, sigl))
1028     {
1029       /* not a raw sig, check armored */
1030       unsigned char *nsig;
1031       if (!unarmor((char *)sig, &nsig, &sigl, "-----BEGIN PGP SIGNATURE-----", "-----END PGP SIGNATURE-----"))
1032         {
1033           solv_free(sig);
1034           return 0;
1035         }
1036       solv_free(sig);
1037       sig = nsig;
1038       if (!is_sig_packet(sig, sigl))
1039         {
1040           solv_free(sig);
1041           return 0;
1042         }
1043     }
1044   hl = parsepkgheader(sig, sigl, &tag, &pktl);
1045   if (!hl || tag != 2 || !pktl)
1046     {
1047       solv_free(sig);
1048       return 0;
1049     }
1050   pgpsig_init(&pgpsig, sig + hl, pktl);
1051   if (pgpsig.type != 0 || !pgpsig.haveissuer)
1052     {
1053       solv_free(sig);
1054       return 0;
1055     }
1056   ss = solv_calloc(1, sizeof(*ss));
1057   ss->sigpkt = solv_memdup(sig + hl, pktl);
1058   ss->sigpktl = pktl;
1059   solv_free(sig);
1060   solv_bin2hex(pgpsig.issuer, 8, ss->keyid);
1061   ss->htype = pgphashalgo2type(pgpsig.hashalgo);
1062   ss->created = pgpsig.created;
1063   ss->expires = pgpsig.expires;
1064   return ss;
1065 }
1066
1067 void
1068 solvsig_free(Solvsig *ss)
1069 {
1070   solv_free(ss->sigpkt);
1071   solv_free(ss);
1072 }
1073
1074 static int
1075 repo_find_all_pubkeys_cmp(const void *va, const void *vb, void *dp)
1076 {
1077   Pool *pool = dp;
1078   Id a = *(Id *)va;
1079   Id b = *(Id *)vb;
1080   /* cannot use evrcmp, as rpm says '0' > 'a' */
1081   return strcmp(pool_id2str(pool, pool->solvables[b].evr), pool_id2str(pool, pool->solvables[a].evr));
1082 }
1083
1084 void
1085 repo_find_all_pubkeys(Repo *repo, const char *keyid, Queue *q)
1086 {
1087   Id p;
1088   Solvable *s;
1089
1090   queue_empty(q);
1091   if (!keyid)
1092     return;
1093   queue_init(q);
1094   FOR_REPO_SOLVABLES(repo, p, s)
1095     {
1096       const char *kidstr, *evr = pool_id2str(s->repo->pool, s->evr);
1097
1098       if (!evr || strncmp(evr, keyid + 8, 8) != 0)
1099        continue;
1100       kidstr = solvable_lookup_str(s, PUBKEY_KEYID);
1101       if (kidstr && !strcmp(kidstr, keyid))
1102         queue_push(q, p);
1103     }
1104   if (q->count > 1)
1105     solv_sort(q->elements, q->count, sizeof(Id), repo_find_all_pubkeys_cmp, repo->pool);
1106 }
1107
1108 Id
1109 repo_find_pubkey(Repo *repo, const char *keyid)
1110 {
1111   Queue q;
1112   Id p;
1113   queue_init(&q);
1114   repo_find_all_pubkeys(repo, keyid, &q);
1115   p = q.count ? q.elements[0] : 0;
1116   queue_free(&q);
1117   return p;
1118 }
1119
1120 #ifdef ENABLE_PGPVRFY
1121
1122 /* warning: does not check key expiry/revokation, same as with gpgv or rpm */
1123 /* returns the Id of the pubkey that verified the signature */
1124 Id
1125 repo_verify_sigdata(Repo *repo, unsigned char *sigdata, int sigdatal, const char *keyid)
1126 {
1127   Id p;
1128   Queue q;
1129   int i;
1130
1131   if (!sigdata || !keyid)
1132     return 0;
1133   queue_init(&q);
1134   repo_find_all_pubkeys(repo, keyid, &q);
1135   for (i = 0; i < q.count; i++)
1136     {
1137       int pubdatal;
1138       const unsigned char *pubdata = repo_lookup_binary(repo, q.elements[i], PUBKEY_DATA, &pubdatal);
1139       if (pubdata && solv_pgpvrfy(pubdata, pubdatal, sigdata, sigdatal))
1140         break;
1141     }
1142   p = i < q.count? q.elements[i] : 0;
1143   queue_free(&q);
1144   return p;
1145 }
1146
1147 Id
1148 solvsig_verify(Solvsig *ss, Repo *repo, Chksum *chk)
1149 {
1150   struct pgpsig pgpsig;
1151   void *chk2;
1152   Id p;
1153
1154   if (!chk || solv_chksum_isfinished(chk))
1155     return 0;
1156   pgpsig_init(&pgpsig, ss->sigpkt, ss->sigpktl);
1157   chk2 = solv_chksum_create_clone(chk);
1158   pgpsig_makesigdata(&pgpsig, ss->sigpkt, ss->sigpktl, 0, 0, 0, 0, chk2);
1159   solv_chksum_free(chk2, 0);
1160   if (!pgpsig.sigdata)
1161     return 0;
1162   p = repo_verify_sigdata(repo, pgpsig.sigdata, pgpsig.sigdatal, ss->keyid);
1163   solv_free(pgpsig.sigdata);
1164   return p;
1165 }
1166
1167 #endif
1168