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 /* PR 24753: Sections which have no content should also be 259 excluded as they contain no size on disk. */ 260 && (bfd_section_flags (sec) & SEC_HAS_CONTENTS) != 0 261 /* The MMO file format supports its own special compression 262 technique, but it uses COMPRESS_SECTION_NONE when loading 263 a section's contents. */ 264 && bfd_get_flavour (abfd) != bfd_target_mmo_flavour) 265 { 266 /* PR 24708: Avoid attempts to allocate a ridiculous amount 267 of memory. */ 268 bfd_set_error (bfd_error_no_memory); 269 _bfd_error_handler 270 /* xgettext:c-format */ 271 (_("error: %pB(%pA) section size (%#" PRIx64 " bytes) is larger than file size (%#" PRIx64 " bytes)"), 272 abfd, sec, (uint64_t) sz, (uint64_t) filesize); 273 return FALSE; 274 } 275 p = (bfd_byte *) bfd_malloc (sz); 276 if (p == NULL) 277 { 278 /* PR 20801: Provide a more helpful error message. */ 279 if (bfd_get_error () == bfd_error_no_memory) 280 _bfd_error_handler 281 /* xgettext:c-format */ 282 (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"), 283 abfd, sec, (uint64_t) sz); 284 return FALSE; 285 } 286 } 287 288 if (!bfd_get_section_contents (abfd, sec, p, 0, sz)) 289 { 290 if (*ptr != p) 291 free (p); 292 return FALSE; 293 } 294 *ptr = p; 295 return TRUE; 296 297 case DECOMPRESS_SECTION_SIZED: 298 /* Read in the full compressed section contents. */ 299 compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size); 300 if (compressed_buffer == NULL) 301 return FALSE; 302 save_rawsize = sec->rawsize; 303 save_size = sec->size; 304 /* Clear rawsize, set size to compressed size and set compress_status 305 to COMPRESS_SECTION_NONE. If the compressed size is bigger than 306 the uncompressed size, bfd_get_section_contents will fail. */ 307 sec->rawsize = 0; 308 sec->size = sec->compressed_size; 309 sec->compress_status = COMPRESS_SECTION_NONE; 310 ret = bfd_get_section_contents (abfd, sec, compressed_buffer, 311 0, sec->compressed_size); 312 /* Restore rawsize and size. */ 313 sec->rawsize = save_rawsize; 314 sec->size = save_size; 315 sec->compress_status = DECOMPRESS_SECTION_SIZED; 316 if (!ret) 317 goto fail_compressed; 318 319 if (p == NULL) 320 p = (bfd_byte *) bfd_malloc (sz); 321 if (p == NULL) 322 goto fail_compressed; 323 324 compression_header_size = bfd_get_compression_header_size (abfd, sec); 325 if (compression_header_size == 0) 326 /* Set header size to the zlib header size if it is a 327 SHF_COMPRESSED section. */ 328 compression_header_size = 12; 329 if (!decompress_contents (compressed_buffer + compression_header_size, 330 sec->compressed_size - compression_header_size, p, sz)) 331 { 332 bfd_set_error (bfd_error_bad_value); 333 if (p != *ptr) 334 free (p); 335 fail_compressed: 336 free (compressed_buffer); 337 return FALSE; 338 } 339 340 free (compressed_buffer); 341 *ptr = p; 342 return TRUE; 343 344 case COMPRESS_SECTION_DONE: 345 if (sec->contents == NULL) 346 return FALSE; 347 if (p == NULL) 348 { 349 p = (bfd_byte *) bfd_malloc (sz); 350 if (p == NULL) 351 return FALSE; 352 *ptr = p; 353 } 354 /* PR 17512; file: 5bc29788. */ 355 if (p != sec->contents) 356 memcpy (p, sec->contents, sz); 357 return TRUE; 358 359 default: 360 abort (); 361 } 362 } 363 364 /* 365 FUNCTION 366 bfd_cache_section_contents 367 368 SYNOPSIS 369 void bfd_cache_section_contents 370 (asection *sec, void *contents); 371 372 DESCRIPTION 373 Stash @var(contents) so any following reads of @var(sec) do 374 not need to decompress again. 375 */ 376 377 void 378 bfd_cache_section_contents (asection *sec, void *contents) 379 { 380 if (sec->compress_status == DECOMPRESS_SECTION_SIZED) 381 sec->compress_status = COMPRESS_SECTION_DONE; 382 sec->contents = contents; 383 sec->flags |= SEC_IN_MEMORY; 384 } 385 386 /* 387 FUNCTION 388 bfd_is_section_compressed_with_header 389 390 SYNOPSIS 391 bfd_boolean bfd_is_section_compressed_with_header 392 (bfd *abfd, asection *section, 393 int *compression_header_size_p, 394 bfd_size_type *uncompressed_size_p, 395 unsigned int *uncompressed_alignment_power_p); 396 397 DESCRIPTION 398 Return @code{TRUE} if @var{section} is compressed. Compression 399 header size is returned in @var{compression_header_size_p}, 400 uncompressed size is returned in @var{uncompressed_size_p} 401 and the uncompressed data alignement power is returned in 402 @var{uncompressed_align_pow_p}. If compression is 403 unsupported, compression header size is returned with -1 404 and uncompressed size is returned with 0. 405 */ 406 407 bfd_boolean 408 bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec, 409 int *compression_header_size_p, 410 bfd_size_type *uncompressed_size_p, 411 unsigned int *uncompressed_align_pow_p) 412 { 413 bfd_byte header[MAX_COMPRESSION_HEADER_SIZE]; 414 int compression_header_size; 415 int header_size; 416 unsigned int saved = sec->compress_status; 417 bfd_boolean compressed; 418 419 *uncompressed_align_pow_p = 0; 420 421 compression_header_size = bfd_get_compression_header_size (abfd, sec); 422 if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) 423 abort (); 424 header_size = compression_header_size ? compression_header_size : 12; 425 426 /* Don't decompress the section. */ 427 sec->compress_status = COMPRESS_SECTION_NONE; 428 429 /* Read the header. */ 430 if (bfd_get_section_contents (abfd, sec, header, 0, header_size)) 431 { 432 if (compression_header_size == 0) 433 /* In this case, it should be "ZLIB" followed by the uncompressed 434 section size, 8 bytes in big-endian order. */ 435 compressed = CONST_STRNEQ ((char*) header , "ZLIB"); 436 else 437 compressed = TRUE; 438 } 439 else 440 compressed = FALSE; 441 442 *uncompressed_size_p = sec->size; 443 if (compressed) 444 { 445 if (compression_header_size != 0) 446 { 447 if (!bfd_check_compression_header (abfd, header, sec, 448 uncompressed_size_p, 449 uncompressed_align_pow_p)) 450 compression_header_size = -1; 451 } 452 /* Check for the pathalogical case of a debug string section that 453 contains the string ZLIB.... as the first entry. We assume that 454 no uncompressed .debug_str section would ever be big enough to 455 have the first byte of its (big-endian) size be non-zero. */ 456 else if (strcmp (sec->name, ".debug_str") == 0 457 && ISPRINT (header[4])) 458 compressed = FALSE; 459 else 460 *uncompressed_size_p = bfd_getb64 (header + 4); 461 } 462 463 /* Restore compress_status. */ 464 sec->compress_status = saved; 465 *compression_header_size_p = compression_header_size; 466 return compressed; 467 } 468 469 /* 470 FUNCTION 471 bfd_is_section_compressed 472 473 SYNOPSIS 474 bfd_boolean bfd_is_section_compressed 475 (bfd *abfd, asection *section); 476 477 DESCRIPTION 478 Return @code{TRUE} if @var{section} is compressed. 479 */ 480 481 bfd_boolean 482 bfd_is_section_compressed (bfd *abfd, sec_ptr sec) 483 { 484 int compression_header_size; 485 bfd_size_type uncompressed_size; 486 unsigned int uncompressed_align_power; 487 return (bfd_is_section_compressed_with_header (abfd, sec, 488 &compression_header_size, 489 &uncompressed_size, 490 &uncompressed_align_power) 491 && compression_header_size >= 0 492 && uncompressed_size > 0); 493 } 494 495 /* 496 FUNCTION 497 bfd_init_section_decompress_status 498 499 SYNOPSIS 500 bfd_boolean bfd_init_section_decompress_status 501 (bfd *abfd, asection *section); 502 503 DESCRIPTION 504 Record compressed section size, update section size with 505 decompressed size and set compress_status to 506 DECOMPRESS_SECTION_SIZED. 507 508 Return @code{FALSE} if the section is not a valid compressed 509 section. Otherwise, return @code{TRUE}. 510 */ 511 512 bfd_boolean 513 bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec) 514 { 515 bfd_byte header[MAX_COMPRESSION_HEADER_SIZE]; 516 int compression_header_size; 517 int header_size; 518 bfd_size_type uncompressed_size; 519 unsigned int uncompressed_alignment_power = 0; 520 521 compression_header_size = bfd_get_compression_header_size (abfd, sec); 522 if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE) 523 abort (); 524 header_size = compression_header_size ? compression_header_size : 12; 525 526 /* Read the header. */ 527 if (sec->rawsize != 0 528 || sec->contents != NULL 529 || sec->compress_status != COMPRESS_SECTION_NONE 530 || !bfd_get_section_contents (abfd, sec, header, 0, header_size)) 531 { 532 bfd_set_error (bfd_error_invalid_operation); 533 return FALSE; 534 } 535 536 if (compression_header_size == 0) 537 { 538 /* In this case, it should be "ZLIB" followed by the uncompressed 539 section size, 8 bytes in big-endian order. */ 540 if (! CONST_STRNEQ ((char*) header, "ZLIB")) 541 { 542 bfd_set_error (bfd_error_wrong_format); 543 return FALSE; 544 } 545 uncompressed_size = bfd_getb64 (header + 4); 546 } 547 else if (!bfd_check_compression_header (abfd, header, sec, 548 &uncompressed_size, 549 &uncompressed_alignment_power)) 550 { 551 bfd_set_error (bfd_error_wrong_format); 552 return FALSE; 553 } 554 555 sec->compressed_size = sec->size; 556 sec->size = uncompressed_size; 557 bfd_set_section_alignment (sec, uncompressed_alignment_power); 558 sec->compress_status = DECOMPRESS_SECTION_SIZED; 559 560 return TRUE; 561 } 562 563 /* 564 FUNCTION 565 bfd_init_section_compress_status 566 567 SYNOPSIS 568 bfd_boolean bfd_init_section_compress_status 569 (bfd *abfd, asection *section); 570 571 DESCRIPTION 572 If open for read, compress section, update section size with 573 compressed size and set compress_status to COMPRESS_SECTION_DONE. 574 575 Return @code{FALSE} if the section is not a valid compressed 576 section. Otherwise, return @code{TRUE}. 577 */ 578 579 bfd_boolean 580 bfd_init_section_compress_status (bfd *abfd, sec_ptr sec) 581 { 582 bfd_size_type uncompressed_size; 583 bfd_byte *uncompressed_buffer; 584 585 /* Error if not opened for read. */ 586 if (abfd->direction != read_direction 587 || sec->size == 0 588 || sec->rawsize != 0 589 || sec->contents != NULL 590 || sec->compress_status != COMPRESS_SECTION_NONE) 591 { 592 bfd_set_error (bfd_error_invalid_operation); 593 return FALSE; 594 } 595 596 /* Read in the full section contents and compress it. */ 597 uncompressed_size = sec->size; 598 uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size); 599 /* PR 21431 */ 600 if (uncompressed_buffer == NULL) 601 return FALSE; 602 603 if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer, 604 0, uncompressed_size)) 605 return FALSE; 606 607 uncompressed_size = bfd_compress_section_contents (abfd, sec, 608 uncompressed_buffer, 609 uncompressed_size); 610 return uncompressed_size != 0; 611 } 612 613 /* 614 FUNCTION 615 bfd_compress_section 616 617 SYNOPSIS 618 bfd_boolean bfd_compress_section 619 (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer); 620 621 DESCRIPTION 622 If open for write, compress section, update section size with 623 compressed size and set compress_status to COMPRESS_SECTION_DONE. 624 625 Return @code{FALSE} if compression fail. Otherwise, return 626 @code{TRUE}. 627 */ 628 629 bfd_boolean 630 bfd_compress_section (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer) 631 { 632 bfd_size_type uncompressed_size = sec->size; 633 634 /* Error if not opened for write. */ 635 if (abfd->direction != write_direction 636 || uncompressed_size == 0 637 || uncompressed_buffer == NULL 638 || sec->contents != NULL 639 || sec->compressed_size != 0 640 || sec->compress_status != COMPRESS_SECTION_NONE) 641 { 642 bfd_set_error (bfd_error_invalid_operation); 643 return FALSE; 644 } 645 646 /* Compress it. */ 647 return bfd_compress_section_contents (abfd, sec, uncompressed_buffer, 648 uncompressed_size) != 0; 649 } 650