bfd/compress.c

   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 }