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.4 2016/03/21 23:04:40 christos Exp $") 39 #endif 40 #endif 41 42 #include <sys/types.h> 43 #include <sys/stat.h> 44 #include <sys/mman.h> 45 46 #include <stdio.h> 47 #include <err.h> 48 #include <fcntl.h> 49 #include <stdlib.h> 50 #include <string.h> 51 #include <ctype.h> 52 53 #ifndef TEST_DER 54 #include "magic.h" 55 #include "der.h" 56 #endif 57 58 #define DER_BAD ((uint32_t)-1) 59 60 #define DER_CLASS_UNIVERSAL 0 61 #define DER_CLASS_APPLICATION 1 62 #define DER_CLASS_CONTEXT 2 63 #define DER_CLASS_PRIVATE 3 64 static const char der_class[] = "UACP"; 65 66 #define DER_TYPE_PRIMITIVE 0 67 #define DER_TYPE_CONSTRUCTED 1 68 static const char der_type[] = "PC"; 69 70 #define DER_TAG_EOC 0x00 71 #define DER_TAG_BOOLEAN 0x01 72 #define DER_TAG_INTEGER 0x02 73 #define DER_TAG_BIT STRING 0x03 74 #define DER_TAG_OCTET_STRING 0x04 75 #define DER_TAG_NULL 0x05 76 #define DER_TAG_OBJECT_IDENTIFIER 0x06 77 #define DER_TAG_OBJECT_DESCRIPTOR 0x07 78 #define DER_TAG_EXTERNAL 0x08 79 #define DER_TAG_REAL 0x09 80 #define DER_TAG_ENUMERATED 0x0a 81 #define DER_TAG_EMBEDDED_PDV 0x0b 82 #define DER_TAG_UTF8_STRING 0x0c 83 #define DER_TAG_RELATIVE_OID 0x0d 84 #define DER_TAG_RESERVED_1 0x0e 85 #define DER_TAG_RESERVED_2 0x0f 86 #define DER_TAG_SEQUENCE 0x10 87 #define DER_TAG_SET 0x11 88 #define DER_TAG_NUMERIC_STRING 0x12 89 #define DER_TAG_PRINTABLE_STRING 0x13 90 #define DER_TAG_T61_STRING 0x14 91 #define DER_TAG_VIDEOTEX_STRING 0x15 92 #define DER_TAG_IA5_STRING 0x16 93 #define DER_TAG_UTCTIME 0x17 94 #define DER_TAG_GENERALIZED_TIME 0x18 95 #define DER_TAG_GRAPHIC_STRING 0x19 96 #define DER_TAG_VISIBLE_STRING 0x1a 97 #define DER_TAG_GENERAL_STRING 0x1b 98 #define DER_TAG_UNIVERSAL_STRING 0x1c 99 #define DER_TAG_CHARACTER_STRING 0x1d 100 #define DER_TAG_BMP_STRING 0x1e 101 #define DER_TAG_LONG 0x1f 102 103 static const char *der__tag[] = { 104 "eoc", "bool", "int", "bit_str", "octet_str", 105 "null", "obj_id", "obj_desc", "ext", "real", 106 "enum", "embed", "utf8_str", "oid", "res1", 107 "res2", "seq", "set", "num_str", "prt_str", 108 "t61_str", "vid_str", "ia5_str", "utc_time", 109 "gen_time", "gr_str", "vis_str", "gen_str", 110 "char_str", "bmp_str", "long" 111 }; 112 113 #ifdef DEBUG_DER 114 #define DPRINTF(a) printf a 115 #else 116 #define DPRINTF(a) 117 #endif 118 119 #ifdef TEST_DER 120 static uint8_t 121 getclass(uint8_t c) 122 { 123 return c >> 6; 124 } 125 126 static uint8_t 127 gettype(uint8_t c) 128 { 129 return (c >> 5) & 1; 130 } 131 #endif 132 133 static uint32_t 134 gettag(const uint8_t *c, size_t *p, size_t l) 135 { 136 uint32_t tag; 137 138 if (*p >= l) 139 return DER_BAD; 140 141 tag = c[(*p)++] & 0x1f; 142 143 if (tag != 0x1f) 144 return tag; 145 146 if (*p >= l) 147 return DER_BAD; 148 149 while (c[*p] >= 0x80) { 150 tag = tag * 128 + c[(*p)++] - 0x80; 151 if (*p >= l) 152 return DER_BAD; 153 } 154 return tag; 155 } 156 157 static uint32_t 158 getlength(const uint8_t *c, size_t *p, size_t l) 159 { 160 uint8_t digits, i; 161 size_t len; 162 163 if (*p >= l) 164 return DER_BAD; 165 166 digits = c[(*p)++]; 167 168 if ((digits & 0x80) == 0) 169 return digits; 170 171 digits &= 0x7f; 172 len = 0; 173 174 if (*p + digits >= l) 175 return DER_BAD; 176 177 for (i = 0; i < digits; i++) 178 len = (len << 8) | c[(*p)++]; 179 return len; 180 } 181 182 static const char * 183 der_tag(char *buf, size_t len, uint32_t tag) 184 { 185 if (tag < DER_TAG_LONG) 186 strlcpy(buf, der__tag[tag], len); 187 else 188 snprintf(buf, len, "%#x", tag); 189 return buf; 190 } 191 192 #ifndef TEST_DER 193 static int 194 der_data(char *buf, size_t blen, uint32_t tag, const void *q, uint32_t len) 195 { 196 const uint8_t *d = q; 197 switch (tag) { 198 case DER_TAG_PRINTABLE_STRING: 199 case DER_TAG_UTF8_STRING: 200 case DER_TAG_IA5_STRING: 201 case DER_TAG_UTCTIME: 202 return snprintf(buf, blen, "%.*s", len, (const char *)q); 203 default: 204 break; 205 } 206 207 for (uint32_t i = 0; i < len; i++) { 208 uint32_t z = i << 1; 209 if (z < blen - 2) 210 snprintf(buf + z, blen - z, "%.2x", d[i]); 211 } 212 return len * 2; 213 } 214 215 int32_t 216 der_offs(struct magic_set *ms, struct magic *m, size_t nbytes) 217 { 218 const uint8_t *b = CAST(const void *, ms->search.s); 219 size_t offs = 0, len = ms->search.rm_len ? ms->search.rm_len : nbytes; 220 221 if (gettag(b, &offs, len) == DER_BAD) 222 return -1; 223 DPRINTF(("%s1: %d %zu %u\n", __func__, ms->offset, offs, m->offset)); 224 225 uint32_t tlen = getlength(b, &offs, len); 226 if (tlen == DER_BAD) 227 return -1; 228 DPRINTF(("%s2: %d %zu %u\n", __func__, ms->offset, offs, tlen)); 229 230 offs += ms->offset + m->offset; 231 DPRINTF(("cont_level = %d\n", m->cont_level)); 232 #ifdef DEBUG_DER 233 for (size_t i = 0; i < m->cont_level; i++) 234 printf("cont_level[%zu] = %u\n", i, ms->c.li[i].off); 235 #endif 236 if (m->cont_level != 0) { 237 if (offs + tlen > nbytes) 238 return DER_BAD; 239 ms->c.li[m->cont_level - 1].off = offs + tlen; 240 DPRINTF(("cont_level[%u] = %u\n", m->cont_level - 1, 241 ms->c.li[m->cont_level - 1].off)); 242 } 243 return offs; 244 } 245 246 int 247 der_cmp(struct magic_set *ms, struct magic *m) 248 { 249 const uint8_t *b = CAST(const void *, ms->search.s); 250 const char *s = m->value.s; 251 size_t offs = 0, len = ms->search.s_len; 252 uint32_t tag, tlen; 253 char buf[128]; 254 255 tag = gettag(b, &offs, len); 256 if (tag == DER_BAD) 257 return -1; 258 259 tlen = getlength(b, &offs, len); 260 if (tlen == DER_BAD) 261 return -1; 262 263 der_tag(buf, sizeof(buf), tag); 264 if ((ms->flags & MAGIC_DEBUG) != 0) 265 fprintf(stderr, "%s: tag %p got=%s exp=%s\n", __func__, b, 266 buf, s); 267 size_t slen = strlen(buf); 268 269 if (strncmp(buf, s, slen) != 0) 270 return 0; 271 272 s += slen; 273 274 again: 275 switch (*s) { 276 case '\0': 277 return 1; 278 case '=': 279 s++; 280 goto val; 281 default: 282 if (!isdigit((unsigned char)*s)) 283 return 0; 284 285 slen = 0; 286 do 287 slen = slen * 10 + *s - '0'; 288 while (isdigit((unsigned char)*++s)); 289 if ((ms->flags & MAGIC_DEBUG) != 0) 290 fprintf(stderr, "%s: len %zu %u\n", __func__, 291 slen, tlen); 292 if (tlen != slen) 293 return 0; 294 goto again; 295 } 296 val: 297 DPRINTF(("%s: before data %zu %u\n", __func__, offs, tlen)); 298 der_data(buf, sizeof(buf), tag, b + offs, tlen); 299 if ((ms->flags & MAGIC_DEBUG) != 0) 300 fprintf(stderr, "%s: data %s %s\n", __func__, buf, s); 301 if (strcmp(buf, s) != 0 && strcmp("x", s) != 0) 302 return 0; 303 strlcpy(ms->ms_value.s, buf, sizeof(ms->ms_value.s)); 304 return 1; 305 } 306 #endif 307 308 #ifdef TEST_DER 309 static void 310 printtag(uint32_t tag, const void *q, uint32_t len) 311 { 312 const uint8_t *d = q; 313 switch (tag) { 314 case DER_TAG_PRINTABLE_STRING: 315 case DER_TAG_UTF8_STRING: 316 printf("%.*s\n", len, (const char *)q); 317 return; 318 default: 319 break; 320 } 321 322 for (uint32_t i = 0; i < len; i++) 323 printf("%.2x", d[i]); 324 printf("\n"); 325 } 326 327 static void 328 printdata(size_t level, const void *v, size_t x, size_t l) 329 { 330 const uint8_t *p = v, *ep = p + l; 331 size_t ox; 332 char buf[128]; 333 334 while (p + x < ep) { 335 const uint8_t *q; 336 uint8_t c = getclass(p[x]); 337 uint8_t t = gettype(p[x]); 338 ox = x; 339 if (x != 0) 340 printf("%.2x %.2x %.2x\n", p[x - 1], p[x], p[x + 1]); 341 uint32_t tag = gettag(p, &x, ep - p + x); 342 if (p + x >= ep) 343 break; 344 uint32_t len = getlength(p, &x, ep - p + x); 345 346 printf("%zu %zu-%zu %c,%c,%s,%u:", level, ox, x, 347 der_class[c], der_type[t], 348 der_tag(buf, sizeof(buf), tag), len); 349 q = p + x; 350 if (p + len > ep) 351 errx(EXIT_FAILURE, "corrupt der"); 352 printtag(tag, q, len); 353 if (t != DER_TYPE_PRIMITIVE) 354 printdata(level + 1, p, x, len + x); 355 x += len; 356 } 357 } 358 359 int 360 main(int argc, char *argv[]) 361 { 362 int fd; 363 struct stat st; 364 size_t l; 365 void *p; 366 367 if ((fd = open(argv[1], O_RDONLY)) == -1) 368 err(EXIT_FAILURE, "open `%s'", argv[1]); 369 if (fstat(fd, &st) == -1) 370 err(EXIT_FAILURE, "stat `%s'", argv[1]); 371 l = (size_t)st.st_size; 372 if ((p = mmap(NULL, l, PROT_READ, MAP_FILE, fd, 0)) == MAP_FAILED) 373 err(EXIT_FAILURE, "mmap `%s'", argv[1]); 374 375 printdata(0, p, 0, l); 376 munmap(p, l); 377 return 0; 378 } 379 #endif 380