2 * Copyright (c) 2007-2013, Novell Inc.
4 * This program is licensed under the BSD license, read LICENSE.BSD
5 * for further information
11 * support for pubkey reading
15 #include <sys/types.h>
27 #include <rpm/rpmio.h>
28 #include <rpm/rpmpgp.h>
30 #include <rpm/header.h>
32 #include <rpm/rpmdb.h>
40 #include "repo_rpmdb.h"
42 #include "solv_pgpvrfy.h"
46 setutf8string(Repodata *repodata, Id handle, Id tag, const char *str)
48 if (str[solv_validutf8(str)])
50 char *ustr = solv_latin1toutf8(str); /* not utf8, assume latin1 */
51 repodata_set_str(repodata, handle, tag, ustr);
55 repodata_set_str(repodata, handle, tag, str);
59 r64dec1(char *p, unsigned int *vp, int *eofp)
69 if (x >= 'A' && x <= 'Z')
71 else if (x >= 'a' && x <= 'z')
73 else if (x >= '0' && x <= '9')
100 crc24(unsigned char *p, int len)
102 unsigned int crc = 0xb704ceL;
108 for (i = 0; i < 8; i++)
109 if ((crc <<= 1) & 0x1000000)
112 return crc & 0xffffffL;
115 static unsigned char *
116 unarmor(char *pubkey, int *pktlp, char *startstr, char *endstr)
120 unsigned char *buf, *bp;
126 l = strlen(startstr);
127 while (strncmp(pubkey, startstr, l) != 0)
129 pubkey = strchr(pubkey, '\n');
134 pubkey = strchr(pubkey, '\n');
137 /* skip header lines */
140 while (*pubkey == ' ' || *pubkey == '\t')
144 pubkey = strchr(pubkey, '\n');
149 p = strchr(pubkey, '=');
153 bp = buf = solv_malloc(l * 3 / 4 + 4);
157 pubkey = r64dec1(pubkey, &v, &eof);
167 while (*pubkey == ' ' || *pubkey == '\t' || *pubkey == '\n' || *pubkey == '\r')
170 if (*pubkey != '=' || (pubkey = r64dec1(pubkey + 1, &v, &eof)) == 0)
175 if (v != crc24(buf, bp - buf))
180 while (*pubkey == ' ' || *pubkey == '\t' || *pubkey == '\n' || *pubkey == '\r')
182 if (strncmp(pubkey, endstr, strlen(endstr)) != 0)
194 unsigned char issuer[8];
196 unsigned int created;
197 unsigned int expires;
198 unsigned int keyexpires;
199 unsigned char *sigdata;
205 pgphashalgo2type(int algo)
208 return REPOKEY_TYPE_MD5;
210 return REPOKEY_TYPE_SHA1;
212 return REPOKEY_TYPE_SHA256;
217 createsigdata(struct pgpsig *sig, unsigned char *p, int l, unsigned char *pubkey, int pubkeyl, unsigned char *userid, int useridl, void *h)
219 int type = sig->type;
221 const unsigned char *cs;
224 if (sig->mpioff < 2 || l <= sig->mpioff)
226 if ((type >= 0x10 && type <= 0x13) || type == 0x1f || type == 0x18 || type == 0x20 || type == 0x28)
231 solv_chksum_add(h, b, 3);
232 solv_chksum_add(h, pubkey, pubkeyl);
234 if ((type >= 0x10 && type <= 0x13))
239 b[1] = useridl >> 24;
240 b[2] = useridl >> 16;
243 solv_chksum_add(h, b, 5);
245 solv_chksum_add(h, userid, useridl);
249 solv_chksum_add(h, p + 2, 5);
252 int hl = 6 + (p[4] << 8 | p[5]);
253 solv_chksum_add(h, p, hl);
260 solv_chksum_add(h, b, 6);
262 cs = solv_chksum_get(h, &csl);
263 if (cs[0] == p[sig->mpioff - 2] && cs[1] == p[sig->mpioff - 1])
265 int ml = l - sig->mpioff;
266 sig->sigdata = solv_malloc(2 + csl + ml);
267 sig->sigdatal = 2 + csl + ml;
268 sig->sigdata[0] = p[0] == 3 ? p[15] : p[2];
269 sig->sigdata[1] = p[0] == 3 ? p[16] : p[3];
270 memcpy(sig->sigdata + 2, cs, csl);
271 memcpy(sig->sigdata + 2 + csl, p + sig->mpioff, ml);
276 parsesubpkglength(unsigned char *q, int ql, int *pktlp)
279 /* decode sub-packet length, ql must be > 0 */
288 if (ql < 5 || q[0] != 0)
290 sl = q[1] << 16 | q[2] << 8 | q[3];
297 sl = ((x - 192) << 8) + q[0] + 192;
300 if (!sl || ql < sl + hl) /* sub pkg tag is included in length, i.e. sl must not be zero */
307 parsesigpacket(struct pgpsig *sig, unsigned char *p, int l)
312 /* printf("V3 signature packet\n"); */
313 if (l <= 19 || p[1] != 5)
317 memcpy(sig->issuer, p + 7, 8);
318 sig->created = p[3] << 24 | p[4] << 16 | p[5] << 8 | p[6];
319 sig->hashalgo = p[16];
327 /* printf("V4 signature packet\n"); */
331 sig->hashalgo = p[3];
333 sig->keyexpires = -1;
334 for (j = 0; q && j < 2; j++)
341 ql = q[0] << 8 | q[1];
351 hl = parsesubpkglength(q, ql, &sl);
359 x = q[0] & 127; /* strip critical bit */
360 /* printf("%d SIGSUB %d %d\n", j, x, sl); */
361 if (x == 16 && sl == 9 && !sig->haveissuer)
364 memcpy(sig->issuer, q + 1, 8);
366 if (x == 2 && j == 0)
367 sig->created = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
368 if (x == 3 && j == 0)
369 sig->expires = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
370 if (x == 9 && j == 0)
371 sig->keyexpires = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
376 if (q && q - p + 2 < l)
377 sig->mpioff = q - p + 2;
382 parsepkgheader(unsigned char *p, int pl, int *tagp, int *pktlp)
384 unsigned char *op = p;
391 if (!(x & 128) || pl <= 0)
395 *tagp = (x & 0x3c) >> 2; /* old format */
397 if (x > 4 || pl < x || (x == 4 && p[0]))
405 *tagp = (x & 0x3f); /* new format */
410 else if (x >= 192 && x < 224)
414 l = ((x - 192) << 8) + *p++ + 192;
419 if (pl <= 4 || p[0] != 0) /* sanity: p[0] must be zero */
421 l = p[1] << 16 | p[2] << 8 | p[3];
436 parsekeydata(Solvable *s, Repodata *data, unsigned char *p, int pl)
439 unsigned char keyid[8];
440 unsigned int kcr = 0, maxex = 0, maxsigcr = 0;
441 unsigned char *pubkey = 0;
443 unsigned char *userid = 0;
445 unsigned char *pubdata = 0;
448 for (; pl; p += l, pl -= l)
450 int hl = parsepkgheader(p, pl, &tag, &l);
458 break; /* one key at a time, please */
459 pubkey = solv_malloc(l);
461 memcpy(pubkey, p, l);
463 if (p[0] == 3 && l >= 10)
467 maxsigcr = kcr = p[1] << 24 | p[2] << 16 | p[3] << 8 | p[4];
471 ex = kcr + 24*3600 * (p[5] << 8 | p[6]);
476 if (p[7] == 1) /* RSA */
479 unsigned char fp[16];
483 ql = ((p[8] << 8 | p[9]) + 7) / 8; /* length of public modulus */
484 if (ql >= 8 && 10 + ql + 2 <= l)
486 memcpy(keyid, p + 10 + ql - 8, 8); /* keyid is last 64 bits of public modulus */
488 ql2 = ((q[0] << 8 | q[1]) + 7) / 8; /* length of encryption exponent */
489 if (10 + ql + 2 + ql2 <= l)
491 /* fingerprint is the md5 over the two MPI bodies */
492 h = solv_chksum_create(REPOKEY_TYPE_MD5);
493 solv_chksum_add(h, p + 10, ql);
494 solv_chksum_add(h, q + 2, ql2);
495 solv_chksum_free(h, fp);
496 solv_bin2hex(fp, 16, fpx);
497 repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
504 else if (p[0] == 4 && l >= 6)
507 unsigned char hdr[3];
508 unsigned char fp[20];
511 maxsigcr = kcr = p[1] << 24 | p[2] << 16 | p[3] << 8 | p[4];
515 /* fingerprint is the sha1 over the packet */
516 h = solv_chksum_create(REPOKEY_TYPE_SHA1);
517 solv_chksum_add(h, hdr, 3);
518 solv_chksum_add(h, p, l);
519 solv_chksum_free(h, fp);
520 solv_bin2hex(fp, 20, fpx);
521 repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
522 memcpy(keyid, fp + 12, 8); /* keyid is last 64 bits of fingerprint */
533 memset(&sig, 0, sizeof(sig));
534 parsesigpacket(&sig, p, l);
535 if (!sig.haveissuer || !((sig.type >= 0x10 && sig.type <= 0x13) || sig.type == 0x1f))
537 if (sig.type >= 0x10 && sig.type <= 0x13 && !userid)
539 htype = pgphashalgo2type(sig.hashalgo);
540 if (htype && sig.mpioff)
542 void *h = solv_chksum_create(htype);
543 createsigdata(&sig, p, l, pubkey, pubkeyl, userid, useridl, h);
544 solv_chksum_free(h, 0);
546 if (!memcmp(keyid, sig.issuer, 8))
548 #ifdef ENABLE_PGPVRFY
549 /* found self sig, verify */
550 if (solv_pgpvrfy(pubdata, pubdatal, sig.sigdata, sig.sigdatal))
553 if (sig.keyexpires && maxex != -1)
555 if (sig.keyexpires == -1)
557 else if (sig.keyexpires + kcr > maxex)
558 maxex = sig.keyexpires + kcr;
560 if (sig.created > maxsigcr)
561 maxsigcr = sig.created;
567 Id shandle = repodata_new_handle(data);
568 solv_bin2hex(sig.issuer, 8, issuerstr);
569 repodata_set_str(data, shandle, SIGNATURE_ISSUER, issuerstr);
571 repodata_set_num(data, shandle, SIGNATURE_TIME, sig.created);
573 repodata_set_num(data, shandle, SIGNATURE_EXPIRES, sig.created + sig.expires);
575 repodata_set_binary(data, shandle, SIGNATURE_DATA, sig.sigdata, sig.sigdatal);
576 repodata_add_flexarray(data, s - s->repo->pool->solvables, PUBKEY_SIGNATURES, shandle);
578 solv_free(sig.sigdata);
582 userid = solv_realloc(userid, l);
584 memcpy(userid, p, l);
589 repodata_set_num(data, s - s->repo->pool->solvables, SOLVABLE_BUILDTIME, kcr);
590 if (maxex && maxex != -1)
591 repodata_set_num(data, s - s->repo->pool->solvables, PUBKEY_EXPIRES, maxex);
592 s->name = pool_str2id(s->repo->pool, "gpg-pubkey", 1);
595 if (userid && useridl)
597 char *useridstr = solv_malloc(useridl + 1);
598 memcpy(useridstr, userid, useridl);
599 useridstr[useridl] = 0;
600 setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_SUMMARY, useridstr);
606 solv_bin2hex(keyid, 8, keyidstr);
607 repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_KEYID, keyidstr);
611 /* build rpm-style evr */
612 char evr[8 + 1 + 8 + 1];
613 solv_bin2hex(keyid + 4, 4, evr);
614 sprintf(evr + 8, "-%08x", maxsigcr);
615 s->evr = pool_str2id(s->repo->pool, evr, 1);
617 repodata_set_binary(data, s - s->repo->pool->solvables, PUBKEY_DATA, pubdata, pubdatal);
626 /* this is private to rpm, but rpm lacks an interface to retrieve
627 * the values. Sigh. */
628 struct pgpDigParams_s {
630 const unsigned char * hash;
631 #ifndef HAVE_PGPDIGGETPARAMS
632 const char * params[4];
635 unsigned char version; /*!< version number. */
636 unsigned char time[4]; /*!< time that the key was created. */
637 unsigned char pubkey_algo; /*!< public key algorithm. */
638 unsigned char hash_algo;
639 unsigned char sigtype;
640 unsigned char hashlen;
641 unsigned char signhash16[2];
642 unsigned char signid[8];
646 #ifndef HAVE_PGPDIGGETPARAMS
648 struct pgpDigParams_s signature;
649 struct pgpDigParams_s pubkey;
654 /* only rpm knows how to do the release calculation, we don't dare
655 * to recreate all the bugs in libsolv */
657 parsekeydata_rpm(Solvable *s, Repodata *data, unsigned char *pkts, int pktsl)
659 Pool *pool = s->repo->pool;
660 struct pgpDigParams_s *digpubkey;
663 char evrbuf[8 + 1 + 8 + 1];
669 dig = pgpDigNew(RPMVSF_DEFAULT, 0);
671 (void) pgpPrtPkts(pkts, pktsl, dig, 0);
672 #ifdef HAVE_PGPDIGGETPARAMS
673 digpubkey = pgpDigGetParams(dig, PGPTAG_PUBLIC_KEY);
675 digpubkey = &dig->pubkey;
679 btime = digpubkey->time[0] << 24 | digpubkey->time[1] << 16 | digpubkey->time[2] << 8 | digpubkey->time[3];
680 solv_bin2hex(digpubkey->signid, 8, keyid);
681 solv_bin2hex(digpubkey->signid + 4, 4, evrbuf);
683 solv_bin2hex(digpubkey->time, 4, evrbuf + 9);
684 s->evr = pool_str2id(pool, evrbuf, 1);
685 repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_KEYID, keyid);
686 if (digpubkey->userid)
687 setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_SUMMARY, digpubkey->userid);
689 repodata_set_num(data, s - s->repo->pool->solvables, SOLVABLE_BUILDTIME, btime);
692 (void)pgpFreeDig(dig);
694 (void)pgpDigFree(dig);
698 #endif /* ENABLE_RPMDB */
701 pubkey2solvable(Solvable *s, Repodata *data, char *pubkey)
706 pkts = unarmor(pubkey, &pktsl, "-----BEGIN PGP PUBLIC KEY BLOCK-----", "-----END PGP PUBLIC KEY BLOCK-----");
709 pool_error(s->repo->pool, 0, "unarmor failure");
712 setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_DESCRIPTION, pubkey);
713 parsekeydata(s, data, pkts, pktsl);
715 parsekeydata_rpm(s, data, pkts, pktsl);
717 solv_free((void *)pkts);
724 repo_add_rpmdb_pubkeys(Repo *repo, int flags)
726 Pool *pool = repo->pool;
732 const char *rootdir = 0;
735 data = repo_add_repodata(repo, flags);
736 if (flags & REPO_USE_ROOTDIR)
737 rootdir = pool_get_rootdir(pool);
738 state = rpm_state_create(repo->pool, rootdir);
740 rpm_installedrpmdbids(state, "Name", "gpg-pubkey", &q);
741 for (i = 0; i < q.count; i++)
744 unsigned long long itime;
746 handle = rpm_byrpmdbid(state, q.elements[i]);
749 str = rpm_query(handle, SOLVABLE_DESCRIPTION);
752 s = pool_id2solvable(pool, repo_add_solvable(repo));
753 pubkey2solvable(s, data, str);
755 itime = rpm_query_num(handle, SOLVABLE_INSTALLTIME, 0);
757 repodata_set_num(data, s - pool->solvables, SOLVABLE_INSTALLTIME, itime);
759 repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
760 repo->rpmdbid[s - pool->solvables - repo->start] = q.elements[i];
763 rpm_state_free(state);
764 if (!(flags & REPO_NO_INTERNALIZE))
765 repodata_internalize(data);
772 solv_slurp(FILE *fp, int *lenp)
778 for (l = 0; ; l += ll)
783 buf = solv_realloc(buf, bufl);
785 ll = fread(buf + l, 1, bufl - l, fp);
788 buf = solv_free(buf);
794 buf[l] = 0; /* always zero-terminate */
804 repo_add_pubkey(Repo *repo, const char *key, int flags)
806 Pool *pool = repo->pool;
812 data = repo_add_repodata(repo, flags);
814 if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, key) : key, "r")) == 0)
816 pool_error(pool, -1, "%s: %s", key, strerror(errno));
819 if ((buf = solv_slurp(fp, 0)) == 0)
821 pool_error(pool, -1, "%s: %s", key, strerror(errno));
826 s = pool_id2solvable(pool, repo_add_solvable(repo));
827 if (!pubkey2solvable(s, data, buf))
829 repo_free_solvable(repo, s - pool->solvables, 1);
834 if (!(flags & REPO_NO_INTERNALIZE))
835 repodata_internalize(data);
836 return s - pool->solvables;
840 is_sig_packet(unsigned char *sig, int sigl)
844 if ((sig[0] & 0x80) == 0 || (sig[0] & 0x40 ? sig[0] & 0x3f : sig[0] >> 2 & 0x0f) != 2)
850 solv_parse_sig(FILE *fp, unsigned char **sigpkgp, int *sigpkglp, char *keyidstr)
853 int sigl, hl, tag, pktl;
854 struct pgpsig pgpsig;
862 if ((sig = (unsigned char *)solv_slurp(fp, &sigl)) == 0)
864 if (!is_sig_packet(sig, sigl))
866 /* not a raw sig, check armored */
868 nsig = unarmor((char *)sig, &sigl, "-----BEGIN PGP SIGNATURE-----", "-----END PGP SIGNATURE-----");
873 if (!is_sig_packet(sig, sigl))
879 hl = parsepkgheader(sig, sigl, &tag, &pktl);
885 memset(&pgpsig, 0, sizeof(pgpsig));
886 parsesigpacket(&pgpsig, sig + hl, pktl);
887 htype = pgphashalgo2type(pgpsig.hashalgo);
888 if (pgpsig.type != 0 || !htype)
901 solv_bin2hex(pgpsig.issuer, 8, keyidstr);
905 #ifdef ENABLE_PGPVRFY
907 solv_verify_sig(const unsigned char *pubdata, int pubdatal, unsigned char *sigpkg, int sigpkgl, void *chk)
909 struct pgpsig pgpsig;
913 memset(&pgpsig, 0, sizeof(pgpsig));
914 parsesigpacket(&pgpsig, sigpkg, sigpkgl);
915 if (pgpsig.type != 0)
917 htype = pgphashalgo2type(pgpsig.hashalgo);
918 if (htype != solv_chksum_get_type(chk))
919 return 0; /* wrong hash type? */
920 createsigdata(&pgpsig, sigpkg, sigpkgl, 0, 0, 0, 0, chk);
923 res = solv_pgpvrfy(pubdata, pubdatal, pgpsig.sigdata, pgpsig.sigdatal);
924 solv_free(pgpsig.sigdata);