1 /* Compressed section support (intended for debug sections). 2 Copyright (C) 2008-2020 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include <zlib.h> 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "safe-ctype.h" 26 27 #define MAX_COMPRESSION_HEADER_SIZE 24 28 29 static bfd_boolean 30 decompress_contents (bfd_byte *compressed_buffer, 31 bfd_size_type compressed_size, 32 bfd_byte *uncompressed_buffer, 33 bfd_size_type uncompressed_size) 34 { 35 z_stream strm; 36 int rc; 37 38 /* It is possible the section consists of several compressed 39 buffers concatenated together, so we uncompress in a loop. */ 40 /* PR 18313: The state field in the z_stream structure is supposed 41 to be invisible to the user (ie us), but some compilers will 42 still complain about it being used without initialisation. So 43 we first zero the entire z_stream structure and then set the fields 44 that we need. */ 45 memset (& strm, 0, sizeof strm); 46 strm.avail_in = compressed_size; 47 strm.next_in = (Bytef*) compressed_buffer; 48 strm.avail_out = uncompressed_size; 49 50 BFD_ASSERT (Z_OK == 0); 51 rc = inflateInit (&strm); 52 while (strm.avail_in > 0 && strm.avail_out > 0) 53 { 54 if (rc != Z_OK) 55 break; 56 strm.next_out = ((Bytef*) uncompressed_buffer 57 + (uncompressed_size - strm.avail_out)); 58 rc = inflate (&strm, Z_FINISH); 59 if (rc != Z_STREAM_END) 60 break; 61 rc = inflateReset (&strm); 62 } 63 rc |= inflateEnd (&strm); 64 return rc == Z_OK && strm.avail_out == 0; 65 } 66 67 /* Compress data of the size specified in @var{uncompressed_size} 68 and pointed to by @var{uncompressed_buffer} using zlib and store 69 as the contents field. This function assumes the contents 70 field was allocated using bfd_malloc() or equivalent. 71 72 Return the uncompressed size if the full section contents is 73 compressed successfully. Otherwise return 0. */ 74 75 static bfd_size_type 76 bfd_compress_section_contents (bfd *abfd, sec_ptr sec, 77 bfd_byte *uncompressed_buffer, 78 bfd_size_type uncompressed_size) 79 { 80 uLong compressed_size; 81 bfd_byte *buffer; 82 bfd_size_type buffer_size; 83 bfd_boolean decompress; 84 int zlib_size = 0; 85 int orig_compression_header_size; 86 bfd_size_type orig_uncompressed_size; 87 unsigned int orig_uncompressed_alignment_pow; 88 int header_size = bfd_get_compression_header_size (abfd, NULL); 89 bfd_boolean compressed 90 = bfd_is_section_compressed_with_header (abfd, sec, 91 &orig_compression_header_size, 92 &orig_uncompressed_size, 93 &orig_uncompressed_alignment_pow); 94 95 /* Either ELF compression header or the 12-byte, "ZLIB" + 8-byte size, 96 overhead in .zdebug* section. */ 97 if (!header_size) 98 header_size = 12; 99 100 if (compressed) 101 { 102 /* We shouldn't decompress unsupported compressed section. */ 103 if (orig_compression_header_size < 0) 104 abort (); 105 106 /* Different compression schemes. Just move the compressed section 107 contents to the right position. */ 108 if (orig_compression_header_size == 0) 109 { 110 /* Convert it from .zdebug* section. Get the uncompressed 111 size first. We need to subtract the 12-byte overhead in 112 .zdebug* section. Set orig_compression_header_size to 113 the 12-bye overhead. */ 114 orig_compression_header_size = 12; 115 zlib_size = uncompressed_size - 12; 116 } 117 else 118 { 119 /* Convert it to .zdebug* section. */ 120 zlib_size = uncompressed_size - orig_compression_header_size; 121 } 122 123 /* Add the header size. */ 124 compressed_size = zlib_size + header_size; 125 } 126 else 127 compressed_size = compressBound (uncompressed_size) + header_size; 128 129 /* Uncompress if it leads to smaller size. */ 130 if (compressed && compressed_size > orig_uncompressed_size) 131 { 132 decompress = TRUE; 133 buffer_size = orig_uncompressed_size; 134 } 135 else 136 { 137 decompress = FALSE; 138 buffer_size = compressed_size; 139 } 140 buffer = (bfd_byte *) bfd_alloc (abfd, buffer_size); 141 if (buffer == NULL) 142 return 0; 143 144 if (compressed) 145 { 146 sec->size = orig_uncompressed_size; 147 if (decompress) 148 { 149 if (!decompress_contents (uncompressed_buffer 150 + orig_compression_header_size, 151 zlib_size, buffer, buffer_size)) 152 { 153 bfd_set_error (bfd_error_bad_value); 154 bfd_release (abfd, buffer); 155 return 0; 156 } 157 free (uncompressed_buffer); 158 bfd_set_section_alignment (sec, orig_uncompressed_alignment_pow); 159 160 sec->contents = buffer; 161 sec->compress_status = COMPRESS_SECTION_DONE; 162 return orig_uncompressed_size; 163 } 164 else 165 { 166 bfd_update_compression_header (abfd, buffer, sec); 167 memmove (buffer + header_size, 168 uncompressed_buffer + orig_compression_header_size, 169 zlib_size); 170 } 171 } 172 else 173 { 174 if (compress ((Bytef*) buffer + header_size, 175 &compressed_size, 176 (const Bytef*) uncompressed_buffer, 177 uncompressed_size) != Z_OK) 178 { 179 bfd_release (abfd, buffer); 180 bfd_set_error (bfd_error_bad_value); 181 return 0; 182 } 183 184 compressed_size += header_size; 185 /* PR binutils/18087: If compression didn't make the section smaller, 186 just keep it uncompressed. */ 187 if (compressed_size < uncompressed_size) 188 bfd_update_compression_header (abfd, buffer, sec); 189 else 190 { 191 /* NOTE: There is a small memory leak here since 192 uncompressed_buffer is malloced and won't be freed. */ 193 bfd_release (abfd, buffer); 194 sec->contents = uncompressed_buffer; 195 sec->compress_status = COMPRESS_SECTION_NONE; 196 return uncompressed_size; 197 } 198 } 199 200 free (uncompressed_buffer); 201 sec->contents = buffer; 202 sec->size = compressed_size; 203 sec->compress_status = COMPRESS_SECTION_DONE; 204 205 return uncompressed_size; 206 } 207 208 /* 209 FUNCTION 210 bfd_get_full_section_contents 211 212 SYNOPSIS 213 bfd_boolean bfd_get_full_section_contents 214 (bfd *abfd, asection *section, bfd_byte **ptr); 215 216 DESCRIPTION 217 Read all data from @var{section} in BFD @var{abfd}, decompress 218 if needed, and store in @var{*ptr}. If @var{*ptr} is NULL, 219 return @var{*ptr} with memory malloc'd by this function. 220 221 Return @code{TRUE} if the full section contents is retrieved 222 successfully. If the section has no contents then this function 223 returns @code{TRUE} but @var{*ptr} is set to NULL. 224 */ 225 226 bfd_boolean 227 bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr) 228 { 229 bfd_size_type sz; 230 bfd_byte *p = *ptr; 231 bfd_boolean ret; 232 bfd_size_type save_size; 233 bfd_size_type save_rawsize; 234 bfd_byte *compressed_buffer; 235 unsigned int compression_header_size; 236 237 if (abfd->direction != write_direction && sec->rawsize != 0) 238 sz = sec->rawsize; 239 else 240 sz = sec->size; 241 if (sz == 0) 242 { 243 *ptr = NULL; 244 return TRUE; 245 } 246 247 switch (sec->compress_status) 248 { 249 case COMPRESS_SECTION_NONE: 250 if (p == NULL) 251 { 252 ufile_ptr filesize = bfd_get_file_size (abfd); 253 if (filesize > 0 254 && filesize < sz 255 /* PR 24753: Linker created sections can be larger than 256 the file size, eg if they are being used to hold stubs. */ 257 && (bfd_section_flags (sec) & SEC_LINKER_CREATED) == 0 258 /* The MMO file format supports its own special compression 259 technique, but it uses COMPRESS_SECTION_NONE when loading 260 a section's contents. */ 261 && bfd_get_flavour (abfd) != bfd_target_mmo_flavour) 262 { 263 /* PR 24708: Avoid attempts to allocate a ridiculous amount 264 of memory. */ 265 bfd_set_error (bfd_error_no_memory); 266 _bfd_error_handler 267 /* xgettext:c-format */ 268 (_("error: %pB(%pA) section size (%#" PRIx64 " bytes) is larger than file size (%#" PRIx64 " bytes)"), 269 abfd, sec, (uint64_t) sz, (uint64_t) filesize); 270 return FALSE; 271 } 272 p = (bfd_byte *) bfd_malloc (sz); 273 if (p == NULL) 274 { 275 /* PR 20801: Provide a more helpful error message. */ 276 if (bfd_get_error () == bfd_error_no_memory) 277 _bfd_error_handler 278 /* xgettext:c-format */ 279 (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"), 280 abfd, sec, (uint64_t) sz); 281 return FALSE; 282 } 283 } 284 285 if (!bfd_get_section_contents (abfd, sec, p, 0, sz)) 286 { 287 if (*ptr != p) 288 free (p); 289 return FALSE; 290 } 291 *ptr = p; 292 return TRUE; 293 294 case DECOMPRESS_SECTION_SIZED: 295 /* Read in the full compressed section contents. */ 296 compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size); 297 if (compressed_buffer == NULL) 298 return FALSE; 299 save_rawsize = sec->rawsize; 300 save_size = sec->size; 301 /* Clear rawsize, set size to compressed size and set compress_status 302 to COMPRESS_SECTION_NONE. If the compressed size is bigger than 303 the uncompressed size, bfd_get_section_contents will fail. */ 304 sec->rawsize = 0; 305 sec->size = sec->compressed_size; 306 sec->compress_status = COMPRESS_SECTION_NONE; 307 ret = bfd_get_section_contents (abfd, sec, compressed_buffer, 308 0, sec->compressed_size); 309 /* Restore rawsize and size. */ 310 sec->rawsize = save_rawsize; 311 sec->size = save_size; 312 sec->compress_status = DECOMPRESS_SECTION_SIZED; 313 if (!ret) 314 goto fail_compressed; 315 316 if (p == NULL) 317 p = (bfd_byte *) bfd_malloc (sz); 318 if (p == NULL) 319 goto fail_compressed; 320 321 compression_header_size = bfd_get_compression_header_size (abfd, sec); 322 if (compression_header_size == 0) 323 /* Set header size to the zlib header size if it is a 324 SHF_COMPRESSED section. */ 325 compression_header_size = 12; 326 if (!decompress_contents (compressed_buffer + compression_header_size, 327 sec->compressed_size - compression_header_size, p, sz)) 328 { 329 bfd_set_error (bfd_error_bad_value); 330 if (p != *ptr) 331 free (p); 332 fail_compressed: 333 free (compressed_buffer); 334 return FALSE; 335 } 336 337 free (compressed_buffer); 338 *ptr = p; 339 return TRUE; 340 341 case COMPRESS_SECTION_DONE: 342 if (sec->contents == NULL) 343 return FALSE; 344 if (p == NULL) 345 { 346 p = (bfd_byte *) bfd_malloc (sz); 347 if (p == NULL) 348 return FALSE; 349 *ptr = p; 350 } 351 /* PR 17512; file: 5bc29788. */ 352 if (p != sec->contents) 353 memcpy (p, sec->contents, sz); 354 return TRUE; 355 356 default: 357 abort (); 358 } 359 } 360 361 /* 362 FUNCTION 363 bfd_cache_section_contents 364 365 SYNOPSIS 366 void bfd_cache_section_contents 367 (asection *sec, void *contents); 368 369 DESCRIPTION 370 Stash @var(contents) so any following reads of @var(sec) do 371 not need to decompress again. 372 */ 373 374 void 375 bfd_cache_section_contents (asection *sec, void *contents) 376 { 377 if (sec->compress_status == DECOMPRESS_SECTION_SIZED) 378 sec->compress_status = COMPRESS_SECTION_DONE; 379 sec->contents = contents; 380 sec->flags |= SEC_IN_MEMORY; 381 } 382 383 /* 384 FUNCTION 385 bfd_is_section_compressed_with_header 386 387 SYNOPSIS 388 bfd_boolean bfd_is_section_compressed_with_header 389 (bfd *abfd, asection *section, 390 int *compression_header_size_p, 391 bfd_size_type *uncompressed_size_p, 392 unsigned int *uncompressed_alignment_power_p); 393 394 DESCRIPTION 395 Return @code{TRUE} if @var{section} is compressed. Compression 396 header size is returned in @var{compression_header_size_p}, 397 uncompressed size is returned in @var{uncompressed_size_p} 398 and the uncompressed data alignement power is returned in 399 @var{uncompressed_align_pow_p}. If compression is 400 unsupported, compression header size is returned with -1 401 and uncompressed size is returned with 0. 402 */ 403 404 bfd_boolean 405 bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec, 406 int *compression_header_size_p, 407 bfd_size_type *uncompressed_size_p, 408 unsigned int *uncompressed_align_pow_p) 409 { 410 bfd_byte header[MAX_COMPRESSION_HEADER_SIZE]; 411 int compression_header_size; 412 int header_size; 413 unsigned int saved = sec->compress_status; 414 bfd_boolean compressed; 415 416 *uncompressed_align_pow_p = 0; 417 418 compression_header_size = bfd_get_compression_header_size (abfd, sec); 419 if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) 420 abort (); 421 header_size = compression_header_size ? compression_header_size : 12; 422 423 /* Don't decompress the section. */ 424 sec->compress_status = COMPRESS_SECTION_NONE; 425 426 /* Read the header. */ 427 if (bfd_get_section_contents (abfd, sec, header, 0, header_size)) 428 { 429 if (compression_header_size == 0) 430 /* In this case, it should be "ZLIB" followed by the uncompressed 431 section size, 8 bytes in big-endian order. */ 432 compressed = CONST_STRNEQ ((char*) header , "ZLIB"); 433 else 434 compressed = TRUE; 435 } 436 else 437 compressed = FALSE; 438 439 *uncompressed_size_p = sec->size; 440 if (compressed) 441 { 442 if (compression_header_size != 0) 443 { 444 if (!bfd_check_compression_header (abfd, header, sec, 445 uncompressed_size_p, 446 uncompressed_align_pow_p)) 447 compression_header_size = -1; 448 } 449 /* Check for the pathalogical case of a debug string section that 450 contains the string ZLIB.... as the first entry. We assume that 451 no uncompressed .debug_str section would ever be big enough to 452 have the first byte of its (big-endian) size be non-zero. */ 453 else if (strcmp (sec->name, ".debug_str") == 0 454 && ISPRINT (header[4])) 455 compressed = FALSE; 456 else 457 *uncompressed_size_p = bfd_getb64 (header + 4); 458 } 459 460 /* Restore compress_status. */ 461 sec->compress_status = saved; 462 *compression_header_size_p = compression_header_size; 463 return compressed; 464 } 465 466 /* 467 FUNCTION 468 bfd_is_section_compressed 469 470 SYNOPSIS 471 bfd_boolean bfd_is_section_compressed 472 (bfd *abfd, asection *section); 473 474 DESCRIPTION 475 Return @code{TRUE} if @var{section} is compressed. 476 */ 477 478 bfd_boolean 479 bfd_is_section_compressed (bfd *abfd, sec_ptr sec) 480 { 481 int compression_header_size; 482 bfd_size_type uncompressed_size; 483 unsigned int uncompressed_align_power; 484 return (bfd_is_section_compressed_with_header (abfd, sec, 485 &compression_header_size, 486 &uncompressed_size, 487 &uncompressed_align_power) 488 && compression_header_size >= 0 489 && uncompressed_size > 0); 490 } 491 492 /* 493 FUNCTION 494 bfd_init_section_decompress_status 495 496 SYNOPSIS 497 bfd_boolean bfd_init_section_decompress_status 498 (bfd *abfd, asection *section); 499 500 DESCRIPTION 501 Record compressed section size, update section size with 502 decompressed size and set compress_status to 503 DECOMPRESS_SECTION_SIZED. 504 505 Return @code{FALSE} if the section is not a valid compressed 506 section. Otherwise, return @code{TRUE}. 507 */ 508 509 bfd_boolean 510 bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec) 511 { 512 bfd_byte header[MAX_COMPRESSION_HEADER_SIZE]; 513 int compression_header_size; 514 int header_size; 515 bfd_size_type uncompressed_size; 516 unsigned int uncompressed_alignment_power = 0; 517 518 compression_header_size = bfd_get_compression_header_size (abfd, sec); 519 if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) 520 abort (); 521 header_size = compression_header_size ? compression_header_size : 12; 522 523 /* Read the header. */ 524 if (sec->rawsize != 0 525 || sec->contents != NULL 526 || sec->compress_status != COMPRESS_SECTION_NONE 527 || !bfd_get_section_contents (abfd, sec, header, 0, header_size)) 528 { 529 bfd_set_error (bfd_error_invalid_operation); 530 return FALSE; 531 } 532 533 if (compression_header_size == 0) 534 { 535 /* In this case, it should be "ZLIB" followed by the uncompressed 536 section size, 8 bytes in big-endian order. */ 537 if (! CONST_STRNEQ ((char*) header, "ZLIB")) 538 { 539 bfd_set_error (bfd_error_wrong_format); 540 return FALSE; 541 } 542 uncompressed_size = bfd_getb64 (header + 4); 543 } 544 else if (!bfd_check_compression_header (abfd, header, sec, 545 &uncompressed_size, 546 &uncompressed_alignment_power)) 547 { 548 bfd_set_error (bfd_error_wrong_format); 549 return FALSE; 550 } 551 552 sec->compressed_size = sec->size; 553 sec->size = uncompressed_size; 554 bfd_set_section_alignment (sec, uncompressed_alignment_power); 555 sec->compress_status = DECOMPRESS_SECTION_SIZED; 556 557 return TRUE; 558 } 559 560 /* 561 FUNCTION 562 bfd_init_section_compress_status 563 564 SYNOPSIS 565 bfd_boolean bfd_init_section_compress_status 566 (bfd *abfd, asection *section); 567 568 DESCRIPTION 569 If open for read, compress section, update section size with 570 compressed size and set compress_status to COMPRESS_SECTION_DONE. 571 572 Return @code{FALSE} if the section is not a valid compressed 573 section. Otherwise, return @code{TRUE}. 574 */ 575 576 bfd_boolean 577 bfd_init_section_compress_status (bfd *abfd, sec_ptr sec) 578 { 579 bfd_size_type uncompressed_size; 580 bfd_byte *uncompressed_buffer; 581 582 /* Error if not opened for read. */ 583 if (abfd->direction != read_direction 584 || sec->size == 0 585 || sec->rawsize != 0 586 || sec->contents != NULL 587 || sec->compress_status != COMPRESS_SECTION_NONE) 588 { 589 bfd_set_error (bfd_error_invalid_operation); 590 return FALSE; 591 } 592 593 /* Read in the full section contents and compress it. */ 594 uncompressed_size = sec->size; 595 uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size); 596 /* PR 21431 */ 597 if (uncompressed_buffer == NULL) 598 return FALSE; 599 600 if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer, 601 0, uncompressed_size)) 602 return FALSE; 603 604 uncompressed_size = bfd_compress_section_contents (abfd, sec, 605 uncompressed_buffer, 606 uncompressed_size); 607 return uncompressed_size != 0; 608 } 609 610 /* 611 FUNCTION 612 bfd_compress_section 613 614 SYNOPSIS 615 bfd_boolean bfd_compress_section 616 (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer); 617 618 DESCRIPTION 619 If open for write, compress section, update section size with 620 compressed size and set compress_status to COMPRESS_SECTION_DONE. 621 622 Return @code{FALSE} if compression fail. Otherwise, return 623 @code{TRUE}. 624 */ 625 626 bfd_boolean 627 bfd_compress_section (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer) 628 { 629 bfd_size_type uncompressed_size = sec->size; 630 631 /* Error if not opened for write. */ 632 if (abfd->direction != write_direction 633 || uncompressed_size == 0 634 || uncompressed_buffer == NULL 635 || sec->contents != NULL 636 || sec->compressed_size != 0 637 || sec->compress_status != COMPRESS_SECTION_NONE) 638 { 639 bfd_set_error (bfd_error_invalid_operation); 640 return FALSE; 641 } 642 643 /* Compress it. */ 644 return bfd_compress_section_contents (abfd, sec, uncompressed_buffer, 645 uncompressed_size) != 0; 646 } 647