1 /* 2 * Copyright (c) Ian F. Darwin 1986-1995. 3 * Software written by Ian F. Darwin and others; 4 * maintained 1995-present by Christos Zoulas and others. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice immediately at the beginning of the file, without modification, 11 * this list of conditions, and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 /* 29 * softmagic - interpret variable magic from MAGIC 30 */ 31 32 #include "file.h" 33 34 #ifndef lint 35 FILE_RCSID("@(#)$File: softmagic.c,v 1.249 2017/06/19 18:30:25 christos Exp $") 36 #endif /* lint */ 37 38 #include "magic.h" 39 #include <assert.h> 40 #include <string.h> 41 #include <ctype.h> 42 #include <stdlib.h> 43 #include <time.h> 44 #include "der.h" 45 46 private int match(struct magic_set *, struct magic *, uint32_t, 47 const unsigned char *, size_t, size_t, int, int, int, uint16_t *, 48 uint16_t *, int *, int *, int *); 49 private int mget(struct magic_set *, const unsigned char *, 50 struct magic *, size_t, size_t, unsigned int, int, int, int, uint16_t *, 51 uint16_t *, int *, int *, int *); 52 private int magiccheck(struct magic_set *, struct magic *); 53 private int32_t mprint(struct magic_set *, struct magic *); 54 private int moffset(struct magic_set *, struct magic *, size_t, int32_t *); 55 private void mdebug(uint32_t, const char *, size_t); 56 private int mcopy(struct magic_set *, union VALUETYPE *, int, int, 57 const unsigned char *, uint32_t, size_t, struct magic *); 58 private int mconvert(struct magic_set *, struct magic *, int); 59 private int print_sep(struct magic_set *, int); 60 private int handle_annotation(struct magic_set *, struct magic *, int); 61 private int cvt_8(union VALUETYPE *, const struct magic *); 62 private int cvt_16(union VALUETYPE *, const struct magic *); 63 private int cvt_32(union VALUETYPE *, const struct magic *); 64 private int cvt_64(union VALUETYPE *, const struct magic *); 65 66 #define OFFSET_OOB(n, o, i) ((n) < (uint32_t)(o) || (i) > ((n) - (o))) 67 #define BE64(p) (((uint64_t)(p)->hq[0]<<56)|((uint64_t)(p)->hq[1]<<48)| \ 68 ((uint64_t)(p)->hq[2]<<40)|((uint64_t)(p)->hq[3]<<32)| \ 69 ((uint64_t)(p)->hq[4]<<24)|((uint64_t)(p)->hq[5]<<16)| \ 70 ((uint64_t)(p)->hq[6]<<8)|((uint64_t)(p)->hq[7])) 71 #define LE64(p) (((uint64_t)(p)->hq[7]<<56)|((uint64_t)(p)->hq[6]<<48)| \ 72 ((uint64_t)(p)->hq[5]<<40)|((uint64_t)(p)->hq[4]<<32)| \ 73 ((uint64_t)(p)->hq[3]<<24)|((uint64_t)(p)->hq[2]<<16)| \ 74 ((uint64_t)(p)->hq[1]<<8)|((uint64_t)(p)->hq[0])) 75 #define LE32(p) (((uint32_t)(p)->hl[3]<<24)|((uint32_t)(p)->hl[2]<<16)| \ 76 ((uint32_t)(p)->hl[1]<<8)|((uint32_t)(p)->hl[0])) 77 #define BE32(p) (((uint32_t)(p)->hl[0]<<24)|((uint32_t)(p)->hl[1]<<16)| \ 78 ((uint32_t)(p)->hl[2]<<8)|((uint32_t)(p)->hl[3])) 79 #define ME32(p) (((uint32_t)(p)->hl[1]<<24)|((uint32_t)(p)->hl[0]<<16)| \ 80 ((uint32_t)(p)->hl[3]<<8)|((uint32_t)(p)->hl[2])) 81 #define BE16(p) (((uint16_t)(p)->hs[0]<<8)|((uint16_t)(p)->hs[1])) 82 #define LE16(p) (((uint16_t)(p)->hs[1]<<8)|((uint16_t)(p)->hs[0])) 83 #define SEXT(s,v,p) ((s)?(intmax_t)(int##v##_t)(p):(intmax_t)(uint##v##_t)(p)) 84 85 /* 86 * softmagic - lookup one file in parsed, in-memory copy of database 87 * Passed the name and FILE * of one file to be typed. 88 */ 89 /*ARGSUSED1*/ /* nbytes passed for regularity, maybe need later */ 90 protected int 91 file_softmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes, 92 uint16_t *indir_count, uint16_t *name_count, int mode, int text) 93 { 94 struct mlist *ml; 95 int rv, printed_something = 0, need_separator = 0; 96 uint16_t nc, ic; 97 98 if (name_count == NULL) { 99 nc = 0; 100 name_count = &nc; 101 } 102 if (indir_count == NULL) { 103 ic = 0; 104 indir_count = ⁣ 105 } 106 107 for (ml = ms->mlist[0]->next; ml != ms->mlist[0]; ml = ml->next) 108 if ((rv = match(ms, ml->magic, ml->nmagic, buf, nbytes, 0, mode, 109 text, 0, indir_count, name_count, 110 &printed_something, &need_separator, NULL)) != 0) 111 return rv; 112 113 return 0; 114 } 115 116 #define FILE_FMTDEBUG 117 #ifdef FILE_FMTDEBUG 118 #define F(a, b, c) file_fmtcheck((a), (b), (c), __FILE__, __LINE__) 119 120 private const char * __attribute__((__format_arg__(3))) 121 file_fmtcheck(struct magic_set *ms, const struct magic *m, const char *def, 122 const char *file, size_t line) 123 { 124 const char *ptr = fmtcheck(m->desc, def); 125 if (ptr == def) 126 file_magerror(ms, 127 "%s, %" SIZE_T_FORMAT "u: format `%s' does not match" 128 " with `%s'", file, line, m->desc, def); 129 return ptr; 130 } 131 #else 132 #define F(a, b, c) fmtcheck((b)->desc, (c)) 133 #endif 134 135 /* 136 * Go through the whole list, stopping if you find a match. Process all 137 * the continuations of that match before returning. 138 * 139 * We support multi-level continuations: 140 * 141 * At any time when processing a successful top-level match, there is a 142 * current continuation level; it represents the level of the last 143 * successfully matched continuation. 144 * 145 * Continuations above that level are skipped as, if we see one, it 146 * means that the continuation that controls them - i.e, the 147 * lower-level continuation preceding them - failed to match. 148 * 149 * Continuations below that level are processed as, if we see one, 150 * it means we've finished processing or skipping higher-level 151 * continuations under the control of a successful or unsuccessful 152 * lower-level continuation, and are now seeing the next lower-level 153 * continuation and should process it. The current continuation 154 * level reverts to the level of the one we're seeing. 155 * 156 * Continuations at the current level are processed as, if we see 157 * one, there's no lower-level continuation that may have failed. 158 * 159 * If a continuation matches, we bump the current continuation level 160 * so that higher-level continuations are processed. 161 */ 162 private int 163 match(struct magic_set *ms, struct magic *magic, uint32_t nmagic, 164 const unsigned char *s, size_t nbytes, size_t offset, int mode, int text, 165 int flip, uint16_t *indir_count, uint16_t *name_count, 166 int *printed_something, int *need_separator, int *returnval) 167 { 168 uint32_t magindex = 0; 169 unsigned int cont_level = 0; 170 int returnvalv = 0, e; /* if a match is found it is set to 1*/ 171 int firstline = 1; /* a flag to print X\n X\n- X */ 172 int print = (ms->flags & MAGIC_NODESC) == 0; 173 174 if (returnval == NULL) 175 returnval = &returnvalv; 176 177 if (file_check_mem(ms, cont_level) == -1) 178 return -1; 179 180 for (magindex = 0; magindex < nmagic; magindex++) { 181 int flush = 0; 182 struct magic *m = &magic[magindex]; 183 184 if (m->type != FILE_NAME) 185 if ((IS_STRING(m->type) && 186 #define FLT (STRING_BINTEST | STRING_TEXTTEST) 187 ((text && (m->str_flags & FLT) == STRING_BINTEST) || 188 (!text && (m->str_flags & FLT) == STRING_TEXTTEST))) || 189 (m->flag & mode) != mode) { 190 flush: 191 /* Skip sub-tests */ 192 while (magindex < nmagic - 1 && 193 magic[magindex + 1].cont_level != 0) 194 magindex++; 195 cont_level = 0; 196 continue; /* Skip to next top-level test*/ 197 } 198 199 ms->offset = m->offset; 200 ms->line = m->lineno; 201 202 /* if main entry matches, print it... */ 203 switch (mget(ms, s, m, nbytes, offset, cont_level, mode, text, 204 flip, indir_count, name_count, 205 printed_something, need_separator, returnval)) { 206 case -1: 207 return -1; 208 case 0: 209 flush = m->reln != '!'; 210 break; 211 default: 212 if (m->type == FILE_INDIRECT) 213 *returnval = 1; 214 215 switch (magiccheck(ms, m)) { 216 case -1: 217 return -1; 218 case 0: 219 flush++; 220 break; 221 default: 222 flush = 0; 223 break; 224 } 225 break; 226 } 227 if (flush) { 228 /* 229 * main entry didn't match, 230 * flush its continuations 231 */ 232 goto flush; 233 } 234 235 if ((e = handle_annotation(ms, m, firstline)) != 0) { 236 *need_separator = 1; 237 *printed_something = 1; 238 *returnval = 1; 239 return e; 240 } 241 242 /* 243 * If we are going to print something, we'll need to print 244 * a blank before we print something else. 245 */ 246 if (*m->desc) { 247 *need_separator = 1; 248 *printed_something = 1; 249 if (print_sep(ms, firstline) == -1) 250 return -1; 251 } 252 253 254 if (print && mprint(ms, m) == -1) 255 return -1; 256 257 switch (moffset(ms, m, nbytes, &ms->c.li[cont_level].off)) { 258 case -1: 259 case 0: 260 goto flush; 261 default: 262 break; 263 } 264 265 /* and any continuations that match */ 266 if (file_check_mem(ms, ++cont_level) == -1) 267 return -1; 268 269 while (magindex + 1 < nmagic && 270 magic[magindex + 1].cont_level != 0) { 271 m = &magic[++magindex]; 272 ms->line = m->lineno; /* for messages */ 273 274 if (cont_level < m->cont_level) 275 continue; 276 if (cont_level > m->cont_level) { 277 /* 278 * We're at the end of the level 279 * "cont_level" continuations. 280 */ 281 cont_level = m->cont_level; 282 } 283 ms->offset = m->offset; 284 if (m->flag & OFFADD) { 285 ms->offset += 286 ms->c.li[cont_level - 1].off; 287 } 288 289 #ifdef ENABLE_CONDITIONALS 290 if (m->cond == COND_ELSE || 291 m->cond == COND_ELIF) { 292 if (ms->c.li[cont_level].last_match == 1) 293 continue; 294 } 295 #endif 296 switch (mget(ms, s, m, nbytes, offset, cont_level, mode, 297 text, flip, indir_count, name_count, 298 printed_something, need_separator, returnval)) { 299 case -1: 300 return -1; 301 case 0: 302 if (m->reln != '!') 303 continue; 304 flush = 1; 305 break; 306 default: 307 if (m->type == FILE_INDIRECT) 308 *returnval = 1; 309 flush = 0; 310 break; 311 } 312 313 switch (flush ? 1 : magiccheck(ms, m)) { 314 case -1: 315 return -1; 316 case 0: 317 #ifdef ENABLE_CONDITIONALS 318 ms->c.li[cont_level].last_match = 0; 319 #endif 320 break; 321 default: 322 #ifdef ENABLE_CONDITIONALS 323 ms->c.li[cont_level].last_match = 1; 324 #endif 325 if (m->type == FILE_CLEAR) 326 ms->c.li[cont_level].got_match = 0; 327 else if (ms->c.li[cont_level].got_match) { 328 if (m->type == FILE_DEFAULT) 329 break; 330 } else 331 ms->c.li[cont_level].got_match = 1; 332 333 if ((e = handle_annotation(ms, m, firstline)) != 0) { 334 *need_separator = 1; 335 *printed_something = 1; 336 *returnval = 1; 337 return e; 338 } 339 /* 340 * If we are going to print something, 341 * make sure that we have a separator first. 342 */ 343 if (*m->desc) { 344 if (!*printed_something) { 345 *printed_something = 1; 346 if (print_sep(ms, firstline) 347 == -1) 348 return -1; 349 } 350 } 351 /* 352 * This continuation matched. Print 353 * its message, with a blank before it 354 * if the previous item printed and 355 * this item isn't empty. 356 */ 357 /* space if previous printed */ 358 if (*need_separator 359 && ((m->flag & NOSPACE) == 0) 360 && *m->desc) { 361 if (print && 362 file_printf(ms, " ") == -1) 363 return -1; 364 *need_separator = 0; 365 } 366 if (print && mprint(ms, m) == -1) 367 return -1; 368 369 switch (moffset(ms, m, nbytes, 370 &ms->c.li[cont_level].off)) { 371 case -1: 372 case 0: 373 flush = 1; 374 cont_level--; 375 break; 376 default: 377 break; 378 } 379 380 if (*m->desc) 381 *need_separator = 1; 382 383 /* 384 * If we see any continuations 385 * at a higher level, 386 * process them. 387 */ 388 if (file_check_mem(ms, ++cont_level) == -1) 389 return -1; 390 break; 391 } 392 } 393 if (*printed_something) { 394 firstline = 0; 395 if (print) 396 *returnval = 1; 397 } 398 if ((ms->flags & MAGIC_CONTINUE) == 0 && *printed_something) { 399 return *returnval; /* don't keep searching */ 400 } 401 cont_level = 0; 402 } 403 return *returnval; /* This is hit if -k is set or there is no match */ 404 } 405 406 private int 407 check_fmt(struct magic_set *ms, struct magic *m) 408 { 409 file_regex_t rx; 410 int rc, rv = -1; 411 412 if (strchr(m->desc, '%') == NULL) 413 return 0; 414 415 rc = file_regcomp(&rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB); 416 if (rc) { 417 file_regerror(&rx, rc, ms); 418 } else { 419 rc = file_regexec(&rx, m->desc, 0, 0, 0); 420 rv = !rc; 421 } 422 file_regfree(&rx); 423 return rv; 424 } 425 426 #ifndef HAVE_STRNDUP 427 char * strndup(const char *, size_t); 428 429 char * 430 strndup(const char *str, size_t n) 431 { 432 size_t len; 433 char *copy; 434 435 for (len = 0; len < n && str[len]; len++) 436 continue; 437 if ((copy = malloc(len + 1)) == NULL) 438 return NULL; 439 (void)memcpy(copy, str, len); 440 copy[len] = '\0'; 441 return copy; 442 } 443 #endif /* HAVE_STRNDUP */ 444 445 private int32_t 446 mprint(struct magic_set *ms, struct magic *m) 447 { 448 uint64_t v; 449 float vf; 450 double vd; 451 int64_t t = 0; 452 char buf[128], tbuf[26], sbuf[512]; 453 union VALUETYPE *p = &ms->ms_value; 454 455 switch (m->type) { 456 case FILE_BYTE: 457 v = file_signextend(ms, m, (uint64_t)p->b); 458 switch (check_fmt(ms, m)) { 459 case -1: 460 return -1; 461 case 1: 462 (void)snprintf(buf, sizeof(buf), "%d", 463 (unsigned char)v); 464 if (file_printf(ms, F(ms, m, "%s"), buf) == -1) 465 return -1; 466 break; 467 default: 468 if (file_printf(ms, F(ms, m, "%d"), 469 (unsigned char) v) == -1) 470 return -1; 471 break; 472 } 473 t = ms->offset + sizeof(char); 474 break; 475 476 case FILE_SHORT: 477 case FILE_BESHORT: 478 case FILE_LESHORT: 479 v = file_signextend(ms, m, (uint64_t)p->h); 480 switch (check_fmt(ms, m)) { 481 case -1: 482 return -1; 483 case 1: 484 (void)snprintf(buf, sizeof(buf), "%u", 485 (unsigned short)v); 486 if (file_printf(ms, F(ms, m, "%s"), buf) == -1) 487 return -1; 488 break; 489 default: 490 if (file_printf(ms, F(ms, m, "%u"), 491 (unsigned short) v) == -1) 492 return -1; 493 break; 494 } 495 t = ms->offset + sizeof(short); 496 break; 497 498 case FILE_LONG: 499 case FILE_BELONG: 500 case FILE_LELONG: 501 case FILE_MELONG: 502 v = file_signextend(ms, m, (uint64_t)p->l); 503 switch (check_fmt(ms, m)) { 504 case -1: 505 return -1; 506 case 1: 507 (void)snprintf(buf, sizeof(buf), "%u", (uint32_t) v); 508 if (file_printf(ms, F(ms, m, "%s"), buf) == -1) 509 return -1; 510 break; 511 default: 512 if (file_printf(ms, F(ms, m, "%u"), (uint32_t) v) == -1) 513 return -1; 514 break; 515 } 516 t = ms->offset + sizeof(int32_t); 517 break; 518 519 case FILE_QUAD: 520 case FILE_BEQUAD: 521 case FILE_LEQUAD: 522 v = file_signextend(ms, m, p->q); 523 switch (check_fmt(ms, m)) { 524 case -1: 525 return -1; 526 case 1: 527 (void)snprintf(buf, sizeof(buf), "%" INT64_T_FORMAT "u", 528 (unsigned long long)v); 529 if (file_printf(ms, F(ms, m, "%s"), buf) == -1) 530 return -1; 531 break; 532 default: 533 if (file_printf(ms, F(ms, m, "%" INT64_T_FORMAT "u"), 534 (unsigned long long) v) == -1) 535 return -1; 536 break; 537 } 538 t = ms->offset + sizeof(int64_t); 539 break; 540 541 case FILE_STRING: 542 case FILE_PSTRING: 543 case FILE_BESTRING16: 544 case FILE_LESTRING16: 545 if (m->reln == '=' || m->reln == '!') { 546 if (file_printf(ms, F(ms, m, "%s"), 547 file_printable(sbuf, sizeof(sbuf), m->value.s)) 548 == -1) 549 return -1; 550 t = ms->offset + m->vallen; 551 } 552 else { 553 char *str = p->s; 554 555 /* compute t before we mangle the string? */ 556 t = ms->offset + strlen(str); 557 558 if (*m->value.s == '\0') 559 str[strcspn(str, "\r\n")] = '\0'; 560 561 if (m->str_flags & STRING_TRIM) { 562 char *last; 563 while (isspace((unsigned char)*str)) 564 str++; 565 last = str; 566 while (*last) 567 last++; 568 --last; 569 while (isspace((unsigned char)*last)) 570 last--; 571 *++last = '\0'; 572 } 573 574 if (file_printf(ms, F(ms, m, "%s"), 575 file_printable(sbuf, sizeof(sbuf), str)) == -1) 576 return -1; 577 578 if (m->type == FILE_PSTRING) 579 t += file_pstring_length_size(m); 580 } 581 break; 582 583 case FILE_DATE: 584 case FILE_BEDATE: 585 case FILE_LEDATE: 586 case FILE_MEDATE: 587 if (file_printf(ms, F(ms, m, "%s"), 588 file_fmttime(p->l, 0, tbuf)) == -1) 589 return -1; 590 t = ms->offset + sizeof(uint32_t); 591 break; 592 593 case FILE_LDATE: 594 case FILE_BELDATE: 595 case FILE_LELDATE: 596 case FILE_MELDATE: 597 if (file_printf(ms, F(ms, m, "%s"), 598 file_fmttime(p->l, FILE_T_LOCAL, tbuf)) == -1) 599 return -1; 600 t = ms->offset + sizeof(uint32_t); 601 break; 602 603 case FILE_QDATE: 604 case FILE_BEQDATE: 605 case FILE_LEQDATE: 606 if (file_printf(ms, F(ms, m, "%s"), 607 file_fmttime(p->q, 0, tbuf)) == -1) 608 return -1; 609 t = ms->offset + sizeof(uint64_t); 610 break; 611 612 case FILE_QLDATE: 613 case FILE_BEQLDATE: 614 case FILE_LEQLDATE: 615 if (file_printf(ms, F(ms, m, "%s"), 616 file_fmttime(p->q, FILE_T_LOCAL, tbuf)) == -1) 617 return -1; 618 t = ms->offset + sizeof(uint64_t); 619 break; 620 621 case FILE_QWDATE: 622 case FILE_BEQWDATE: 623 case FILE_LEQWDATE: 624 if (file_printf(ms, F(ms, m, "%s"), 625 file_fmttime(p->q, FILE_T_WINDOWS, tbuf)) == -1) 626 return -1; 627 t = ms->offset + sizeof(uint64_t); 628 break; 629 630 case FILE_FLOAT: 631 case FILE_BEFLOAT: 632 case FILE_LEFLOAT: 633 vf = p->f; 634 switch (check_fmt(ms, m)) { 635 case -1: 636 return -1; 637 case 1: 638 (void)snprintf(buf, sizeof(buf), "%g", vf); 639 if (file_printf(ms, F(ms, m, "%s"), buf) == -1) 640 return -1; 641 break; 642 default: 643 if (file_printf(ms, F(ms, m, "%g"), vf) == -1) 644 return -1; 645 break; 646 } 647 t = ms->offset + sizeof(float); 648 break; 649 650 case FILE_DOUBLE: 651 case FILE_BEDOUBLE: 652 case FILE_LEDOUBLE: 653 vd = p->d; 654 switch (check_fmt(ms, m)) { 655 case -1: 656 return -1; 657 case 1: 658 (void)snprintf(buf, sizeof(buf), "%g", vd); 659 if (file_printf(ms, F(ms, m, "%s"), buf) == -1) 660 return -1; 661 break; 662 default: 663 if (file_printf(ms, F(ms, m, "%g"), vd) == -1) 664 return -1; 665 break; 666 } 667 t = ms->offset + sizeof(double); 668 break; 669 670 case FILE_SEARCH: 671 case FILE_REGEX: { 672 char *cp; 673 int rval; 674 675 cp = strndup((const char *)ms->search.s, ms->search.rm_len); 676 if (cp == NULL) { 677 file_oomem(ms, ms->search.rm_len); 678 return -1; 679 } 680 rval = file_printf(ms, F(ms, m, "%s"), 681 file_printable(sbuf, sizeof(sbuf), cp)); 682 free(cp); 683 684 if (rval == -1) 685 return -1; 686 687 if ((m->str_flags & REGEX_OFFSET_START)) 688 t = ms->search.offset; 689 else 690 t = ms->search.offset + ms->search.rm_len; 691 break; 692 } 693 694 case FILE_DEFAULT: 695 case FILE_CLEAR: 696 if (file_printf(ms, "%s", m->desc) == -1) 697 return -1; 698 t = ms->offset; 699 break; 700 701 case FILE_INDIRECT: 702 case FILE_USE: 703 case FILE_NAME: 704 t = ms->offset; 705 break; 706 case FILE_DER: 707 if (file_printf(ms, F(ms, m, "%s"), 708 file_printable(sbuf, sizeof(sbuf), ms->ms_value.s)) == -1) 709 return -1; 710 t = ms->offset; 711 break; 712 default: 713 file_magerror(ms, "invalid m->type (%d) in mprint()", m->type); 714 return -1; 715 } 716 return (int32_t)t; 717 } 718 719 private int 720 moffset(struct magic_set *ms, struct magic *m, size_t nbytes, int32_t *op) 721 { 722 int32_t o; 723 724 switch (m->type) { 725 case FILE_BYTE: 726 o = CAST(int32_t, (ms->offset + sizeof(char))); 727 break; 728 729 case FILE_SHORT: 730 case FILE_BESHORT: 731 case FILE_LESHORT: 732 o = CAST(int32_t, (ms->offset + sizeof(short))); 733 break; 734 735 case FILE_LONG: 736 case FILE_BELONG: 737 case FILE_LELONG: 738 case FILE_MELONG: 739 o = CAST(int32_t, (ms->offset + sizeof(int32_t))); 740 break; 741 742 case FILE_QUAD: 743 case FILE_BEQUAD: 744 case FILE_LEQUAD: 745 o = CAST(int32_t, (ms->offset + sizeof(int64_t))); 746 break; 747 748 case FILE_STRING: 749 case FILE_PSTRING: 750 case FILE_BESTRING16: 751 case FILE_LESTRING16: 752 if (m->reln == '=' || m->reln == '!') { 753 o = ms->offset + m->vallen; 754 } else { 755 union VALUETYPE *p = &ms->ms_value; 756 757 if (*m->value.s == '\0') 758 p->s[strcspn(p->s, "\r\n")] = '\0'; 759 o = CAST(uint32_t, (ms->offset + strlen(p->s))); 760 if (m->type == FILE_PSTRING) 761 o += (uint32_t)file_pstring_length_size(m); 762 } 763 break; 764 765 case FILE_DATE: 766 case FILE_BEDATE: 767 case FILE_LEDATE: 768 case FILE_MEDATE: 769 o = CAST(int32_t, (ms->offset + sizeof(uint32_t))); 770 break; 771 772 case FILE_LDATE: 773 case FILE_BELDATE: 774 case FILE_LELDATE: 775 case FILE_MELDATE: 776 o = CAST(int32_t, (ms->offset + sizeof(uint32_t))); 777 break; 778 779 case FILE_QDATE: 780 case FILE_BEQDATE: 781 case FILE_LEQDATE: 782 o = CAST(int32_t, (ms->offset + sizeof(uint64_t))); 783 break; 784 785 case FILE_QLDATE: 786 case FILE_BEQLDATE: 787 case FILE_LEQLDATE: 788 o = CAST(int32_t, (ms->offset + sizeof(uint64_t))); 789 break; 790 791 case FILE_FLOAT: 792 case FILE_BEFLOAT: 793 case FILE_LEFLOAT: 794 o = CAST(int32_t, (ms->offset + sizeof(float))); 795 break; 796 797 case FILE_DOUBLE: 798 case FILE_BEDOUBLE: 799 case FILE_LEDOUBLE: 800 o = CAST(int32_t, (ms->offset + sizeof(double))); 801 break; 802 803 case FILE_REGEX: 804 if ((m->str_flags & REGEX_OFFSET_START) != 0) 805 o = CAST(int32_t, ms->search.offset); 806 else 807 o = CAST(int32_t, 808 (ms->search.offset + ms->search.rm_len)); 809 break; 810 811 case FILE_SEARCH: 812 if ((m->str_flags & REGEX_OFFSET_START) != 0) 813 o = CAST(int32_t, ms->search.offset); 814 else 815 o = CAST(int32_t, (ms->search.offset + m->vallen)); 816 break; 817 818 case FILE_CLEAR: 819 case FILE_DEFAULT: 820 case FILE_INDIRECT: 821 o = ms->offset; 822 break; 823 824 case FILE_DER: 825 { 826 o = der_offs(ms, m, nbytes); 827 if (o == -1 || (size_t)o > nbytes) { 828 if ((ms->flags & MAGIC_DEBUG) != 0) { 829 (void)fprintf(stderr, 830 "Bad DER offset %d nbytes=%zu", 831 o, nbytes); 832 } 833 *op = 0; 834 return 0; 835 } 836 break; 837 } 838 839 default: 840 o = 0; 841 break; 842 } 843 844 if ((size_t)o > nbytes) { 845 #if 0 846 file_error(ms, 0, "Offset out of range %zu > %zu", 847 (size_t)o, nbytes); 848 #endif 849 return -1; 850 } 851 *op = o; 852 return 1; 853 } 854 855 private uint32_t 856 cvt_id3(struct magic_set *ms, uint32_t v) 857 { 858 v = ((((v >> 0) & 0x7f) << 0) | 859 (((v >> 8) & 0x7f) << 7) | 860 (((v >> 16) & 0x7f) << 14) | 861 (((v >> 24) & 0x7f) << 21)); 862 if ((ms->flags & MAGIC_DEBUG) != 0) 863 fprintf(stderr, "id3 offs=%u\n", v); 864 return v; 865 } 866 867 private int 868 cvt_flip(int type, int flip) 869 { 870 if (flip == 0) 871 return type; 872 switch (type) { 873 case FILE_BESHORT: 874 return FILE_LESHORT; 875 case FILE_BELONG: 876 return FILE_LELONG; 877 case FILE_BEDATE: 878 return FILE_LEDATE; 879 case FILE_BELDATE: 880 return FILE_LELDATE; 881 case FILE_BEQUAD: 882 return FILE_LEQUAD; 883 case FILE_BEQDATE: 884 return FILE_LEQDATE; 885 case FILE_BEQLDATE: 886 return FILE_LEQLDATE; 887 case FILE_BEQWDATE: 888 return FILE_LEQWDATE; 889 case FILE_LESHORT: 890 return FILE_BESHORT; 891 case FILE_LELONG: 892 return FILE_BELONG; 893 case FILE_LEDATE: 894 return FILE_BEDATE; 895 case FILE_LELDATE: 896 return FILE_BELDATE; 897 case FILE_LEQUAD: 898 return FILE_BEQUAD; 899 case FILE_LEQDATE: 900 return FILE_BEQDATE; 901 case FILE_LEQLDATE: 902 return FILE_BEQLDATE; 903 case FILE_LEQWDATE: 904 return FILE_BEQWDATE; 905 case FILE_BEFLOAT: 906 return FILE_LEFLOAT; 907 case FILE_LEFLOAT: 908 return FILE_BEFLOAT; 909 case FILE_BEDOUBLE: 910 return FILE_LEDOUBLE; 911 case FILE_LEDOUBLE: 912 return FILE_BEDOUBLE; 913 default: 914 return type; 915 } 916 } 917 #define DO_CVT(fld, cast) \ 918 if (m->num_mask) \ 919 switch (m->mask_op & FILE_OPS_MASK) { \ 920 case FILE_OPAND: \ 921 p->fld &= cast m->num_mask; \ 922 break; \ 923 case FILE_OPOR: \ 924 p->fld |= cast m->num_mask; \ 925 break; \ 926 case FILE_OPXOR: \ 927 p->fld ^= cast m->num_mask; \ 928 break; \ 929 case FILE_OPADD: \ 930 p->fld += cast m->num_mask; \ 931 break; \ 932 case FILE_OPMINUS: \ 933 p->fld -= cast m->num_mask; \ 934 break; \ 935 case FILE_OPMULTIPLY: \ 936 p->fld *= cast m->num_mask; \ 937 break; \ 938 case FILE_OPDIVIDE: \ 939 if (cast m->num_mask == 0) \ 940 return -1; \ 941 p->fld /= cast m->num_mask; \ 942 break; \ 943 case FILE_OPMODULO: \ 944 if (cast m->num_mask == 0) \ 945 return -1; \ 946 p->fld %= cast m->num_mask; \ 947 break; \ 948 } \ 949 if (m->mask_op & FILE_OPINVERSE) \ 950 p->fld = ~p->fld \ 951 952 private int 953 cvt_8(union VALUETYPE *p, const struct magic *m) 954 { 955 DO_CVT(b, (uint8_t)); 956 return 0; 957 } 958 959 private int 960 cvt_16(union VALUETYPE *p, const struct magic *m) 961 { 962 DO_CVT(h, (uint16_t)); 963 return 0; 964 } 965 966 private int 967 cvt_32(union VALUETYPE *p, const struct magic *m) 968 { 969 DO_CVT(l, (uint32_t)); 970 return 0; 971 } 972 973 private int 974 cvt_64(union VALUETYPE *p, const struct magic *m) 975 { 976 DO_CVT(q, (uint64_t)); 977 return 0; 978 } 979 980 #define DO_CVT2(fld, cast) \ 981 if (m->num_mask) \ 982 switch (m->mask_op & FILE_OPS_MASK) { \ 983 case FILE_OPADD: \ 984 p->fld += cast m->num_mask; \ 985 break; \ 986 case FILE_OPMINUS: \ 987 p->fld -= cast m->num_mask; \ 988 break; \ 989 case FILE_OPMULTIPLY: \ 990 p->fld *= cast m->num_mask; \ 991 break; \ 992 case FILE_OPDIVIDE: \ 993 if (cast m->num_mask == 0) \ 994 return -1; \ 995 p->fld /= cast m->num_mask; \ 996 break; \ 997 } \ 998 999 private int 1000 cvt_float(union VALUETYPE *p, const struct magic *m) 1001 { 1002 DO_CVT2(f, (float)); 1003 return 0; 1004 } 1005 1006 private int 1007 cvt_double(union VALUETYPE *p, const struct magic *m) 1008 { 1009 DO_CVT2(d, (double)); 1010 return 0; 1011 } 1012 1013 /* 1014 * Convert the byte order of the data we are looking at 1015 * While we're here, let's apply the mask operation 1016 * (unless you have a better idea) 1017 */ 1018 private int 1019 mconvert(struct magic_set *ms, struct magic *m, int flip) 1020 { 1021 union VALUETYPE *p = &ms->ms_value; 1022 1023 switch (cvt_flip(m->type, flip)) { 1024 case FILE_BYTE: 1025 if (cvt_8(p, m) == -1) 1026 goto out; 1027 return 1; 1028 case FILE_SHORT: 1029 if (cvt_16(p, m) == -1) 1030 goto out; 1031 return 1; 1032 case FILE_LONG: 1033 case FILE_DATE: 1034 case FILE_LDATE: 1035 if (cvt_32(p, m) == -1) 1036 goto out; 1037 return 1; 1038 case FILE_QUAD: 1039 case FILE_QDATE: 1040 case FILE_QLDATE: 1041 case FILE_QWDATE: 1042 if (cvt_64(p, m) == -1) 1043 goto out; 1044 return 1; 1045 case FILE_STRING: 1046 case FILE_BESTRING16: 1047 case FILE_LESTRING16: { 1048 /* Null terminate and eat *trailing* return */ 1049 p->s[sizeof(p->s) - 1] = '\0'; 1050 return 1; 1051 } 1052 case FILE_PSTRING: { 1053 size_t sz = file_pstring_length_size(m); 1054 char *ptr1 = p->s, *ptr2 = ptr1 + sz; 1055 size_t len = file_pstring_get_length(m, ptr1); 1056 sz = sizeof(p->s) - sz; /* maximum length of string */ 1057 if (len >= sz) { 1058 /* 1059 * The size of the pascal string length (sz) 1060 * is 1, 2, or 4. We need at least 1 byte for NUL 1061 * termination, but we've already truncated the 1062 * string by p->s, so we need to deduct sz. 1063 * Because we can use one of the bytes of the length 1064 * after we shifted as NUL termination. 1065 */ 1066 len = sz; 1067 } 1068 while (len--) 1069 *ptr1++ = *ptr2++; 1070 *ptr1 = '\0'; 1071 return 1; 1072 } 1073 case FILE_BESHORT: 1074 p->h = (short)BE16(p); 1075 if (cvt_16(p, m) == -1) 1076 goto out; 1077 return 1; 1078 case FILE_BELONG: 1079 case FILE_BEDATE: 1080 case FILE_BELDATE: 1081 p->l = (int32_t)BE32(p); 1082 if (cvt_32(p, m) == -1) 1083 goto out; 1084 return 1; 1085 case FILE_BEQUAD: 1086 case FILE_BEQDATE: 1087 case FILE_BEQLDATE: 1088 case FILE_BEQWDATE: 1089 p->q = (uint64_t)BE64(p); 1090 if (cvt_64(p, m) == -1) 1091 goto out; 1092 return 1; 1093 case FILE_LESHORT: 1094 p->h = (short)LE16(p); 1095 if (cvt_16(p, m) == -1) 1096 goto out; 1097 return 1; 1098 case FILE_LELONG: 1099 case FILE_LEDATE: 1100 case FILE_LELDATE: 1101 p->l = (int32_t)LE32(p); 1102 if (cvt_32(p, m) == -1) 1103 goto out; 1104 return 1; 1105 case FILE_LEQUAD: 1106 case FILE_LEQDATE: 1107 case FILE_LEQLDATE: 1108 case FILE_LEQWDATE: 1109 p->q = (uint64_t)LE64(p); 1110 if (cvt_64(p, m) == -1) 1111 goto out; 1112 return 1; 1113 case FILE_MELONG: 1114 case FILE_MEDATE: 1115 case FILE_MELDATE: 1116 p->l = (int32_t)ME32(p); 1117 if (cvt_32(p, m) == -1) 1118 goto out; 1119 return 1; 1120 case FILE_FLOAT: 1121 if (cvt_float(p, m) == -1) 1122 goto out; 1123 return 1; 1124 case FILE_BEFLOAT: 1125 p->l = BE32(p); 1126 if (cvt_float(p, m) == -1) 1127 goto out; 1128 return 1; 1129 case FILE_LEFLOAT: 1130 p->l = LE32(p); 1131 if (cvt_float(p, m) == -1) 1132 goto out; 1133 return 1; 1134 case FILE_DOUBLE: 1135 if (cvt_double(p, m) == -1) 1136 goto out; 1137 return 1; 1138 case FILE_BEDOUBLE: 1139 p->q = BE64(p); 1140 if (cvt_double(p, m) == -1) 1141 goto out; 1142 return 1; 1143 case FILE_LEDOUBLE: 1144 p->q = LE64(p); 1145 if (cvt_double(p, m) == -1) 1146 goto out; 1147 return 1; 1148 case FILE_REGEX: 1149 case FILE_SEARCH: 1150 case FILE_DEFAULT: 1151 case FILE_CLEAR: 1152 case FILE_NAME: 1153 case FILE_USE: 1154 case FILE_DER: 1155 return 1; 1156 default: 1157 file_magerror(ms, "invalid type %d in mconvert()", m->type); 1158 return 0; 1159 } 1160 out: 1161 file_magerror(ms, "zerodivide in mconvert()"); 1162 return 0; 1163 } 1164 1165 1166 private void 1167 mdebug(uint32_t offset, const char *str, size_t len) 1168 { 1169 (void) fprintf(stderr, "mget/%" SIZE_T_FORMAT "u @%d: ", len, offset); 1170 file_showstr(stderr, str, len); 1171 (void) fputc('\n', stderr); 1172 (void) fputc('\n', stderr); 1173 } 1174 1175 private int 1176 mcopy(struct magic_set *ms, union VALUETYPE *p, int type, int indir, 1177 const unsigned char *s, uint32_t offset, size_t nbytes, struct magic *m) 1178 { 1179 /* 1180 * Note: FILE_SEARCH and FILE_REGEX do not actually copy 1181 * anything, but setup pointers into the source 1182 */ 1183 if (indir == 0) { 1184 switch (type) { 1185 case FILE_DER: 1186 case FILE_SEARCH: 1187 if (offset > nbytes) 1188 offset = CAST(uint32_t, nbytes); 1189 ms->search.s = RCAST(const char *, s) + offset; 1190 ms->search.s_len = nbytes - offset; 1191 ms->search.offset = offset; 1192 return 0; 1193 1194 case FILE_REGEX: { 1195 const char *b; 1196 const char *c; 1197 const char *last; /* end of search region */ 1198 const char *buf; /* start of search region */ 1199 const char *end; 1200 size_t lines, linecnt, bytecnt; 1201 1202 if (s == NULL || nbytes < offset) { 1203 ms->search.s_len = 0; 1204 ms->search.s = NULL; 1205 return 0; 1206 } 1207 1208 if (m->str_flags & REGEX_LINE_COUNT) { 1209 linecnt = m->str_range; 1210 bytecnt = linecnt * 80; 1211 } else { 1212 linecnt = 0; 1213 bytecnt = m->str_range; 1214 } 1215 1216 if (bytecnt == 0 || bytecnt > nbytes - offset) 1217 bytecnt = nbytes - offset; 1218 if (bytecnt > ms->regex_max) 1219 bytecnt = ms->regex_max; 1220 1221 buf = RCAST(const char *, s) + offset; 1222 end = last = RCAST(const char *, s) + bytecnt + offset; 1223 /* mget() guarantees buf <= last */ 1224 for (lines = linecnt, b = buf; lines && b < end && 1225 ((b = CAST(const char *, 1226 memchr(c = b, '\n', CAST(size_t, (end - b))))) 1227 || (b = CAST(const char *, 1228 memchr(c, '\r', CAST(size_t, (end - c)))))); 1229 lines--, b++) { 1230 last = b; 1231 if (b < end - 1 && b[0] == '\r' && b[1] == '\n') 1232 b++; 1233 } 1234 if (lines) 1235 last = RCAST(const char *, s) + bytecnt; 1236 1237 ms->search.s = buf; 1238 ms->search.s_len = last - buf; 1239 ms->search.offset = offset; 1240 ms->search.rm_len = 0; 1241 return 0; 1242 } 1243 case FILE_BESTRING16: 1244 case FILE_LESTRING16: { 1245 const unsigned char *src = s + offset; 1246 const unsigned char *esrc = s + nbytes; 1247 char *dst = p->s; 1248 char *edst = &p->s[sizeof(p->s) - 1]; 1249 1250 if (type == FILE_BESTRING16) 1251 src++; 1252 1253 /* check that offset is within range */ 1254 if (offset >= nbytes) 1255 break; 1256 for (/*EMPTY*/; src < esrc; src += 2, dst++) { 1257 if (dst < edst) 1258 *dst = *src; 1259 else 1260 break; 1261 if (*dst == '\0') { 1262 if (type == FILE_BESTRING16 ? 1263 *(src - 1) != '\0' : 1264 ((src + 1 < esrc) && 1265 *(src + 1) != '\0')) 1266 *dst = ' '; 1267 } 1268 } 1269 *edst = '\0'; 1270 return 0; 1271 } 1272 case FILE_STRING: /* XXX - these two should not need */ 1273 case FILE_PSTRING: /* to copy anything, but do anyway. */ 1274 default: 1275 break; 1276 } 1277 } 1278 1279 if (offset >= nbytes) { 1280 (void)memset(p, '\0', sizeof(*p)); 1281 return 0; 1282 } 1283 if (nbytes - offset < sizeof(*p)) 1284 nbytes = nbytes - offset; 1285 else 1286 nbytes = sizeof(*p); 1287 1288 (void)memcpy(p, s + offset, nbytes); 1289 1290 /* 1291 * the usefulness of padding with zeroes eludes me, it 1292 * might even cause problems 1293 */ 1294 if (nbytes < sizeof(*p)) 1295 (void)memset(((char *)(void *)p) + nbytes, '\0', 1296 sizeof(*p) - nbytes); 1297 return 0; 1298 } 1299 1300 private uint32_t 1301 do_ops(struct magic *m, intmax_t lhs, intmax_t off) 1302 { 1303 intmax_t offset = 0; 1304 if (off) { 1305 switch (m->in_op & FILE_OPS_MASK) { 1306 case FILE_OPAND: 1307 offset = lhs & off; 1308 break; 1309 case FILE_OPOR: 1310 offset = lhs | off; 1311 break; 1312 case FILE_OPXOR: 1313 offset = lhs ^ off; 1314 break; 1315 case FILE_OPADD: 1316 offset = lhs + off; 1317 break; 1318 case FILE_OPMINUS: 1319 offset = lhs - off; 1320 break; 1321 case FILE_OPMULTIPLY: 1322 offset = lhs * off; 1323 break; 1324 case FILE_OPDIVIDE: 1325 offset = lhs / off; 1326 break; 1327 case FILE_OPMODULO: 1328 offset = lhs % off; 1329 break; 1330 } 1331 } else 1332 offset = lhs; 1333 if (m->in_op & FILE_OPINVERSE) 1334 offset = ~offset; 1335 1336 return (uint32_t)offset; 1337 } 1338 1339 private int 1340 mget(struct magic_set *ms, const unsigned char *s, struct magic *m, 1341 size_t nbytes, size_t o, unsigned int cont_level, int mode, int text, 1342 int flip, uint16_t *indir_count, uint16_t *name_count, 1343 int *printed_something, int *need_separator, int *returnval) 1344 { 1345 uint32_t offset = ms->offset; 1346 intmax_t lhs; 1347 file_pushbuf_t *pb; 1348 int rv, oneed_separator, in_type; 1349 char *rbuf; 1350 union VALUETYPE *p = &ms->ms_value; 1351 struct mlist ml; 1352 1353 if (*indir_count >= ms->indir_max) { 1354 file_error(ms, 0, "indirect count (%hu) exceeded", 1355 *indir_count); 1356 return -1; 1357 } 1358 1359 if (*name_count >= ms->name_max) { 1360 file_error(ms, 0, "name use count (%hu) exceeded", 1361 *name_count); 1362 return -1; 1363 } 1364 1365 if (mcopy(ms, p, m->type, m->flag & INDIR, s, (uint32_t)(offset + o), 1366 (uint32_t)nbytes, m) == -1) 1367 return -1; 1368 1369 if ((ms->flags & MAGIC_DEBUG) != 0) { 1370 fprintf(stderr, "mget(type=%d, flag=%#x, offset=%u, o=%" 1371 SIZE_T_FORMAT "u, " "nbytes=%" SIZE_T_FORMAT 1372 "u, il=%hu, nc=%hu)\n", 1373 m->type, m->flag, offset, o, nbytes, 1374 *indir_count, *name_count); 1375 mdebug(offset, (char *)(void *)p, sizeof(union VALUETYPE)); 1376 #ifndef COMPILE_ONLY 1377 file_mdump(m); 1378 #endif 1379 } 1380 1381 if (m->flag & INDIR) { 1382 intmax_t off = m->in_offset; 1383 const int sgn = m->in_op & FILE_OPSIGNED; 1384 if (m->in_op & FILE_OPINDIRECT) { 1385 const union VALUETYPE *q = CAST(const union VALUETYPE *, 1386 ((const void *)(s + offset + off))); 1387 if (OFFSET_OOB(nbytes, offset + off, sizeof(*q))) 1388 return 0; 1389 switch (cvt_flip(m->in_type, flip)) { 1390 case FILE_BYTE: 1391 off = SEXT(sgn,8,q->b); 1392 break; 1393 case FILE_SHORT: 1394 off = SEXT(sgn,16,q->h); 1395 break; 1396 case FILE_BESHORT: 1397 off = SEXT(sgn,16,BE16(q)); 1398 break; 1399 case FILE_LESHORT: 1400 off = SEXT(sgn,16,LE16(q)); 1401 break; 1402 case FILE_LONG: 1403 off = SEXT(sgn,32,q->l); 1404 break; 1405 case FILE_BELONG: 1406 case FILE_BEID3: 1407 off = SEXT(sgn,32,BE32(q)); 1408 break; 1409 case FILE_LEID3: 1410 case FILE_LELONG: 1411 off = SEXT(sgn,32,LE32(q)); 1412 break; 1413 case FILE_MELONG: 1414 off = SEXT(sgn,32,ME32(q)); 1415 break; 1416 } 1417 if ((ms->flags & MAGIC_DEBUG) != 0) 1418 fprintf(stderr, "indirect offs=%jd\n", off); 1419 } 1420 switch (in_type = cvt_flip(m->in_type, flip)) { 1421 case FILE_BYTE: 1422 if (OFFSET_OOB(nbytes, offset, 1)) 1423 return 0; 1424 offset = do_ops(m, SEXT(sgn,8,p->b), off); 1425 break; 1426 case FILE_BESHORT: 1427 if (OFFSET_OOB(nbytes, offset, 2)) 1428 return 0; 1429 offset = do_ops(m, SEXT(sgn,16,BE16(p)), off); 1430 break; 1431 case FILE_LESHORT: 1432 if (OFFSET_OOB(nbytes, offset, 2)) 1433 return 0; 1434 offset = do_ops(m, SEXT(sgn,16,LE16(p)), off); 1435 break; 1436 case FILE_SHORT: 1437 if (OFFSET_OOB(nbytes, offset, 2)) 1438 return 0; 1439 offset = do_ops(m, SEXT(sgn,16,p->h), off); 1440 break; 1441 case FILE_BELONG: 1442 case FILE_BEID3: 1443 if (OFFSET_OOB(nbytes, offset, 4)) 1444 return 0; 1445 lhs = BE32(p); 1446 if (in_type == FILE_BEID3) 1447 lhs = cvt_id3(ms, (uint32_t)lhs); 1448 offset = do_ops(m, SEXT(sgn,32,lhs), off); 1449 break; 1450 case FILE_LELONG: 1451 case FILE_LEID3: 1452 if (OFFSET_OOB(nbytes, offset, 4)) 1453 return 0; 1454 lhs = LE32(p); 1455 if (in_type == FILE_LEID3) 1456 lhs = cvt_id3(ms, (uint32_t)lhs); 1457 offset = do_ops(m, SEXT(sgn,32,lhs), off); 1458 break; 1459 case FILE_MELONG: 1460 if (OFFSET_OOB(nbytes, offset, 4)) 1461 return 0; 1462 offset = do_ops(m, SEXT(sgn,32,ME32(p)), off); 1463 break; 1464 case FILE_LONG: 1465 if (OFFSET_OOB(nbytes, offset, 4)) 1466 return 0; 1467 offset = do_ops(m, SEXT(sgn,32,p->l), off); 1468 break; 1469 default: 1470 break; 1471 } 1472 1473 if (m->flag & INDIROFFADD) { 1474 offset += ms->c.li[cont_level-1].off; 1475 if (offset == 0) { 1476 if ((ms->flags & MAGIC_DEBUG) != 0) 1477 fprintf(stderr, 1478 "indirect *zero* offset\n"); 1479 return 0; 1480 } 1481 if ((ms->flags & MAGIC_DEBUG) != 0) 1482 fprintf(stderr, "indirect +offs=%u\n", offset); 1483 } 1484 if (mcopy(ms, p, m->type, 0, s, offset, nbytes, m) == -1) 1485 return -1; 1486 ms->offset = offset; 1487 1488 if ((ms->flags & MAGIC_DEBUG) != 0) { 1489 mdebug(offset, (char *)(void *)p, 1490 sizeof(union VALUETYPE)); 1491 #ifndef COMPILE_ONLY 1492 file_mdump(m); 1493 #endif 1494 } 1495 } 1496 1497 /* Verify we have enough data to match magic type */ 1498 switch (m->type) { 1499 case FILE_BYTE: 1500 if (OFFSET_OOB(nbytes, offset, 1)) 1501 return 0; 1502 break; 1503 1504 case FILE_SHORT: 1505 case FILE_BESHORT: 1506 case FILE_LESHORT: 1507 if (OFFSET_OOB(nbytes, offset, 2)) 1508 return 0; 1509 break; 1510 1511 case FILE_LONG: 1512 case FILE_BELONG: 1513 case FILE_LELONG: 1514 case FILE_MELONG: 1515 case FILE_DATE: 1516 case FILE_BEDATE: 1517 case FILE_LEDATE: 1518 case FILE_MEDATE: 1519 case FILE_LDATE: 1520 case FILE_BELDATE: 1521 case FILE_LELDATE: 1522 case FILE_MELDATE: 1523 case FILE_FLOAT: 1524 case FILE_BEFLOAT: 1525 case FILE_LEFLOAT: 1526 if (OFFSET_OOB(nbytes, offset, 4)) 1527 return 0; 1528 break; 1529 1530 case FILE_DOUBLE: 1531 case FILE_BEDOUBLE: 1532 case FILE_LEDOUBLE: 1533 if (OFFSET_OOB(nbytes, offset, 8)) 1534 return 0; 1535 break; 1536 1537 case FILE_STRING: 1538 case FILE_PSTRING: 1539 case FILE_SEARCH: 1540 if (OFFSET_OOB(nbytes, offset, m->vallen)) 1541 return 0; 1542 break; 1543 1544 case FILE_REGEX: 1545 if (nbytes < offset) 1546 return 0; 1547 break; 1548 1549 case FILE_INDIRECT: 1550 if (m->str_flags & INDIRECT_RELATIVE) 1551 offset += CAST(uint32_t, o); 1552 if (offset == 0) 1553 return 0; 1554 1555 if (nbytes < offset) 1556 return 0; 1557 1558 if ((pb = file_push_buffer(ms)) == NULL) 1559 return -1; 1560 1561 (*indir_count)++; 1562 rv = file_softmagic(ms, s + offset, nbytes - offset, 1563 indir_count, name_count, BINTEST, text); 1564 1565 if ((ms->flags & MAGIC_DEBUG) != 0) 1566 fprintf(stderr, "indirect @offs=%u[%d]\n", offset, rv); 1567 1568 rbuf = file_pop_buffer(ms, pb); 1569 if (rbuf == NULL && ms->event_flags & EVENT_HAD_ERR) 1570 return -1; 1571 1572 if (rv == 1) { 1573 if ((ms->flags & MAGIC_NODESC) == 0 && 1574 file_printf(ms, F(ms, m, "%u"), offset) == -1) { 1575 free(rbuf); 1576 return -1; 1577 } 1578 if (file_printf(ms, "%s", rbuf) == -1) { 1579 free(rbuf); 1580 return -1; 1581 } 1582 } 1583 free(rbuf); 1584 return rv; 1585 1586 case FILE_USE: 1587 if (nbytes < offset) 1588 return 0; 1589 rbuf = m->value.s; 1590 if (*rbuf == '^') { 1591 rbuf++; 1592 flip = !flip; 1593 } 1594 if (file_magicfind(ms, rbuf, &ml) == -1) { 1595 file_error(ms, 0, "cannot find entry `%s'", rbuf); 1596 return -1; 1597 } 1598 (*name_count)++; 1599 oneed_separator = *need_separator; 1600 if (m->flag & NOSPACE) 1601 *need_separator = 0; 1602 rv = match(ms, ml.magic, ml.nmagic, s, nbytes, offset + o, 1603 mode, text, flip, indir_count, name_count, 1604 printed_something, need_separator, returnval); 1605 if (rv != 1) 1606 *need_separator = oneed_separator; 1607 return 1; 1608 1609 case FILE_NAME: 1610 if (ms->flags & MAGIC_NODESC) 1611 return 1; 1612 if (file_printf(ms, "%s", m->desc) == -1) 1613 return -1; 1614 return 1; 1615 case FILE_DER: 1616 case FILE_DEFAULT: /* nothing to check */ 1617 case FILE_CLEAR: 1618 default: 1619 break; 1620 } 1621 if (!mconvert(ms, m, flip)) 1622 return 0; 1623 return 1; 1624 } 1625 1626 private uint64_t 1627 file_strncmp(const char *s1, const char *s2, size_t len, uint32_t flags) 1628 { 1629 /* 1630 * Convert the source args to unsigned here so that (1) the 1631 * compare will be unsigned as it is in strncmp() and (2) so 1632 * the ctype functions will work correctly without extra 1633 * casting. 1634 */ 1635 const unsigned char *a = (const unsigned char *)s1; 1636 const unsigned char *b = (const unsigned char *)s2; 1637 const unsigned char *eb = b + len; 1638 uint64_t v; 1639 1640 /* 1641 * What we want here is v = strncmp(s1, s2, len), 1642 * but ignoring any nulls. 1643 */ 1644 v = 0; 1645 if (0L == flags) { /* normal string: do it fast */ 1646 while (len-- > 0) 1647 if ((v = *b++ - *a++) != '\0') 1648 break; 1649 } 1650 else { /* combine the others */ 1651 while (len-- > 0) { 1652 if (b >= eb) { 1653 v = 1; 1654 break; 1655 } 1656 if ((flags & STRING_IGNORE_LOWERCASE) && 1657 islower(*a)) { 1658 if ((v = tolower(*b++) - *a++) != '\0') 1659 break; 1660 } 1661 else if ((flags & STRING_IGNORE_UPPERCASE) && 1662 isupper(*a)) { 1663 if ((v = toupper(*b++) - *a++) != '\0') 1664 break; 1665 } 1666 else if ((flags & STRING_COMPACT_WHITESPACE) && 1667 isspace(*a)) { 1668 a++; 1669 if (isspace(*b++)) { 1670 if (!isspace(*a)) 1671 while (b < eb && isspace(*b)) 1672 b++; 1673 } 1674 else { 1675 v = 1; 1676 break; 1677 } 1678 } 1679 else if ((flags & STRING_COMPACT_OPTIONAL_WHITESPACE) && 1680 isspace(*a)) { 1681 a++; 1682 while (b < eb && isspace(*b)) 1683 b++; 1684 } 1685 else { 1686 if ((v = *b++ - *a++) != '\0') 1687 break; 1688 } 1689 } 1690 } 1691 return v; 1692 } 1693 1694 private uint64_t 1695 file_strncmp16(const char *a, const char *b, size_t len, uint32_t flags) 1696 { 1697 /* 1698 * XXX - The 16-bit string compare probably needs to be done 1699 * differently, especially if the flags are to be supported. 1700 * At the moment, I am unsure. 1701 */ 1702 flags = 0; 1703 return file_strncmp(a, b, len, flags); 1704 } 1705 1706 private int 1707 magiccheck(struct magic_set *ms, struct magic *m) 1708 { 1709 uint64_t l = m->value.q; 1710 uint64_t v; 1711 float fl, fv; 1712 double dl, dv; 1713 int matched; 1714 union VALUETYPE *p = &ms->ms_value; 1715 1716 switch (m->type) { 1717 case FILE_BYTE: 1718 v = p->b; 1719 break; 1720 1721 case FILE_SHORT: 1722 case FILE_BESHORT: 1723 case FILE_LESHORT: 1724 v = p->h; 1725 break; 1726 1727 case FILE_LONG: 1728 case FILE_BELONG: 1729 case FILE_LELONG: 1730 case FILE_MELONG: 1731 case FILE_DATE: 1732 case FILE_BEDATE: 1733 case FILE_LEDATE: 1734 case FILE_MEDATE: 1735 case FILE_LDATE: 1736 case FILE_BELDATE: 1737 case FILE_LELDATE: 1738 case FILE_MELDATE: 1739 v = p->l; 1740 break; 1741 1742 case FILE_QUAD: 1743 case FILE_LEQUAD: 1744 case FILE_BEQUAD: 1745 case FILE_QDATE: 1746 case FILE_BEQDATE: 1747 case FILE_LEQDATE: 1748 case FILE_QLDATE: 1749 case FILE_BEQLDATE: 1750 case FILE_LEQLDATE: 1751 case FILE_QWDATE: 1752 case FILE_BEQWDATE: 1753 case FILE_LEQWDATE: 1754 v = p->q; 1755 break; 1756 1757 case FILE_FLOAT: 1758 case FILE_BEFLOAT: 1759 case FILE_LEFLOAT: 1760 fl = m->value.f; 1761 fv = p->f; 1762 switch (m->reln) { 1763 case 'x': 1764 matched = 1; 1765 break; 1766 1767 case '!': 1768 matched = fv != fl; 1769 break; 1770 1771 case '=': 1772 matched = fv == fl; 1773 break; 1774 1775 case '>': 1776 matched = fv > fl; 1777 break; 1778 1779 case '<': 1780 matched = fv < fl; 1781 break; 1782 1783 default: 1784 file_magerror(ms, "cannot happen with float: invalid relation `%c'", 1785 m->reln); 1786 return -1; 1787 } 1788 return matched; 1789 1790 case FILE_DOUBLE: 1791 case FILE_BEDOUBLE: 1792 case FILE_LEDOUBLE: 1793 dl = m->value.d; 1794 dv = p->d; 1795 switch (m->reln) { 1796 case 'x': 1797 matched = 1; 1798 break; 1799 1800 case '!': 1801 matched = dv != dl; 1802 break; 1803 1804 case '=': 1805 matched = dv == dl; 1806 break; 1807 1808 case '>': 1809 matched = dv > dl; 1810 break; 1811 1812 case '<': 1813 matched = dv < dl; 1814 break; 1815 1816 default: 1817 file_magerror(ms, "cannot happen with double: invalid relation `%c'", m->reln); 1818 return -1; 1819 } 1820 return matched; 1821 1822 case FILE_DEFAULT: 1823 case FILE_CLEAR: 1824 l = 0; 1825 v = 0; 1826 break; 1827 1828 case FILE_STRING: 1829 case FILE_PSTRING: 1830 l = 0; 1831 v = file_strncmp(m->value.s, p->s, (size_t)m->vallen, m->str_flags); 1832 break; 1833 1834 case FILE_BESTRING16: 1835 case FILE_LESTRING16: 1836 l = 0; 1837 v = file_strncmp16(m->value.s, p->s, (size_t)m->vallen, m->str_flags); 1838 break; 1839 1840 case FILE_SEARCH: { /* search ms->search.s for the string m->value.s */ 1841 size_t slen; 1842 size_t idx; 1843 1844 if (ms->search.s == NULL) 1845 return 0; 1846 1847 slen = MIN(m->vallen, sizeof(m->value.s)); 1848 l = 0; 1849 v = 0; 1850 1851 for (idx = 0; m->str_range == 0 || idx < m->str_range; idx++) { 1852 if (slen + idx > ms->search.s_len) 1853 return 0; 1854 1855 v = file_strncmp(m->value.s, ms->search.s + idx, slen, 1856 m->str_flags); 1857 if (v == 0) { /* found match */ 1858 ms->search.offset += idx; 1859 ms->search.rm_len = ms->search.s_len - idx; 1860 break; 1861 } 1862 } 1863 break; 1864 } 1865 case FILE_REGEX: { 1866 int rc; 1867 file_regex_t rx; 1868 const char *search; 1869 1870 if (ms->search.s == NULL) 1871 return 0; 1872 1873 l = 0; 1874 rc = file_regcomp(&rx, m->value.s, 1875 REG_EXTENDED|REG_NEWLINE| 1876 ((m->str_flags & STRING_IGNORE_CASE) ? REG_ICASE : 0)); 1877 if (rc) { 1878 file_regerror(&rx, rc, ms); 1879 v = (uint64_t)-1; 1880 } else { 1881 regmatch_t pmatch; 1882 size_t slen = ms->search.s_len; 1883 char *copy; 1884 if (slen != 0) { 1885 copy = CAST(char *, malloc(slen)); 1886 if (copy == NULL) { 1887 file_regfree(&rx); 1888 file_error(ms, errno, 1889 "can't allocate %" SIZE_T_FORMAT "u bytes", 1890 slen); 1891 return -1; 1892 } 1893 memcpy(copy, ms->search.s, slen); 1894 copy[--slen] = '\0'; 1895 search = copy; 1896 } else { 1897 search = CCAST(char *, ""); 1898 copy = NULL; 1899 } 1900 rc = file_regexec(&rx, (const char *)search, 1901 1, &pmatch, 0); 1902 free(copy); 1903 switch (rc) { 1904 case 0: 1905 ms->search.s += (int)pmatch.rm_so; 1906 ms->search.offset += (size_t)pmatch.rm_so; 1907 ms->search.rm_len = 1908 (size_t)(pmatch.rm_eo - pmatch.rm_so); 1909 v = 0; 1910 break; 1911 1912 case REG_NOMATCH: 1913 v = 1; 1914 break; 1915 1916 default: 1917 file_regerror(&rx, rc, ms); 1918 v = (uint64_t)-1; 1919 break; 1920 } 1921 } 1922 file_regfree(&rx); 1923 if (v == (uint64_t)-1) 1924 return -1; 1925 break; 1926 } 1927 case FILE_INDIRECT: 1928 case FILE_USE: 1929 case FILE_NAME: 1930 return 1; 1931 case FILE_DER: 1932 matched = der_cmp(ms, m); 1933 if (matched == -1) { 1934 if ((ms->flags & MAGIC_DEBUG) != 0) { 1935 (void) fprintf(stderr, 1936 "EOF comparing DER entries"); 1937 } 1938 return 0; 1939 } 1940 return matched; 1941 default: 1942 file_magerror(ms, "invalid type %d in magiccheck()", m->type); 1943 return -1; 1944 } 1945 1946 v = file_signextend(ms, m, v); 1947 1948 switch (m->reln) { 1949 case 'x': 1950 if ((ms->flags & MAGIC_DEBUG) != 0) 1951 (void) fprintf(stderr, "%" INT64_T_FORMAT 1952 "u == *any* = 1\n", (unsigned long long)v); 1953 matched = 1; 1954 break; 1955 1956 case '!': 1957 matched = v != l; 1958 if ((ms->flags & MAGIC_DEBUG) != 0) 1959 (void) fprintf(stderr, "%" INT64_T_FORMAT "u != %" 1960 INT64_T_FORMAT "u = %d\n", (unsigned long long)v, 1961 (unsigned long long)l, matched); 1962 break; 1963 1964 case '=': 1965 matched = v == l; 1966 if ((ms->flags & MAGIC_DEBUG) != 0) 1967 (void) fprintf(stderr, "%" INT64_T_FORMAT "u == %" 1968 INT64_T_FORMAT "u = %d\n", (unsigned long long)v, 1969 (unsigned long long)l, matched); 1970 break; 1971 1972 case '>': 1973 if (m->flag & UNSIGNED) { 1974 matched = v > l; 1975 if ((ms->flags & MAGIC_DEBUG) != 0) 1976 (void) fprintf(stderr, "%" INT64_T_FORMAT 1977 "u > %" INT64_T_FORMAT "u = %d\n", 1978 (unsigned long long)v, 1979 (unsigned long long)l, matched); 1980 } 1981 else { 1982 matched = (int64_t) v > (int64_t) l; 1983 if ((ms->flags & MAGIC_DEBUG) != 0) 1984 (void) fprintf(stderr, "%" INT64_T_FORMAT 1985 "d > %" INT64_T_FORMAT "d = %d\n", 1986 (long long)v, (long long)l, matched); 1987 } 1988 break; 1989 1990 case '<': 1991 if (m->flag & UNSIGNED) { 1992 matched = v < l; 1993 if ((ms->flags & MAGIC_DEBUG) != 0) 1994 (void) fprintf(stderr, "%" INT64_T_FORMAT 1995 "u < %" INT64_T_FORMAT "u = %d\n", 1996 (unsigned long long)v, 1997 (unsigned long long)l, matched); 1998 } 1999 else { 2000 matched = (int64_t) v < (int64_t) l; 2001 if ((ms->flags & MAGIC_DEBUG) != 0) 2002 (void) fprintf(stderr, "%" INT64_T_FORMAT 2003 "d < %" INT64_T_FORMAT "d = %d\n", 2004 (long long)v, (long long)l, matched); 2005 } 2006 break; 2007 2008 case '&': 2009 matched = (v & l) == l; 2010 if ((ms->flags & MAGIC_DEBUG) != 0) 2011 (void) fprintf(stderr, "((%" INT64_T_FORMAT "x & %" 2012 INT64_T_FORMAT "x) == %" INT64_T_FORMAT 2013 "x) = %d\n", (unsigned long long)v, 2014 (unsigned long long)l, (unsigned long long)l, 2015 matched); 2016 break; 2017 2018 case '^': 2019 matched = (v & l) != l; 2020 if ((ms->flags & MAGIC_DEBUG) != 0) 2021 (void) fprintf(stderr, "((%" INT64_T_FORMAT "x & %" 2022 INT64_T_FORMAT "x) != %" INT64_T_FORMAT 2023 "x) = %d\n", (unsigned long long)v, 2024 (unsigned long long)l, (unsigned long long)l, 2025 matched); 2026 break; 2027 2028 default: 2029 file_magerror(ms, "cannot happen: invalid relation `%c'", 2030 m->reln); 2031 return -1; 2032 } 2033 2034 return matched; 2035 } 2036 2037 private int 2038 handle_annotation(struct magic_set *ms, struct magic *m, int firstline) 2039 { 2040 if ((ms->flags & MAGIC_APPLE) && m->apple[0]) { 2041 if (!firstline && file_printf(ms, "\n- ") == -1) 2042 return -1; 2043 if (file_printf(ms, "%.8s", m->apple) == -1) 2044 return -1; 2045 return 1; 2046 } 2047 if ((ms->flags & MAGIC_EXTENSION) && m->ext[0]) { 2048 if (!firstline && file_printf(ms, "\n- ") == -1) 2049 return -1; 2050 if (file_printf(ms, "%s", m->ext) == -1) 2051 return -1; 2052 return 1; 2053 } 2054 if ((ms->flags & MAGIC_MIME_TYPE) && m->mimetype[0]) { 2055 if (!firstline && file_printf(ms, "\n- ") == -1) 2056 return -1; 2057 if (file_printf(ms, "%s", m->mimetype) == -1) 2058 return -1; 2059 return 1; 2060 } 2061 return 0; 2062 } 2063 2064 private int 2065 print_sep(struct magic_set *ms, int firstline) 2066 { 2067 // if (ms->flags & MAGIC_NODESC) 2068 // return 0; 2069 if (firstline) 2070 return 0; 2071 /* 2072 * we found another match 2073 * put a newline and '-' to do some simple formatting 2074 */ 2075 return file_printf(ms, "\n- "); 2076 } 2077