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.10 2016/10/24 18:02:17 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 static uint32_t
 163 getlength(const uint8_t *c, size_t *p, size_t l)
 164 {
 165         uint8_t digits, i;
 166         size_t len;
 167
 168         if (*p >= l)
 169                 return DER_BAD;
 170
 171         digits = c[(*p)++];
 172
 173         if ((digits & 0x80) == 0)
 174                 return digits;
 175
 176         digits &= 0x7f;
 177         len = 0;
 178
 179         if (*p + digits >= l)
 180                 return DER_BAD;
 181
 182         for (i = 0; i < digits; i++)
 183                 len = (len << 8) | c[(*p)++];
 184         if (*p + len >= l)
 185                 return DER_BAD;
 186         return len;
 187 }
 188
 189 static const char *
 190 der_tag(char *buf, size_t len, uint32_t tag)
 191 {
 192         if (tag < DER_TAG_LONG)
 193                 strlcpy(buf, der__tag[tag], len);
 194         else
 195                 snprintf(buf, len, "%#x", tag);
 196         return buf;
 197 }
 198
 199 #ifndef TEST_DER
 200 static int
 201 der_data(char *buf, size_t blen, uint32_t tag, const void *q, uint32_t len)
 202 {
 203         const uint8_t *d = CAST(const uint8_t *, q);
 204         switch (tag) {
 205         case DER_TAG_PRINTABLE_STRING:
 206         case DER_TAG_UTF8_STRING:
 207         case DER_TAG_IA5_STRING:
 208         case DER_TAG_UTCTIME:
 209                 return snprintf(buf, blen, "%.*s", len, (const char *)q);
 210         default:
 211                 break;
 212         }
 213
 214         for (uint32_t i = 0; i < len; i++) {
 215                 uint32_t z = i << 1;
 216                 if (z < blen - 2)
 217                         snprintf(buf + z, blen - z, "%.2x", d[i]);
 218         }
 219         return len * 2;
 220 }
 221
 222 int32_t
 223 der_offs(struct magic_set *ms, struct magic *m, size_t nbytes)
 224 {
 225         const uint8_t *b = RCAST(const uint8_t *, ms->search.s);
 226         size_t offs = 0, len = ms->search.s_len ? ms->search.s_len : nbytes;
 227
 228         if (gettag(b, &offs, len) == DER_BAD)
 229                 return -1;
 230         DPRINTF(("%s1: %d %zu %u\n", __func__, ms->offset, offs, m->offset));
 231
 232         uint32_t tlen = getlength(b, &offs, len);
 233         if (tlen == DER_BAD)
 234                 return -1;
 235         DPRINTF(("%s2: %d %zu %u\n", __func__, ms->offset, offs, tlen));
 236
 237         offs += ms->offset + m->offset;
 238         DPRINTF(("cont_level = %d\n", m->cont_level));
 239 #ifdef DEBUG_DER
 240         for (size_t i = 0; i < m->cont_level; i++)
 241                 printf("cont_level[%zu] = %u\n", i, ms->c.li[i].off);
 242 #endif
 243         if (m->cont_level != 0) {
 244                 if (offs + tlen > nbytes)
 245                         return DER_BAD;
 246                 ms->c.li[m->cont_level - 1].off = offs + tlen;
 247                 DPRINTF(("cont_level[%u] = %u\n", m->cont_level - 1,
 248                     ms->c.li[m->cont_level - 1].off));
 249         }
 250         return offs;
 251 }
 252
 253 int
 254 der_cmp(struct magic_set *ms, struct magic *m)
 255 {
 256         const uint8_t *b = RCAST(const uint8_t *, ms->search.s);
 257         const char *s = m->value.s;
 258         size_t offs = 0, len = ms->search.s_len;
 259         uint32_t tag, tlen;
 260         char buf[128];
 261
 262         tag = gettag(b, &offs, len);
 263         if (tag == DER_BAD)
 264                 return -1;
 265
 266         tlen = getlength(b, &offs, len);
 267         if (tlen == DER_BAD)
 268                 return -1;
 269
 270         der_tag(buf, sizeof(buf), tag);
 271         if ((ms->flags & MAGIC_DEBUG) != 0)
 272                 fprintf(stderr, "%s: tag %p got=%s exp=%s\n", __func__, b,
 273                     buf, s);
 274         size_t slen = strlen(buf);
 275
 276         if (strncmp(buf, s, slen) != 0)
 277                 return 0;
 278
 279         s += slen;
 280
 281 again:
 282         switch (*s) {
 283         case '\0':
 284                 return 1;
 285         case '=':
 286                 s++;
 287                 goto val;
 288         default:
 289                 if (!isdigit((unsigned char)*s))
 290                         return 0;
 291
 292                 slen = 0;
 293                 do
 294                         slen = slen * 10 + *s - '0';
 295                 while (isdigit((unsigned char)*++s));
 296                 if ((ms->flags & MAGIC_DEBUG) != 0)
 297                         fprintf(stderr, "%s: len %zu %u\n", __func__,
 298                             slen, tlen);
 299                 if (tlen != slen)
 300                         return 0;
 301                 goto again;
 302         }
 303 val:
 304         DPRINTF(("%s: before data %zu %u\n", __func__, offs, tlen));
 305         der_data(buf, sizeof(buf), tag, b + offs, tlen);
 306         if ((ms->flags & MAGIC_DEBUG) != 0)
 307                 fprintf(stderr, "%s: data %s %s\n", __func__, buf, s);
 308         if (strcmp(buf, s) != 0 && strcmp("x", s) != 0)
 309                 return 0;
 310         strlcpy(ms->ms_value.s, buf, sizeof(ms->ms_value.s));
 311         return 1;
 312 }
 313 #endif
 314
 315 #ifdef TEST_DER
 316 static void
 317 printtag(uint32_t tag, const void *q, uint32_t len)
 318 {
 319         const uint8_t *d = q;
 320         switch (tag) {
 321         case DER_TAG_PRINTABLE_STRING:
 322         case DER_TAG_UTF8_STRING:
 323                 printf("%.*s\n", len, (const char *)q);
 324                 return;
 325         default:
 326                 break;
 327         }
 328
 329         for (uint32_t i = 0; i < len; i++)
 330                 printf("%.2x", d[i]);
 331         printf("\n");
 332 }
 333
 334 static void
 335 printdata(size_t level, const void *v, size_t x, size_t l)
 336 {
 337         const uint8_t *p = v, *ep = p + l;
 338         size_t ox;
 339         char buf[128];
 340
 341         while (p + x < ep) {
 342                 const uint8_t *q;
 343                 uint8_t c = getclass(p[x]);
 344                 uint8_t t = gettype(p[x]);
 345                 ox = x;
 346                 if (x != 0)
 347                 printf("%.2x %.2x %.2x\n", p[x - 1], p[x], p[x + 1]);
 348                 uint32_t tag = gettag(p, &x, ep - p + x);
 349                 if (p + x >= ep)
 350                         break;
 351                 uint32_t len = getlength(p, &x, ep - p + x);
 352
 353                 printf("%zu %zu-%zu %c,%c,%s,%u:", level, ox, x,
 354                     der_class[c], der_type[t],
 355                     der_tag(buf, sizeof(buf), tag), len);
 356                 q = p + x;
 357                 if (p + len > ep)
 358                         errx(EXIT_FAILURE, "corrupt der");
 359                 printtag(tag, q, len);
 360                 if (t != DER_TYPE_PRIMITIVE)
 361                         printdata(level + 1, p, x, len + x);
 362                 x += len;
 363         }
 364 }
 365
 366 int
 367 main(int argc, char *argv[])
 368 {
 369         int fd;
 370         struct stat st;
 371         size_t l;
 372         void *p;
 373
 374         if ((fd = open(argv[1], O_RDONLY)) == -1)
 375                 err(EXIT_FAILURE, "open `%s'", argv[1]);
 376         if (fstat(fd, &st) == -1)
 377                 err(EXIT_FAILURE, "stat `%s'", argv[1]);
 378         l = (size_t)st.st_size;
 379         if ((p = mmap(NULL, l, PROT_READ, MAP_FILE, fd, 0)) == MAP_FAILED)
 380                 err(EXIT_FAILURE, "mmap `%s'", argv[1]);
 381
 382         printdata(0, p, 0, l);
 383         munmap(p, l);
 384         return 0;
 385 }
 386 #endif