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