bfd/compress.c

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