contrib/file/src/der.c

   1 /*-
   2  * Copyright (c) 2016 Christos Zoulas
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  15  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  16  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24  * POSSIBILITY OF SUCH DAMAGE.
  25  */
  26 /*
  27  * DER (Distinguished Encoding Rules) Parser
  28  *
  29  * Sources:
  30  * https://en.wikipedia.org/wiki/X.690
  31  * http://fm4dd.com/openssl/certexamples.htm
  32  * http://blog.engelke.com/2014/10/17/parsing-ber-and-der-encoded-asn-1-objects/
  33  */
  34 #ifndef TEST_DER
  35 #include "file.h"
  36
  37 #ifndef lint
  38 FILE_RCSID("@(#)$File: der.c,v 1.12 2017/02/10 18:14:01 christos Exp $")
  39 #endif
  40 #endif
  41
  42 #include <sys/types.h>
  43
  44 #include <stdio.h>
  45 #include <fcntl.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <ctype.h>
  49
  50 #ifndef TEST_DER
  51 #include "magic.h"
  52 #include "der.h"
  53 #else
  54 #include <sys/mman.h>
  55 #include <sys/stat.h>
  56 #include <err.h>
  57 #endif
  58
  59 #define DER_BAD ((uint32_t)-1)
  60
  61 #define DER_CLASS_UNIVERSAL     0
  62 #define DER_CLASS_APPLICATION   1
  63 #define DER_CLASS_CONTEXT       2
  64 #define DER_CLASS_PRIVATE       3
  65 #ifdef DEBUG_DER
  66 static const char der_class[] = "UACP";
  67 #endif
  68
  69 #define DER_TYPE_PRIMITIVE      0
  70 #define DER_TYPE_CONSTRUCTED    1
  71 #ifdef DEBUG_DER
  72 static const char der_type[] = "PC";
  73 #endif
  74
  75 #define DER_TAG_EOC                     0x00
  76 #define DER_TAG_BOOLEAN                 0x01
  77 #define DER_TAG_INTEGER                 0x02
  78 #define DER_TAG_BIT STRING              0x03
  79 #define DER_TAG_OCTET_STRING            0x04
  80 #define DER_TAG_NULL                    0x05
  81 #define DER_TAG_OBJECT_IDENTIFIER       0x06
  82 #define DER_TAG_OBJECT_DESCRIPTOR       0x07
  83 #define DER_TAG_EXTERNAL                0x08
  84 #define DER_TAG_REAL                    0x09
  85 #define DER_TAG_ENUMERATED              0x0a
  86 #define DER_TAG_EMBEDDED_PDV            0x0b
  87 #define DER_TAG_UTF8_STRING             0x0c
  88 #define DER_TAG_RELATIVE_OID            0x0d
  89 #define DER_TAG_RESERVED_1              0x0e
  90 #define DER_TAG_RESERVED_2              0x0f
  91 #define DER_TAG_SEQUENCE                0x10
  92 #define DER_TAG_SET                     0x11
  93 #define DER_TAG_NUMERIC_STRING          0x12
  94 #define DER_TAG_PRINTABLE_STRING        0x13
  95 #define DER_TAG_T61_STRING              0x14
  96 #define DER_TAG_VIDEOTEX_STRING         0x15
  97 #define DER_TAG_IA5_STRING              0x16
  98 #define DER_TAG_UTCTIME                 0x17
  99 #define DER_TAG_GENERALIZED_TIME        0x18
 100 #define DER_TAG_GRAPHIC_STRING          0x19
 101 #define DER_TAG_VISIBLE_STRING          0x1a
 102 #define DER_TAG_GENERAL_STRING          0x1b
 103 #define DER_TAG_UNIVERSAL_STRING        0x1c
 104 #define DER_TAG_CHARACTER_STRING        0x1d
 105 #define DER_TAG_BMP_STRING              0x1e
 106 #define DER_TAG_LONG                    0x1f
 107
 108 static const char *der__tag[] = {
 109         "eoc", "bool", "int", "bit_str", "octet_str",
 110         "null", "obj_id", "obj_desc", "ext", "real",
 111         "enum", "embed", "utf8_str", "oid", "res1",
 112         "res2", "seq", "set", "num_str", "prt_str",
 113         "t61_str", "vid_str", "ia5_str", "utc_time",
 114         "gen_time", "gr_str", "vis_str", "gen_str",
 115         "char_str", "bmp_str", "long"
 116 };
 117
 118 #ifdef DEBUG_DER
 119 #define DPRINTF(a) printf a
 120 #else
 121 #define DPRINTF(a)
 122 #endif
 123
 124 #ifdef TEST_DER
 125 static uint8_t
 126 getclass(uint8_t c)
 127 {
 128         return c >> 6;
 129 }
 130
 131 static uint8_t
 132 gettype(uint8_t c)
 133 {
 134         return (c >> 5) & 1;
 135 }
 136 #endif
 137
 138 static uint32_t
 139 gettag(const uint8_t *c, size_t *p, size_t l)
 140 {
 141         uint32_t tag;
 142
 143         if (*p >= l)
 144                 return DER_BAD;
 145
 146         tag = c[(*p)++] & 0x1f;
 147
 148         if (tag != 0x1f)
 149                 return tag;
 150
 151         if (*p >= l)
 152                 return DER_BAD;
 153
 154         while (c[*p] >= 0x80) {
 155                 tag = tag * 128 + c[(*p)++] - 0x80;
 156                 if (*p >= l)
 157                         return DER_BAD;
 158         }
 159         return tag;
 160 }
 161
 162 /*
 163  * Read the length of a DER tag from the input.
 164  *
 165  * `c` is the input, `p` is an output parameter that specifies how much of the
 166  * input we consumed, and `l` is the maximum input length.
 167  *
 168  * Returns the length, or DER_BAD if the end of the input is reached or the
 169  * length exceeds the remaining input.
 170  */
 171 static uint32_t
 172 getlength(const uint8_t *c, size_t *p, size_t l)
 173 {
 174         uint8_t digits, i;
 175         size_t len;
 176         int is_onebyte_result;
 177
 178         if (*p >= l)
 179                 return DER_BAD;
 180
 181         /*
 182          * Digits can either be 0b0 followed by the result, or 0b1
 183          * followed by the number of digits of the result. In either case,
 184          * we verify that we can read so many bytes from the input.
 185          */
 186         is_onebyte_result = (c[*p] & 0x80) == 0;
 187         digits = c[(*p)++] & 0x7f;
 188         if (*p + digits >= l)
 189                 return DER_BAD;
 190
 191         if (is_onebyte_result)
 192                 return digits;
 193
 194         /*
 195          * Decode len. We've already verified that we're allowed to read
 196          * `digits` bytes.
 197          */
 198         len = 0;
 199         for (i = 0; i < digits; i++)
 200                 len = (len << 8) | c[(*p)++];
 201
 202         if (*p + len >= l)
 203                 return DER_BAD;
 204         return CAST(uint32_t, len);
 205 }
 206
 207 static const char *
 208 der_tag(char *buf, size_t len, uint32_t tag)
 209 {
 210         if (tag < DER_TAG_LONG)
 211                 strlcpy(buf, der__tag[tag], len);
 212         else
 213                 snprintf(buf, len, "%#x", tag);
 214         return buf;
 215 }
 216
 217 #ifndef TEST_DER
 218 static int
 219 der_data(char *buf, size_t blen, uint32_t tag, const void *q, uint32_t len)
 220 {
 221         const uint8_t *d = CAST(const uint8_t *, q);
 222         switch (tag) {
 223         case DER_TAG_PRINTABLE_STRING:
 224         case DER_TAG_UTF8_STRING:
 225         case DER_TAG_IA5_STRING:
 226         case DER_TAG_UTCTIME:
 227                 return snprintf(buf, blen, "%.*s", len, (const char *)q);
 228         default:
 229                 break;
 230         }
 231
 232         for (uint32_t i = 0; i < len; i++) {
 233                 uint32_t z = i << 1;
 234                 if (z < blen - 2)
 235                         snprintf(buf + z, blen - z, "%.2x", d[i]);
 236         }
 237         return len * 2;
 238 }
 239
 240 int32_t
 241 der_offs(struct magic_set *ms, struct magic *m, size_t nbytes)
 242 {
 243         const uint8_t *b = RCAST(const uint8_t *, ms->search.s);
 244         size_t offs = 0, len = ms->search.s_len ? ms->search.s_len : nbytes;
 245
 246         if (gettag(b, &offs, len) == DER_BAD)
 247                 return -1;
 248         DPRINTF(("%s1: %d %zu %u\n", __func__, ms->offset, offs, m->offset));
 249
 250         uint32_t tlen = getlength(b, &offs, len);
 251         if (tlen == DER_BAD)
 252                 return -1;
 253         DPRINTF(("%s2: %d %zu %u\n", __func__, ms->offset, offs, tlen));
 254
 255         offs += ms->offset + m->offset;
 256         DPRINTF(("cont_level = %d\n", m->cont_level));
 257 #ifdef DEBUG_DER
 258         for (size_t i = 0; i < m->cont_level; i++)
 259                 printf("cont_level[%zu] = %u\n", i, ms->c.li[i].off);
 260 #endif
 261         if (m->cont_level != 0) {
 262                 if (offs + tlen > nbytes)
 263                         return -1;
 264                 ms->c.li[m->cont_level - 1].off = CAST(int, offs + tlen);
 265                 DPRINTF(("cont_level[%u] = %u\n", m->cont_level - 1,
 266                     ms->c.li[m->cont_level - 1].off));
 267         }
 268         return CAST(int32_t, offs);
 269 }
 270
 271 int
 272 der_cmp(struct magic_set *ms, struct magic *m)
 273 {
 274         const uint8_t *b = RCAST(const uint8_t *, ms->search.s);
 275         const char *s = m->value.s;
 276         size_t offs = 0, len = ms->search.s_len;
 277         uint32_t tag, tlen;
 278         char buf[128];
 279
 280         tag = gettag(b, &offs, len);
 281         if (tag == DER_BAD)
 282                 return -1;
 283
 284         tlen = getlength(b, &offs, len);
 285         if (tlen == DER_BAD)
 286                 return -1;
 287
 288         der_tag(buf, sizeof(buf), tag);
 289         if ((ms->flags & MAGIC_DEBUG) != 0)
 290                 fprintf(stderr, "%s: tag %p got=%s exp=%s\n", __func__, b,
 291                     buf, s);
 292         size_t slen = strlen(buf);
 293
 294         if (strncmp(buf, s, slen) != 0)
 295                 return 0;
 296
 297         s += slen;
 298
 299 again:
 300         switch (*s) {
 301         case '\0':
 302                 return 1;
 303         case '=':
 304                 s++;
 305                 goto val;
 306         default:
 307                 if (!isdigit((unsigned char)*s))
 308                         return 0;
 309
 310                 slen = 0;
 311                 do
 312                         slen = slen * 10 + *s - '0';
 313                 while (isdigit((unsigned char)*++s));
 314                 if ((ms->flags & MAGIC_DEBUG) != 0)
 315                         fprintf(stderr, "%s: len %zu %u\n", __func__,
 316                             slen, tlen);
 317                 if (tlen != slen)
 318                         return 0;
 319                 goto again;
 320         }
 321 val:
 322         DPRINTF(("%s: before data %zu %u\n", __func__, offs, tlen));
 323         der_data(buf, sizeof(buf), tag, b + offs, tlen);
 324         if ((ms->flags & MAGIC_DEBUG) != 0)
 325                 fprintf(stderr, "%s: data %s %s\n", __func__, buf, s);
 326         if (strcmp(buf, s) != 0 && strcmp("x", s) != 0)
 327                 return 0;
 328         strlcpy(ms->ms_value.s, buf, sizeof(ms->ms_value.s));
 329         return 1;
 330 }
 331 #endif
 332
 333 #ifdef TEST_DER
 334 static void
 335 printtag(uint32_t tag, const void *q, uint32_t len)
 336 {
 337         const uint8_t *d = q;
 338         switch (tag) {
 339         case DER_TAG_PRINTABLE_STRING:
 340         case DER_TAG_UTF8_STRING:
 341                 printf("%.*s\n", len, (const char *)q);
 342                 return;
 343         default:
 344                 break;
 345         }
 346
 347         for (uint32_t i = 0; i < len; i++)
 348                 printf("%.2x", d[i]);
 349         printf("\n");
 350 }
 351
 352 static void
 353 printdata(size_t level, const void *v, size_t x, size_t l)
 354 {
 355         const uint8_t *p = v, *ep = p + l;
 356         size_t ox;
 357         char buf[128];
 358
 359         while (p + x < ep) {
 360                 const uint8_t *q;
 361                 uint8_t c = getclass(p[x]);
 362                 uint8_t t = gettype(p[x]);
 363                 ox = x;
 364                 if (x != 0)
 365                 printf("%.2x %.2x %.2x\n", p[x - 1], p[x], p[x + 1]);
 366                 uint32_t tag = gettag(p, &x, ep - p + x);
 367                 if (p + x >= ep)
 368                         break;
 369                 uint32_t len = getlength(p, &x, ep - p + x);
 370
 371                 printf("%zu %zu-%zu %c,%c,%s,%u:", level, ox, x,
 372                     der_class[c], der_type[t],
 373                     der_tag(buf, sizeof(buf), tag), len);
 374                 q = p + x;
 375                 if (p + len > ep)
 376                         errx(EXIT_FAILURE, "corrupt der");
 377                 printtag(tag, q, len);
 378                 if (t != DER_TYPE_PRIMITIVE)
 379                         printdata(level + 1, p, x, len + x);
 380                 x += len;
 381         }
 382 }
 383
 384 int
 385 main(int argc, char *argv[])
 386 {
 387         int fd;
 388         struct stat st;
 389         size_t l;
 390         void *p;
 391
 392         if ((fd = open(argv[1], O_RDONLY)) == -1)
 393                 err(EXIT_FAILURE, "open `%s'", argv[1]);
 394         if (fstat(fd, &st) == -1)
 395                 err(EXIT_FAILURE, "stat `%s'", argv[1]);
 396         l = (size_t)st.st_size;
 397         if ((p = mmap(NULL, l, PROT_READ, MAP_FILE, fd, 0)) == MAP_FAILED)
 398                 err(EXIT_FAILURE, "mmap `%s'", argv[1]);
 399
 400         printdata(0, p, 0, l);
 401         munmap(p, l);
 402         return 0;
 403 }
 404 #endif