bin/blhc

   1 #!/usr/bin/perl
   2
   3 # Build log hardening check, checks build logs for missing hardening flags.
   4
   5 # Copyright (C) 2012-2017  Simon Ruderich
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20
  21 use strict;
  22 use warnings;
  23
  24 use Getopt::Long ();
  25 use Text::ParseWords ();
  26
  27 our $VERSION = '0.07';
  28
  29
  30 # CONSTANTS/VARIABLES
  31
  32 # Regex to catch compiler commands.
  33 my $cc_regex = qr/
  34     (?<!\s-)               # ignore options, e.g. "-c++" [sic!] (used by swig)
  35     (?<!\.)                # ignore file names, e.g. "test.gcc"
  36     (?:cc|gcc|g\+\+|c\+\+|gfortran|mpicc|mpicxx|mpifort)
  37     (?:-[\d.]+)?           # version suffix, e.g. "gcc-4.6"
  38     /x;
  39 # Full regex which matches the complete compiler name. Used in a few places to
  40 # prevent false negatives.
  41 my $cc_regex_full_prefix = qr/
  42     [a-z0-9_]+-(?:linux-|kfreebsd-)?gnu(?:eabi|eabihf)?
  43     /x;
  44 my $cc_regex_full = qr/
  45     (?:$cc_regex_full_prefix-)?
  46     $cc_regex
  47     /x;
  48 # Regex to check if a line contains a compiler command.
  49 my $cc_regex_normal = qr/
  50     \b$cc_regex(?:\s|\\)
  51     /x;
  52 # Regex to catch (GCC) compiler warnings.
  53 my $warning_regex = qr/^(.+?):(\d+):\d+: warning: (.+?) \[(.+?)\]$/;
  54 # Regex to catch libtool commands and not lines which show commands executed
  55 # by libtool (e.g. libtool: link: ...).
  56 my $libtool_regex = qr/\blibtool\s.*--mode=/;
  57 my $libtool_link_regex = qr/\blibtool: link: /;
  58
  59 # List of source file extensions which require preprocessing.
  60 my @source_preprocess_compile_cpp = (
  61     # C++
  62     qw( cc cp cxx cpp CPP c++ C ),
  63     # Objective-C++
  64     qw( mm M ),
  65 );
  66 my @source_preprocess_compile_fortran = (
  67     # Fortran
  68     qw( F FOR fpp FPP FTN F90 F95 F03 F08 ),
  69 );
  70 my @source_preprocess_compile = (
  71     # C
  72     qw( c ),
  73     # Objective-C
  74     qw( m ),
  75     # (Objective-)C++
  76     @source_preprocess_compile_cpp,
  77     # Fortran
  78     @source_preprocess_compile_fortran,
  79 );
  80 my @source_preprocess_no_compile = (
  81     # Assembly
  82     qw( S sx ),
  83 );
  84 my @source_preprocess = (
  85     @source_preprocess_compile,
  86     @source_preprocess_no_compile,
  87 );
  88 # List of source file extensions which don't require preprocessing.
  89 my @source_no_preprocess_compile_cpp = (
  90     # C++
  91     qw( ii ),
  92     # Objective-C++
  93     qw( mii ),
  94 );
  95 my @source_no_preprocess_compile_ada = (
  96     # Ada source
  97     qw( ada ),
  98     # Ada body
  99     qw( adb ),
 100 );
 101 my @source_no_preprocess_compile_fortran = (
 102     # Fortran
 103     qw( f for ftn f90 f95 f03 f08 ),
 104 );
 105 my @source_no_preprocess_compile = (
 106     # C
 107     qw( i ),
 108     # (Objective-)C++
 109     @source_no_preprocess_compile_cpp,
 110     # Objective-C
 111     qw( mi ),
 112     # Fortran
 113     @source_no_preprocess_compile_fortran,
 114     # Ada
 115     @source_no_preprocess_compile_ada,
 116 );
 117 my @source_no_preprocess_no_compile_ada = (
 118     # Ada specification
 119     qw( ads ),
 120 );
 121 my @source_no_preprocess_no_compile = (
 122     # Assembly
 123     qw( s ),
 124     # Ada
 125     @source_no_preprocess_no_compile_ada,
 126 );
 127 my @source_no_preprocess = (
 128     @source_no_preprocess_compile,
 129     @source_no_preprocess_no_compile,
 130 );
 131 # List of header file extensions which require preprocessing.
 132 my @header_preprocess = (
 133     # C, C++, Objective-C, Objective-C++
 134     qw( h ),
 135     # C++
 136     qw( hh H hp hxx hpp HPP h++ tcc ),
 137 );
 138 # Object files.
 139 my @object = (
 140     # Normal object files.
 141     qw ( o ),
 142     # Libtool object files.
 143     qw ( lo la ),
 144     # Dynamic libraries. bzip2 uses .sho.
 145     qw ( so sho ),
 146     # Static libraries.
 147     qw ( a ),
 148 );
 149
 150 # Hashes for fast extensions lookup to check if a file falls in one of these
 151 # categories.
 152 my %extensions_no_preprocess = map { $_ => 1 } (
 153     # There's no @header_no_preprocess.
 154     @source_no_preprocess,
 155 );
 156 my %extensions_preprocess = map { $_ => 1 } (
 157     @header_preprocess,
 158     @source_preprocess,
 159 );
 160 my %extensions_compile_link = map { $_ => 1 } (
 161     @source_preprocess,
 162     @source_no_preprocess,
 163 );
 164 my %extensions_compile = map { $_ => 1 } (
 165     @source_preprocess_compile,
 166     @source_no_preprocess_compile,
 167 );
 168 my %extensions_no_compile = map { $_ => 1 } (
 169     @source_preprocess_no_compile,
 170     @source_no_preprocess_no_compile,
 171 );
 172 my %extensions_compile_cpp = map { $_ => 1 } (
 173     @source_preprocess_compile_cpp,
 174     @source_no_preprocess_compile_cpp,
 175 );
 176 my %extensions_ada = map { $_ => 1 } (
 177     @source_no_preprocess_compile_ada,
 178     @source_no_preprocess_no_compile_ada,
 179 );
 180 my %extensions_fortran = map { $_ => 1 } (
 181     @source_no_preprocess_compile_fortran,
 182     @source_preprocess_compile_fortran,
 183 );
 184 my %extensions_object = map { $_ => 1 } (
 185     @object,
 186 );
 187 my %extension = map { $_ => 1 } (
 188     @source_no_preprocess,
 189     @header_preprocess,
 190     @source_preprocess,
 191     @object,
 192 );
 193
 194 # Regexp to match file extensions.
 195 my $file_extension_regex = qr/
 196     \s
 197     \S+             # Filename without extension.
 198     \.
 199     ([^\/\\.,;:\s]+)# File extension.
 200     (?=\s|\\)       # At end of word. Can't use \b because some files have non
 201                     # word characters at the end and because \b matches double
 202                     # extensions (like .cpp.o). Works always as all lines are
 203                     # terminated with "\n".
 204     /x;
 205
 206 # Expected (hardening) flags. All flags are used as regexps (and compiled to
 207 # real regexps below for better execution speed).
 208 my @def_cflags = (
 209     '-g',
 210     '-O(?:2|3)', # keep at index 1, search for @def_cflags_debug to change it
 211 );
 212 my @def_cflags_debug = (
 213     # These flags indicate a debug build which disables checks for -O2.
 214     '-O0',
 215     '-Og',
 216 );
 217 my @def_cflags_format = (
 218     '-Wformat(?:=2)?', # -Wformat=2 implies -Wformat, accept it too
 219     '-Werror=format-security', # implies -Wformat-security
 220 );
 221 my @def_cflags_fortify = (
 222     # fortify needs at least -O1, but -O2 is recommended anyway
 223 );
 224 my @def_cflags_stack = (
 225     '-fstack-protector',
 226     '--param[= ]ssp-buffer-size=4',
 227 );
 228 my @def_cflags_stack_strong = (
 229     '-fstack-protector-strong',
 230 );
 231 my @def_cflags_pie = (
 232     '-fPIE',
 233 );
 234 my @def_cxxflags = (
 235     @def_cflags,
 236 );
 237 # @def_cxxflags_* is the same as @def_cflags_*.
 238 my @def_cppflags = ();
 239 my @def_cppflags_fortify = (
 240     '-D_FORTIFY_SOURCE=2', # must be first, see cppflags_fortify_broken()
 241     # If you add another flag fix hack below (search for "Hack to fix") and
 242     # $def_cppflags_fortify[0].
 243 );
 244 my @def_cppflags_fortify_bad = (
 245     # These flags may overwrite -D_FORTIFY_SOURCE=2.
 246     '-U_FORTIFY_SOURCE',
 247     '-D_FORTIFY_SOURCE=0',
 248     '-D_FORTIFY_SOURCE=1',
 249 );
 250 my @def_ldflags = ();
 251 my @def_ldflags_relro = (
 252     '-Wl,(?:-z,)?relro',
 253 );
 254 my @def_ldflags_bindnow = (
 255     '-Wl,(?:-z,)?now',
 256 );
 257 my @def_ldflags_pie = (
 258     '-fPIE',
 259     '-pie',
 260 );
 261 my @def_ldflags_pic = (
 262     '-fPIC',
 263     '-fpic',
 264     '-shared',
 265 );
 266 # References to all flags checked by the flag checker.
 267 my @flag_refs = (
 268     \@def_cflags,
 269     \@def_cflags_format,
 270     \@def_cflags_fortify,
 271     \@def_cflags_stack,
 272     \@def_cflags_stack_strong,
 273     \@def_cflags_pie,
 274     \@def_cxxflags,
 275     \@def_cppflags,
 276     \@def_cppflags_fortify,
 277     \@def_ldflags,
 278     \@def_ldflags_relro,
 279     \@def_ldflags_bindnow,
 280     \@def_ldflags_pie,
 281 );
 282 # References to all used flags.
 283 my @flag_refs_all = (
 284     @flag_refs,
 285     \@def_cflags_debug,
 286     \@def_cppflags_fortify_bad,
 287     \@def_ldflags_pic,
 288 );
 289 # Renaming rules for the output so the regex parts are not visible. Also
 290 # stores string values of flag regexps above, see compile_flag_regexp().
 291 my %flag_renames = (
 292     '-O(?:2|3)'                    => '-O2',
 293     '-Wformat(?:=2)?'              => '-Wformat',
 294     '--param[= ]ssp-buffer-size=4' => '--param=ssp-buffer-size=4',
 295     '-Wl,(?:-z,)?relro'            => '-Wl,-z,relro',
 296     '-Wl,(?:-z,)?now'              => '-Wl,-z,now',
 297 );
 298
 299 my %exit_code = (
 300     no_compiler_commands => 1 << 0,
 301     # used by POD::Usage => 1 << 1,
 302     non_verbose_build    => 1 << 2,
 303     flags_missing        => 1 << 3,
 304     hardening_wrapper    => 1 << 4,
 305     invalid_cmake        => 1 << 5,
 306 );
 307
 308 my %buildd_tag = (
 309     no_compiler_commands => 'I-no-compiler-commands',
 310     non_verbose_build    => 'W-compiler-flags-hidden',
 311     flags_missing        => 'W-dpkg-buildflags-missing',
 312     hardening_wrapper    => 'I-hardening-wrapper-used',
 313     invalid_cmake        => 'I-invalid-cmake-used',
 314 );
 315
 316 # Statistics of missing flags and non-verbose build commands. Used for
 317 # $option_buildd.
 318 my %statistics = (
 319     preprocess          => 0,
 320     preprocess_missing  => 0,
 321     compile             => 0,
 322     compile_missing     => 0,
 323     compile_cpp         => 0,
 324     compile_cpp_missing => 0,
 325     link                => 0,
 326     link_missing        => 0,
 327     commands            => 0,
 328     commands_nonverbose => 0,
 329 );
 330
 331 # Use colored (ANSI) output?
 332 my $option_color;
 333
 334
 335 # FUNCTIONS
 336
 337 # Only works for single-level arrays with no undef values. Thanks to perlfaq4.
 338 sub array_equal {
 339     my ($first_ref, $second_ref) = @_;
 340
 341     return 0 if scalar @{$first_ref} != scalar @{$second_ref};
 342
 343     my $length = scalar @{$first_ref};
 344     for (my $i = 0; $i < $length; $i++) {
 345         return 0 if $first_ref->[$i] ne $second_ref->[$i];
 346     }
 347
 348     return 1;
 349 }
 350
 351 sub error_flags {
 352     my ($message, $missing_flags_ref, $flag_renames_ref, $line) = @_;
 353
 354     # Get string value of qr//-escaped regexps and if requested rename them.
 355     my @missing_flags = map {
 356             $flag_renames_ref->{$_}
 357         } @{$missing_flags_ref};
 358
 359     my $flags = join ' ', @missing_flags;
 360     printf '%s (%s)%s %s',
 361            error_color($message, 'red'), $flags, error_color(':', 'yellow'),
 362            $line;
 363
 364     return;
 365 }
 366 sub error_non_verbose_build {
 367     my ($line) = @_;
 368
 369     printf '%s%s %s',
 370            error_color('NONVERBOSE BUILD', 'red'),
 371            error_color(':', 'yellow'),
 372            $line;
 373
 374     return;
 375 }
 376 sub error_invalid_cmake {
 377     my ($version) = @_;
 378
 379     printf "%s%s %s\n",
 380             error_color('INVALID CMAKE', 'red'),
 381             error_color(':', 'yellow'),
 382             $version;
 383
 384     return;
 385 }
 386 sub error_hardening_wrapper {
 387     printf "%s%s %s\n",
 388             error_color('HARDENING WRAPPER', 'red'),
 389             error_color(':', 'yellow'),
 390             'no checks possible, aborting';
 391
 392     return;
 393 }
 394 sub error_color {
 395     my ($message, $color) = @_;
 396
 397     if ($option_color) {
 398         return Term::ANSIColor::colored($message, $color);
 399     } else {
 400         return $message;
 401     }
 402 }
 403
 404 sub any_flags_used {
 405     my ($line, @flags) = @_;
 406
 407     foreach my $flag (@flags) {
 408         return 1 if $line =~ /$flag/;
 409     }
 410
 411     return 0;
 412 }
 413 sub all_flags_used {
 414     my ($line, $missing_flags_ref, @flags) = @_;
 415
 416     my @missing_flags = ();
 417     foreach my $flag (@flags) {
 418         if (not $line =~ /$flag/) {
 419             push @missing_flags, $flag;
 420         }
 421     }
 422
 423     return 1 if scalar @missing_flags == 0;
 424
 425     @{$missing_flags_ref} = @missing_flags;
 426     return 0;
 427 }
 428
 429 sub cppflags_fortify_broken {
 430     my ($line, $missing_flags) = @_;
 431
 432     # This doesn't take the position into account, but is a simple solution.
 433     # And if the build system tries to force -D_FORTIFY_SOURCE=0/1, something
 434     # is wrong anyway.
 435
 436     if (any_flags_used($line, @def_cppflags_fortify_bad)) {
 437         # $def_cppflags_fortify[0] must be -D_FORTIFY_SOURCE=2!
 438         push @{$missing_flags}, $def_cppflags_fortify[0];
 439         return 1;
 440     }
 441
 442     return 0;
 443 }
 444
 445 # Modifies $missing_flags_ref array.
 446 sub pic_pie_conflict {
 447     my ($line, $pie, $missing_flags_ref, @flags_pie) = @_;
 448
 449     return 0 if not $pie;
 450     return 0 if not any_flags_used($line, @def_ldflags_pic);
 451
 452     my %flags = map { $_ => 1 } @flags_pie;
 453
 454     # Remove all PIE flags from @missing_flags as they are not required with
 455     # -fPIC.
 456     my @result = grep {
 457         not exists $flags{$_}
 458     } @{$missing_flags_ref};
 459     @{$missing_flags_ref} = @result;
 460
 461     # We got a conflict when no flags are left, thus only PIE flags were
 462     # missing. If other flags were missing abort because the conflict is not
 463     # the problem.
 464     return scalar @result == 0;
 465 }
 466
 467 sub is_non_verbose_build {
 468     my ($line, $skip_ref, $input_ref, $line_offset, $line_count) = @_;
 469
 470     if ($line =~ /$libtool_regex/o) {
 471         # libtool's --silent hides the real compiler flags.
 472         if ($line =~ /\s--silent/) {
 473             return 1;
 474         # If --silent is not present, skip this line as some compiler flags
 475         # might be missing (e.g. -fPIE) which are handled correctly by libtool
 476         # internally. libtool displays the real compiler command on the next
 477         # line, so the flags are checked as usual.
 478         } else {
 479             ${$skip_ref} = 1;
 480             return 0;
 481         }
 482     }
 483
 484     if (not (index($line, 'checking if you want to see long compiling messages... no') == 0
 485                 or $line =~ /^\s*\[?(?:CC|CCLD|C\+\+|CXX|CXXLD|LD|LINK)\]?\s+(.+?)$/
 486                 or $line =~ /^\s*[Cc]ompiling\s+(.+?)(?:\.\.\.)?$/
 487                 or $line =~ /^\s*[Bb]uilding (?:program|shared library)\s+(.+?)$/
 488                 or $line =~ /^\s*\[[\d ]+%\] Building (?:C|CXX) object (.+?)$/)) {
 489         return 0;
 490     }
 491
 492     # False positives.
 493     #
 494     # C++ compiler setting.
 495     return 0 if $line =~ /^\s*C\+\+.+?:\s+(?:yes|no)\s*$/;
 496     return 0 if $line =~ /^\s*C\+\+ Library: stdc\+\+$/;
 497     # "Compiling" non binary files.
 498     return 0 if $line =~ /^\s*Compiling \S+\.(?:py|el)['"]?\s*(?:\.\.\.)?$/;
 499     # "Compiling" with no file name.
 500     if ($line =~ /^\s*[Cc]ompiling\s+(.+?)(?:\.\.\.)?$/) {
 501         # $file_extension_regex may need spaces around the filename.
 502         return 0 if not " $1 " =~ /$file_extension_regex/o;
 503     }
 504
 505     my $file = $1;
 506
 507     # On the first pass we only check if this line is verbose or not.
 508     return 1 if not defined $input_ref;
 509
 510     # Second pass, we have access to the next lines.
 511     ${$skip_ref} = 0;
 512
 513     # CMake and other build systems print the non-verbose messages also when
 514     # building verbose. If a compiler and the file name occurs in the next
 515     # lines, treat it as verbose build.
 516     if (defined $file) {
 517         # Get filename, we can't use the complete path as only parts of it are
 518         # used in the real compiler command.
 519         $file =~ m{/([^/\s]+)$};
 520         $file = $1;
 521
 522         for (my $i = 1; $i <= $line_count; $i++) {
 523             my $next_line = $input_ref->[$line_offset + $i];
 524             last unless defined $next_line;
 525
 526             if (index($next_line, $file) != -1 and $next_line =~ /$cc_regex/o) {
 527                 # Not a non-verbose line, but we still have to skip the
 528                 # current line as it doesn't contain any compiler commands.
 529                 ${$skip_ref} = 1;
 530                 return 0;
 531             }
 532         }
 533     }
 534
 535     return 1;
 536 }
 537
 538 # Remove @flags from $flag_refs_ref, uses $flag_renames_ref as reference.
 539 sub remove_flags {
 540     my ($flag_refs_ref, $flag_renames_ref, @flags) = @_;
 541
 542     my %removes = map { $_ => 1 } @flags;
 543     foreach my $flags (@{$flag_refs_ref}) {
 544         @{$flags} = grep {
 545             # Flag found as string.
 546             not exists $removes{$_}
 547             # Flag found as string representation of regexp.
 548                 and (not defined $flag_renames_ref->{$_}
 549                         or not exists $removes{$flag_renames_ref->{$_}})
 550         } @{$flags};
 551     }
 552
 553     return;
 554 }
 555
 556 # Modifies $flag_renames_ref hash.
 557 sub compile_flag_regexp {
 558     my ($flag_renames_ref, @flags) = @_;
 559
 560     my @result = ();
 561     foreach my $flag (@flags) {
 562         # Compile flag regexp for faster execution.
 563         my $regex = qr/\s$flag(?:\s|\\)/;
 564
 565         # Store flag name in replacement string for correct flags in messages
 566         # with qr//ed flag regexps.
 567         $flag_renames_ref->{$regex}
 568             = (exists $flag_renames_ref->{$flag})
 569                 ? $flag_renames_ref->{$flag}
 570                 : $flag;
 571
 572         push @result, $regex;
 573     }
 574     return @result;
 575 }
 576
 577 # Does any extension in @extensions exist in %{$extensions_ref}?
 578 sub extension_found {
 579     my ($extensions_ref, @extensions) = @_;
 580
 581     foreach my $extension (@extensions) {
 582         if (exists $extensions_ref->{$extension}) {
 583             return 1;
 584         }
 585     }
 586     return 0;
 587 }
 588
 589
 590 # MAIN
 591
 592 # Parse command line arguments.
 593 my $option_help             = 0;
 594 my $option_version          = 0;
 595 my $option_pie              = 0;
 596 my $option_bindnow          = 0;
 597 my @option_ignore_arch      = ();
 598 my @option_ignore_flag      = ();
 599 my @option_ignore_arch_flag = ();
 600 my @option_ignore_line      = ();
 601 my @option_ignore_arch_line = ();
 602 my $option_all              = 0;
 603 my $option_arch             = undef;
 604 my $option_buildd           = 0;
 605    $option_color            = 0;
 606 if (not Getopt::Long::GetOptions(
 607             'help|h|?'           => \$option_help,
 608             'version'            => \$option_version,
 609             # Hardening options.
 610             'pie'                => \$option_pie,
 611             'bindnow'            => \$option_bindnow,
 612             'all'                => \$option_all,
 613             # Ignore.
 614             'ignore-arch=s'      => \@option_ignore_arch,
 615             'ignore-flag=s'      => \@option_ignore_flag,
 616             'ignore-arch-flag=s' => \@option_ignore_arch_flag,
 617             'ignore-line=s'      => \@option_ignore_line,
 618             'ignore-arch-line=s' => \@option_ignore_arch_line,
 619             # Misc.
 620             'color'              => \$option_color,
 621             'arch=s'             => \$option_arch,
 622             'buildd'             => \$option_buildd,
 623         )) {
 624     require Pod::Usage;
 625     Pod::Usage::pod2usage(2);
 626 }
 627 if ($option_help) {
 628     require Pod::Usage;
 629     Pod::Usage::pod2usage(1);
 630 }
 631 if ($option_version) {
 632     print <<"EOF";
 633 blhc $VERSION  Copyright (C) 2012-2017  Simon Ruderich
 634
 635 This program is free software: you can redistribute it and/or modify
 636 it under the terms of the GNU General Public License as published by
 637 the Free Software Foundation, either version 3 of the License, or
 638 (at your option) any later version.
 639
 640 This program is distributed in the hope that it will be useful,
 641 but WITHOUT ANY WARRANTY; without even the implied warranty of
 642 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 643 GNU General Public License for more details.
 644
 645 You should have received a copy of the GNU General Public License
 646 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 647 EOF
 648     exit 0;
 649 }
 650
 651 # Arguments missing.
 652 if (scalar @ARGV == 0) {
 653     require Pod::Usage;
 654     Pod::Usage::pod2usage(2);
 655 }
 656
 657 # Don't load Term::ANSIColor in buildd mode because Term::ANSIColor is not
 658 # installed on Debian's buildds.
 659 if (not $option_buildd) {
 660     require Term::ANSIColor;
 661 }
 662
 663 if ($option_all) {
 664     $option_pie     = 1;
 665     $option_bindnow = 1;
 666 }
 667
 668 # Precompiled ignores for faster lookup.
 669 my %option_ignore_arch_flag = ();
 670 my %option_ignore_arch_line = ();
 671
 672 # Strip flags which should be ignored.
 673 if (scalar @option_ignore_flag > 0) {
 674     remove_flags(\@flag_refs, \%flag_renames, @option_ignore_flag);
 675 }
 676 # Same for arch specific ignore flags, but only prepare here.
 677 if (scalar @option_ignore_arch_flag > 0) {
 678     foreach my $ignore (@option_ignore_arch_flag) {
 679         my ($ignore_arch, $ignore_flag) = split /:/, $ignore, 2;
 680
 681         if (not $ignore_arch or not $ignore_flag) {
 682             printf STDERR 'Value "%s" invalid for option ignore-arch-flag '
 683                         . '("arch:flag" expected)' . "\n", $ignore;
 684             require Pod::Usage;
 685             Pod::Usage::pod2usage(2);
 686         }
 687
 688         push @{$option_ignore_arch_flag{$ignore_arch}}, $ignore_flag;
 689     }
 690 }
 691
 692 # Precompile all flag regexps. any_flags_used(), all_flags_used() get a lot
 693 # faster with this.
 694 foreach my $flags (@flag_refs_all) {
 695     @{$flags} = compile_flag_regexp(\%flag_renames, @{$flags});
 696 }
 697
 698 # Precompile ignore line regexps, also anchor at beginning and end of line.
 699 foreach my $ignore (@option_ignore_line) {
 700     $ignore = qr/^$ignore$/;
 701 }
 702 # Same for arch specific ignore lines.
 703 if (scalar @option_ignore_arch_line > 0) {
 704     foreach my $ignore (@option_ignore_arch_line) {
 705         my ($ignore_arch, $ignore_line) = split /:/, $ignore, 2;
 706
 707         if (not $ignore_arch or not $ignore_line) {
 708             printf STDERR 'Value "%s" invalid for option ignore-arch-line '
 709                         . '("arch:line" expected)' . "\n", $ignore;
 710             require Pod::Usage;
 711             Pod::Usage::pod2usage(2);
 712         }
 713
 714         push @{$option_ignore_arch_line{$ignore_arch}}, qr/^$ignore_line$/;
 715     }
 716 }
 717
 718 # Final exit code.
 719 my $exit = 0;
 720
 721 FILE:
 722 foreach my $file (@ARGV) {
 723     print "checking '$file'...\n" if scalar @ARGV > 1;
 724
 725     -f $file or die "No such file: $file";
 726
 727     open my $fh, '<', $file or die $!;
 728
 729     # Architecture of this file.
 730     my $arch = $option_arch;
 731
 732     # Hardening options. Not all architectures support all hardening options.
 733     my $harden_format  = 1;
 734     my $harden_fortify = 1;
 735     my $harden_stack   = 1;
 736     my $harden_stack_strong = 1;
 737     my $harden_relro   = 1;
 738     my $harden_bindnow = $option_bindnow; # defaults to 0
 739     my $harden_pie     = $option_pie;     # defaults to 0
 740
 741     # Does this build log use ada? Ada also uses gcc as compiler but uses
 742     # different CFLAGS. But only perform ada checks if an ada compiler is used
 743     # for performance reasons.
 744     my $ada = 0;
 745     # Fortran also requires different CFLAGS.
 746     my $fortran = 0;
 747
 748     # Number of parallel jobs to prevent false positives when detecting
 749     # non-verbose builds. As not all jobs declare the number of parallel jobs
 750     # use a large enough default.
 751     my $parallel = 10;
 752
 753     # Don't check for PIE flags if automatically applied by the compiler. Only
 754     # used in buildd mode.
 755     my $disable_harden_pie = 0;
 756
 757     while (my $line = <$fh>) {
 758         # Detect architecture automatically unless overridden. For buildd logs
 759         # only, doesn't use the dpkg-buildpackage header. Necessary to ignore
 760         # build logs which aren't built (wrong architecture, build error,
 761         # etc.).
 762         if (not $arch) {
 763             if (index($line, 'Build Architecture: ') == 0) {
 764                 $arch = substr $line, 20, -1; # -1 to ignore '\n' at the end
 765             # For old logs (sbuild << 0.63.0-1).
 766             } elsif (index($line, 'Architecture: ') == 0) {
 767                 $arch = substr $line, 14, -1; # -1 to ignore '\n' at the end
 768             }
 769         }
 770
 771         # dpkg-buildflags only provides hardening flags since 1.16.1, don't
 772         # check for hardening flags in buildd mode if an older dpkg-dev is
 773         # used. Default flags (-g -O2) are still checked.
 774         #
 775         # Packages which were built before 1.16.1 but used their own hardening
 776         # flags are not checked.
 777         #
 778         # Strong stack protector is used since dpkg 1.17.11.
 779         #
 780         # Recent GCC versions automatically use PIE (only on supported
 781         # architectures) and dpkg respects this properly since 1.18.15 and
 782         # doesn't pass PIE flags manually.
 783         if ($option_buildd
 784                 and index($line, 'Toolchain package versions: ') == 0) {
 785             require Dpkg::Version;
 786
 787             my $disable = 1;
 788             my $disable_strong = 1;
 789
 790             if ($line =~ /\bdpkg-dev_(\S+)/) {
 791                 if (Dpkg::Version::version_compare($1, '1.16.1') >= 0) {
 792                     $disable = 0;
 793                 }
 794                 if (Dpkg::Version::version_compare($1, '1.17.11') >= 0) {
 795                     $disable_strong = 0;
 796                 }
 797                 if (Dpkg::Version::version_compare($1, '1.18.15') >= 0) {
 798                     $disable_harden_pie = 1;
 799                 }
 800             }
 801
 802             if ($disable) {
 803                 $harden_format  = 0;
 804                 $harden_fortify = 0;
 805                 $harden_stack   = 0;
 806                 $harden_relro   = 0;
 807                 $harden_bindnow = 0;
 808                 $harden_pie     = 0;
 809             }
 810             if ($disable_strong) {
 811                 $harden_stack_strong = 0;
 812             }
 813         }
 814
 815         # The following two versions of CMake in Debian obeyed CPPFLAGS, but
 816         # this was later dropped because upstream rejected the patch. Thus
 817         # build logs with these versions will have fortify hardening flags
 818         # enabled, even though they may be not correctly set and are missing
 819         # when build with later CMake versions. Thanks to Aron Xu for letting
 820         # me know.
 821         if (index($line, 'Package versions: ') == 0
 822                 and $line =~ /\bcmake_(\S+)/
 823                 and ($1 eq '2.8.7-1' or $1 eq '2.8.7-2')) {
 824             if (not $option_buildd) {
 825                 error_invalid_cmake($1);
 826                 $exit |= $exit_code{invalid_cmake};
 827             } else {
 828                 print "$buildd_tag{invalid_cmake}|$1|\n";
 829             }
 830         }
 831
 832         # Debian's build daemons use "Filtered Build-Depends:" (or just
 833         # "Build-Depends:" in older versions) for the build dependencies, but
 834         # pbuilder uses "Depends:"; support both.
 835         if (index($line, 'Filtered Build-Depends: ') == 0
 836                 or index($line, 'Build-Depends: ') == 0
 837                 or index($line, 'Depends: ') == 0) {
 838             # If hardening wrapper is used (wraps calls to gcc and adds
 839             # hardening flags automatically) we can't perform any checks,
 840             # abort.
 841             if ($line =~ /\bhardening-wrapper\b/) {
 842                 if (not $option_buildd) {
 843                     error_hardening_wrapper();
 844                     $exit |= $exit_code{hardening_wrapper};
 845                 } else {
 846                     print "$buildd_tag{hardening_wrapper}||\n";
 847                 }
 848                 next FILE;
 849             }
 850
 851             # Ada compiler.
 852             if ($line =~ /\bgnat\b/) {
 853                 $ada = 1;
 854             }
 855             # Fortran compiler.
 856             if ($line =~ /\bgfortran\b/) {
 857                 $fortran = 1;
 858             }
 859         }
 860
 861         # This flags is not always available, but if it is use it.
 862         if ($line =~ /^DEB_BUILD_OPTIONS=.*\bparallel=(\d+)/) {
 863             $parallel = $1;
 864         }
 865
 866         # We skip over unimportant lines at the beginning of the log to
 867         # prevent false positives.
 868         last if index($line, 'dpkg-buildpackage: ') == 0;
 869     }
 870
 871     # Input lines, contain only the lines with compiler commands.
 872     my @input = ();
 873     # Non-verbose lines in the input. Used to reduce calls to
 874     # is_non_verbose_build() (which is quite slow) in the second loop when
 875     # it's already clear if a line is non-verbose or not.
 876     my @input_nonverbose = ();
 877
 878     my $continuation = 0;
 879     my $complete_line = undef;
 880     my $non_verbose;
 881     while (my $line = <$fh>) {
 882         # And stop at the end of the build log. Package details (reported by
 883         # the buildd logs) are not important for us. This also prevents false
 884         # positives.
 885         last if index($line, 'Build finished at ') == 0
 886                 and $line =~ /^Build finished at \d{8}-\d{4}$/;
 887
 888         if (not $continuation) {
 889             $non_verbose = 0;
 890         }
 891
 892         # Detect architecture automatically unless overridden.
 893         if (not $arch
 894                 and index($line, 'dpkg-buildpackage: host architecture ') == 0) {
 895             $arch = substr $line, 37, -1; # -1 to ignore '\n' at the end
 896
 897             # Old buildd logs use e.g. "host architecture is alpha", remove
 898             # the "is", otherwise debarch_to_debtriplet() will not detect the
 899             # architecture.
 900             if (index($arch, 'is ') == 0) {
 901                 $arch = substr $arch, 3;
 902             }
 903         }
 904
 905         next if $line =~ /^\s*#/;
 906         # Ignore compiler warnings for now.
 907         next if $line =~ /$warning_regex/o;
 908
 909         if (not $option_buildd and index($line, "\033") != -1) { # \033 = esc
 910             # Remove all ANSI color sequences which are sometimes used in
 911             # non-verbose builds.
 912             $line = Term::ANSIColor::colorstrip($line);
 913             # Also strip '\0xf' (delete previous character), used by Elinks'
 914             # build system.
 915             $line =~ s/\x0f//g;
 916             # And "ESC(B" which seems to be used on armhf and hurd (not sure
 917             # what it does).
 918             $line =~ s/\033\(B//g;
 919         }
 920
 921         # Check if this line indicates a non verbose build.
 922         my $skip = 0;
 923         $non_verbose |= is_non_verbose_build($line, \$skip);
 924         next if $skip;
 925
 926         # One line may contain multiple commands (";"). Treat each one as
 927         # single line. parse_line() is slow, only use it when necessary.
 928         my @line = (index($line, ';') == -1)
 929                  ? ($line)
 930                  : map {
 931                        # Ensure newline at the line end - necessary for
 932                        # correct parsing later.
 933                        $_ =~ s/\s+$//;
 934                        $_ .= "\n";
 935                    } Text::ParseWords::parse_line(';', 1, $line);
 936         foreach my $line (@line) {
 937             if ($continuation) {
 938                 $continuation = 0;
 939
 940                 # Join lines, but leave the "\" in place so it's clear where
 941                 # the original line break was.
 942                 chomp $complete_line;
 943                 $complete_line .= ' ' . $line;
 944             }
 945             # Line continuation, line ends with "\".
 946             if ($line =~ /\\$/) {
 947                 $continuation = 1;
 948                 # Start line continuation.
 949                 if (not defined $complete_line) {
 950                     $complete_line = $line;
 951                 }
 952                 next;
 953             }
 954
 955             # Use the complete line if a line continuation occurred.
 956             if (defined $complete_line) {
 957                 $line = $complete_line;
 958                 $complete_line = undef;
 959             }
 960
 961             # Ignore lines with no compiler commands.
 962             next if not $non_verbose
 963                     and not $line =~ /$cc_regex_normal/o;
 964             # Ignore lines with no filenames with extensions. May miss some
 965             # non-verbose builds (e.g. "gcc -o test" [sic!]), but shouldn't be
 966             # a problem as the log will most likely contain other non-verbose
 967             # commands which are detected.
 968             next if not $non_verbose
 969                     and not $line =~ /$file_extension_regex/o;
 970
 971             # Ignore false positives.
 972             #
 973             # `./configure` output.
 974             next if not $non_verbose
 975                     and $line =~ /^(?:checking|[Cc]onfigure:) /;
 976             next if $line =~ /^\s*(?:Host\s+)?(?:C(?:\+\+)?\s+)?
 977                                 [Cc]ompiler[\s.]*:?\s+
 978                                 /x;
 979             next if $line =~ m{^\s*(?:-\s)?(?:HOST_)?(?:CC|CXX)
 980                                 \s*=\s*$cc_regex_full
 981                                 # optional compiler options, don't allow
 982                                 # "everything" here to prevent false negatives
 983                                 \s*(?:\s-\S+)*\s*$}xo;
 984             # `moc-qt4`/`moc-qt5` contain '-I.../linux-g++' in their command
 985             # line (or similar for other architectures) which gets recognized
 986             # as a compiler line, but `moc-qt*` is only a preprocessor for Qt
 987             # C++ files. No hardening flags are relevant during this step,
 988             # thus ignore `moc-qt*` lines. The resulting files will be
 989             # compiled in a separate step (and therefore checked).
 990             next if $line =~ m{^\S+/bin/moc(?:-qt[45])?
 991                                \s.+\s
 992                                -I\S+/mkspecs/[a-z]+-g\++(?:-64)?
 993                                \s}x;
 994             # Ignore false positives when the line contains only CC=gcc but no
 995             # other gcc command.
 996             if ($line =~ /(.*)CC=$cc_regex_full(.*)/o) {
 997                 my $before = $1;
 998                 my $after  = $2;
 999                 next if     not $before =~ /$cc_regex_normal/o
1000                         and not $after  =~ /$cc_regex_normal/o;
1001             }
1002             # Ignore false positives caused by gcc -v. It outputs a line
1003             # looking like a normal compiler line but which is sometimes
1004             # missing hardening flags, although the normal compiler line
1005             # contains them.
1006             next if $line =~ m{^\s+/usr/lib/gcc/$cc_regex_full_prefix/
1007                                    [0-9.]+/cc1(?:plus)?}xo;
1008             # Ignore false positive with `rm` which may remove files which
1009             # look like a compiler executable thus causing the line to be
1010             # treated as a normal compiler line.
1011             next if $line =~ m{^\s*rm\s+};
1012             # Some build systems emit "gcc > file".
1013             next if $line =~ m{$cc_regex_normal\s*>\s*\S+};
1014
1015             # Check if additional hardening options were used. Used to ensure
1016             # they are used for the complete build.
1017             $harden_pie     = 1 if any_flags_used($line, @def_cflags_pie,
1018                                                          @def_ldflags_pie);
1019             $harden_bindnow = 1 if any_flags_used($line, @def_ldflags_bindnow);
1020
1021             push @input, $line;
1022             push @input_nonverbose, $non_verbose;
1023         }
1024     }
1025
1026     close $fh or die $!;
1027
1028     # Ignore arch if requested.
1029     if (scalar @option_ignore_arch > 0 and $arch) {
1030         foreach my $ignore (@option_ignore_arch) {
1031             if ($arch eq $ignore) {
1032                 print "ignoring architecture '$arch'\n";
1033                 next FILE;
1034             }
1035         }
1036     }
1037
1038     if (scalar @input == 0) {
1039         if (not $option_buildd) {
1040             print "No compiler commands!\n";
1041             $exit |= $exit_code{no_compiler_commands};
1042         } else {
1043             print "$buildd_tag{no_compiler_commands}||\n";
1044         }
1045         next FILE;
1046     }
1047
1048     if ($option_buildd) {
1049         $statistics{commands} += scalar @input;
1050     }
1051
1052     # Option or auto detected.
1053     if ($arch) {
1054         # The following was partially copied from dpkg-dev 1.18.24
1055         # (/usr/share/perl5/Dpkg/Vendor/Debian.pm, _add_hardening_flags()),
1056         # copyright Raphaël Hertzog <hertzog@debian.org>, Kees Cook
1057         # <kees@debian.org>, Canonical, Ltd. licensed under GPL version 2 or
1058         # later. Keep it in sync.
1059
1060         require Dpkg::Arch;
1061         my ($os, $cpu);
1062         # Recent dpkg versions use a quadruplet for arch. Support both.
1063         eval {
1064             (undef, undef, $os, $cpu) = Dpkg::Arch::debarch_to_debtuple($arch);
1065         };
1066         if ($@) {
1067             (undef, $os, $cpu) = Dpkg::Arch::debarch_to_debtriplet($arch);
1068         }
1069
1070         my %builtin_pie_arch = map { $_ => 1 } qw(
1071             amd64 arm64 armel armhf i386 kfreebsd-amd64 kfreebsd-i386
1072             mips mipsel mips64el ppc64el s390x sparc sparc64
1073         );
1074
1075         # Disable unsupported hardening options.
1076         if ($os !~ /^(?:linux|kfreebsd|knetbsd|hurd)$/
1077                 or $cpu =~ /^(?:hppa|avr32)$/) {
1078             $harden_pie = 0;
1079         }
1080         if ($cpu =~ /^(?:ia64|alpha|hppa|nios2)$/ or $arch eq 'arm') {
1081             $harden_stack = 0;
1082             $harden_stack_strong = 0;
1083         }
1084         if ($cpu =~ /^(?:ia64|hppa|avr32)$/) {
1085             $harden_relro   = 0;
1086             $harden_bindnow = 0;
1087         }
1088
1089         if ($disable_harden_pie and exists $builtin_pie_arch{$arch}) {
1090             $harden_pie = 0;
1091         }
1092     }
1093
1094     # Default values.
1095     my @cflags   = @def_cflags;
1096     my @cxxflags = @def_cxxflags;
1097     my @cppflags = @def_cppflags;
1098     my @ldflags  = @def_ldflags;
1099     # Check the specified hardening options, same order as dpkg-buildflags.
1100     if ($harden_pie) {
1101         @cflags   = (@cflags,   @def_cflags_pie);
1102         @cxxflags = (@cxxflags, @def_cflags_pie);
1103         @ldflags  = (@ldflags,  @def_ldflags_pie);
1104     }
1105     if ($harden_stack_strong) {
1106         @cflags   = (@cflags,   @def_cflags_stack_strong);
1107         @cxxflags = (@cxxflags, @def_cflags_stack_strong);
1108     } elsif ($harden_stack) {
1109         @cflags   = (@cflags,   @def_cflags_stack);
1110         @cxxflags = (@cxxflags, @def_cflags_stack);
1111     }
1112     if ($harden_fortify) {
1113         @cflags   = (@cflags,   @def_cflags_fortify);
1114         @cxxflags = (@cxxflags, @def_cflags_fortify);
1115         @cppflags = (@cppflags, @def_cppflags_fortify);
1116     }
1117     if ($harden_format) {
1118         @cflags   = (@cflags,   @def_cflags_format);
1119         @cxxflags = (@cxxflags, @def_cflags_format);
1120     }
1121     if ($harden_relro) {
1122         @ldflags = (@ldflags, @def_ldflags_relro);
1123     }
1124     if ($harden_bindnow) {
1125         @ldflags = (@ldflags, @def_ldflags_bindnow);
1126     }
1127
1128     # Ada doesn't support format hardening flags, see #680117 for more
1129     # information. Same for fortran. Filter them out if either language is
1130     # used.
1131     my @cflags_backup;
1132     my @cflags_noformat;
1133     if (($ada or $fortran) and $harden_format) {
1134         @cflags_noformat = grep {
1135             my $ok = 1;
1136             foreach my $flag (@def_cflags_format) {
1137                 $ok = 0 if $_ eq $flag;
1138             }
1139             $ok;
1140         } @cflags;
1141     }
1142
1143     # Hack to fix cppflags_fortify_broken() if --ignore-flag
1144     # -D_FORTIFY_SOURCE=2 is used to ignore missing fortification. Only works
1145     # as long as @def_cppflags_fortify contains only one variable.
1146     if (scalar @def_cppflags_fortify == 0) {
1147         $harden_fortify = 0;
1148     }
1149
1150     # Ignore flags for this arch if requested.
1151     if ($arch and exists $option_ignore_arch_flag{$arch}) {
1152         my @local_flag_refs = (\@cflags, \@cxxflags, \@cppflags, \@ldflags);
1153
1154         remove_flags(\@local_flag_refs,
1155                      \%flag_renames,
1156                      @{$option_ignore_arch_flag{$arch}});
1157     }
1158
1159     my @ignore_line = @option_ignore_line;
1160     # Ignore lines for this arch if requested.
1161     if ($arch and exists $option_ignore_arch_line{$arch}) {
1162         @ignore_line = (@ignore_line, @{$option_ignore_arch_line{$arch}});
1163     }
1164
1165 LINE:
1166     for (my $i = 0; $i < scalar @input; $i++) {
1167         my $line = $input[$i];
1168
1169         # Ignore line if requested.
1170         foreach my $ignore (@ignore_line) {
1171             next LINE if $line =~ /$ignore/;
1172         }
1173
1174         my $skip = 0;
1175         if ($input_nonverbose[$i]
1176                 and is_non_verbose_build($line, \$skip,
1177                                          \@input, $i, $parallel)) {
1178             if (not $option_buildd) {
1179                 error_non_verbose_build($line);
1180                 $exit |= $exit_code{non_verbose_build};
1181             } else {
1182                 $statistics{commands_nonverbose}++;
1183             }
1184             next;
1185         }
1186         # Even if it's a verbose build, we might have to skip this line (see
1187         # is_non_verbose_build()).
1188         next if $skip;
1189
1190         my $orig_line = $line;
1191
1192         # Remove everything until and including the compiler command. Makes
1193         # checks easier and faster.
1194         $line =~ s/^.*?$cc_regex//o;
1195         # "([...] test.c)" is not detected as 'test.c' - fix this by removing
1196         # the brace and similar characters at the line end.
1197         $line =~ s/['")]+$//;
1198
1199         # Skip unnecessary tests when only preprocessing.
1200         my $flag_preprocess = 0;
1201
1202         my $dependency = 0;
1203         my $preprocess = 0;
1204         my $compile    = 0;
1205         my $link       = 0;
1206
1207         # Preprocess, compile, assemble.
1208         if ($line =~ /\s(-E|-S|-c)\b/) {
1209             $preprocess      = 1;
1210             $flag_preprocess = 1 if $1 eq '-E';
1211             $compile         = 1 if $1 eq '-S' or $1 eq '-c';
1212         # Dependency generation for Makefiles. The other flags (-MF -MG -MP
1213         # -MT -MQ) are always used with -M/-MM.
1214         } elsif ($line =~ /\s(?:-M|-MM)\b/) {
1215             $dependency = 1;
1216         # Otherwise assume we are linking.
1217         } else {
1218             $link = 1;
1219         }
1220
1221         # -MD/-MMD also cause dependency generation, but they don't imply -E!
1222         if ($line =~ /\s(?:-MD|-MMD)\b/) {
1223             $dependency      = 0;
1224             $flag_preprocess = 0;
1225         }
1226
1227         # Dependency generation for Makefiles, no preprocessing or other flags
1228         # needed.
1229         next if $dependency;
1230
1231         # Get all file extensions on this line.
1232         my @extensions = $line =~ /$file_extension_regex/go;
1233         # Ignore all unknown extensions to speedup the search below.
1234         @extensions = grep { exists $extension{$_} } @extensions;
1235
1236         # These file types don't require preprocessing.
1237         if (extension_found(\%extensions_no_preprocess, @extensions)) {
1238             $preprocess = 0;
1239         }
1240         # These file types require preprocessing.
1241         if (extension_found(\%extensions_preprocess, @extensions)) {
1242             # Prevent false positives with "libtool: link: g++ -include test.h
1243             # .." compiler lines.
1244             if ($orig_line !~ /$libtool_link_regex/o) {
1245                 $preprocess = 1;
1246             }
1247         }
1248
1249         if (not $flag_preprocess) {
1250             # If there are source files then it's compiling/linking in one
1251             # step and we must check both. We only check for source files
1252             # here, because header files cause too many false positives.
1253             if (extension_found(\%extensions_compile_link, @extensions)) {
1254                 # Assembly files don't need CFLAGS.
1255                 if (not extension_found(\%extensions_compile, @extensions)
1256                         and extension_found(\%extensions_no_compile, @extensions)) {
1257                     $compile = 0;
1258                 # But the rest does.
1259                 } else {
1260                     $compile = 1;
1261                 }
1262             # No compilable extensions found, either linking or compiling
1263             # header flags.
1264             #
1265             # If there are also no object files we are just compiling headers
1266             # (.h -> .h.gch). Don't check for linker flags in this case. Due
1267             # to our liberal checks for compiler lines, this also reduces the
1268             # number of false positives considerably.
1269             } elsif ($link
1270                     and not extension_found(\%extensions_object, @extensions)) {
1271                 $link = 0;
1272             }
1273         }
1274
1275         my $compile_cpp = 0;
1276         my $restore_cflags = 0;
1277         # Assume CXXFLAGS are required when a C++ file is specified in the
1278         # compiler line.
1279         if ($compile
1280                 and extension_found(\%extensions_compile_cpp, @extensions)) {
1281             $compile     = 0;
1282             $compile_cpp = 1;
1283         # Ada needs special CFLAGS, use them if only ada files are compiled.
1284         } elsif ($ada
1285                 and extension_found(\%extensions_ada, @extensions)) {
1286             $restore_cflags = 1;
1287             $preprocess = 0; # Ada uses no CPPFLAGS
1288             @cflags_backup = @cflags;
1289             @cflags        = @cflags_noformat;
1290         # Same for fortran.
1291         } elsif ($fortran
1292                 and extension_found(\%extensions_fortran, @extensions)) {
1293             $restore_cflags = 1;
1294             @cflags_backup = @cflags;
1295             @cflags        = @cflags_noformat;
1296         }
1297
1298         if ($option_buildd) {
1299             $statistics{preprocess}++  if $preprocess;
1300             $statistics{compile}++     if $compile;
1301             $statistics{compile_cpp}++ if $compile_cpp;
1302             $statistics{link}++        if $link;
1303         }
1304
1305         # Check if there are flags indicating a debug build. If that's true,
1306         # skip the check for -O2. This prevents fortification, but that's fine
1307         # for a debug build.
1308         if (any_flags_used($line, @def_cflags_debug)) {
1309             remove_flags([\@cflags], \%flag_renames, $def_cflags[1]);
1310             remove_flags([\@cppflags], \%flag_renames, $def_cppflags_fortify[0]);
1311         }
1312
1313         # Check hardening flags.
1314         my @missing;
1315         if ($compile and not all_flags_used($line, \@missing, @cflags)
1316                 # Libraries linked with -fPIC don't have to (and can't) be
1317                 # linked with -fPIE as well. It's no error if only PIE flags
1318                 # are missing.
1319                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1320                 # Assume dpkg-buildflags returns the correct flags.
1321                 and index($line, '`dpkg-buildflags --get CFLAGS`') == -1) {
1322             if (not $option_buildd) {
1323                 error_flags('CFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1324                 $exit |= $exit_code{flags_missing};
1325             } else {
1326                 $statistics{compile_missing}++;
1327             }
1328         } elsif ($compile_cpp and not all_flags_used($line, \@missing, @cflags)
1329                 # Libraries linked with -fPIC don't have to (and can't) be
1330                 # linked with -fPIE as well. It's no error if only PIE flags
1331                 # are missing.
1332                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1333                 # Assume dpkg-buildflags returns the correct flags.
1334                 and index($line, '`dpkg-buildflags --get CXXFLAGS`') == -1) {
1335             if (not $option_buildd) {
1336                 error_flags('CXXFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1337                 $exit |= $exit_code{flags_missing};
1338             } else {
1339                 $statistics{compile_cpp_missing}++;
1340             }
1341         }
1342         if ($preprocess
1343                 and (not all_flags_used($line, \@missing, @cppflags)
1344                     # The fortify flag might be overwritten, detect that.
1345                      or ($harden_fortify
1346                          and cppflags_fortify_broken($line, \@missing)))
1347                 # Assume dpkg-buildflags returns the correct flags.
1348                 and index($line, '`dpkg-buildflags --get CPPFLAGS`') == -1) {
1349             if (not $option_buildd) {
1350                 error_flags('CPPFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1351                 $exit |= $exit_code{flags_missing};
1352             } else {
1353                 $statistics{preprocess_missing}++;
1354             }
1355         }
1356         if ($link and not all_flags_used($line, \@missing, @ldflags)
1357                 # Same here, -fPIC conflicts with -fPIE.
1358                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_ldflags_pie)
1359                 # Assume dpkg-buildflags returns the correct flags.
1360                 and index($line, '`dpkg-buildflags --get LDFLAGS`') == -1) {
1361             if (not $option_buildd) {
1362                 error_flags('LDFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1363                 $exit |= $exit_code{flags_missing};
1364             } else {
1365                 $statistics{link_missing}++;
1366             }
1367         }
1368
1369         # Restore normal CFLAGS.
1370         if ($restore_cflags) {
1371             @cflags = @cflags_backup;
1372         }
1373     }
1374 }
1375
1376 # Print statistics for buildd mode, only output in this mode.
1377 if ($option_buildd) {
1378     my @warning;
1379
1380     if ($statistics{preprocess_missing}) {
1381         push @warning, sprintf 'CPPFLAGS %d (of %d)',
1382                                $statistics{preprocess_missing},
1383                                $statistics{preprocess};
1384     }
1385     if ($statistics{compile_missing}) {
1386         push @warning, sprintf 'CFLAGS %d (of %d)',
1387                                $statistics{compile_missing},
1388                                $statistics{compile};
1389     }
1390     if ($statistics{compile_cpp_missing}) {
1391         push @warning, sprintf 'CXXFLAGS %d (of %d)',
1392                                $statistics{compile_cpp_missing},
1393                                $statistics{compile_cpp};
1394     }
1395     if ($statistics{link_missing}) {
1396         push @warning, sprintf 'LDFLAGS %d (of %d)',
1397                                $statistics{link_missing},
1398                                $statistics{link};
1399     }
1400     if (scalar @warning) {
1401         local $" = ', '; # array join string
1402         print "$buildd_tag{flags_missing}|@warning missing|\n";
1403     }
1404
1405     if ($statistics{commands_nonverbose}) {
1406         printf "$buildd_tag{non_verbose_build}|%d (of %d) hidden|\n",
1407                $statistics{commands_nonverbose},
1408                $statistics{commands},
1409     }
1410 }
1411
1412
1413 exit $exit;
1414
1415
1416 __END__
1417
1418 =head1 NAME
1419
1420 blhc - build log hardening check, checks build logs for missing hardening flags
1421
1422 =head1 SYNOPSIS
1423
1424 B<blhc> [I<options>] I<< <dpkg-buildpackage build log file>.. >>
1425
1426 =head1 DESCRIPTION
1427
1428 blhc is a small tool which checks build logs for missing hardening flags. It's
1429 licensed under the GPL 3 or later.
1430
1431 It's designed to check build logs generated by Debian's dpkg-buildpackage (or
1432 tools using dpkg-buildpackage like pbuilder or sbuild (which is used for the
1433 official buildd build logs)) to help maintainers detect missing hardening
1434 flags in their packages.
1435
1436 Only gcc is detected as compiler at the moment. If other compilers support
1437 hardening flags as well, please report them.
1438
1439 If there's no output, no flags are missing and the build log is fine.
1440
1441 See F<README> for details about performed checks, auto-detection and
1442 limitations.
1443
1444 =head1 OPTIONS
1445
1446 =over 8
1447
1448 =item B<--all>
1449
1450 Force check for all +all (+pie, +bindnow) hardening flags. By default it's
1451 auto detected.
1452
1453 =item B<--arch> I<architecture>
1454
1455 Set the specific architecture (e.g. amd64, armel, etc.), automatically
1456 disables hardening flags not available on this architecture. Is detected
1457 automatically if dpkg-buildpackage is used.
1458
1459 =item B<--bindnow>
1460
1461 Force check for all +bindnow hardening flags. By default it's auto detected.
1462
1463 =item B<--buildd>
1464
1465 Special mode for buildds when automatically parsing log files. The following
1466 changes are in effect:
1467
1468 =over 2
1469
1470 =item *
1471
1472 Print tags instead of normal warnings, see L</"BUILDD TAGS"> for a list of
1473 possible tags.
1474
1475 =item *
1476
1477 Don't check hardening flags in old log files (if dpkg-dev << 1.16.1 is
1478 detected).
1479
1480 =item *
1481
1482 Don't require Term::ANSIColor.
1483
1484 =item *
1485
1486 Return exit code 0, unless there was a error (-I, -W messages don't count as
1487 error).
1488
1489 =back
1490
1491 =item B<--color>
1492
1493 Use colored (ANSI) output for warning messages.
1494
1495 =item B<--ignore-arch> I<arch>
1496
1497 Ignore build logs from architectures matching I<arch>. I<arch> is a string.
1498
1499 Used to prevent false positives. This option can be specified multiple times.
1500
1501 =item B<--ignore-arch-flag> I<arch>:I<flag>
1502
1503 Like B<--ignore-flag>, but only ignore flag on I<arch>.
1504
1505 =item B<--ignore-arch-line> I<arch>:I<line>
1506
1507 Like B<--ignore-line>, but only ignore line on I<arch>.
1508
1509 =item B<--ignore-flag> I<flag>
1510
1511 Don't print an error when the specific flag is missing in a compiler line.
1512 I<flag> is a string.
1513
1514 Used to prevent false positives. This option can be specified multiple times.
1515
1516 =item B<--ignore-line> I<regex>
1517
1518 Ignore lines matching the given Perl regex. I<regex> is automatically anchored
1519 at the beginning and end of the line to prevent false negatives.
1520
1521 B<NOTE>: Not the input lines are checked, but the lines which are displayed in
1522 warnings (which have line continuation resolved).
1523
1524 Used to prevent false positives. This option can be specified multiple times.
1525
1526 =item B<--pie>
1527
1528 Force check for all +pie hardening flags. By default it's auto detected.
1529
1530 =item B<-h -? --help>
1531
1532 Print available options.
1533
1534 =item B<--version>
1535
1536 Print version number and license.
1537
1538 =back
1539
1540 Auto detection for B<--pie> and B<--bindnow> only works if at least one
1541 command uses the required hardening flag (e.g. -fPIE). Then it's required for
1542 all other commands as well.
1543
1544 =head1 EXAMPLES
1545
1546 Normal usage, parse a single log file.
1547
1548     blhc path/to/log/file
1549
1550 If there's no output, no flags are missing and the build log is fine.
1551
1552 Parse multiple log files. The exit code is ORed over all files.
1553
1554     blhc path/to/directory/with/log/files/*
1555
1556 Don't treat missing C<-g> as error:
1557
1558     blhc --ignore-flag -g path/to/log/file
1559
1560 Don't treat missing C<-pie> on kfreebsd-amd64 as error:
1561
1562     blhc --ignore-arch-flag kfreebsd-amd64:-pie path/to/log/file
1563
1564 Ignore lines consisting exactly of C<./script gcc file> which would cause a
1565 false positive.
1566
1567     blhc --ignore-line '\./script gcc file' path/to/log/file
1568
1569 Ignore lines matching C<./script gcc file> somewhere in the line.
1570
1571     blhc --ignore-line '.*\./script gcc file.*' path/to/log/file
1572
1573 Use blhc with pbuilder.
1574
1575     pbuilder path/to/package.dsc | tee path/log/file
1576     blhc path/to/file || echo flags missing
1577
1578 =head1 BUILDD TAGS
1579
1580 The following tags are used in I<--buildd> mode. In braces the additional data
1581 which is displayed.
1582
1583 =over 2
1584
1585 =item B<I-hardening-wrapper-used>
1586
1587 The package uses hardening-wrapper which intercepts calls to gcc and adds
1588 hardening flags. The build log doesn't contain any hardening flags and thus
1589 can't be checked by blhc.
1590
1591 =item B<W-compiler-flags-hidden> (summary of hidden lines)
1592
1593 Build log contains lines which hide the real compiler flags. For example:
1594
1595     CC test-a.c
1596     CC test-b.c
1597     CC test-c.c
1598     LD test
1599
1600 Most of the time either C<export V=1> or C<export verbose=1> in
1601 F<debian/rules> fixes builds with hidden compiler flags. Sometimes C<.SILENT>
1602 in a F<Makefile> must be removed. And as last resort the F<Makefile> must be
1603 patched to remove the C<@>s hiding the real compiler commands.
1604
1605 =item B<W-dpkg-buildflags-missing> (summary of missing flags)
1606
1607 CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS missing.
1608
1609 =item B<I-invalid-cmake-used> (version)
1610
1611 By default CMake ignores CPPFLAGS thus missing those hardening flags. Debian
1612 patched CMake in versions 2.8.7-1 and 2.8.7-2 to respect CPPFLAGS, but this
1613 patch was rejected by upstream and later reverted in Debian. Thus those two
1614 versions show correct usage of CPPFLAGS even if the package doesn't correctly
1615 handle them (for example by passing them to CFLAGS). To prevent false
1616 negatives just blacklist those two versions.
1617
1618 =item B<I-no-compiler-commands>
1619
1620 No compiler commands were detected. Either the log contains none or they were
1621 not correctly detected by blhc (please report the bug in this case).
1622
1623 =back
1624
1625 =head1 EXIT STATUS
1626
1627 The exit status is a "bit mask", each listed status is ORed when the error
1628 condition occurs to get the result.
1629
1630 =over 4
1631
1632 =item B<0>
1633
1634 Success.
1635
1636 =item B<1>
1637
1638 No compiler commands were found.
1639
1640 =item B<2>
1641
1642 Invalid arguments/options given to blhc.
1643
1644 =item B<4>
1645
1646 Non verbose build.
1647
1648 =item B<8>
1649
1650 Missing hardening flags.
1651
1652 =item B<16>
1653
1654 Hardening wrapper detected, no tests performed.
1655
1656 =item B<32>
1657
1658 Invalid CMake version used. See B<I-invalid-cmake-used> under L</"BUILDD
1659 TAGS"> for a detailed explanation.
1660
1661 =back
1662
1663 =head1 AUTHOR
1664
1665 Simon Ruderich, E<lt>simon@ruderich.orgE<gt>
1666
1667 Thanks to to Bernhard R. Link E<lt>brlink@debian.orgE<gt> and Jaria Alto
1668 E<lt>jari.aalto@cante.netE<gt> for their valuable input and suggestions.
1669
1670 =head1 LICENSE AND COPYRIGHT
1671
1672 Copyright (C) 2012-2017 by Simon Ruderich
1673
1674 This program is free software: you can redistribute it and/or modify
1675 it under the terms of the GNU General Public License as published by
1676 the Free Software Foundation, either version 3 of the License, or
1677 (at your option) any later version.
1678
1679 This program is distributed in the hope that it will be useful,
1680 but WITHOUT ANY WARRANTY; without even the implied warranty of
1681 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1682 GNU General Public License for more details.
1683
1684 You should have received a copy of the GNU General Public License
1685 along with this program.  If not, see <http://www.gnu.org/licenses/>.
1686
1687 =head1 SEE ALSO
1688
1689 L<hardening-check(1)>, L<dpkg-buildflags(1)>
1690
1691 =cut