1 /*- 2 * Copyright (c) 2009 The NetBSD Foundation, Inc. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to The NetBSD Foundation 6 * by Alistair Crooks (agc@NetBSD.org) 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 27 * POSSIBILITY OF SUCH DAMAGE. 28 */ 29 /* 30 * Copyright (c) 2005-2008 Nominet UK (www.nic.uk) 31 * All rights reserved. 32 * Contributors: Ben Laurie, Rachel Willmer. The Contributors have asserted 33 * their moral rights under the UK Copyright Design and Patents Act 1988 to 34 * be recorded as the authors of this copyright work. 35 * 36 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 37 * use this file except in compliance with the License. 38 * 39 * You may obtain a copy of the License at 40 * http://www.apache.org/licenses/LICENSE-2.0 41 * 42 * Unless required by applicable law or agreed to in writing, software 43 * distributed under the License is distributed on an "AS IS" BASIS, 44 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 45 * 46 * See the License for the specific language governing permissions and 47 * limitations under the License. 48 */ 49 50 /** \file 51 * \brief Parser for OpenPGP packets 52 */ 53 #include "config.h" 54 55 #ifdef HAVE_SYS_CDEFS_H 56 #include <sys/cdefs.h> 57 #endif 58 59 #if defined(__NetBSD__) 60 __COPYRIGHT("@(#) Copyright (c) 2009 The NetBSD Foundation, Inc. All rights reserved."); 61 __RCSID("$NetBSD: packet-parse.c,v 1.27 2009/11/20 07:17:07 agc Exp $"); 62 #endif 63 64 #ifdef HAVE_OPENSSL_CAST_H 65 #include <openssl/cast.h> 66 #endif 67 68 #include <stdarg.h> 69 #include <stdlib.h> 70 #include <string.h> 71 72 #ifdef HAVE_UNISTD_H 73 #include <unistd.h> 74 #endif 75 76 #ifdef HAVE_LIMITS_H 77 #include <limits.h> 78 #endif 79 80 #include "packet.h" 81 #include "packet-parse.h" 82 #include "keyring.h" 83 #include "errors.h" 84 #include "packet-show.h" 85 #include "create.h" 86 #include "readerwriter.h" 87 #include "netpgpdefs.h" 88 #include "crypto.h" 89 #include "netpgpdigest.h" 90 91 #define ERRP(cbinfo, cont, err) do { \ 92 cont.u.error.error = err; \ 93 CALLBACK(OPS_PARSER_ERROR, cbinfo, &cont); \ 94 return 0; \ 95 /*NOTREACHED*/ \ 96 } while(/*CONSTCOND*/0) 97 98 /** 99 * limread_data reads the specified amount of the subregion's data 100 * into a data_t structure 101 * 102 * \param data Empty structure which will be filled with data 103 * \param len Number of octets to read 104 * \param subregion 105 * \param stream How to parse 106 * 107 * \return 1 on success, 0 on failure 108 */ 109 static int 110 limread_data(__ops_data_t *data, unsigned int len, 111 __ops_region_t *subregion, __ops_stream_t *stream) 112 { 113 data->len = len; 114 115 if (subregion->length - subregion->readc < len) { 116 (void) fprintf(stderr, "limread_data: bad length\n"); 117 return 0; 118 } 119 120 data->contents = calloc(1, data->len); 121 if (!data->contents) { 122 return 0; 123 } 124 125 return __ops_limited_read(data->contents, data->len, subregion, 126 &stream->errors, &stream->readinfo, &stream->cbinfo); 127 } 128 129 /** 130 * read_data reads the remainder of the subregion's data 131 * into a data_t structure 132 * 133 * \param data 134 * \param subregion 135 * \param stream 136 * 137 * \return 1 on success, 0 on failure 138 */ 139 static int 140 read_data(__ops_data_t *data, __ops_region_t *region, __ops_stream_t *stream) 141 { 142 int cc; 143 144 cc = region->length - region->readc; 145 return (cc >= 0) ? limread_data(data, (unsigned)cc, region, stream) : 0; 146 } 147 148 /** 149 * Reads the remainder of the subregion as a string. 150 * It is the user's responsibility to free the memory allocated here. 151 */ 152 153 static int 154 read_unsig_str(unsigned char **str, __ops_region_t *subregion, 155 __ops_stream_t *stream) 156 { 157 size_t len; 158 159 len = subregion->length - subregion->readc; 160 if ((*str = calloc(1, len + 1)) == NULL) { 161 return 0; 162 } 163 if (len && 164 !__ops_limited_read(*str, len, subregion, &stream->errors, 165 &stream->readinfo, &stream->cbinfo)) { 166 return 0; 167 } 168 (*str)[len] = '\0'; 169 return 1; 170 } 171 172 static int 173 read_string(char **str, __ops_region_t *subregion, __ops_stream_t *stream) 174 { 175 return read_unsig_str((unsigned char **) str, subregion, stream); 176 } 177 178 void 179 __ops_init_subregion(__ops_region_t *subregion, __ops_region_t *region) 180 { 181 (void) memset(subregion, 0x0, sizeof(*subregion)); 182 subregion->parent = region; 183 } 184 185 /* 186 * XXX: replace __ops_ptag_t with something more appropriate for limiting reads 187 */ 188 189 /** 190 * low-level function to read data from reader function 191 * 192 * Use this function, rather than calling the reader directly. 193 * 194 * If the accumulate flag is set in *stream, the function 195 * adds the read data to the accumulated data, and updates 196 * the accumulated length. This is useful if, for example, 197 * the application wants access to the raw data as well as the 198 * parsed data. 199 * 200 * This function will also try to read the entire amount asked for, but not 201 * if it is over INT_MAX. Obviously many callers will know that they 202 * never ask for that much and so can avoid the extra complexity of 203 * dealing with return codes and filled-in lengths. 204 * 205 * \param *dest 206 * \param *plength 207 * \param flags 208 * \param *stream 209 * 210 * \return OPS_R_OK 211 * \return OPS_R_PARTIAL_READ 212 * \return OPS_R_EOF 213 * \return OPS_R_EARLY_EOF 214 * 215 * \sa #__ops_reader_ret_t for details of return codes 216 */ 217 218 static int 219 sub_base_read(void *dest, size_t length, __ops_error_t **errors, 220 __ops_reader_t *readinfo, __ops_cbdata_t *cbinfo) 221 { 222 size_t n; 223 224 /* reading more than this would look like an error */ 225 if (length > INT_MAX) 226 length = INT_MAX; 227 228 for (n = 0; n < length;) { 229 int r; 230 231 r = readinfo->reader((char *) dest + n, length - n, errors, 232 readinfo, cbinfo); 233 if (r > (int)(length - n)) { 234 (void) fprintf(stderr, "sub_base_read: bad read\n"); 235 return 0; 236 } 237 if (r < 0) { 238 return r; 239 } 240 if (r == 0) { 241 break; 242 } 243 n += (unsigned)r; 244 } 245 246 if (n == 0) { 247 return 0; 248 } 249 if (readinfo->accumulate) { 250 if (readinfo->asize < readinfo->alength) { 251 (void) fprintf(stderr, "sub_base_read: bad size\n"); 252 return 0; 253 } 254 if (readinfo->alength + n > readinfo->asize) { 255 unsigned char *temp; 256 257 readinfo->asize = (readinfo->asize * 2) + n; 258 temp = realloc(readinfo->accumulated, readinfo->asize); 259 if (temp == NULL) { 260 (void) fprintf(stderr, 261 "sub_base_read: bad alloc\n"); 262 return 0; 263 } 264 readinfo->accumulated = temp; 265 } 266 if (readinfo->asize < readinfo->alength + n) { 267 (void) fprintf(stderr, "sub_base_read: bad realloc\n"); 268 return 0; 269 } 270 (void) memcpy(readinfo->accumulated + readinfo->alength, dest, 271 n); 272 } 273 /* we track length anyway, because it is used for packet offsets */ 274 readinfo->alength += n; 275 /* and also the position */ 276 readinfo->position += n; 277 278 return n; 279 } 280 281 int 282 __ops_stacked_read(void *dest, size_t length, __ops_error_t **errors, 283 __ops_reader_t *readinfo, __ops_cbdata_t *cbinfo) 284 { 285 return sub_base_read(dest, length, errors, readinfo->next, cbinfo); 286 } 287 288 /* This will do a full read so long as length < MAX_INT */ 289 static int 290 base_read(unsigned char *dest, size_t length, 291 __ops_stream_t *stream) 292 { 293 return sub_base_read(dest, length, &stream->errors, &stream->readinfo, 294 &stream->cbinfo); 295 } 296 297 /* 298 * Read a full size_t's worth. If the return is < than length, then 299 * *last_read tells you why - < 0 for an error, == 0 for EOF 300 */ 301 302 static size_t 303 full_read(unsigned char *dest, 304 size_t length, 305 int *last_read, 306 __ops_error_t **errors, 307 __ops_reader_t *readinfo, 308 __ops_cbdata_t *cbinfo) 309 { 310 size_t t; 311 int r = 0; /* preset in case some loon calls with length 312 * == 0 */ 313 314 for (t = 0; t < length;) { 315 r = sub_base_read(dest + t, length - t, errors, readinfo, 316 cbinfo); 317 if (r <= 0) { 318 *last_read = r; 319 return t; 320 } 321 t += (size_t)r; 322 } 323 324 *last_read = r; 325 326 return t; 327 } 328 329 330 331 /** Read a scalar value of selected length from reader. 332 * 333 * Read an unsigned scalar value from reader in Big Endian representation. 334 * 335 * This function does not know or care about packet boundaries. It 336 * also assumes that an EOF is an error. 337 * 338 * \param *result The scalar value is stored here 339 * \param *reader Our reader 340 * \param length How many bytes to read 341 * \return 1 on success, 0 on failure 342 */ 343 static unsigned 344 _read_scalar(unsigned *result, unsigned length, 345 __ops_stream_t *stream) 346 { 347 unsigned t = 0; 348 349 if (length > sizeof(*result)) { 350 (void) fprintf(stderr, "_read_scalar: bad length\n"); 351 return 0; 352 } 353 354 while (length--) { 355 unsigned char c; 356 int r; 357 358 r = base_read(&c, 1, stream); 359 if (r != 1) 360 return 0; 361 t = (t << 8) + c; 362 } 363 364 *result = t; 365 return 1; 366 } 367 368 /** 369 * \ingroup Core_ReadPackets 370 * \brief Read bytes from a region within the packet. 371 * 372 * Read length bytes into the buffer pointed to by *dest. 373 * Make sure we do not read over the packet boundary. 374 * Updates the Packet Tag's __ops_ptag_t::readc. 375 * 376 * If length would make us read over the packet boundary, or if 377 * reading fails, we call the callback with an error. 378 * 379 * Note that if the region is indeterminate, this can return a short 380 * read - check region->last_read for the length. EOF is indicated by 381 * a success return and region->last_read == 0 in this case (for a 382 * region of known length, EOF is an error). 383 * 384 * This function makes sure to respect packet boundaries. 385 * 386 * \param dest The destination buffer 387 * \param length How many bytes to read 388 * \param region Pointer to packet region 389 * \param errors Error stack 390 * \param readinfo Reader info 391 * \param cbinfo Callback info 392 * \return 1 on success, 0 on error 393 */ 394 unsigned 395 __ops_limited_read(unsigned char *dest, 396 size_t length, 397 __ops_region_t *region, 398 __ops_error_t **errors, 399 __ops_reader_t *readinfo, 400 __ops_cbdata_t *cbinfo) 401 { 402 size_t r; 403 int lr; 404 405 if (!region->indeterminate && 406 region->readc + length > region->length) { 407 OPS_ERROR(errors, OPS_E_P_NOT_ENOUGH_DATA, "Not enough data"); 408 return 0; 409 } 410 r = full_read(dest, length, &lr, errors, readinfo, cbinfo); 411 if (lr < 0) { 412 OPS_ERROR(errors, OPS_E_R_READ_FAILED, "Read failed"); 413 return 0; 414 } 415 if (!region->indeterminate && r != length) { 416 OPS_ERROR(errors, OPS_E_R_READ_FAILED, "Read failed"); 417 return 0; 418 } 419 region->last_read = r; 420 do { 421 region->readc += r; 422 if (region->parent && region->length > region->parent->length) { 423 (void) fprintf(stderr, 424 "ops_limited_read: bad length\n"); 425 return 0; 426 } 427 } while ((region = region->parent) != NULL); 428 return 1; 429 } 430 431 /** 432 \ingroup Core_ReadPackets 433 \brief Call __ops_limited_read on next in stack 434 */ 435 unsigned 436 __ops_stacked_limited_read(unsigned char *dest, unsigned length, 437 __ops_region_t *region, 438 __ops_error_t **errors, 439 __ops_reader_t *readinfo, 440 __ops_cbdata_t *cbinfo) 441 { 442 return __ops_limited_read(dest, length, region, errors, 443 readinfo->next, cbinfo); 444 } 445 446 static unsigned 447 limread(unsigned char *dest, unsigned length, 448 __ops_region_t *region, __ops_stream_t *info) 449 { 450 return __ops_limited_read(dest, length, region, &info->errors, 451 &info->readinfo, &info->cbinfo); 452 } 453 454 static unsigned 455 exact_limread(unsigned char *dest, unsigned len, 456 __ops_region_t *region, 457 __ops_stream_t *stream) 458 { 459 unsigned ret; 460 461 stream->exact_read = 1; 462 ret = limread(dest, len, region, stream); 463 stream->exact_read = 0; 464 return ret; 465 } 466 467 /** Skip over length bytes of this packet. 468 * 469 * Calls limread() to skip over some data. 470 * 471 * This function makes sure to respect packet boundaries. 472 * 473 * \param length How many bytes to skip 474 * \param *region Pointer to packet region 475 * \param *stream How to parse 476 * \return 1 on success, 0 on error (calls the cb with OPS_PARSER_ERROR in limread()). 477 */ 478 static int 479 limskip(unsigned length, __ops_region_t *region, __ops_stream_t *stream) 480 { 481 unsigned char buf[NETPGP_BUFSIZ]; 482 483 while (length > 0) { 484 unsigned n = length % NETPGP_BUFSIZ; 485 486 if (!limread(buf, n, region, stream)) { 487 return 0; 488 } 489 length -= n; 490 } 491 return 1; 492 } 493 494 /** Read a scalar. 495 * 496 * Read a big-endian scalar of length bytes, respecting packet 497 * boundaries (by calling limread() to read the raw data). 498 * 499 * This function makes sure to respect packet boundaries. 500 * 501 * \param *dest The scalar value is stored here 502 * \param length How many bytes make up this scalar (at most 4) 503 * \param *region Pointer to current packet region 504 * \param *stream How to parse 505 * \param *cb The callback 506 * \return 1 on success, 0 on error (calls the cb with OPS_PARSER_ERROR in limread()). 507 * 508 * \see RFC4880 3.1 509 */ 510 static int 511 limread_scalar(unsigned *dest, 512 unsigned len, 513 __ops_region_t *region, 514 __ops_stream_t *stream) 515 { 516 unsigned char c[4] = ""; 517 unsigned t; 518 unsigned n; 519 520 if (len > 4) { 521 (void) fprintf(stderr, "limread_scalar: bad length\n"); 522 return 0; 523 } 524 /*LINTED*/ 525 if (/*CONSTCOND*/sizeof(*dest) < 4) { 526 (void) fprintf(stderr, "limread_scalar: bad dest\n"); 527 return 0; 528 } 529 if (!limread(c, len, region, stream)) { 530 return 0; 531 } 532 for (t = 0, n = 0; n < len; ++n) { 533 t = (t << 8) + c[n]; 534 } 535 *dest = t; 536 return 1; 537 } 538 539 /** Read a scalar. 540 * 541 * Read a big-endian scalar of length bytes, respecting packet 542 * boundaries (by calling limread() to read the raw data). 543 * 544 * The value read is stored in a size_t, which is a different size 545 * from an unsigned on some platforms. 546 * 547 * This function makes sure to respect packet boundaries. 548 * 549 * \param *dest The scalar value is stored here 550 * \param length How many bytes make up this scalar (at most 4) 551 * \param *region Pointer to current packet region 552 * \param *stream How to parse 553 * \param *cb The callback 554 * \return 1 on success, 0 on error (calls the cb with OPS_PARSER_ERROR in limread()). 555 * 556 * \see RFC4880 3.1 557 */ 558 static int 559 limread_size_t(size_t *dest, 560 unsigned length, 561 __ops_region_t *region, 562 __ops_stream_t *stream) 563 { 564 unsigned tmp; 565 566 /* 567 * Note that because the scalar is at most 4 bytes, we don't care if 568 * size_t is bigger than usigned 569 */ 570 if (!limread_scalar(&tmp, length, region, stream)) 571 return 0; 572 573 *dest = tmp; 574 return 1; 575 } 576 577 /** Read a timestamp. 578 * 579 * Timestamps in OpenPGP are unix time, i.e. seconds since The Epoch (1.1.1970). They are stored in an unsigned scalar 580 * of 4 bytes. 581 * 582 * This function reads the timestamp using limread_scalar(). 583 * 584 * This function makes sure to respect packet boundaries. 585 * 586 * \param *dest The timestamp is stored here 587 * \param *ptag Pointer to current packet's Packet Tag. 588 * \param *reader Our reader 589 * \param *cb The callback 590 * \return see limread_scalar() 591 * 592 * \see RFC4880 3.5 593 */ 594 static int 595 limited_read_time(time_t *dest, __ops_region_t *region, 596 __ops_stream_t *stream) 597 { 598 unsigned char c; 599 time_t mytime = 0; 600 int i; 601 602 /* 603 * Cannot assume that time_t is 4 octets long - 604 * SunOS 5.10 and NetBSD both have 64-bit time_ts. 605 */ 606 if (/* CONSTCOND */sizeof(time_t) == 4) { 607 return limread_scalar((unsigned *)(void *)dest, 4, region, stream); 608 } 609 for (i = 0; i < 4; i++) { 610 if (!limread(&c, 1, region, stream)) { 611 return 0; 612 } 613 mytime = (mytime << 8) + c; 614 } 615 *dest = mytime; 616 return 1; 617 } 618 619 /** 620 * \ingroup Core_MPI 621 * Read a multiprecision integer. 622 * 623 * Large numbers (multiprecision integers, MPI) are stored in OpenPGP in two parts. First there is a 2 byte scalar 624 * indicating the length of the following MPI in Bits. Then follow the bits that make up the actual number, most 625 * significant bits first (Big Endian). The most significant bit in the MPI is supposed to be 1 (unless the MPI is 626 * encrypted - then it may be different as the bit count refers to the plain text but the bits are encrypted). 627 * 628 * Unused bits (i.e. those filling up the most significant byte from the left to the first bits that counts) are 629 * supposed to be cleared - I guess. XXX - does anything actually say so? 630 * 631 * This function makes sure to respect packet boundaries. 632 * 633 * \param **pgn return the integer there - the BIGNUM is created by BN_bin2bn() and probably needs to be freed 634 * by the caller XXX right ben? 635 * \param *ptag Pointer to current packet's Packet Tag. 636 * \param *reader Our reader 637 * \param *cb The callback 638 * \return 1 on success, 0 on error (by limread_scalar() or limread() or if the MPI is not properly formed (XXX 639 * see comment below - the callback is called with a OPS_PARSER_ERROR in case of an error) 640 * 641 * \see RFC4880 3.2 642 */ 643 static int 644 limread_mpi(BIGNUM **pbn, __ops_region_t *region, __ops_stream_t *stream) 645 { 646 unsigned char buf[NETPGP_BUFSIZ] = ""; 647 /* an MPI has a 2 byte length part. 648 * Length is given in bits, so the 649 * largest we should ever need for 650 * the buffer is NETPGP_BUFSIZ bytes. */ 651 unsigned length; 652 unsigned nonzero; 653 unsigned ret; 654 655 stream->reading_mpi_len = 1; 656 ret = (unsigned)limread_scalar(&length, 2, region, stream); 657 658 stream->reading_mpi_len = 0; 659 if (!ret) 660 return 0; 661 662 nonzero = length & 7; /* there should be this many zero bits in the 663 * MS byte */ 664 if (!nonzero) 665 nonzero = 8; 666 length = (length + 7) / 8; 667 668 if (length == 0) { 669 /* if we try to read a length of 0, then fail */ 670 if (__ops_get_debug_level(__FILE__)) { 671 (void) fprintf(stderr, "limread_mpi: 0 length\n"); 672 } 673 return 0; 674 } 675 if (length > NETPGP_BUFSIZ) { 676 (void) fprintf(stderr, "limread_mpi: bad length\n"); 677 return 0; 678 } 679 if (!limread(buf, length, region, stream)) { 680 return 0; 681 } 682 if (((unsigned)buf[0] >> nonzero) != 0 || 683 !((unsigned)buf[0] & (1U << (nonzero - 1U)))) { 684 OPS_ERROR(&stream->errors, OPS_E_P_MPI_FORMAT_ERROR, "MPI Format error"); 685 /* XXX: Ben, one part of 686 * this constraint does 687 * not apply to 688 * encrypted MPIs the 689 * draft says. -- peter */ 690 return 0; 691 } 692 *pbn = BN_bin2bn(buf, (int)length, NULL); 693 return 1; 694 } 695 696 /** Read some data with a New-Format length from reader. 697 * 698 * \sa Internet-Draft RFC4880.txt Section 4.2.2 699 * 700 * \param *length Where the decoded length will be put 701 * \param *stream How to parse 702 * \return 1 if OK, else 0 703 * 704 */ 705 706 static unsigned 707 read_new_length(unsigned *length, __ops_stream_t *stream) 708 { 709 unsigned char c; 710 711 if (base_read(&c, 1, stream) != 1) 712 return 0; 713 if (c < 192) { 714 /* 1. One-octet packet */ 715 *length = c; 716 return 1; 717 } else if (c >= 192 && c <= 223) { 718 /* 2. Two-octet packet */ 719 unsigned t = (c - 192) << 8; 720 721 if (base_read(&c, 1, stream) != 1) 722 return 0; 723 *length = t + c + 192; 724 return 1; 725 } else if (c == 255) { 726 /* 3. Five-Octet packet */ 727 return _read_scalar(length, 4, stream); 728 } else if (c >= 224 && c < 255) { 729 /* 4. Partial Body Length */ 730 /* XXX - agc - gpg multi-recipient encryption uses this */ 731 OPS_ERROR(&stream->errors, OPS_E_UNIMPLEMENTED, 732 "New format Partial Body Length fields not yet implemented"); 733 return 0; 734 } 735 return 0; 736 } 737 738 /** Read the length information for a new format Packet Tag. 739 * 740 * New style Packet Tags encode the length in one to five octets. This function reads the right amount of bytes and 741 * decodes it to the proper length information. 742 * 743 * This function makes sure to respect packet boundaries. 744 * 745 * \param *length return the length here 746 * \param *ptag Pointer to current packet's Packet Tag. 747 * \param *reader Our reader 748 * \param *cb The callback 749 * \return 1 on success, 0 on error (by limread_scalar() or limread() or if the MPI is not properly formed (XXX 750 * see comment below) 751 * 752 * \see RFC4880 4.2.2 753 * \see __ops_ptag_t 754 */ 755 static int 756 limited_read_new_length(unsigned *length, __ops_region_t *region, 757 __ops_stream_t *stream) 758 { 759 unsigned char c = 0x0; 760 761 if (!limread(&c, 1, region, stream)) { 762 return 0; 763 } 764 if (c < 192) { 765 *length = c; 766 return 1; 767 } 768 if (c < 255) { 769 unsigned t = (c - 192) << 8; 770 771 if (!limread(&c, 1, region, stream)) { 772 return 0; 773 } 774 *length = t + c + 192; 775 return 1; 776 } 777 return limread_scalar(length, 4, region, stream); 778 } 779 780 /** 781 \ingroup Core_Create 782 \brief Free allocated memory 783 */ 784 static void 785 data_free(__ops_data_t *data) 786 { 787 free(data->contents); 788 data->contents = NULL; 789 data->len = 0; 790 } 791 792 /** 793 \ingroup Core_Create 794 \brief Free allocated memory 795 */ 796 static void 797 string_free(char **str) 798 { 799 free(*str); 800 *str = NULL; 801 } 802 803 /** 804 \ingroup Core_Create 805 \brief Free allocated memory 806 */ 807 /* ! Free packet memory, set pointer to NULL */ 808 void 809 __ops_subpacket_free(__ops_subpacket_t *packet) 810 { 811 free(packet->raw); 812 packet->raw = NULL; 813 } 814 815 /** 816 \ingroup Core_Create 817 \brief Free allocated memory 818 */ 819 static void 820 __ops_headers_free(__ops_headers_t *headers) 821 { 822 unsigned n; 823 824 for (n = 0; n < headers->headerc; ++n) { 825 free(headers->headers[n].key); 826 free(headers->headers[n].value); 827 } 828 free(headers->headers); 829 headers->headers = NULL; 830 } 831 832 /** 833 \ingroup Core_Create 834 \brief Free allocated memory 835 */ 836 static void 837 cleartext_trailer_free(__ops_cleartext_trailer_t *trailer) 838 { 839 free(trailer->hash); 840 trailer->hash = NULL; 841 } 842 843 /** 844 \ingroup Core_Create 845 \brief Free allocated memory 846 */ 847 static void 848 __ops_cmd_get_passphrase_free(__ops_seckey_passphrase_t *skp) 849 { 850 if (skp->passphrase && *skp->passphrase) { 851 free(*skp->passphrase); 852 *skp->passphrase = NULL; 853 } 854 } 855 856 /** 857 \ingroup Core_Create 858 \brief Free the memory used when parsing this signature sub-packet type 859 */ 860 static void 861 ss_userdef_free(__ops_ss_userdef_t *ss_userdef) 862 { 863 data_free(&ss_userdef->data); 864 } 865 866 /** 867 \ingroup Core_Create 868 \brief Free the memory used when parsing this signature sub-packet type 869 */ 870 static void 871 ss_reserved_free(__ops_ss_unknown_t *ss_unknown) 872 { 873 data_free(&ss_unknown->data); 874 } 875 876 /** 877 \ingroup Core_Create 878 \brief Free the memory used when parsing this packet type 879 */ 880 static void 881 trust_free(__ops_trust_t *trust) 882 { 883 data_free(&trust->data); 884 } 885 886 /** 887 * \ingroup Core_Create 888 * \brief Free the memory used when parsing a private/experimental PKA signature 889 * \param unknown_sig 890 */ 891 static void 892 free_unknown_sig_pka(__ops_unknown_sig_t *unknown_sig) 893 { 894 data_free(&unknown_sig->data); 895 } 896 897 /** 898 \ingroup Core_Create 899 \brief Free allocated memory 900 */ 901 static void 902 free_BN(BIGNUM **pp) 903 { 904 BN_free(*pp); 905 *pp = NULL; 906 } 907 908 /** 909 * \ingroup Core_Create 910 * \brief Free the memory used when parsing a signature 911 * \param sig 912 */ 913 static void 914 sig_free(__ops_sig_t *sig) 915 { 916 switch (sig->info.key_alg) { 917 case OPS_PKA_RSA: 918 case OPS_PKA_RSA_SIGN_ONLY: 919 free_BN(&sig->info.sig.rsa.sig); 920 break; 921 922 case OPS_PKA_DSA: 923 free_BN(&sig->info.sig.dsa.r); 924 free_BN(&sig->info.sig.dsa.s); 925 break; 926 927 case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN: 928 free_BN(&sig->info.sig.elgamal.r); 929 free_BN(&sig->info.sig.elgamal.s); 930 break; 931 932 case OPS_PKA_PRIVATE00: 933 case OPS_PKA_PRIVATE01: 934 case OPS_PKA_PRIVATE02: 935 case OPS_PKA_PRIVATE03: 936 case OPS_PKA_PRIVATE04: 937 case OPS_PKA_PRIVATE05: 938 case OPS_PKA_PRIVATE06: 939 case OPS_PKA_PRIVATE07: 940 case OPS_PKA_PRIVATE08: 941 case OPS_PKA_PRIVATE09: 942 case OPS_PKA_PRIVATE10: 943 free_unknown_sig_pka(&sig->info.sig.unknown); 944 break; 945 946 default: 947 (void) fprintf(stderr, "sig_free: bad sig type\n"); 948 } 949 } 950 951 /** 952 \ingroup Core_Create 953 \brief Free the memory used when parsing this signature sub-packet type 954 \param ss_skapref 955 */ 956 static void 957 ss_skapref_free(__ops_ss_skapref_t *ss_skapref) 958 { 959 data_free(&ss_skapref->data); 960 } 961 962 /** 963 \ingroup Core_Create 964 \brief Free the memory used when parsing this signature sub-packet type 965 \param ss_hashpref 966 */ 967 static void 968 ss_hashpref_free(__ops_ss_hashpref_t *ss_hashpref) 969 { 970 data_free(&ss_hashpref->data); 971 } 972 973 /** 974 \ingroup Core_Create 975 \brief Free the memory used when parsing this signature sub-packet type 976 */ 977 static void 978 ss_zpref_free(__ops_ss_zpref_t *ss_zpref) 979 { 980 data_free(&ss_zpref->data); 981 } 982 983 /** 984 \ingroup Core_Create 985 \brief Free the memory used when parsing this signature sub-packet type 986 */ 987 static void 988 ss_key_flags_free(__ops_ss_key_flags_t *ss_key_flags) 989 { 990 data_free(&ss_key_flags->data); 991 } 992 993 /** 994 \ingroup Core_Create 995 \brief Free the memory used when parsing this signature sub-packet type 996 */ 997 static void 998 ss_key_server_prefs_free(__ops_ss_key_server_prefs_t *ss_key_server_prefs) 999 { 1000 data_free(&ss_key_server_prefs->data); 1001 } 1002 1003 /** 1004 \ingroup Core_Create 1005 \brief Free the memory used when parsing this signature sub-packet type 1006 */ 1007 static void 1008 ss_features_free(__ops_ss_features_t *ss_features) 1009 { 1010 data_free(&ss_features->data); 1011 } 1012 1013 /** 1014 \ingroup Core_Create 1015 \brief Free the memory used when parsing this signature sub-packet type 1016 */ 1017 static void 1018 ss_notation_free(__ops_ss_notation_t *ss_notation) 1019 { 1020 data_free(&ss_notation->name); 1021 data_free(&ss_notation->value); 1022 } 1023 1024 /** 1025 \ingroup Core_Create 1026 \brief Free allocated memory 1027 */ 1028 /* ! Free the memory used when parsing this signature sub-packet type */ 1029 static void 1030 ss_regexp_free(__ops_ss_regexp_t *regexp) 1031 { 1032 string_free(®exp->regexp); 1033 } 1034 1035 /** 1036 \ingroup Core_Create 1037 \brief Free allocated memory 1038 */ 1039 /* ! Free the memory used when parsing this signature sub-packet type */ 1040 static void 1041 ss_policy_free(__ops_ss_policy_t *policy) 1042 { 1043 string_free(&policy->url); 1044 } 1045 1046 /** 1047 \ingroup Core_Create 1048 \brief Free allocated memory 1049 */ 1050 /* ! Free the memory used when parsing this signature sub-packet type */ 1051 static void 1052 ss_keyserv_free(__ops_ss_keyserv_t *preferred_key_server) 1053 { 1054 string_free(&preferred_key_server->name); 1055 } 1056 1057 /** 1058 \ingroup Core_Create 1059 \brief Free the memory used when parsing this signature sub-packet type 1060 */ 1061 static void 1062 ss_revocation_free(__ops_ss_revocation_t *ss_revocation) 1063 { 1064 string_free(&ss_revocation->reason); 1065 } 1066 1067 static void 1068 ss_embedded_sig_free(__ops_ss_embedded_sig_t *ss_embedded_sig) 1069 { 1070 data_free(&ss_embedded_sig->sig); 1071 } 1072 1073 /** 1074 \ingroup Core_Create 1075 \brief Free allocated memory 1076 */ 1077 /* ! Free any memory allocated when parsing the packet content */ 1078 void 1079 __ops_parser_content_free(__ops_packet_t *c) 1080 { 1081 switch (c->tag) { 1082 case OPS_PARSER_PTAG: 1083 case OPS_PTAG_CT_COMPRESSED: 1084 case OPS_PTAG_SS_CREATION_TIME: 1085 case OPS_PTAG_SS_EXPIRATION_TIME: 1086 case OPS_PTAG_SS_KEY_EXPIRY: 1087 case OPS_PTAG_SS_TRUST: 1088 case OPS_PTAG_SS_ISSUER_KEY_ID: 1089 case OPS_PTAG_CT_1_PASS_SIG: 1090 case OPS_PTAG_SS_PRIMARY_USER_ID: 1091 case OPS_PTAG_SS_REVOCABLE: 1092 case OPS_PTAG_SS_REVOCATION_KEY: 1093 case OPS_PTAG_CT_LITDATA_HEADER: 1094 case OPS_PTAG_CT_LITDATA_BODY: 1095 case OPS_PTAG_CT_SIGNED_CLEARTEXT_BODY: 1096 case OPS_PTAG_CT_UNARMOURED_TEXT: 1097 case OPS_PTAG_CT_ARMOUR_TRAILER: 1098 case OPS_PTAG_CT_SIGNATURE_HEADER: 1099 case OPS_PTAG_CT_SE_DATA_HEADER: 1100 case OPS_PTAG_CT_SE_IP_DATA_HEADER: 1101 case OPS_PTAG_CT_SE_IP_DATA_BODY: 1102 case OPS_PTAG_CT_MDC: 1103 case OPS_GET_SECKEY: 1104 break; 1105 1106 case OPS_PTAG_CT_SIGNED_CLEARTEXT_HEADER: 1107 __ops_headers_free(&c->u.cleartext_head.headers); 1108 break; 1109 1110 case OPS_PTAG_CT_ARMOUR_HEADER: 1111 __ops_headers_free(&c->u.armour_header.headers); 1112 break; 1113 1114 case OPS_PTAG_CT_SIGNED_CLEARTEXT_TRAILER: 1115 cleartext_trailer_free(&c->u.cleartext_trailer); 1116 break; 1117 1118 case OPS_PTAG_CT_TRUST: 1119 trust_free(&c->u.trust); 1120 break; 1121 1122 case OPS_PTAG_CT_SIGNATURE: 1123 case OPS_PTAG_CT_SIGNATURE_FOOTER: 1124 sig_free(&c->u.sig); 1125 break; 1126 1127 case OPS_PTAG_CT_PUBLIC_KEY: 1128 case OPS_PTAG_CT_PUBLIC_SUBKEY: 1129 __ops_pubkey_free(&c->u.pubkey); 1130 break; 1131 1132 case OPS_PTAG_CT_USER_ID: 1133 __ops_userid_free(&c->u.userid); 1134 break; 1135 1136 case OPS_PTAG_SS_SIGNERS_USER_ID: 1137 __ops_userid_free(&c->u.ss_signer); 1138 break; 1139 1140 case OPS_PTAG_CT_USER_ATTR: 1141 __ops_userattr_free(&c->u.userattr); 1142 break; 1143 1144 case OPS_PTAG_SS_PREFERRED_SKA: 1145 ss_skapref_free(&c->u.ss_skapref); 1146 break; 1147 1148 case OPS_PTAG_SS_PREFERRED_HASH: 1149 ss_hashpref_free(&c->u.ss_hashpref); 1150 break; 1151 1152 case OPS_PTAG_SS_PREF_COMPRESS: 1153 ss_zpref_free(&c->u.ss_zpref); 1154 break; 1155 1156 case OPS_PTAG_SS_KEY_FLAGS: 1157 ss_key_flags_free(&c->u.ss_key_flags); 1158 break; 1159 1160 case OPS_PTAG_SS_KEYSERV_PREFS: 1161 ss_key_server_prefs_free(&c->u.ss_key_server_prefs); 1162 break; 1163 1164 case OPS_PTAG_SS_FEATURES: 1165 ss_features_free(&c->u.ss_features); 1166 break; 1167 1168 case OPS_PTAG_SS_NOTATION_DATA: 1169 ss_notation_free(&c->u.ss_notation); 1170 break; 1171 1172 case OPS_PTAG_SS_REGEXP: 1173 ss_regexp_free(&c->u.ss_regexp); 1174 break; 1175 1176 case OPS_PTAG_SS_POLICY_URI: 1177 ss_policy_free(&c->u.ss_policy); 1178 break; 1179 1180 case OPS_PTAG_SS_PREF_KEYSERV: 1181 ss_keyserv_free(&c->u.ss_keyserv); 1182 break; 1183 1184 case OPS_PTAG_SS_USERDEFINED00: 1185 case OPS_PTAG_SS_USERDEFINED01: 1186 case OPS_PTAG_SS_USERDEFINED02: 1187 case OPS_PTAG_SS_USERDEFINED03: 1188 case OPS_PTAG_SS_USERDEFINED04: 1189 case OPS_PTAG_SS_USERDEFINED05: 1190 case OPS_PTAG_SS_USERDEFINED06: 1191 case OPS_PTAG_SS_USERDEFINED07: 1192 case OPS_PTAG_SS_USERDEFINED08: 1193 case OPS_PTAG_SS_USERDEFINED09: 1194 case OPS_PTAG_SS_USERDEFINED10: 1195 ss_userdef_free(&c->u.ss_userdef); 1196 break; 1197 1198 case OPS_PTAG_SS_RESERVED: 1199 ss_reserved_free(&c->u.ss_unknown); 1200 break; 1201 1202 case OPS_PTAG_SS_REVOCATION_REASON: 1203 ss_revocation_free(&c->u.ss_revocation); 1204 break; 1205 1206 case OPS_PTAG_SS_EMBEDDED_SIGNATURE: 1207 ss_embedded_sig_free(&c->u.ss_embedded_sig); 1208 break; 1209 1210 case OPS_PARSER_PACKET_END: 1211 __ops_subpacket_free(&c->u.packet); 1212 break; 1213 1214 case OPS_PARSER_ERROR: 1215 case OPS_PARSER_ERRCODE: 1216 break; 1217 1218 case OPS_PTAG_CT_SECRET_KEY: 1219 case OPS_PTAG_CT_ENCRYPTED_SECRET_KEY: 1220 __ops_seckey_free(&c->u.seckey); 1221 break; 1222 1223 case OPS_PTAG_CT_PK_SESSION_KEY: 1224 case OPS_PTAG_CT_ENCRYPTED_PK_SESSION_KEY: 1225 __ops_pk_sesskey_free(&c->u.pk_sesskey); 1226 break; 1227 1228 case OPS_GET_PASSPHRASE: 1229 __ops_cmd_get_passphrase_free(&c->u.skey_passphrase); 1230 break; 1231 1232 default: 1233 fprintf(stderr, "Can't free %d (0x%x)\n", c->tag, c->tag); 1234 } 1235 } 1236 1237 /** 1238 \ingroup Core_Create 1239 \brief Free allocated memory 1240 */ 1241 void 1242 __ops_pk_sesskey_free(__ops_pk_sesskey_t *sk) 1243 { 1244 switch (sk->alg) { 1245 case OPS_PKA_RSA: 1246 free_BN(&sk->params.rsa.encrypted_m); 1247 break; 1248 1249 case OPS_PKA_ELGAMAL: 1250 free_BN(&sk->params.elgamal.g_to_k); 1251 free_BN(&sk->params.elgamal.encrypted_m); 1252 break; 1253 1254 default: 1255 (void) fprintf(stderr, "__ops_pk_sesskey_free: bad alg\n"); 1256 break; 1257 } 1258 } 1259 1260 /** 1261 \ingroup Core_Create 1262 \brief Free allocated memory 1263 */ 1264 /* ! Free the memory used when parsing a public key */ 1265 void 1266 __ops_pubkey_free(__ops_pubkey_t *p) 1267 { 1268 switch (p->alg) { 1269 case OPS_PKA_RSA: 1270 case OPS_PKA_RSA_ENCRYPT_ONLY: 1271 case OPS_PKA_RSA_SIGN_ONLY: 1272 free_BN(&p->key.rsa.n); 1273 free_BN(&p->key.rsa.e); 1274 break; 1275 1276 case OPS_PKA_DSA: 1277 free_BN(&p->key.dsa.p); 1278 free_BN(&p->key.dsa.q); 1279 free_BN(&p->key.dsa.g); 1280 free_BN(&p->key.dsa.y); 1281 break; 1282 1283 case OPS_PKA_ELGAMAL: 1284 case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN: 1285 free_BN(&p->key.elgamal.p); 1286 free_BN(&p->key.elgamal.g); 1287 free_BN(&p->key.elgamal.y); 1288 break; 1289 1290 case OPS_PKA_NOTHING: 1291 /* nothing to free */ 1292 break; 1293 1294 default: 1295 (void) fprintf(stderr, "__ops_pubkey_free: bad alg\n"); 1296 } 1297 } 1298 1299 /** 1300 \ingroup Core_ReadPackets 1301 */ 1302 static int 1303 parse_pubkey_data(__ops_pubkey_t *key, __ops_region_t *region, 1304 __ops_stream_t *stream) 1305 { 1306 unsigned char c = 0x0; 1307 1308 if (region->readc != 0) { 1309 /* We should not have read anything so far */ 1310 (void) fprintf(stderr, "parse_pubkey_data: bad length\n"); 1311 return 0; 1312 } 1313 if (!limread(&c, 1, region, stream)) { 1314 return 0; 1315 } 1316 key->version = (__ops_version_t)c; 1317 switch (key->version) { 1318 case OPS_V2: 1319 case OPS_V3: 1320 case OPS_V4: 1321 break; 1322 default: 1323 OPS_ERROR_1(&stream->errors, OPS_E_PROTO_BAD_PUBLIC_KEY_VRSN, 1324 "Bad public key version (0x%02x)", key->version); 1325 return 0; 1326 } 1327 if (!limited_read_time(&key->birthtime, region, stream)) { 1328 return 0; 1329 } 1330 1331 key->days_valid = 0; 1332 if ((key->version == 2 || key->version == 3) && 1333 !limread_scalar(&key->days_valid, 2, region, stream)) { 1334 return 0; 1335 } 1336 1337 if (!limread(&c, 1, region, stream)) { 1338 return 0; 1339 } 1340 key->alg = c; 1341 1342 switch (key->alg) { 1343 case OPS_PKA_DSA: 1344 if (!limread_mpi(&key->key.dsa.p, region, stream) || 1345 !limread_mpi(&key->key.dsa.q, region, stream) || 1346 !limread_mpi(&key->key.dsa.g, region, stream) || 1347 !limread_mpi(&key->key.dsa.y, region, stream)) { 1348 return 0; 1349 } 1350 break; 1351 1352 case OPS_PKA_RSA: 1353 case OPS_PKA_RSA_ENCRYPT_ONLY: 1354 case OPS_PKA_RSA_SIGN_ONLY: 1355 if (!limread_mpi(&key->key.rsa.n, region, stream) || 1356 !limread_mpi(&key->key.rsa.e, region, stream)) { 1357 return 0; 1358 } 1359 break; 1360 1361 case OPS_PKA_ELGAMAL: 1362 case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN: 1363 if (!limread_mpi(&key->key.elgamal.p, region, stream) || 1364 !limread_mpi(&key->key.elgamal.g, region, stream) || 1365 !limread_mpi(&key->key.elgamal.y, region, stream)) { 1366 return 0; 1367 } 1368 break; 1369 1370 default: 1371 OPS_ERROR_1(&stream->errors, 1372 OPS_E_ALG_UNSUPPORTED_PUBLIC_KEY_ALG, 1373 "Unsupported Public Key algorithm (%s)", 1374 __ops_show_pka(key->alg)); 1375 return 0; 1376 } 1377 1378 return 1; 1379 } 1380 1381 1382 /** 1383 * \ingroup Core_ReadPackets 1384 * \brief Parse a public key packet. 1385 * 1386 * This function parses an entire v3 (== v2) or v4 public key packet for RSA, ElGamal, and DSA keys. 1387 * 1388 * Once the key has been parsed successfully, it is passed to the callback. 1389 * 1390 * \param *ptag Pointer to the current Packet Tag. This function should consume the entire packet. 1391 * \param *reader Our reader 1392 * \param *cb The callback 1393 * \return 1 on success, 0 on error 1394 * 1395 * \see RFC4880 5.5.2 1396 */ 1397 static int 1398 parse_pubkey(__ops_content_tag_t tag, __ops_region_t *region, 1399 __ops_stream_t *stream) 1400 { 1401 __ops_packet_t pkt; 1402 1403 if (!parse_pubkey_data(&pkt.u.pubkey, region, stream)) 1404 return 0; 1405 1406 /* XXX: this test should be done for all packets, surely? */ 1407 if (region->readc != region->length) { 1408 OPS_ERROR_1(&stream->errors, OPS_E_R_UNCONSUMED_DATA, 1409 "Unconsumed data (%d)", region->length - region->readc); 1410 return 0; 1411 } 1412 CALLBACK(tag, &stream->cbinfo, &pkt); 1413 1414 return 1; 1415 } 1416 1417 1418 /** 1419 \ingroup Core_Create 1420 \brief Free allocated memory 1421 */ 1422 /* ! Free the memory used when parsing this packet type */ 1423 void 1424 __ops_userattr_free(__ops_userattr_t *user_att) 1425 { 1426 data_free(&user_att->data); 1427 } 1428 1429 /** 1430 * \ingroup Core_ReadPackets 1431 * \brief Parse one user attribute packet. 1432 * 1433 * User attribute packets contain one or more attribute subpackets. 1434 * For now, handle the whole packet as raw data. 1435 */ 1436 1437 static int 1438 parse_userattr(__ops_region_t *region, __ops_stream_t *stream) 1439 { 1440 1441 __ops_packet_t pkt; 1442 1443 /* 1444 * xxx- treat as raw data for now. Could break down further into 1445 * attribute sub-packets later - rachel 1446 */ 1447 1448 if (region->readc != 0) { 1449 /* We should not have read anything so far */ 1450 (void) fprintf(stderr, "parse_userattr: bad length\n"); 1451 return 0; 1452 } 1453 1454 if (!read_data(&pkt.u.userattr.data, region, stream)) 1455 return 0; 1456 1457 CALLBACK(OPS_PTAG_CT_USER_ATTR, &stream->cbinfo, &pkt); 1458 1459 return 1; 1460 } 1461 1462 /** 1463 \ingroup Core_Create 1464 \brief Free allocated memory 1465 */ 1466 /* ! Free the memory used when parsing this packet type */ 1467 void 1468 __ops_userid_free(__ops_userid_t *id) 1469 { 1470 free(id->userid); 1471 id->userid = NULL; 1472 } 1473 1474 /** 1475 * \ingroup Core_ReadPackets 1476 * \brief Parse a user id. 1477 * 1478 * This function parses an user id packet, which is basically just a char array the size of the packet. 1479 * 1480 * The char array is to be treated as an UTF-8 string. 1481 * 1482 * The userid gets null terminated by this function. Freeing it is the responsibility of the caller. 1483 * 1484 * Once the userid has been parsed successfully, it is passed to the callback. 1485 * 1486 * \param *ptag Pointer to the Packet Tag. This function should consume the entire packet. 1487 * \param *reader Our reader 1488 * \param *cb The callback 1489 * \return 1 on success, 0 on error 1490 * 1491 * \see RFC4880 5.11 1492 */ 1493 static int 1494 parse_userid(__ops_region_t *region, __ops_stream_t *stream) 1495 { 1496 __ops_packet_t pkt; 1497 1498 if (region->readc != 0) { 1499 /* We should not have read anything so far */ 1500 (void) fprintf(stderr, "parse_userid: bad length\n"); 1501 return 0; 1502 } 1503 1504 if ((pkt.u.userid.userid = calloc(1, region->length + 1)) == NULL) { 1505 (void) fprintf(stderr, "parse_userid: bad alloc\n"); 1506 return 0; 1507 } 1508 1509 if (region->length && 1510 !limread(pkt.u.userid.userid, region->length, region, 1511 stream)) { 1512 return 0; 1513 } 1514 pkt.u.userid.userid[region->length] = '\0'; 1515 CALLBACK(OPS_PTAG_CT_USER_ID, &stream->cbinfo, &pkt); 1516 return 1; 1517 } 1518 1519 static __ops_hash_t * 1520 parse_hash_find(__ops_stream_t *stream, const unsigned char *keyid) 1521 { 1522 __ops_hashtype_t *hp; 1523 size_t n; 1524 1525 for (n = 0, hp = stream->hashes; n < stream->hashc; n++, hp++) { 1526 if (memcmp(hp->keyid, keyid, OPS_KEY_ID_SIZE) == 0) { 1527 return &hp->hash; 1528 } 1529 } 1530 return NULL; 1531 } 1532 1533 /** 1534 * \ingroup Core_Parse 1535 * \brief Parse a version 3 signature. 1536 * 1537 * This function parses an version 3 signature packet, handling RSA and DSA signatures. 1538 * 1539 * Once the signature has been parsed successfully, it is passed to the callback. 1540 * 1541 * \param *ptag Pointer to the Packet Tag. This function should consume the entire packet. 1542 * \param *reader Our reader 1543 * \param *cb The callback 1544 * \return 1 on success, 0 on error 1545 * 1546 * \see RFC4880 5.2.2 1547 */ 1548 static int 1549 parse_v3_sig(__ops_region_t *region, 1550 __ops_stream_t *stream) 1551 { 1552 __ops_packet_t pkt; 1553 unsigned char c = 0x0; 1554 1555 /* clear signature */ 1556 (void) memset(&pkt.u.sig, 0x0, sizeof(pkt.u.sig)); 1557 1558 pkt.u.sig.info.version = OPS_V3; 1559 1560 /* hash info length */ 1561 if (!limread(&c, 1, region, stream)) { 1562 return 0; 1563 } 1564 if (c != 5) { 1565 ERRP(&stream->cbinfo, pkt, "bad hash info length"); 1566 } 1567 1568 if (!limread(&c, 1, region, stream)) { 1569 return 0; 1570 } 1571 pkt.u.sig.info.type = (__ops_sig_type_t)c; 1572 /* XXX: check signature type */ 1573 1574 if (!limited_read_time(&pkt.u.sig.info.birthtime, region, stream)) { 1575 return 0; 1576 } 1577 pkt.u.sig.info.birthtime_set = 1; 1578 1579 if (!limread(pkt.u.sig.info.signer_id, OPS_KEY_ID_SIZE, region, 1580 stream)) { 1581 return 0; 1582 } 1583 pkt.u.sig.info.signer_id_set = 1; 1584 1585 if (!limread(&c, 1, region, stream)) { 1586 return 0; 1587 } 1588 pkt.u.sig.info.key_alg = (__ops_pubkey_alg_t)c; 1589 /* XXX: check algorithm */ 1590 1591 if (!limread(&c, 1, region, stream)) { 1592 return 0; 1593 } 1594 pkt.u.sig.info.hash_alg = (__ops_hash_alg_t)c; 1595 /* XXX: check algorithm */ 1596 1597 if (!limread(pkt.u.sig.hash2, 2, region, stream)) { 1598 return 0; 1599 } 1600 1601 switch (pkt.u.sig.info.key_alg) { 1602 case OPS_PKA_RSA: 1603 case OPS_PKA_RSA_SIGN_ONLY: 1604 if (!limread_mpi(&pkt.u.sig.info.sig.rsa.sig, region, stream)) { 1605 return 0; 1606 } 1607 break; 1608 1609 case OPS_PKA_DSA: 1610 if (!limread_mpi(&pkt.u.sig.info.sig.dsa.r, region, stream) || 1611 !limread_mpi(&pkt.u.sig.info.sig.dsa.s, region, stream)) { 1612 return 0; 1613 } 1614 break; 1615 1616 case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN: 1617 if (!limread_mpi(&pkt.u.sig.info.sig.elgamal.r, region, 1618 stream) || 1619 !limread_mpi(&pkt.u.sig.info.sig.elgamal.s, region, 1620 stream)) { 1621 return 0; 1622 } 1623 break; 1624 1625 default: 1626 OPS_ERROR_1(&stream->errors, 1627 OPS_E_ALG_UNSUPPORTED_SIGNATURE_ALG, 1628 "Unsupported signature key algorithm (%s)", 1629 __ops_show_pka(pkt.u.sig.info.key_alg)); 1630 return 0; 1631 } 1632 1633 if (region->readc != region->length) { 1634 OPS_ERROR_1(&stream->errors, OPS_E_R_UNCONSUMED_DATA, 1635 "Unconsumed data (%d)", 1636 region->length - region->readc); 1637 return 0; 1638 } 1639 if (pkt.u.sig.info.signer_id_set) { 1640 pkt.u.sig.hash = parse_hash_find(stream, 1641 pkt.u.sig.info.signer_id); 1642 } 1643 CALLBACK(OPS_PTAG_CT_SIGNATURE, &stream->cbinfo, &pkt); 1644 return 1; 1645 } 1646 1647 /** 1648 * \ingroup Core_ReadPackets 1649 * \brief Parse one signature sub-packet. 1650 * 1651 * Version 4 signatures can have an arbitrary amount of (hashed and unhashed) subpackets. Subpackets are used to hold 1652 * optional attributes of subpackets. 1653 * 1654 * This function parses one such signature subpacket. 1655 * 1656 * Once the subpacket has been parsed successfully, it is passed to the callback. 1657 * 1658 * \param *ptag Pointer to the Packet Tag. This function should consume the entire subpacket. 1659 * \param *reader Our reader 1660 * \param *cb The callback 1661 * \return 1 on success, 0 on error 1662 * 1663 * \see RFC4880 5.2.3 1664 */ 1665 static int 1666 parse_one_sig_subpacket(__ops_sig_t *sig, 1667 __ops_region_t *region, 1668 __ops_stream_t *stream) 1669 { 1670 __ops_region_t subregion; 1671 __ops_packet_t pkt; 1672 unsigned char bools = 0x0; 1673 unsigned char c = 0x0; 1674 unsigned doread = 1; 1675 unsigned t8; 1676 unsigned t7; 1677 1678 __ops_init_subregion(&subregion, region); 1679 if (!limited_read_new_length(&subregion.length, region, stream)) { 1680 return 0; 1681 } 1682 1683 if (subregion.length > region->length) { 1684 ERRP(&stream->cbinfo, pkt, "Subpacket too long"); 1685 } 1686 1687 if (!limread(&c, 1, &subregion, stream)) { 1688 return 0; 1689 } 1690 1691 t8 = (c & 0x7f) / 8; 1692 t7 = 1 << (c & 7); 1693 1694 pkt.critical = (unsigned)c >> 7; 1695 pkt.tag = (__ops_content_tag_t)(OPS_PTAG_SIG_SUBPKT_BASE + (c & 0x7f)); 1696 1697 /* Application wants it delivered raw */ 1698 if (stream->ss_raw[t8] & t7) { 1699 pkt.u.ss_raw.tag = pkt.tag; 1700 pkt.u.ss_raw.length = subregion.length - 1; 1701 pkt.u.ss_raw.raw = calloc(1, pkt.u.ss_raw.length); 1702 if (pkt.u.ss_raw.raw == NULL) { 1703 (void) fprintf(stderr, "parse_one_sig_subpacket: bad alloc\n"); 1704 return 0; 1705 } 1706 if (!limread(pkt.u.ss_raw.raw, pkt.u.ss_raw.length, 1707 &subregion, stream)) { 1708 return 0; 1709 } 1710 CALLBACK(OPS_PTAG_RAW_SS, &stream->cbinfo, &pkt); 1711 return 1; 1712 } 1713 switch (pkt.tag) { 1714 case OPS_PTAG_SS_CREATION_TIME: 1715 case OPS_PTAG_SS_EXPIRATION_TIME: 1716 case OPS_PTAG_SS_KEY_EXPIRY: 1717 if (!limited_read_time(&pkt.u.ss_time.time, &subregion, stream)) 1718 return 0; 1719 if (pkt.tag == OPS_PTAG_SS_CREATION_TIME) { 1720 sig->info.birthtime = pkt.u.ss_time.time; 1721 sig->info.birthtime_set = 1; 1722 } 1723 break; 1724 1725 case OPS_PTAG_SS_TRUST: 1726 if (!limread(&pkt.u.ss_trust.level, 1, &subregion, stream) || 1727 !limread(&pkt.u.ss_trust.amount, 1, &subregion, stream)) { 1728 return 0; 1729 } 1730 break; 1731 1732 case OPS_PTAG_SS_REVOCABLE: 1733 if (!limread(&bools, 1, &subregion, stream)) { 1734 return 0; 1735 } 1736 pkt.u.ss_revocable.revocable = !!bools; 1737 break; 1738 1739 case OPS_PTAG_SS_ISSUER_KEY_ID: 1740 if (!limread(pkt.u.ss_issuer.key_id, OPS_KEY_ID_SIZE, 1741 &subregion, stream)) { 1742 return 0; 1743 } 1744 (void) memcpy(sig->info.signer_id, 1745 pkt.u.ss_issuer.key_id, OPS_KEY_ID_SIZE); 1746 sig->info.signer_id_set = 1; 1747 break; 1748 1749 case OPS_PTAG_SS_PREFERRED_SKA: 1750 if (!read_data(&pkt.u.ss_skapref.data, &subregion, stream)) { 1751 return 0; 1752 } 1753 break; 1754 1755 case OPS_PTAG_SS_PREFERRED_HASH: 1756 if (!read_data(&pkt.u.ss_hashpref.data, &subregion, stream)) { 1757 return 0; 1758 } 1759 break; 1760 1761 case OPS_PTAG_SS_PREF_COMPRESS: 1762 if (!read_data(&pkt.u.ss_zpref.data, 1763 &subregion, stream)) { 1764 return 0; 1765 } 1766 break; 1767 1768 case OPS_PTAG_SS_PRIMARY_USER_ID: 1769 if (!limread(&bools, 1, &subregion, stream)) { 1770 return 0; 1771 } 1772 pkt.u.ss_primary_userid.primary_userid = !!bools; 1773 break; 1774 1775 case OPS_PTAG_SS_KEY_FLAGS: 1776 if (!read_data(&pkt.u.ss_key_flags.data, &subregion, stream)) { 1777 return 0; 1778 } 1779 break; 1780 1781 case OPS_PTAG_SS_KEYSERV_PREFS: 1782 if (!read_data(&pkt.u.ss_key_server_prefs.data, &subregion, 1783 stream)) { 1784 return 0; 1785 } 1786 break; 1787 1788 case OPS_PTAG_SS_FEATURES: 1789 if (!read_data(&pkt.u.ss_features.data, &subregion, stream)) { 1790 return 0; 1791 } 1792 break; 1793 1794 case OPS_PTAG_SS_SIGNERS_USER_ID: 1795 if (!read_unsig_str(&pkt.u.ss_signer.userid, &subregion, 1796 stream)) { 1797 return 0; 1798 } 1799 break; 1800 1801 case OPS_PTAG_SS_EMBEDDED_SIGNATURE: 1802 /* \todo should do something with this sig? */ 1803 if (!read_data(&pkt.u.ss_embedded_sig.sig, &subregion, stream)) { 1804 return 0; 1805 } 1806 break; 1807 1808 case OPS_PTAG_SS_NOTATION_DATA: 1809 if (!limread_data(&pkt.u.ss_notation.flags, 4, 1810 &subregion, stream)) { 1811 return 0; 1812 } 1813 if (!limread_size_t(&pkt.u.ss_notation.name.len, 2, 1814 &subregion, stream)) { 1815 return 0; 1816 } 1817 if (!limread_size_t(&pkt.u.ss_notation.value.len, 2, 1818 &subregion, stream)) { 1819 return 0; 1820 } 1821 if (!limread_data(&pkt.u.ss_notation.name, 1822 pkt.u.ss_notation.name.len, 1823 &subregion, stream)) { 1824 return 0; 1825 } 1826 if (!limread_data(&pkt.u.ss_notation.value, 1827 pkt.u.ss_notation.value.len, 1828 &subregion, stream)) { 1829 return 0; 1830 } 1831 break; 1832 1833 case OPS_PTAG_SS_POLICY_URI: 1834 if (!read_string(&pkt.u.ss_policy.url, &subregion, stream)) { 1835 return 0; 1836 } 1837 break; 1838 1839 case OPS_PTAG_SS_REGEXP: 1840 if (!read_string(&pkt.u.ss_regexp.regexp, &subregion, stream)) { 1841 return 0; 1842 } 1843 break; 1844 1845 case OPS_PTAG_SS_PREF_KEYSERV: 1846 if (!read_string(&pkt.u.ss_keyserv.name, &subregion, stream)) { 1847 return 0; 1848 } 1849 break; 1850 1851 case OPS_PTAG_SS_USERDEFINED00: 1852 case OPS_PTAG_SS_USERDEFINED01: 1853 case OPS_PTAG_SS_USERDEFINED02: 1854 case OPS_PTAG_SS_USERDEFINED03: 1855 case OPS_PTAG_SS_USERDEFINED04: 1856 case OPS_PTAG_SS_USERDEFINED05: 1857 case OPS_PTAG_SS_USERDEFINED06: 1858 case OPS_PTAG_SS_USERDEFINED07: 1859 case OPS_PTAG_SS_USERDEFINED08: 1860 case OPS_PTAG_SS_USERDEFINED09: 1861 case OPS_PTAG_SS_USERDEFINED10: 1862 if (!read_data(&pkt.u.ss_userdef.data, &subregion, stream)) { 1863 return 0; 1864 } 1865 break; 1866 1867 case OPS_PTAG_SS_RESERVED: 1868 if (!read_data(&pkt.u.ss_unknown.data, &subregion, stream)) { 1869 return 0; 1870 } 1871 break; 1872 1873 case OPS_PTAG_SS_REVOCATION_REASON: 1874 /* first byte is the machine-readable code */ 1875 if (!limread(&pkt.u.ss_revocation.code, 1, &subregion, stream)) { 1876 return 0; 1877 } 1878 /* the rest is a human-readable UTF-8 string */ 1879 if (!read_string(&pkt.u.ss_revocation.reason, &subregion, 1880 stream)) { 1881 return 0; 1882 } 1883 break; 1884 1885 case OPS_PTAG_SS_REVOCATION_KEY: 1886 /* octet 0 = class. Bit 0x80 must be set */ 1887 if (!limread(&pkt.u.ss_revocation_key.class, 1, 1888 &subregion, stream)) { 1889 return 0; 1890 } 1891 if (!(pkt.u.ss_revocation_key.class & 0x80)) { 1892 printf("Warning: OPS_PTAG_SS_REVOCATION_KEY class: " 1893 "Bit 0x80 should be set\n"); 1894 return 0; 1895 } 1896 /* octet 1 = algid */ 1897 if (!limread(&pkt.u.ss_revocation_key.algid, 1, 1898 &subregion, stream)) { 1899 return 0; 1900 } 1901 /* octets 2-21 = fingerprint */ 1902 if (!limread(&pkt.u.ss_revocation_key.fingerprint[0], 1903 OPS_FINGERPRINT_SIZE, &subregion, stream)) { 1904 return 0; 1905 } 1906 break; 1907 1908 default: 1909 if (stream->ss_parsed[t8] & t7) { 1910 OPS_ERROR_1(&stream->errors, OPS_E_PROTO_UNKNOWN_SS, 1911 "Unknown signature subpacket type (%d)", 1912 c & 0x7f); 1913 } 1914 doread = 0; 1915 break; 1916 } 1917 1918 /* Application doesn't want it delivered parsed */ 1919 if (!(stream->ss_parsed[t8] & t7)) { 1920 if (pkt.critical) { 1921 OPS_ERROR_1(&stream->errors, 1922 OPS_E_PROTO_CRITICAL_SS_IGNORED, 1923 "Critical signature subpacket ignored (%d)", 1924 c & 0x7f); 1925 } 1926 if (!doread && 1927 !limskip(subregion.length - 1, &subregion, stream)) { 1928 return 0; 1929 } 1930 if (doread) { 1931 __ops_parser_content_free(&pkt); 1932 } 1933 return 1; 1934 } 1935 if (doread && subregion.readc != subregion.length) { 1936 OPS_ERROR_1(&stream->errors, OPS_E_R_UNCONSUMED_DATA, 1937 "Unconsumed data (%d)", 1938 subregion.length - subregion.readc); 1939 return 0; 1940 } 1941 CALLBACK(pkt.tag, &stream->cbinfo, &pkt); 1942 return 1; 1943 } 1944 1945 /** 1946 * \ingroup Core_ReadPackets 1947 * \brief Parse several signature subpackets. 1948 * 1949 * Hashed and unhashed subpacket sets are preceded by an octet count that specifies the length of the complete set. 1950 * This function parses this length and then calls parse_one_sig_subpacket() for each subpacket until the 1951 * entire set is consumed. 1952 * 1953 * This function does not call the callback directly, parse_one_sig_subpacket() does for each subpacket. 1954 * 1955 * \param *ptag Pointer to the Packet Tag. 1956 * \param *reader Our reader 1957 * \param *cb The callback 1958 * \return 1 on success, 0 on error 1959 * 1960 * \see RFC4880 5.2.3 1961 */ 1962 static int 1963 parse_sig_subpkts(__ops_sig_t *sig, 1964 __ops_region_t *region, 1965 __ops_stream_t *stream) 1966 { 1967 __ops_region_t subregion; 1968 __ops_packet_t pkt; 1969 1970 __ops_init_subregion(&subregion, region); 1971 if (!limread_scalar(&subregion.length, 2, region, stream)) { 1972 return 0; 1973 } 1974 1975 if (subregion.length > region->length) { 1976 ERRP(&stream->cbinfo, pkt, "Subpacket set too long"); 1977 } 1978 1979 while (subregion.readc < subregion.length) { 1980 if (!parse_one_sig_subpacket(sig, &subregion, stream)) { 1981 return 0; 1982 } 1983 } 1984 1985 if (subregion.readc != subregion.length) { 1986 if (!limskip(subregion.length - subregion.readc, 1987 &subregion, stream)) { 1988 ERRP(&stream->cbinfo, pkt, 1989 "parse_sig_subpkts: subpacket length read mismatch"); 1990 } 1991 ERRP(&stream->cbinfo, pkt, "Subpacket length mismatch"); 1992 } 1993 return 1; 1994 } 1995 1996 /** 1997 * \ingroup Core_ReadPackets 1998 * \brief Parse a version 4 signature. 1999 * 2000 * This function parses a version 4 signature including all its hashed and unhashed subpackets. 2001 * 2002 * Once the signature packet has been parsed successfully, it is passed to the callback. 2003 * 2004 * \param *ptag Pointer to the Packet Tag. 2005 * \param *reader Our reader 2006 * \param *cb The callback 2007 * \return 1 on success, 0 on error 2008 * 2009 * \see RFC4880 5.2.3 2010 */ 2011 static int 2012 parse_v4_sig(__ops_region_t *region, __ops_stream_t *stream) 2013 { 2014 unsigned char c = 0x0; 2015 __ops_packet_t pkt; 2016 2017 /* debug=1; */ 2018 if (__ops_get_debug_level(__FILE__)) { 2019 fprintf(stderr, "\nparse_v4_sig\n"); 2020 } 2021 /* clear signature */ 2022 (void) memset(&pkt.u.sig, 0x0, sizeof(pkt.u.sig)); 2023 2024 /* 2025 * We need to hash the packet data from version through the hashed 2026 * subpacket data 2027 */ 2028 2029 pkt.u.sig.v4_hashstart = stream->readinfo.alength - 1; 2030 2031 /* Set version,type,algorithms */ 2032 2033 pkt.u.sig.info.version = OPS_V4; 2034 2035 if (!limread(&c, 1, region, stream)) { 2036 return 0; 2037 } 2038 pkt.u.sig.info.type = (__ops_sig_type_t)c; 2039 if (__ops_get_debug_level(__FILE__)) { 2040 fprintf(stderr, "signature type=%d (%s)\n", 2041 pkt.u.sig.info.type, 2042 __ops_show_sig_type(pkt.u.sig.info.type)); 2043 } 2044 /* XXX: check signature type */ 2045 2046 if (!limread(&c, 1, region, stream)) { 2047 return 0; 2048 } 2049 pkt.u.sig.info.key_alg = (__ops_pubkey_alg_t)c; 2050 /* XXX: check algorithm */ 2051 if (__ops_get_debug_level(__FILE__)) { 2052 (void) fprintf(stderr, "key_alg=%d (%s)\n", 2053 pkt.u.sig.info.key_alg, 2054 __ops_show_pka(pkt.u.sig.info.key_alg)); 2055 } 2056 if (!limread(&c, 1, region, stream)) { 2057 return 0; 2058 } 2059 pkt.u.sig.info.hash_alg = (__ops_hash_alg_t)c; 2060 /* XXX: check algorithm */ 2061 if (__ops_get_debug_level(__FILE__)) { 2062 fprintf(stderr, "hash_alg=%d %s\n", 2063 pkt.u.sig.info.hash_alg, 2064 __ops_show_hash_alg(pkt.u.sig.info.hash_alg)); 2065 } 2066 CALLBACK(OPS_PTAG_CT_SIGNATURE_HEADER, &stream->cbinfo, &pkt); 2067 2068 if (!parse_sig_subpkts(&pkt.u.sig, region, stream)) { 2069 return 0; 2070 } 2071 2072 pkt.u.sig.info.v4_hashlen = stream->readinfo.alength 2073 - pkt.u.sig.v4_hashstart; 2074 2075 /* copy hashed subpackets */ 2076 if (pkt.u.sig.info.v4_hashed) { 2077 free(pkt.u.sig.info.v4_hashed); 2078 } 2079 pkt.u.sig.info.v4_hashed = calloc(1, pkt.u.sig.info.v4_hashlen); 2080 if (pkt.u.sig.info.v4_hashed == NULL) { 2081 (void) fprintf(stderr, "parse_v4_sig: bad alloc\n"); 2082 return 0; 2083 } 2084 2085 if (!stream->readinfo.accumulate) { 2086 /* We must accumulate, else we can't check the signature */ 2087 fprintf(stderr, "*** ERROR: must set accumulate to 1\n"); 2088 return 0; 2089 } 2090 (void) memcpy(pkt.u.sig.info.v4_hashed, 2091 stream->readinfo.accumulated + pkt.u.sig.v4_hashstart, 2092 pkt.u.sig.info.v4_hashlen); 2093 2094 if (!parse_sig_subpkts(&pkt.u.sig, region, stream)) { 2095 return 0; 2096 } 2097 2098 if (!limread(pkt.u.sig.hash2, 2, region, stream)) { 2099 return 0; 2100 } 2101 2102 switch (pkt.u.sig.info.key_alg) { 2103 case OPS_PKA_RSA: 2104 if (!limread_mpi(&pkt.u.sig.info.sig.rsa.sig, region, stream)) { 2105 return 0; 2106 } 2107 break; 2108 2109 case OPS_PKA_DSA: 2110 if (!limread_mpi(&pkt.u.sig.info.sig.dsa.r, region, stream)) { 2111 /* 2112 * usually if this fails, it just means we've reached 2113 * the end of the keyring 2114 */ 2115 if (__ops_get_debug_level(__FILE__)) { 2116 (void) fprintf(stderr, 2117 "Error reading DSA r field in signature"); 2118 } 2119 return 0; 2120 } 2121 if (!limread_mpi(&pkt.u.sig.info.sig.dsa.s, region, stream)) { 2122 ERRP(&stream->cbinfo, pkt, 2123 "Error reading DSA s field in signature"); 2124 } 2125 break; 2126 2127 case OPS_PKA_ELGAMAL_ENCRYPT_OR_SIGN: 2128 if (!limread_mpi(&pkt.u.sig.info.sig.elgamal.r, region, 2129 stream) || 2130 !limread_mpi(&pkt.u.sig.info.sig.elgamal.s, region, 2131 stream)) { 2132 return 0; 2133 } 2134 break; 2135 2136 case OPS_PKA_PRIVATE00: 2137 case OPS_PKA_PRIVATE01: 2138 case OPS_PKA_PRIVATE02: 2139 case OPS_PKA_PRIVATE03: 2140 case OPS_PKA_PRIVATE04: 2141 case OPS_PKA_PRIVATE05: 2142 case OPS_PKA_PRIVATE06: 2143 case OPS_PKA_PRIVATE07: 2144 case OPS_PKA_PRIVATE08: 2145 case OPS_PKA_PRIVATE09: 2146 case OPS_PKA_PRIVATE10: 2147 if (!read_data(&pkt.u.sig.info.sig.unknown.data, region, 2148 stream)) { 2149 return 0; 2150 } 2151 break; 2152 2153 default: 2154 OPS_ERROR_1(&stream->errors, OPS_E_ALG_UNSUPPORTED_SIGNATURE_ALG, 2155 "Bad v4 signature key algorithm (%s)", 2156 __ops_show_pka(pkt.u.sig.info.key_alg)); 2157 return 0; 2158 } 2159 if (region->readc != region->length) { 2160 OPS_ERROR_1(&stream->errors, OPS_E_R_UNCONSUMED_DATA, 2161 "Unconsumed data (%d)", 2162 region->length - region->readc); 2163 return 0; 2164 } 2165 CALLBACK(OPS_PTAG_CT_SIGNATURE_FOOTER, &stream->cbinfo, &pkt); 2166 return 1; 2167 } 2168 2169 /** 2170 * \ingroup Core_ReadPackets 2171 * \brief Parse a signature subpacket. 2172 * 2173 * This function calls the appropriate function to handle v3 or v4 signatures. 2174 * 2175 * Once the signature packet has been parsed successfully, it is passed to the callback. 2176 * 2177 * \param *ptag Pointer to the Packet Tag. 2178 * \param *reader Our reader 2179 * \param *cb The callback 2180 * \return 1 on success, 0 on error 2181 */ 2182 static int 2183 parse_sig(__ops_region_t *region, __ops_stream_t *stream) 2184 { 2185 unsigned char c = 0x0; 2186 __ops_packet_t pkt; 2187 2188 if (region->readc != 0) { 2189 /* We should not have read anything so far */ 2190 (void) fprintf(stderr, "parse_sig: bad length\n"); 2191 return 0; 2192 } 2193 2194 (void) memset(&pkt, 0x0, sizeof(pkt)); 2195 if (!limread(&c, 1, region, stream)) { 2196 return 0; 2197 } 2198 if (c == 2 || c == 3) { 2199 return parse_v3_sig(region, stream); 2200 } 2201 if (c == 4) { 2202 return parse_v4_sig(region, stream); 2203 } 2204 OPS_ERROR_1(&stream->errors, OPS_E_PROTO_BAD_SIGNATURE_VRSN, 2205 "Bad signature version (%d)", c); 2206 return 0; 2207 } 2208 2209 /** 2210 \ingroup Core_ReadPackets 2211 \brief Parse Compressed packet 2212 */ 2213 static int 2214 parse_compressed(__ops_region_t *region, __ops_stream_t *stream) 2215 { 2216 __ops_packet_t pkt; 2217 unsigned char c = 0x0; 2218 2219 if (!limread(&c, 1, region, stream)) { 2220 return 0; 2221 } 2222 2223 pkt.u.compressed.type = (__ops_compression_type_t)c; 2224 2225 CALLBACK(OPS_PTAG_CT_COMPRESSED, &stream->cbinfo, &pkt); 2226 2227 /* 2228 * The content of a compressed data packet is more OpenPGP packets 2229 * once decompressed, so recursively handle them 2230 */ 2231 2232 return __ops_decompress(region, stream, pkt.u.compressed.type); 2233 } 2234 2235 /* XXX: this could be improved by sharing all hashes that are the */ 2236 /* same, then duping them just before checking the signature. */ 2237 static void 2238 parse_hash_init(__ops_stream_t *stream, __ops_hash_alg_t type, 2239 const unsigned char *keyid) 2240 { 2241 __ops_hashtype_t *hash; 2242 2243 hash = realloc(stream->hashes, 2244 (stream->hashc + 1) * sizeof(*stream->hashes)); 2245 if (hash == NULL) { 2246 (void) fprintf(stderr, "parse_hash_init: bad alloc 0\n"); 2247 /* just continue and die here */ 2248 /* XXX - agc - no way to return failure */ 2249 } else { 2250 stream->hashes = hash; 2251 } 2252 hash = &stream->hashes[stream->hashc++]; 2253 2254 __ops_hash_any(&hash->hash, type); 2255 if (!hash->hash.init(&hash->hash)) { 2256 (void) fprintf(stderr, "parse_hash_init: bad alloc\n"); 2257 /* just continue and die here */ 2258 /* XXX - agc - no way to return failure */ 2259 } 2260 (void) memcpy(hash->keyid, keyid, sizeof(hash->keyid)); 2261 } 2262 2263 /** 2264 \ingroup Core_ReadPackets 2265 \brief Parse a One Pass Signature packet 2266 */ 2267 static int 2268 parse_one_pass(__ops_region_t * region, __ops_stream_t * stream) 2269 { 2270 unsigned char c = 0x0; 2271 __ops_packet_t pkt; 2272 2273 if (!limread(&pkt.u.one_pass_sig.version, 1, region, stream)) { 2274 return 0; 2275 } 2276 if (pkt.u.one_pass_sig.version != 3) { 2277 OPS_ERROR_1(&stream->errors, OPS_E_PROTO_BAD_ONE_PASS_SIG_VRSN, 2278 "Bad one-pass signature version (%d)", 2279 pkt.u.one_pass_sig.version); 2280 return 0; 2281 } 2282 if (!limread(&c, 1, region, stream)) { 2283 return 0; 2284 } 2285 pkt.u.one_pass_sig.sig_type = (__ops_sig_type_t)c; 2286 2287 if (!limread(&c, 1, region, stream)) { 2288 return 0; 2289 } 2290 pkt.u.one_pass_sig.hash_alg = (__ops_hash_alg_t)c; 2291 2292 if (!limread(&c, 1, region, stream)) { 2293 return 0; 2294 } 2295 pkt.u.one_pass_sig.key_alg = (__ops_pubkey_alg_t)c; 2296 2297 if (!limread(pkt.u.one_pass_sig.keyid, 2298 sizeof(pkt.u.one_pass_sig.keyid), region, stream)) { 2299 return 0; 2300 } 2301 2302 if (!limread(&c, 1, region, stream)) { 2303 return 0; 2304 } 2305 pkt.u.one_pass_sig.nested = !!c; 2306 CALLBACK(OPS_PTAG_CT_1_PASS_SIG, &stream->cbinfo, &pkt); 2307 /* XXX: we should, perhaps, let the app choose whether to hash or not */ 2308 parse_hash_init(stream, pkt.u.one_pass_sig.hash_alg, 2309 pkt.u.one_pass_sig.keyid); 2310 return 1; 2311 } 2312 2313 /** 2314 \ingroup Core_ReadPackets 2315 \brief Parse a Trust packet 2316 */ 2317 static int 2318 parse_trust(__ops_region_t *region, __ops_stream_t *stream) 2319 { 2320 __ops_packet_t pkt; 2321 2322 if (!read_data(&pkt.u.trust.data, region, stream)) { 2323 return 0; 2324 } 2325 CALLBACK(OPS_PTAG_CT_TRUST, &stream->cbinfo, &pkt); 2326 return 1; 2327 } 2328 2329 static void 2330 parse_hash_data(__ops_stream_t *stream, const void *data, 2331 size_t length) 2332 { 2333 size_t n; 2334 2335 for (n = 0; n < stream->hashc; ++n) { 2336 stream->hashes[n].hash.add(&stream->hashes[n].hash, data, length); 2337 } 2338 } 2339 2340 /** 2341 \ingroup Core_ReadPackets 2342 \brief Parse a Literal Data packet 2343 */ 2344 static int 2345 parse_litdata(__ops_region_t *region, __ops_stream_t *stream) 2346 { 2347 __ops_memory_t *mem; 2348 __ops_packet_t pkt; 2349 unsigned char c = 0x0; 2350 2351 if (!limread(&c, 1, region, stream)) { 2352 return 0; 2353 } 2354 pkt.u.litdata_header.format = (__ops_litdata_type_t)c; 2355 if (!limread(&c, 1, region, stream)) { 2356 return 0; 2357 } 2358 if (!limread((unsigned char *)pkt.u.litdata_header.filename, 2359 (unsigned)c, region, stream)) { 2360 return 0; 2361 } 2362 pkt.u.litdata_header.filename[c] = '\0'; 2363 if (!limited_read_time(&pkt.u.litdata_header.mtime, region, stream)) { 2364 return 0; 2365 } 2366 CALLBACK(OPS_PTAG_CT_LITDATA_HEADER, &stream->cbinfo, &pkt); 2367 mem = pkt.u.litdata_body.mem = __ops_memory_new(); 2368 __ops_memory_init(pkt.u.litdata_body.mem, 2369 (unsigned)((region->length * 101) / 100) + 12); 2370 pkt.u.litdata_body.data = mem->buf; 2371 2372 while (region->readc < region->length) { 2373 unsigned readc = region->length - region->readc; 2374 2375 if (!limread(mem->buf, readc, region, stream)) { 2376 return 0; 2377 } 2378 pkt.u.litdata_body.length = readc; 2379 parse_hash_data(stream, pkt.u.litdata_body.data, region->length); 2380 CALLBACK(OPS_PTAG_CT_LITDATA_BODY, &stream->cbinfo, &pkt); 2381 } 2382 2383 /* XXX - get rid of mem here? */ 2384 2385 return 1; 2386 } 2387 2388 /** 2389 * \ingroup Core_Create 2390 * 2391 * __ops_seckey_free() frees the memory associated with "key". Note that 2392 * the key itself is not freed. 2393 * 2394 * \param key 2395 */ 2396 2397 void 2398 __ops_seckey_free(__ops_seckey_t *key) 2399 { 2400 switch (key->pubkey.alg) { 2401 case OPS_PKA_RSA: 2402 case OPS_PKA_RSA_ENCRYPT_ONLY: 2403 case OPS_PKA_RSA_SIGN_ONLY: 2404 free_BN(&key->key.rsa.d); 2405 free_BN(&key->key.rsa.p); 2406 free_BN(&key->key.rsa.q); 2407 free_BN(&key->key.rsa.u); 2408 break; 2409 2410 case OPS_PKA_DSA: 2411 free_BN(&key->key.dsa.x); 2412 break; 2413 2414 default: 2415 (void) fprintf(stderr, 2416 "__ops_seckey_free: Unknown algorithm: %d (%s)\n", 2417 key->pubkey.alg, 2418 __ops_show_pka(key->pubkey.alg)); 2419 } 2420 free(key->checkhash); 2421 __ops_pubkey_free(&key->pubkey); 2422 } 2423 2424 static int 2425 consume_packet(__ops_region_t *region, __ops_stream_t *stream, unsigned warn) 2426 { 2427 __ops_packet_t pkt; 2428 __ops_data_t remainder; 2429 2430 if (region->indeterminate) { 2431 ERRP(&stream->cbinfo, pkt, 2432 "Can't consume indeterminate packets"); 2433 } 2434 2435 if (read_data(&remainder, region, stream)) { 2436 /* now throw it away */ 2437 data_free(&remainder); 2438 if (warn) { 2439 OPS_ERROR(&stream->errors, OPS_E_P_PACKET_CONSUMED, 2440 "Warning: packet consumer"); 2441 } 2442 return 1; 2443 } 2444 OPS_ERROR(&stream->errors, OPS_E_P_PACKET_NOT_CONSUMED, 2445 (warn) ? "Warning: Packet was not consumed" : 2446 "Packet was not consumed"); 2447 return warn; 2448 } 2449 2450 /** 2451 * \ingroup Core_ReadPackets 2452 * \brief Parse a secret key 2453 */ 2454 static int 2455 parse_seckey(__ops_region_t *region, __ops_stream_t *stream) 2456 { 2457 __ops_packet_t pkt; 2458 __ops_region_t encregion; 2459 __ops_region_t *saved_region = NULL; 2460 unsigned char c = 0x0; 2461 __ops_crypt_t decrypt; 2462 __ops_hash_t checkhash; 2463 unsigned blocksize; 2464 unsigned crypted; 2465 int ret = 1; 2466 2467 if (__ops_get_debug_level(__FILE__)) { 2468 fprintf(stderr, "\n---------\nparse_seckey:\n"); 2469 fprintf(stderr, 2470 "region length=%u, readc=%u, remainder=%u\n", 2471 region->length, region->readc, 2472 region->length - region->readc); 2473 } 2474 (void) memset(&pkt, 0x0, sizeof(pkt)); 2475 if (!parse_pubkey_data(&pkt.u.seckey.pubkey, region, stream)) { 2476 return 0; 2477 } 2478 if (__ops_get_debug_level(__FILE__)) { 2479 fprintf(stderr, "parse_seckey: public key parsed\n"); 2480 __ops_print_pubkey(&pkt.u.seckey.pubkey); 2481 } 2482 stream->reading_v3_secret = (pkt.u.seckey.pubkey.version != OPS_V4); 2483 2484 if (!limread(&c, 1, region, stream)) { 2485 return 0; 2486 } 2487 pkt.u.seckey.s2k_usage = (__ops_s2k_usage_t)c; 2488 2489 if (pkt.u.seckey.s2k_usage == OPS_S2KU_ENCRYPTED || 2490 pkt.u.seckey.s2k_usage == OPS_S2KU_ENCRYPTED_AND_HASHED) { 2491 if (!limread(&c, 1, region, stream)) { 2492 return 0; 2493 } 2494 pkt.u.seckey.alg = (__ops_symm_alg_t)c; 2495 if (!limread(&c, 1, region, stream)) { 2496 return 0; 2497 } 2498 pkt.u.seckey.s2k_specifier = (__ops_s2k_specifier_t)c; 2499 switch (pkt.u.seckey.s2k_specifier) { 2500 case OPS_S2KS_SIMPLE: 2501 case OPS_S2KS_SALTED: 2502 case OPS_S2KS_ITERATED_AND_SALTED: 2503 break; 2504 default: 2505 (void) fprintf(stderr, 2506 "parse_seckey: bad seckey\n"); 2507 return 0; 2508 } 2509 if (!limread(&c, 1, region, stream)) { 2510 return 0; 2511 } 2512 pkt.u.seckey.hash_alg = (__ops_hash_alg_t)c; 2513 if (pkt.u.seckey.s2k_specifier != OPS_S2KS_SIMPLE && 2514 !limread(pkt.u.seckey.salt, 8, region, stream)) { 2515 return 0; 2516 } 2517 if (pkt.u.seckey.s2k_specifier == 2518 OPS_S2KS_ITERATED_AND_SALTED) { 2519 if (!limread(&c, 1, region, stream)) { 2520 return 0; 2521 } 2522 pkt.u.seckey.octetc = 2523 (16 + ((unsigned)c & 15)) << 2524 (((unsigned)c >> 4) + 6); 2525 } 2526 } else if (pkt.u.seckey.s2k_usage != OPS_S2KU_NONE) { 2527 /* this is V3 style, looks just like a V4 simple hash */ 2528 pkt.u.seckey.alg = (__ops_symm_alg_t)c; 2529 pkt.u.seckey.s2k_usage = OPS_S2KU_ENCRYPTED; 2530 pkt.u.seckey.s2k_specifier = OPS_S2KS_SIMPLE; 2531 pkt.u.seckey.hash_alg = OPS_HASH_MD5; 2532 } 2533 crypted = pkt.u.seckey.s2k_usage == OPS_S2KU_ENCRYPTED || 2534 pkt.u.seckey.s2k_usage == OPS_S2KU_ENCRYPTED_AND_HASHED; 2535 2536 if (crypted) { 2537 __ops_packet_t seckey; 2538 unsigned char key[OPS_MAX_KEY_SIZE + OPS_MAX_HASH_SIZE]; 2539 __ops_hash_t hashes[(OPS_MAX_KEY_SIZE + OPS_MIN_HASH_SIZE - 1) / OPS_MIN_HASH_SIZE]; 2540 size_t passlen; 2541 char *passphrase; 2542 int hashsize; 2543 int keysize; 2544 int n; 2545 2546 blocksize = __ops_block_size(pkt.u.seckey.alg); 2547 if (blocksize == 0 || blocksize > OPS_MAX_BLOCK_SIZE) { 2548 (void) fprintf(stderr, 2549 "parse_seckey: bad blocksize\n"); 2550 return 0; 2551 } 2552 2553 if (!limread(pkt.u.seckey.iv, blocksize, region, stream)) { 2554 return 0; 2555 } 2556 (void) memset(&seckey, 0x0, sizeof(seckey)); 2557 passphrase = NULL; 2558 seckey.u.skey_passphrase.passphrase = &passphrase; 2559 seckey.u.skey_passphrase.seckey = &pkt.u.seckey; 2560 CALLBACK(OPS_GET_PASSPHRASE, &stream->cbinfo, &seckey); 2561 if (!passphrase) { 2562 if (__ops_get_debug_level(__FILE__)) { 2563 /* \todo make into proper error */ 2564 (void) fprintf(stderr, 2565 "parse_seckey: can't get passphrase\n"); 2566 } 2567 if (!consume_packet(region, stream, 0)) { 2568 return 0; 2569 } 2570 2571 CALLBACK(OPS_PTAG_CT_ENCRYPTED_SECRET_KEY, 2572 &stream->cbinfo, &pkt); 2573 2574 return 1; 2575 } 2576 keysize = __ops_key_size(pkt.u.seckey.alg); 2577 if (keysize == 0 || keysize > OPS_MAX_KEY_SIZE) { 2578 (void) fprintf(stderr, 2579 "parse_seckey: bad keysize\n"); 2580 return 0; 2581 } 2582 2583 hashsize = __ops_hash_size(pkt.u.seckey.hash_alg); 2584 if (hashsize == 0 || hashsize > OPS_MAX_HASH_SIZE) { 2585 (void) fprintf(stderr, 2586 "parse_seckey: bad hashsize\n"); 2587 return 0; 2588 } 2589 2590 for (n = 0; n * hashsize < keysize; ++n) { 2591 int i; 2592 2593 __ops_hash_any(&hashes[n], 2594 pkt.u.seckey.hash_alg); 2595 if (!hashes[n].init(&hashes[n])) { 2596 (void) fprintf(stderr, 2597 "parse_seckey: bad alloc\n"); 2598 return 0; 2599 } 2600 /* preload hashes with zeroes... */ 2601 for (i = 0; i < n; ++i) { 2602 hashes[n].add(&hashes[n], 2603 (const unsigned char *) "", 1); 2604 } 2605 } 2606 passlen = strlen(passphrase); 2607 for (n = 0; n * hashsize < keysize; ++n) { 2608 unsigned i; 2609 2610 switch (pkt.u.seckey.s2k_specifier) { 2611 case OPS_S2KS_SALTED: 2612 hashes[n].add(&hashes[n], 2613 pkt.u.seckey.salt, 2614 OPS_SALT_SIZE); 2615 /* FALLTHROUGH */ 2616 case OPS_S2KS_SIMPLE: 2617 hashes[n].add(&hashes[n], 2618 (unsigned char *) passphrase, passlen); 2619 break; 2620 2621 case OPS_S2KS_ITERATED_AND_SALTED: 2622 for (i = 0; i < pkt.u.seckey.octetc; 2623 i += passlen + OPS_SALT_SIZE) { 2624 unsigned j; 2625 2626 j = passlen + OPS_SALT_SIZE; 2627 if (i + j > pkt.u.seckey.octetc && i != 0) { 2628 j = pkt.u.seckey.octetc - i; 2629 } 2630 hashes[n].add(&hashes[n], 2631 pkt.u.seckey.salt, 2632 (unsigned)(j > OPS_SALT_SIZE) ? 2633 OPS_SALT_SIZE : j); 2634 if (j > OPS_SALT_SIZE) { 2635 hashes[n].add(&hashes[n], 2636 (unsigned char *) passphrase, 2637 j - OPS_SALT_SIZE); 2638 } 2639 } 2640 break; 2641 default: 2642 break; 2643 } 2644 } 2645 2646 for (n = 0; n * hashsize < keysize; ++n) { 2647 int r; 2648 2649 r = hashes[n].finish(&hashes[n], key + n * hashsize); 2650 if (r != hashsize) { 2651 (void) fprintf(stderr, 2652 "parse_seckey: bad r\n"); 2653 return 0; 2654 } 2655 } 2656 2657 __ops_forget(passphrase, passlen); 2658 2659 __ops_crypt_any(&decrypt, pkt.u.seckey.alg); 2660 if (__ops_get_debug_level(__FILE__)) { 2661 unsigned i; 2662 2663 fprintf(stderr, "\nREADING:\niv="); 2664 for (i = 0; 2665 i < __ops_block_size(pkt.u.seckey.alg); 2666 i++) { 2667 fprintf(stderr, "%02x ", pkt.u.seckey.iv[i]); 2668 } 2669 fprintf(stderr, "\nkey="); 2670 for (i = 0; i < CAST_KEY_LENGTH; i++) { 2671 fprintf(stderr, "%02x ", key[i]); 2672 } 2673 fprintf(stderr, "\n"); 2674 } 2675 decrypt.set_iv(&decrypt, pkt.u.seckey.iv); 2676 decrypt.set_crypt_key(&decrypt, key); 2677 2678 /* now read encrypted data */ 2679 2680 __ops_reader_push_decrypt(stream, &decrypt, region); 2681 2682 /* 2683 * Since all known encryption for PGP doesn't compress, we 2684 * can limit to the same length as the current region (for 2685 * now). 2686 */ 2687 __ops_init_subregion(&encregion, NULL); 2688 encregion.length = region->length - region->readc; 2689 if (pkt.u.seckey.pubkey.version != OPS_V4) { 2690 encregion.length -= 2; 2691 } 2692 saved_region = region; 2693 region = &encregion; 2694 } 2695 if (pkt.u.seckey.s2k_usage == OPS_S2KU_ENCRYPTED_AND_HASHED) { 2696 pkt.u.seckey.checkhash = calloc(1, OPS_CHECKHASH_SIZE); 2697 if (pkt.u.seckey.checkhash == NULL) { 2698 (void) fprintf(stderr, "parse_seckey: bad alloc\n"); 2699 return 0; 2700 } 2701 __ops_hash_sha1(&checkhash); 2702 __ops_reader_push_hash(stream, &checkhash); 2703 } else { 2704 __ops_reader_push_sum16(stream); 2705 } 2706 2707 switch (pkt.u.seckey.pubkey.alg) { 2708 case OPS_PKA_RSA: 2709 case OPS_PKA_RSA_ENCRYPT_ONLY: 2710 case OPS_PKA_RSA_SIGN_ONLY: 2711 if (!limread_mpi(&pkt.u.seckey.key.rsa.d, region, stream) || 2712 !limread_mpi(&pkt.u.seckey.key.rsa.p, region, stream) || 2713 !limread_mpi(&pkt.u.seckey.key.rsa.q, region, stream) || 2714 !limread_mpi(&pkt.u.seckey.key.rsa.u, region, stream)) { 2715 ret = 0; 2716 } 2717 break; 2718 2719 case OPS_PKA_DSA: 2720 if (!limread_mpi(&pkt.u.seckey.key.dsa.x, region, stream)) { 2721 ret = 0; 2722 } 2723 break; 2724 2725 default: 2726 OPS_ERROR_2(&stream->errors, 2727 OPS_E_ALG_UNSUPPORTED_PUBLIC_KEY_ALG, 2728 "Unsupported Public Key algorithm %d (%s)", 2729 pkt.u.seckey.pubkey.alg, 2730 __ops_show_pka(pkt.u.seckey.pubkey.alg)); 2731 ret = 0; 2732 } 2733 2734 if (__ops_get_debug_level(__FILE__)) { 2735 (void) fprintf(stderr, "4 MPIs read\n"); 2736 } 2737 stream->reading_v3_secret = 0; 2738 2739 if (pkt.u.seckey.s2k_usage == OPS_S2KU_ENCRYPTED_AND_HASHED) { 2740 unsigned char hash[OPS_CHECKHASH_SIZE]; 2741 2742 __ops_reader_pop_hash(stream); 2743 checkhash.finish(&checkhash, hash); 2744 2745 if (crypted && 2746 pkt.u.seckey.pubkey.version != OPS_V4) { 2747 __ops_reader_pop_decrypt(stream); 2748 region = saved_region; 2749 } 2750 if (ret) { 2751 if (!limread(pkt.u.seckey.checkhash, 2752 OPS_CHECKHASH_SIZE, region, stream)) { 2753 return 0; 2754 } 2755 2756 if (memcmp(hash, pkt.u.seckey.checkhash, 2757 OPS_CHECKHASH_SIZE) != 0) { 2758 ERRP(&stream->cbinfo, pkt, 2759 "Hash mismatch in secret key"); 2760 } 2761 } 2762 } else { 2763 unsigned short sum; 2764 2765 sum = __ops_reader_pop_sum16(stream); 2766 if (crypted && 2767 pkt.u.seckey.pubkey.version != OPS_V4) { 2768 __ops_reader_pop_decrypt(stream); 2769 region = saved_region; 2770 } 2771 if (ret) { 2772 if (!limread_scalar(&pkt.u.seckey.checksum, 2, 2773 region, stream)) 2774 return 0; 2775 2776 if (sum != pkt.u.seckey.checksum) { 2777 ERRP(&stream->cbinfo, pkt, 2778 "Checksum mismatch in secret key"); 2779 } 2780 } 2781 } 2782 2783 if (crypted && pkt.u.seckey.pubkey.version == OPS_V4) { 2784 __ops_reader_pop_decrypt(stream); 2785 } 2786 if (region == NULL) { 2787 (void) fprintf(stderr, "parse_seckey: NULL region\n"); 2788 return 0; 2789 } 2790 if (ret && region->readc != region->length) { 2791 (void) fprintf(stderr, "parse_seckey: bad length\n"); 2792 return 0; 2793 } 2794 if (!ret) { 2795 return 0; 2796 } 2797 CALLBACK(OPS_PTAG_CT_SECRET_KEY, &stream->cbinfo, &pkt); 2798 if (__ops_get_debug_level(__FILE__)) { 2799 (void) fprintf(stderr, "--- end of parse_seckey\n\n"); 2800 } 2801 return 1; 2802 } 2803 2804 /** 2805 \ingroup Core_ReadPackets 2806 \brief Parse a Public Key Session Key packet 2807 */ 2808 static int 2809 parse_pk_sesskey(__ops_region_t *region, 2810 __ops_stream_t *stream) 2811 { 2812 const __ops_seckey_t *secret; 2813 __ops_packet_t sesskey; 2814 __ops_packet_t pkt; 2815 unsigned char *iv; 2816 unsigned char c = 0x0; 2817 unsigned char cs[2]; 2818 unsigned k; 2819 BIGNUM *enc_m; 2820 int n; 2821 2822 /* Can't rely on it being CAST5 */ 2823 /* \todo FIXME RW */ 2824 /* const size_t sz_unencoded_m_buf=CAST_KEY_LENGTH+1+2; */ 2825 unsigned char unencoded_m_buf[1024]; 2826 2827 if (!limread(&c, 1, region, stream)) { 2828 return 0; 2829 } 2830 pkt.u.pk_sesskey.version = (__ops_pk_sesskey_version_t)c; 2831 if (pkt.u.pk_sesskey.version != OPS_PKSK_V3) { 2832 OPS_ERROR_1(&stream->errors, OPS_E_PROTO_BAD_PKSK_VRSN, 2833 "Bad public-key encrypted session key version (%d)", 2834 pkt.u.pk_sesskey.version); 2835 return 0; 2836 } 2837 if (!limread(pkt.u.pk_sesskey.key_id, 2838 sizeof(pkt.u.pk_sesskey.key_id), region, stream)) { 2839 return 0; 2840 } 2841 if (__ops_get_debug_level(__FILE__)) { 2842 int i; 2843 int x = sizeof(pkt.u.pk_sesskey.key_id); 2844 2845 printf("session key: public key id: x=%d\n", x); 2846 for (i = 0; i < x; i++) { 2847 printf("%2x ", pkt.u.pk_sesskey.key_id[i]); 2848 } 2849 printf("\n"); 2850 } 2851 if (!limread(&c, 1, region, stream)) { 2852 return 0; 2853 } 2854 pkt.u.pk_sesskey.alg = (__ops_pubkey_alg_t)c; 2855 switch (pkt.u.pk_sesskey.alg) { 2856 case OPS_PKA_RSA: 2857 if (!limread_mpi(&pkt.u.pk_sesskey.params.rsa.encrypted_m, 2858 region, stream)) { 2859 return 0; 2860 } 2861 enc_m = pkt.u.pk_sesskey.params.rsa.encrypted_m; 2862 break; 2863 2864 case OPS_PKA_ELGAMAL: 2865 if (!limread_mpi(&pkt.u.pk_sesskey.params.elgamal.g_to_k, 2866 region, stream) || 2867 !limread_mpi( 2868 &pkt.u.pk_sesskey.params.elgamal.encrypted_m, 2869 region, stream)) { 2870 return 0; 2871 } 2872 enc_m = pkt.u.pk_sesskey.params.elgamal.encrypted_m; 2873 break; 2874 2875 default: 2876 OPS_ERROR_1(&stream->errors, 2877 OPS_E_ALG_UNSUPPORTED_PUBLIC_KEY_ALG, 2878 "Unknown public key algorithm in session key (%s)", 2879 __ops_show_pka(pkt.u.pk_sesskey.alg)); 2880 return 0; 2881 } 2882 2883 (void) memset(&sesskey, 0x0, sizeof(sesskey)); 2884 secret = NULL; 2885 sesskey.u.get_seckey.seckey = &secret; 2886 sesskey.u.get_seckey.pk_sesskey = &pkt.u.pk_sesskey; 2887 2888 CALLBACK(OPS_GET_SECKEY, &stream->cbinfo, &sesskey); 2889 2890 if (!secret) { 2891 CALLBACK(OPS_PTAG_CT_ENCRYPTED_PK_SESSION_KEY, &stream->cbinfo, 2892 &pkt); 2893 return 1; 2894 } 2895 n = __ops_decrypt_decode_mpi(unencoded_m_buf, sizeof(unencoded_m_buf), 2896 enc_m, secret); 2897 if (n < 1) { 2898 ERRP(&stream->cbinfo, pkt, "decrypted message too short"); 2899 return 0; 2900 } 2901 2902 /* PKA */ 2903 pkt.u.pk_sesskey.symm_alg = (__ops_symm_alg_t)unencoded_m_buf[0]; 2904 2905 if (!__ops_is_sa_supported(pkt.u.pk_sesskey.symm_alg)) { 2906 /* ERR1P */ 2907 OPS_ERROR_1(&stream->errors, OPS_E_ALG_UNSUPPORTED_SYMMETRIC_ALG, 2908 "Symmetric algorithm %s not supported", 2909 __ops_show_symm_alg( 2910 pkt.u.pk_sesskey.symm_alg)); 2911 return 0; 2912 } 2913 k = __ops_key_size(pkt.u.pk_sesskey.symm_alg); 2914 2915 if ((unsigned) n != k + 3) { 2916 OPS_ERROR_2(&stream->errors, OPS_E_PROTO_DECRYPTED_MSG_WRONG_LEN, 2917 "decrypted message wrong length (got %d expected %d)", 2918 n, k + 3); 2919 return 0; 2920 } 2921 if (k > sizeof(pkt.u.pk_sesskey.key)) { 2922 (void) fprintf(stderr, "parse_pk_sesskey: bad keylength\n"); 2923 return 0; 2924 } 2925 2926 (void) memcpy(pkt.u.pk_sesskey.key, unencoded_m_buf + 1, k); 2927 2928 if (__ops_get_debug_level(__FILE__)) { 2929 unsigned int j; 2930 printf("session key recovered (len=%u):\n", k); 2931 for (j = 0; j < k; j++) 2932 printf("%2x ", pkt.u.pk_sesskey.key[j]); 2933 printf("\n"); 2934 } 2935 pkt.u.pk_sesskey.checksum = unencoded_m_buf[k + 1] + 2936 (unencoded_m_buf[k + 2] << 8); 2937 if (__ops_get_debug_level(__FILE__)) { 2938 printf("session key checksum: %2x %2x\n", 2939 unencoded_m_buf[k + 1], unencoded_m_buf[k + 2]); 2940 } 2941 2942 /* Check checksum */ 2943 __ops_calc_sesskey_checksum(&pkt.u.pk_sesskey, &cs[0]); 2944 if (unencoded_m_buf[k + 1] != cs[0] || 2945 unencoded_m_buf[k + 2] != cs[1]) { 2946 OPS_ERROR_4(&stream->errors, OPS_E_PROTO_BAD_SK_CHECKSUM, 2947 "Session key checksum wrong: expected %2x %2x, got %2x %2x", 2948 cs[0], cs[1], unencoded_m_buf[k + 1], 2949 unencoded_m_buf[k + 2]); 2950 return 0; 2951 } 2952 /* all is well */ 2953 CALLBACK(OPS_PTAG_CT_PK_SESSION_KEY, &stream->cbinfo, &pkt); 2954 2955 __ops_crypt_any(&stream->decrypt, pkt.u.pk_sesskey.symm_alg); 2956 iv = calloc(1, stream->decrypt.blocksize); 2957 if (iv == NULL) { 2958 (void) fprintf(stderr, "parse_pk_sesskey: bad alloc\n"); 2959 return 0; 2960 } 2961 stream->decrypt.set_iv(&stream->decrypt, iv); 2962 stream->decrypt.set_crypt_key(&stream->decrypt, pkt.u.pk_sesskey.key); 2963 __ops_encrypt_init(&stream->decrypt); 2964 free(iv); 2965 return 1; 2966 } 2967 2968 static int 2969 __ops_decrypt_se_data(__ops_content_tag_t tag, __ops_region_t *region, 2970 __ops_stream_t *stream) 2971 { 2972 __ops_crypt_t *decrypt; 2973 const int printerrors = 1; 2974 int r = 1; 2975 2976 decrypt = __ops_get_decrypt(stream); 2977 if (decrypt) { 2978 unsigned char buf[OPS_MAX_BLOCK_SIZE + 2] = ""; 2979 size_t b = decrypt->blocksize; 2980 /* __ops_packet_t pkt; */ 2981 __ops_region_t encregion; 2982 2983 2984 __ops_reader_push_decrypt(stream, decrypt, region); 2985 2986 __ops_init_subregion(&encregion, NULL); 2987 encregion.length = b + 2; 2988 2989 if (!exact_limread(buf, b + 2, &encregion, stream)) { 2990 return 0; 2991 } 2992 if (buf[b - 2] != buf[b] || buf[b - 1] != buf[b + 1]) { 2993 __ops_reader_pop_decrypt(stream); 2994 OPS_ERROR_4(&stream->errors, 2995 OPS_E_PROTO_BAD_SYMMETRIC_DECRYPT, 2996 "Bad symmetric decrypt (%02x%02x vs %02x%02x)", 2997 buf[b - 2], buf[b - 1], buf[b], buf[b + 1]); 2998 return 0; 2999 } 3000 if (tag == OPS_PTAG_CT_SE_DATA_BODY) { 3001 decrypt->decrypt_resync(decrypt); 3002 decrypt->block_encrypt(decrypt, decrypt->civ, 3003 decrypt->civ); 3004 } 3005 r = __ops_parse(stream, !printerrors); 3006 3007 __ops_reader_pop_decrypt(stream); 3008 } else { 3009 __ops_packet_t pkt; 3010 3011 while (region->readc < region->length) { 3012 unsigned len; 3013 3014 len = region->length - region->readc; 3015 if (len > sizeof(pkt.u.se_data_body.data)) 3016 len = sizeof(pkt.u.se_data_body.data); 3017 3018 if (!limread(pkt.u.se_data_body.data, len, 3019 region, stream)) { 3020 return 0; 3021 } 3022 pkt.u.se_data_body.length = len; 3023 CALLBACK(tag, &stream->cbinfo, &pkt); 3024 } 3025 } 3026 3027 return r; 3028 } 3029 3030 static int 3031 __ops_decrypt_se_ip_data(__ops_content_tag_t tag, __ops_region_t *region, 3032 __ops_stream_t *stream) 3033 { 3034 __ops_crypt_t *decrypt; 3035 const int printerrors = 1; 3036 int r = 1; 3037 3038 decrypt = __ops_get_decrypt(stream); 3039 if (decrypt) { 3040 __ops_reader_push_decrypt(stream, decrypt, region); 3041 __ops_reader_push_se_ip_data(stream, decrypt, region); 3042 3043 r = __ops_parse(stream, !printerrors); 3044 3045 __ops_reader_pop_se_ip_data(stream); 3046 __ops_reader_pop_decrypt(stream); 3047 } else { 3048 __ops_packet_t pkt; 3049 3050 while (region->readc < region->length) { 3051 unsigned len; 3052 3053 len = region->length - region->readc; 3054 if (len > sizeof(pkt.u.se_data_body.data)) { 3055 len = sizeof(pkt.u.se_data_body.data); 3056 } 3057 3058 if (!limread(pkt.u.se_data_body.data, 3059 len, region, stream)) { 3060 return 0; 3061 } 3062 3063 pkt.u.se_data_body.length = len; 3064 3065 CALLBACK(tag, &stream->cbinfo, &pkt); 3066 } 3067 } 3068 3069 return r; 3070 } 3071 3072 /** 3073 \ingroup Core_ReadPackets 3074 \brief Read a Symmetrically Encrypted packet 3075 */ 3076 static int 3077 parse_se_data(__ops_region_t *region, __ops_stream_t *stream) 3078 { 3079 __ops_packet_t pkt; 3080 3081 /* there's no info to go with this, so just announce it */ 3082 CALLBACK(OPS_PTAG_CT_SE_DATA_HEADER, &stream->cbinfo, &pkt); 3083 3084 /* 3085 * The content of an encrypted data packet is more OpenPGP packets 3086 * once decrypted, so recursively handle them 3087 */ 3088 return __ops_decrypt_se_data(OPS_PTAG_CT_SE_DATA_BODY, region, stream); 3089 } 3090 3091 /** 3092 \ingroup Core_ReadPackets 3093 \brief Read a Symmetrically Encrypted Integrity Protected packet 3094 */ 3095 static int 3096 parse_se_ip_data(__ops_region_t *region, __ops_stream_t *stream) 3097 { 3098 __ops_packet_t pkt; 3099 unsigned char c = 0x0; 3100 3101 if (!limread(&c, 1, region, stream)) { 3102 return 0; 3103 } 3104 pkt.u.se_ip_data_header.version = (__ops_se_ip_version_t)c; 3105 3106 if (pkt.u.se_ip_data_header.version != OPS_SE_IP_V1) { 3107 (void) fprintf(stderr, "parse_se_ip_data: bad version\n"); 3108 return 0; 3109 } 3110 3111 /* 3112 * The content of an encrypted data packet is more OpenPGP packets 3113 * once decrypted, so recursively handle them 3114 */ 3115 return __ops_decrypt_se_ip_data(OPS_PTAG_CT_SE_IP_DATA_BODY, region, 3116 stream); 3117 } 3118 3119 /** 3120 \ingroup Core_ReadPackets 3121 \brief Read a MDC packet 3122 */ 3123 static int 3124 parse_mdc(__ops_region_t *region, __ops_stream_t *stream) 3125 { 3126 __ops_packet_t pkt; 3127 3128 pkt.u.mdc.length = OPS_SHA1_HASH_SIZE; 3129 if ((pkt.u.mdc.data = calloc(1, OPS_SHA1_HASH_SIZE)) == NULL) { 3130 (void) fprintf(stderr, "parse_mdc: bad alloc\n"); 3131 return 0; 3132 } 3133 if (!limread(pkt.u.mdc.data, OPS_SHA1_HASH_SIZE, region, stream)) { 3134 return 0; 3135 } 3136 CALLBACK(OPS_PTAG_CT_MDC, &stream->cbinfo, &pkt); 3137 free(pkt.u.mdc.data); 3138 return 1; 3139 } 3140 3141 /** 3142 * \ingroup Core_ReadPackets 3143 * \brief Parse one packet. 3144 * 3145 * This function parses the packet tag. It computes the value of the 3146 * content tag and then calls the appropriate function to handle the 3147 * content. 3148 * 3149 * \param *stream How to parse 3150 * \param *pktlen On return, will contain number of bytes in packet 3151 * \return 1 on success, 0 on error, -1 on EOF */ 3152 static int 3153 __ops_parse_packet(__ops_stream_t *stream, unsigned long *pktlen) 3154 { 3155 __ops_packet_t pkt; 3156 __ops_region_t region; 3157 unsigned char ptag; 3158 unsigned indeterminate = 0; 3159 int ret; 3160 3161 pkt.u.ptag.position = stream->readinfo.position; 3162 3163 ret = base_read(&ptag, 1, stream); 3164 3165 if (__ops_get_debug_level(__FILE__)) { 3166 (void) fprintf(stderr, 3167 "__ops_parse_packet: base_read returned %d\n", 3168 ret); 3169 } 3170 3171 /* errors in the base read are effectively EOF. */ 3172 if (ret <= 0) { 3173 return -1; 3174 } 3175 3176 *pktlen = 0; 3177 3178 if (!(ptag & OPS_PTAG_ALWAYS_SET)) { 3179 pkt.u.error.error = "Format error (ptag bit not set)"; 3180 CALLBACK(OPS_PARSER_ERROR, &stream->cbinfo, &pkt); 3181 return 0; 3182 } 3183 pkt.u.ptag.new_format = !!(ptag & OPS_PTAG_NEW_FORMAT); 3184 if (pkt.u.ptag.new_format) { 3185 pkt.u.ptag.type = (ptag & OPS_PTAG_NF_CONTENT_TAG_MASK); 3186 pkt.u.ptag.length_type = 0; 3187 if (!read_new_length(&pkt.u.ptag.length, stream)) { 3188 return 0; 3189 } 3190 } else { 3191 unsigned rb; 3192 3193 rb = 0; 3194 pkt.u.ptag.type = ((unsigned)ptag & 3195 OPS_PTAG_OF_CONTENT_TAG_MASK) 3196 >> OPS_PTAG_OF_CONTENT_TAG_SHIFT; 3197 pkt.u.ptag.length_type = ptag & OPS_PTAG_OF_LENGTH_TYPE_MASK; 3198 switch (pkt.u.ptag.length_type) { 3199 case OPS_PTAG_OLD_LEN_1: 3200 rb = _read_scalar(&pkt.u.ptag.length, 1, stream); 3201 break; 3202 3203 case OPS_PTAG_OLD_LEN_2: 3204 rb = _read_scalar(&pkt.u.ptag.length, 2, stream); 3205 break; 3206 3207 case OPS_PTAG_OLD_LEN_4: 3208 rb = _read_scalar(&pkt.u.ptag.length, 4, stream); 3209 break; 3210 3211 case OPS_PTAG_OLD_LEN_INDETERMINATE: 3212 pkt.u.ptag.length = 0; 3213 indeterminate = 1; 3214 rb = 1; 3215 break; 3216 } 3217 if (!rb) { 3218 return 0; 3219 } 3220 } 3221 3222 CALLBACK(OPS_PARSER_PTAG, &stream->cbinfo, &pkt); 3223 3224 __ops_init_subregion(®ion, NULL); 3225 region.length = pkt.u.ptag.length; 3226 region.indeterminate = indeterminate; 3227 if (__ops_get_debug_level(__FILE__)) { 3228 (void) fprintf(stderr, "__ops_parse_packet: type %u\n", 3229 pkt.u.ptag.type); 3230 } 3231 switch (pkt.u.ptag.type) { 3232 case OPS_PTAG_CT_SIGNATURE: 3233 ret = parse_sig(®ion, stream); 3234 break; 3235 3236 case OPS_PTAG_CT_PUBLIC_KEY: 3237 case OPS_PTAG_CT_PUBLIC_SUBKEY: 3238 ret = parse_pubkey(pkt.u.ptag.type, ®ion, stream); 3239 break; 3240 3241 case OPS_PTAG_CT_TRUST: 3242 ret = parse_trust(®ion, stream); 3243 break; 3244 3245 case OPS_PTAG_CT_USER_ID: 3246 ret = parse_userid(®ion, stream); 3247 break; 3248 3249 case OPS_PTAG_CT_COMPRESSED: 3250 ret = parse_compressed(®ion, stream); 3251 break; 3252 3253 case OPS_PTAG_CT_1_PASS_SIG: 3254 ret = parse_one_pass(®ion, stream); 3255 break; 3256 3257 case OPS_PTAG_CT_LITDATA: 3258 ret = parse_litdata(®ion, stream); 3259 break; 3260 3261 case OPS_PTAG_CT_USER_ATTR: 3262 ret = parse_userattr(®ion, stream); 3263 break; 3264 3265 case OPS_PTAG_CT_SECRET_KEY: 3266 ret = parse_seckey(®ion, stream); 3267 break; 3268 3269 case OPS_PTAG_CT_SECRET_SUBKEY: 3270 ret = parse_seckey(®ion, stream); 3271 break; 3272 3273 case OPS_PTAG_CT_PK_SESSION_KEY: 3274 ret = parse_pk_sesskey(®ion, stream); 3275 break; 3276 3277 case OPS_PTAG_CT_SE_DATA: 3278 ret = parse_se_data(®ion, stream); 3279 break; 3280 3281 case OPS_PTAG_CT_SE_IP_DATA: 3282 ret = parse_se_ip_data(®ion, stream); 3283 break; 3284 3285 case OPS_PTAG_CT_MDC: 3286 ret = parse_mdc(®ion, stream); 3287 break; 3288 3289 default: 3290 OPS_ERROR_1(&stream->errors, OPS_E_P_UNKNOWN_TAG, 3291 "Unknown content tag 0x%x", 3292 pkt.u.ptag.type); 3293 ret = 0; 3294 } 3295 3296 /* Ensure that the entire packet has been consumed */ 3297 3298 if (region.length != region.readc && !region.indeterminate) { 3299 if (!consume_packet(®ion, stream, 0)) { 3300 ret = -1; 3301 } 3302 } 3303 3304 /* also consume it if there's been an error? */ 3305 /* \todo decide what to do about an error on an */ 3306 /* indeterminate packet */ 3307 if (ret == 0) { 3308 if (!consume_packet(®ion, stream, 0)) { 3309 ret = -1; 3310 } 3311 } 3312 /* set pktlen */ 3313 3314 *pktlen = stream->readinfo.alength; 3315 3316 /* do callback on entire packet, if desired and there was no error */ 3317 3318 if (ret > 0 && stream->readinfo.accumulate) { 3319 pkt.u.packet.length = stream->readinfo.alength; 3320 pkt.u.packet.raw = stream->readinfo.accumulated; 3321 stream->readinfo.accumulated = NULL; 3322 stream->readinfo.asize = 0; 3323 CALLBACK(OPS_PARSER_PACKET_END, &stream->cbinfo, &pkt); 3324 } 3325 stream->readinfo.alength = 0; 3326 3327 return (ret < 0) ? -1 : (ret) ? 1 : 0; 3328 } 3329 3330 /** 3331 * \ingroup Core_ReadPackets 3332 * 3333 * \brief Parse packets from an input stream until EOF or error. 3334 * 3335 * \details Setup the necessary parsing configuration in "stream" 3336 * before calling __ops_parse(). 3337 * 3338 * That information includes : 3339 * 3340 * - a "reader" function to be used to get the data to be parsed 3341 * 3342 * - a "callback" function to be called when this library has identified 3343 * a parseable object within the data 3344 * 3345 * - whether the calling function wants the signature subpackets 3346 * returned raw, parsed or not at all. 3347 * 3348 * After returning, stream->errors holds any errors encountered while parsing. 3349 * 3350 * \param stream Parsing configuration 3351 * \return 1 on success in all packets, 0 on error in any packet 3352 * 3353 * \sa CoreAPI Overview 3354 * 3355 * \sa __ops_print_errors() 3356 * 3357 */ 3358 3359 int 3360 __ops_parse(__ops_stream_t *stream, const int perrors) 3361 { 3362 unsigned long pktlen; 3363 int r; 3364 3365 do { 3366 r = __ops_parse_packet(stream, &pktlen); 3367 } while (r != -1); 3368 if (perrors) { 3369 __ops_print_errors(stream->errors); 3370 } 3371 return (stream->errors == NULL); 3372 } 3373 3374 /** 3375 * \ingroup Core_ReadPackets 3376 * 3377 * \brief Specifies whether one or more signature 3378 * subpacket types should be returned parsed; or raw; or ignored. 3379 * 3380 * \param stream Pointer to previously allocated structure 3381 * \param tag Packet tag. OPS_PTAG_SS_ALL for all SS tags; or one individual signature subpacket tag 3382 * \param type Parse type 3383 * \todo Make all packet types optional, not just subpackets */ 3384 void 3385 __ops_parse_options(__ops_stream_t *stream, 3386 __ops_content_tag_t tag, 3387 __ops_parse_type_t type) 3388 { 3389 unsigned t7; 3390 unsigned t8; 3391 3392 if (tag == OPS_PTAG_SS_ALL) { 3393 int n; 3394 3395 for (n = 0; n < 256; ++n) { 3396 __ops_parse_options(stream, 3397 OPS_PTAG_SIG_SUBPKT_BASE + n, 3398 type); 3399 } 3400 return; 3401 } 3402 if (tag < OPS_PTAG_SIG_SUBPKT_BASE || 3403 tag > OPS_PTAG_SIG_SUBPKT_BASE + NTAGS - 1) { 3404 (void) fprintf(stderr, "__ops_parse_options: bad tag\n"); 3405 return; 3406 } 3407 t8 = (tag - OPS_PTAG_SIG_SUBPKT_BASE) / 8; 3408 t7 = 1 << ((tag - OPS_PTAG_SIG_SUBPKT_BASE) & 7); 3409 switch (type) { 3410 case OPS_PARSE_RAW: 3411 stream->ss_raw[t8] |= t7; 3412 stream->ss_parsed[t8] &= ~t7; 3413 break; 3414 3415 case OPS_PARSE_PARSED: 3416 stream->ss_raw[t8] &= ~t7; 3417 stream->ss_parsed[t8] |= t7; 3418 break; 3419 3420 case OPS_PARSE_IGNORE: 3421 stream->ss_raw[t8] &= ~t7; 3422 stream->ss_parsed[t8] &= ~t7; 3423 break; 3424 } 3425 } 3426 3427 /** 3428 \ingroup Core_ReadPackets 3429 \brief Free __ops_stream_t struct and its contents 3430 */ 3431 void 3432 __ops_stream_delete(__ops_stream_t *stream) 3433 { 3434 __ops_cbdata_t *cbinfo; 3435 __ops_cbdata_t *next; 3436 3437 for (cbinfo = stream->cbinfo.next; cbinfo; cbinfo = next) { 3438 next = cbinfo->next; 3439 free(cbinfo); 3440 } 3441 if (stream->readinfo.destroyer) { 3442 stream->readinfo.destroyer(&stream->readinfo); 3443 } 3444 __ops_free_errors(stream->errors); 3445 if (stream->readinfo.accumulated) { 3446 free(stream->readinfo.accumulated); 3447 } 3448 free(stream); 3449 } 3450 3451 /** 3452 \ingroup Core_ReadPackets 3453 \brief Returns the parse_info's reader_info 3454 \return Pointer to the reader_info inside the parse_info 3455 */ 3456 __ops_reader_t * 3457 __ops_readinfo(__ops_stream_t *stream) 3458 { 3459 return &stream->readinfo; 3460 } 3461 3462 /** 3463 \ingroup Core_ReadPackets 3464 \brief Sets the parse_info's callback 3465 This is used when adding the first callback in a stack of callbacks. 3466 \sa __ops_callback_push() 3467 */ 3468 3469 void 3470 __ops_set_callback(__ops_stream_t *stream, __ops_cbfunc_t *cb, void *arg) 3471 { 3472 stream->cbinfo.cbfunc = cb; 3473 stream->cbinfo.arg = arg; 3474 stream->cbinfo.errors = &stream->errors; 3475 } 3476 3477 /** 3478 \ingroup Core_ReadPackets 3479 \brief Adds a further callback to a stack of callbacks 3480 \sa __ops_set_callback() 3481 */ 3482 void 3483 __ops_callback_push(__ops_stream_t *stream, __ops_cbfunc_t *cb, void *arg) 3484 { 3485 __ops_cbdata_t *cbinfo; 3486 3487 if ((cbinfo = calloc(1, sizeof(*cbinfo))) == NULL) { 3488 (void) fprintf(stderr, "__ops_callback_push: bad alloc\n"); 3489 return; 3490 } 3491 (void) memcpy(cbinfo, &stream->cbinfo, sizeof(*cbinfo)); 3492 cbinfo->io = stream->io; 3493 stream->cbinfo.next = cbinfo; 3494 __ops_set_callback(stream, cb, arg); 3495 } 3496 3497 /** 3498 \ingroup Core_ReadPackets 3499 \brief Returns callback's arg 3500 */ 3501 void * 3502 __ops_callback_arg(__ops_cbdata_t *cbinfo) 3503 { 3504 return cbinfo->arg; 3505 } 3506 3507 /** 3508 \ingroup Core_ReadPackets 3509 \brief Returns callback's errors 3510 */ 3511 void * 3512 __ops_callback_errors(__ops_cbdata_t *cbinfo) 3513 { 3514 return cbinfo->errors; 3515 } 3516 3517 /** 3518 \ingroup Core_ReadPackets 3519 \brief Calls the parse_cb_info's callback if present 3520 \return Return value from callback, if present; else OPS_FINISHED 3521 */ 3522 __ops_cb_ret_t 3523 __ops_callback(const __ops_packet_t *pkt, __ops_cbdata_t *cbinfo) 3524 { 3525 return (cbinfo->cbfunc) ? cbinfo->cbfunc(pkt, cbinfo) : OPS_FINISHED; 3526 } 3527 3528 /** 3529 \ingroup Core_ReadPackets 3530 \brief Calls the next callback in the stack 3531 \return Return value from callback 3532 */ 3533 __ops_cb_ret_t 3534 __ops_stacked_callback(const __ops_packet_t *pkt, __ops_cbdata_t *cbinfo) 3535 { 3536 return __ops_callback(pkt, cbinfo->next); 3537 } 3538 3539 /** 3540 \ingroup Core_ReadPackets 3541 \brief Returns the parse_info's errors 3542 \return parse_info's errors 3543 */ 3544 __ops_error_t * 3545 __ops_stream_get_errors(__ops_stream_t *stream) 3546 { 3547 return stream->errors; 3548 } 3549 3550 __ops_crypt_t * 3551 __ops_get_decrypt(__ops_stream_t *stream) 3552 { 3553 return (stream->decrypt.alg) ? &stream->decrypt : NULL; 3554 } 3555