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     while (my $line = <$fh>) {
 754         # Detect architecture automatically unless overridden. For buildd logs
 755         # only, doesn't use the dpkg-buildpackage header. Necessary to ignore
 756         # build logs which aren't built (wrong architecture, build error,
 757         # etc.).
 758         if (not $arch) {
 759             if (index($line, 'Build Architecture: ') == 0) {
 760                 $arch = substr $line, 20, -1; # -1 to ignore '\n' at the end
 761             # For old logs (sbuild << 0.63.0-1).
 762             } elsif (index($line, 'Architecture: ') == 0) {
 763                 $arch = substr $line, 14, -1; # -1 to ignore '\n' at the end
 764             }
 765         }
 766
 767         # dpkg-buildflags only provides hardening flags since 1.16.1, don't
 768         # check for hardening flags in buildd mode if an older dpkg-dev is
 769         # used. Default flags (-g -O2) are still checked.
 770         #
 771         # Packages which were built before 1.16.1 but used their own hardening
 772         # flags are not checked.
 773         #
 774         # Strong stack protector is used since dpkg 1.17.11.
 775         if ($option_buildd
 776                 and index($line, 'Toolchain package versions: ') == 0) {
 777             require Dpkg::Version;
 778
 779             my $disable = 1;
 780             my $disable_strong = 1;
 781
 782             if ($line =~ /\bdpkg-dev_(\S+)/) {
 783                 if (Dpkg::Version::version_compare($1, '1.16.1') >= 0) {
 784                     $disable = 0;
 785                 }
 786                 if (Dpkg::Version::version_compare($1, '1.17.11') >= 0) {
 787                     $disable_strong = 0;
 788                 }
 789             }
 790
 791             if ($disable) {
 792                 $harden_format  = 0;
 793                 $harden_fortify = 0;
 794                 $harden_stack   = 0;
 795                 $harden_relro   = 0;
 796                 $harden_bindnow = 0;
 797                 $harden_pie     = 0;
 798             }
 799             if ($disable_strong) {
 800                 $harden_stack_strong = 0;
 801             }
 802         }
 803
 804         # The following two versions of CMake in Debian obeyed CPPFLAGS, but
 805         # this was later dropped because upstream rejected the patch. Thus
 806         # build logs with these versions will have fortify hardening flags
 807         # enabled, even though they may be not correctly set and are missing
 808         # when build with later CMake versions. Thanks to Aron Xu for letting
 809         # me know.
 810         if (index($line, 'Package versions: ') == 0
 811                 and $line =~ /\bcmake_(\S+)/
 812                 and ($1 eq '2.8.7-1' or $1 eq '2.8.7-2')) {
 813             if (not $option_buildd) {
 814                 error_invalid_cmake($1);
 815                 $exit |= $exit_code{invalid_cmake};
 816             } else {
 817                 print "$buildd_tag{invalid_cmake}|$1|\n";
 818             }
 819         }
 820
 821         # Debian's build daemons use "Filtered Build-Depends:" (or just
 822         # "Build-Depends:" in older versions) for the build dependencies, but
 823         # pbuilder uses "Depends:"; support both.
 824         if (index($line, 'Filtered Build-Depends: ') == 0
 825                 or index($line, 'Build-Depends: ') == 0
 826                 or index($line, 'Depends: ') == 0) {
 827             # If hardening wrapper is used (wraps calls to gcc and adds
 828             # hardening flags automatically) we can't perform any checks,
 829             # abort.
 830             if ($line =~ /\bhardening-wrapper\b/) {
 831                 if (not $option_buildd) {
 832                     error_hardening_wrapper();
 833                     $exit |= $exit_code{hardening_wrapper};
 834                 } else {
 835                     print "$buildd_tag{hardening_wrapper}||\n";
 836                 }
 837                 next FILE;
 838             }
 839
 840             # Ada compiler.
 841             if ($line =~ /\bgnat\b/) {
 842                 $ada = 1;
 843             }
 844             # Fortran compiler.
 845             if ($line =~ /\bgfortran\b/) {
 846                 $fortran = 1;
 847             }
 848         }
 849
 850         # This flags is not always available, but if it is use it.
 851         if ($line =~ /^DEB_BUILD_OPTIONS=.*\bparallel=(\d+)/) {
 852             $parallel = $1;
 853         }
 854
 855         # We skip over unimportant lines at the beginning of the log to
 856         # prevent false positives.
 857         last if index($line, 'dpkg-buildpackage: ') == 0;
 858     }
 859
 860     # Input lines, contain only the lines with compiler commands.
 861     my @input = ();
 862     # Non-verbose lines in the input. Used to reduce calls to
 863     # is_non_verbose_build() (which is quite slow) in the second loop when
 864     # it's already clear if a line is non-verbose or not.
 865     my @input_nonverbose = ();
 866
 867     my $continuation = 0;
 868     my $complete_line = undef;
 869     my $non_verbose;
 870     while (my $line = <$fh>) {
 871         # And stop at the end of the build log. Package details (reported by
 872         # the buildd logs) are not important for us. This also prevents false
 873         # positives.
 874         last if index($line, 'Build finished at ') == 0
 875                 and $line =~ /^Build finished at \d{8}-\d{4}$/;
 876
 877         if (not $continuation) {
 878             $non_verbose = 0;
 879         }
 880
 881         # Detect architecture automatically unless overridden.
 882         if (not $arch
 883                 and index($line, 'dpkg-buildpackage: host architecture ') == 0) {
 884             $arch = substr $line, 37, -1; # -1 to ignore '\n' at the end
 885
 886             # Old buildd logs use e.g. "host architecture is alpha", remove
 887             # the "is", otherwise debarch_to_debtriplet() will not detect the
 888             # architecture.
 889             if (index($arch, 'is ') == 0) {
 890                 $arch = substr $arch, 3;
 891             }
 892         }
 893
 894         next if $line =~ /^\s*#/;
 895         # Ignore compiler warnings for now.
 896         next if $line =~ /$warning_regex/o;
 897
 898         if (not $option_buildd and index($line, "\033") != -1) { # \033 = esc
 899             # Remove all ANSI color sequences which are sometimes used in
 900             # non-verbose builds.
 901             $line = Term::ANSIColor::colorstrip($line);
 902             # Also strip '\0xf' (delete previous character), used by Elinks'
 903             # build system.
 904             $line =~ s/\x0f//g;
 905             # And "ESC(B" which seems to be used on armhf and hurd (not sure
 906             # what it does).
 907             $line =~ s/\033\(B//g;
 908         }
 909
 910         # Check if this line indicates a non verbose build.
 911         my $skip = 0;
 912         $non_verbose |= is_non_verbose_build($line, \$skip);
 913         next if $skip;
 914
 915         # One line may contain multiple commands (";"). Treat each one as
 916         # single line. parse_line() is slow, only use it when necessary.
 917         my @line = (index($line, ';') == -1)
 918                  ? ($line)
 919                  : map {
 920                        # Ensure newline at the line end - necessary for
 921                        # correct parsing later.
 922                        $_ =~ s/\s+$//;
 923                        $_ .= "\n";
 924                    } Text::ParseWords::parse_line(';', 1, $line);
 925         foreach my $line (@line) {
 926             if ($continuation) {
 927                 $continuation = 0;
 928
 929                 # Join lines, but leave the "\" in place so it's clear where
 930                 # the original line break was.
 931                 chomp $complete_line;
 932                 $complete_line .= ' ' . $line;
 933             }
 934             # Line continuation, line ends with "\".
 935             if ($line =~ /\\$/) {
 936                 $continuation = 1;
 937                 # Start line continuation.
 938                 if (not defined $complete_line) {
 939                     $complete_line = $line;
 940                 }
 941                 next;
 942             }
 943
 944             # Use the complete line if a line continuation occurred.
 945             if (defined $complete_line) {
 946                 $line = $complete_line;
 947                 $complete_line = undef;
 948             }
 949
 950             # Ignore lines with no compiler commands.
 951             next if not $non_verbose
 952                     and not $line =~ /$cc_regex_normal/o;
 953             # Ignore lines with no filenames with extensions. May miss some
 954             # non-verbose builds (e.g. "gcc -o test" [sic!]), but shouldn't be
 955             # a problem as the log will most likely contain other non-verbose
 956             # commands which are detected.
 957             next if not $non_verbose
 958                     and not $line =~ /$file_extension_regex/o;
 959
 960             # Ignore false positives.
 961             #
 962             # `./configure` output.
 963             next if not $non_verbose
 964                     and $line =~ /^(?:checking|[Cc]onfigure:) /;
 965             next if $line =~ /^\s*(?:Host\s+)?(?:C(?:\+\+)?\s+)?
 966                                 [Cc]ompiler[\s.]*:?\s+
 967                                 /x;
 968             next if $line =~ m{^\s*(?:-\s)?(?:HOST_)?(?:CC|CXX)
 969                                 \s*=\s*$cc_regex_full
 970                                 # optional compiler options, don't allow
 971                                 # "everything" here to prevent false negatives
 972                                 \s*(?:\s-\S+)*\s*$}xo;
 973             # `moc-qt4`/`moc-qt5` contain '-I.../linux-g++' in their command
 974             # line (or similar for other architectures) which gets recognized
 975             # as a compiler line, but `moc-qt*` is only a preprocessor for Qt
 976             # C++ files. No hardening flags are relevant during this step,
 977             # thus ignore `moc-qt*` lines. The resulting files will be
 978             # compiled in a separate step (and therefore checked).
 979             next if $line =~ m{^\S+/bin/moc(?:-qt[45])?
 980                                \s.+\s
 981                                -I\S+/mkspecs/[a-z]+-g\++(?:-64)?
 982                                \s}x;
 983             # Ignore false positives when the line contains only CC=gcc but no
 984             # other gcc command.
 985             if ($line =~ /(.*)CC=$cc_regex_full(.*)/o) {
 986                 my $before = $1;
 987                 my $after  = $2;
 988                 next if     not $before =~ /$cc_regex_normal/o
 989                         and not $after  =~ /$cc_regex_normal/o;
 990             }
 991             # Ignore false positives caused by gcc -v. It outputs a line
 992             # looking like a normal compiler line but which is sometimes
 993             # missing hardening flags, although the normal compiler line
 994             # contains them.
 995             next if $line =~ m{^\s+/usr/lib/gcc/$cc_regex_full_prefix/
 996                                    [0-9.]+/cc1(?:plus)?}xo;
 997             # Ignore false positive with `rm` which may remove files which
 998             # look like a compiler executable thus causing the line to be
 999             # treated as a normal compiler line.
1000             next if $line =~ m{^\s*rm\s+};
1001             # Some build systems emit "gcc > file".
1002             next if $line =~ m{$cc_regex_normal\s*>\s*\S+};
1003
1004             # Check if additional hardening options were used. Used to ensure
1005             # they are used for the complete build.
1006             $harden_pie     = 1 if any_flags_used($line, @def_cflags_pie,
1007                                                          @def_ldflags_pie);
1008             $harden_bindnow = 1 if any_flags_used($line, @def_ldflags_bindnow);
1009
1010             push @input, $line;
1011             push @input_nonverbose, $non_verbose;
1012         }
1013     }
1014
1015     close $fh or die $!;
1016
1017     # Ignore arch if requested.
1018     if (scalar @option_ignore_arch > 0 and $arch) {
1019         foreach my $ignore (@option_ignore_arch) {
1020             if ($arch eq $ignore) {
1021                 print "ignoring architecture '$arch'\n";
1022                 next FILE;
1023             }
1024         }
1025     }
1026
1027     if (scalar @input == 0) {
1028         if (not $option_buildd) {
1029             print "No compiler commands!\n";
1030             $exit |= $exit_code{no_compiler_commands};
1031         } else {
1032             print "$buildd_tag{no_compiler_commands}||\n";
1033         }
1034         next FILE;
1035     }
1036
1037     if ($option_buildd) {
1038         $statistics{commands} += scalar @input;
1039     }
1040
1041     # Option or auto detected.
1042     if ($arch) {
1043         # The following was partially copied from dpkg-dev 1.18.15
1044         # (/usr/share/perl5/Dpkg/Vendor/Debian.pm, _add_hardening_flags()),
1045         # copyright Raphaël Hertzog <hertzog@debian.org>, Kees Cook
1046         # <kees@debian.org>, Canonical, Ltd. licensed under GPL version 2 or
1047         # later. Keep it in sync.
1048
1049         require Dpkg::Arch;
1050         my ($os, $cpu);
1051         # Recent dpkg versions use a quadruplet for arch. Support both.
1052         eval {
1053             (undef, undef, $os, $cpu) = Dpkg::Arch::debarch_to_debtuple($arch);
1054         };
1055         if ($@) {
1056             (undef, $os, $cpu) = Dpkg::Arch::debarch_to_debtriplet($arch);
1057         }
1058
1059         # Disable unsupported hardening options.
1060         if ($os !~ /^(?:linux|kfreebsd|knetbsd|hurd)$/
1061                 or $cpu =~ /^(?:hppa|avr32)$/) {
1062             $harden_pie = 0;
1063         }
1064         if ($cpu =~ /^(?:ia64|alpha|hppa|nios2)$/ or $arch eq 'arm') {
1065             $harden_stack = 0;
1066             $harden_stack_strong = 0;
1067         }
1068         if ($cpu =~ /^(?:ia64|hppa|avr32)$/) {
1069             $harden_relro   = 0;
1070             $harden_bindnow = 0;
1071         }
1072     }
1073
1074     # Default values.
1075     my @cflags   = @def_cflags;
1076     my @cxxflags = @def_cxxflags;
1077     my @cppflags = @def_cppflags;
1078     my @ldflags  = @def_ldflags;
1079     # Check the specified hardening options, same order as dpkg-buildflags.
1080     if ($harden_pie) {
1081         @cflags   = (@cflags,   @def_cflags_pie);
1082         @cxxflags = (@cxxflags, @def_cflags_pie);
1083         @ldflags  = (@ldflags,  @def_ldflags_pie);
1084     }
1085     if ($harden_stack_strong) {
1086         @cflags   = (@cflags,   @def_cflags_stack_strong);
1087         @cxxflags = (@cxxflags, @def_cflags_stack_strong);
1088     } elsif ($harden_stack) {
1089         @cflags   = (@cflags,   @def_cflags_stack);
1090         @cxxflags = (@cxxflags, @def_cflags_stack);
1091     }
1092     if ($harden_fortify) {
1093         @cflags   = (@cflags,   @def_cflags_fortify);
1094         @cxxflags = (@cxxflags, @def_cflags_fortify);
1095         @cppflags = (@cppflags, @def_cppflags_fortify);
1096     }
1097     if ($harden_format) {
1098         @cflags   = (@cflags,   @def_cflags_format);
1099         @cxxflags = (@cxxflags, @def_cflags_format);
1100     }
1101     if ($harden_relro) {
1102         @ldflags = (@ldflags, @def_ldflags_relro);
1103     }
1104     if ($harden_bindnow) {
1105         @ldflags = (@ldflags, @def_ldflags_bindnow);
1106     }
1107
1108     # Ada doesn't support format hardening flags, see #680117 for more
1109     # information. Same for fortran. Filter them out if either language is
1110     # used.
1111     my @cflags_backup;
1112     my @cflags_noformat;
1113     if (($ada or $fortran) and $harden_format) {
1114         @cflags_noformat = grep {
1115             my $ok = 1;
1116             foreach my $flag (@def_cflags_format) {
1117                 $ok = 0 if $_ eq $flag;
1118             }
1119             $ok;
1120         } @cflags;
1121     }
1122
1123     # Hack to fix cppflags_fortify_broken() if --ignore-flag
1124     # -D_FORTIFY_SOURCE=2 is used to ignore missing fortification. Only works
1125     # as long as @def_cppflags_fortify contains only one variable.
1126     if (scalar @def_cppflags_fortify == 0) {
1127         $harden_fortify = 0;
1128     }
1129
1130     # Ignore flags for this arch if requested.
1131     if ($arch and exists $option_ignore_arch_flag{$arch}) {
1132         my @local_flag_refs = (\@cflags, \@cxxflags, \@cppflags, \@ldflags);
1133
1134         remove_flags(\@local_flag_refs,
1135                      \%flag_renames,
1136                      @{$option_ignore_arch_flag{$arch}});
1137     }
1138
1139     my @ignore_line = @option_ignore_line;
1140     # Ignore lines for this arch if requested.
1141     if ($arch and exists $option_ignore_arch_line{$arch}) {
1142         @ignore_line = (@ignore_line, @{$option_ignore_arch_line{$arch}});
1143     }
1144
1145 LINE:
1146     for (my $i = 0; $i < scalar @input; $i++) {
1147         my $line = $input[$i];
1148
1149         # Ignore line if requested.
1150         foreach my $ignore (@ignore_line) {
1151             next LINE if $line =~ /$ignore/;
1152         }
1153
1154         my $skip = 0;
1155         if ($input_nonverbose[$i]
1156                 and is_non_verbose_build($line, \$skip,
1157                                          \@input, $i, $parallel)) {
1158             if (not $option_buildd) {
1159                 error_non_verbose_build($line);
1160                 $exit |= $exit_code{non_verbose_build};
1161             } else {
1162                 $statistics{commands_nonverbose}++;
1163             }
1164             next;
1165         }
1166         # Even if it's a verbose build, we might have to skip this line (see
1167         # is_non_verbose_build()).
1168         next if $skip;
1169
1170         my $orig_line = $line;
1171
1172         # Remove everything until and including the compiler command. Makes
1173         # checks easier and faster.
1174         $line =~ s/^.*?$cc_regex//o;
1175         # "([...] test.c)" is not detected as 'test.c' - fix this by removing
1176         # the brace and similar characters at the line end.
1177         $line =~ s/['")]+$//;
1178
1179         # Skip unnecessary tests when only preprocessing.
1180         my $flag_preprocess = 0;
1181
1182         my $dependency = 0;
1183         my $preprocess = 0;
1184         my $compile    = 0;
1185         my $link       = 0;
1186
1187         # Preprocess, compile, assemble.
1188         if ($line =~ /\s(-E|-S|-c)\b/) {
1189             $preprocess      = 1;
1190             $flag_preprocess = 1 if $1 eq '-E';
1191             $compile         = 1 if $1 eq '-S' or $1 eq '-c';
1192         # Dependency generation for Makefiles. The other flags (-MF -MG -MP
1193         # -MT -MQ) are always used with -M/-MM.
1194         } elsif ($line =~ /\s(?:-M|-MM)\b/) {
1195             $dependency = 1;
1196         # Otherwise assume we are linking.
1197         } else {
1198             $link = 1;
1199         }
1200
1201         # -MD/-MMD also cause dependency generation, but they don't imply -E!
1202         if ($line =~ /\s(?:-MD|-MMD)\b/) {
1203             $dependency      = 0;
1204             $flag_preprocess = 0;
1205         }
1206
1207         # Dependency generation for Makefiles, no preprocessing or other flags
1208         # needed.
1209         next if $dependency;
1210
1211         # Get all file extensions on this line.
1212         my @extensions = $line =~ /$file_extension_regex/go;
1213         # Ignore all unknown extensions to speedup the search below.
1214         @extensions = grep { exists $extension{$_} } @extensions;
1215
1216         # These file types don't require preprocessing.
1217         if (extension_found(\%extensions_no_preprocess, @extensions)) {
1218             $preprocess = 0;
1219         }
1220         # These file types require preprocessing.
1221         if (extension_found(\%extensions_preprocess, @extensions)) {
1222             # Prevent false positives with "libtool: link: g++ -include test.h
1223             # .." compiler lines.
1224             if ($orig_line !~ /$libtool_link_regex/o) {
1225                 $preprocess = 1;
1226             }
1227         }
1228
1229         if (not $flag_preprocess) {
1230             # If there are source files then it's compiling/linking in one
1231             # step and we must check both. We only check for source files
1232             # here, because header files cause too many false positives.
1233             if (extension_found(\%extensions_compile_link, @extensions)) {
1234                 # Assembly files don't need CFLAGS.
1235                 if (not extension_found(\%extensions_compile, @extensions)
1236                         and extension_found(\%extensions_no_compile, @extensions)) {
1237                     $compile = 0;
1238                 # But the rest does.
1239                 } else {
1240                     $compile = 1;
1241                 }
1242             # No compilable extensions found, either linking or compiling
1243             # header flags.
1244             #
1245             # If there are also no object files we are just compiling headers
1246             # (.h -> .h.gch). Don't check for linker flags in this case. Due
1247             # to our liberal checks for compiler lines, this also reduces the
1248             # number of false positives considerably.
1249             } elsif ($link
1250                     and not extension_found(\%extensions_object, @extensions)) {
1251                 $link = 0;
1252             }
1253         }
1254
1255         my $compile_cpp = 0;
1256         my $restore_cflags = 0;
1257         # Assume CXXFLAGS are required when a C++ file is specified in the
1258         # compiler line.
1259         if ($compile
1260                 and extension_found(\%extensions_compile_cpp, @extensions)) {
1261             $compile     = 0;
1262             $compile_cpp = 1;
1263         # Ada needs special CFLAGS, use them if only ada files are compiled.
1264         } elsif ($ada
1265                 and extension_found(\%extensions_ada, @extensions)) {
1266             $restore_cflags = 1;
1267             $preprocess = 0; # Ada uses no CPPFLAGS
1268             @cflags_backup = @cflags;
1269             @cflags        = @cflags_noformat;
1270         # Same for fortran.
1271         } elsif ($fortran
1272                 and extension_found(\%extensions_fortran, @extensions)) {
1273             $restore_cflags = 1;
1274             @cflags_backup = @cflags;
1275             @cflags        = @cflags_noformat;
1276         }
1277
1278         if ($option_buildd) {
1279             $statistics{preprocess}++  if $preprocess;
1280             $statistics{compile}++     if $compile;
1281             $statistics{compile_cpp}++ if $compile_cpp;
1282             $statistics{link}++        if $link;
1283         }
1284
1285         # Check if there are flags indicating a debug build. If that's true,
1286         # skip the check for -O2. This prevents fortification, but that's fine
1287         # for a debug build.
1288         if (any_flags_used($line, @def_cflags_debug)) {
1289             remove_flags([\@cflags], \%flag_renames, $def_cflags[1]);
1290             remove_flags([\@cppflags], \%flag_renames, $def_cppflags_fortify[0]);
1291         }
1292
1293         # Check hardening flags.
1294         my @missing;
1295         if ($compile and not all_flags_used($line, \@missing, @cflags)
1296                 # Libraries linked with -fPIC don't have to (and can't) be
1297                 # linked with -fPIE as well. It's no error if only PIE flags
1298                 # are missing.
1299                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1300                 # Assume dpkg-buildflags returns the correct flags.
1301                 and index($line, '`dpkg-buildflags --get CFLAGS`') == -1) {
1302             if (not $option_buildd) {
1303                 error_flags('CFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1304                 $exit |= $exit_code{flags_missing};
1305             } else {
1306                 $statistics{compile_missing}++;
1307             }
1308         } elsif ($compile_cpp and not all_flags_used($line, \@missing, @cflags)
1309                 # Libraries linked with -fPIC don't have to (and can't) be
1310                 # linked with -fPIE as well. It's no error if only PIE flags
1311                 # are missing.
1312                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1313                 # Assume dpkg-buildflags returns the correct flags.
1314                 and index($line, '`dpkg-buildflags --get CXXFLAGS`') == -1) {
1315             if (not $option_buildd) {
1316                 error_flags('CXXFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1317                 $exit |= $exit_code{flags_missing};
1318             } else {
1319                 $statistics{compile_cpp_missing}++;
1320             }
1321         }
1322         if ($preprocess
1323                 and (not all_flags_used($line, \@missing, @cppflags)
1324                     # The fortify flag might be overwritten, detect that.
1325                      or ($harden_fortify
1326                          and cppflags_fortify_broken($line, \@missing)))
1327                 # Assume dpkg-buildflags returns the correct flags.
1328                 and index($line, '`dpkg-buildflags --get CPPFLAGS`') == -1) {
1329             if (not $option_buildd) {
1330                 error_flags('CPPFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1331                 $exit |= $exit_code{flags_missing};
1332             } else {
1333                 $statistics{preprocess_missing}++;
1334             }
1335         }
1336         if ($link and not all_flags_used($line, \@missing, @ldflags)
1337                 # Same here, -fPIC conflicts with -fPIE.
1338                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_ldflags_pie)
1339                 # Assume dpkg-buildflags returns the correct flags.
1340                 and index($line, '`dpkg-buildflags --get LDFLAGS`') == -1) {
1341             if (not $option_buildd) {
1342                 error_flags('LDFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1343                 $exit |= $exit_code{flags_missing};
1344             } else {
1345                 $statistics{link_missing}++;
1346             }
1347         }
1348
1349         # Restore normal CFLAGS.
1350         if ($restore_cflags) {
1351             @cflags = @cflags_backup;
1352         }
1353     }
1354 }
1355
1356 # Print statistics for buildd mode, only output in this mode.
1357 if ($option_buildd) {
1358     my @warning;
1359
1360     if ($statistics{preprocess_missing}) {
1361         push @warning, sprintf 'CPPFLAGS %d (of %d)',
1362                                $statistics{preprocess_missing},
1363                                $statistics{preprocess};
1364     }
1365     if ($statistics{compile_missing}) {
1366         push @warning, sprintf 'CFLAGS %d (of %d)',
1367                                $statistics{compile_missing},
1368                                $statistics{compile};
1369     }
1370     if ($statistics{compile_cpp_missing}) {
1371         push @warning, sprintf 'CXXFLAGS %d (of %d)',
1372                                $statistics{compile_cpp_missing},
1373                                $statistics{compile_cpp};
1374     }
1375     if ($statistics{link_missing}) {
1376         push @warning, sprintf 'LDFLAGS %d (of %d)',
1377                                $statistics{link_missing},
1378                                $statistics{link};
1379     }
1380     if (scalar @warning) {
1381         local $" = ', '; # array join string
1382         print "$buildd_tag{flags_missing}|@warning missing|\n";
1383     }
1384
1385     if ($statistics{commands_nonverbose}) {
1386         printf "$buildd_tag{non_verbose_build}|%d (of %d) hidden|\n",
1387                $statistics{commands_nonverbose},
1388                $statistics{commands},
1389     }
1390 }
1391
1392
1393 exit $exit;
1394
1395
1396 __END__
1397
1398 =head1 NAME
1399
1400 blhc - build log hardening check, checks build logs for missing hardening flags
1401
1402 =head1 SYNOPSIS
1403
1404 B<blhc> [I<options>] I<< <dpkg-buildpackage build log file>.. >>
1405
1406 =head1 DESCRIPTION
1407
1408 blhc is a small tool which checks build logs for missing hardening flags. It's
1409 licensed under the GPL 3 or later.
1410
1411 It's designed to check build logs generated by Debian's dpkg-buildpackage (or
1412 tools using dpkg-buildpackage like pbuilder or sbuild (which is used for the
1413 official buildd build logs)) to help maintainers detect missing hardening
1414 flags in their packages.
1415
1416 Only gcc is detected as compiler at the moment. If other compilers support
1417 hardening flags as well, please report them.
1418
1419 If there's no output, no flags are missing and the build log is fine.
1420
1421 See F<README> for details about performed checks, auto-detection and
1422 limitations.
1423
1424 =head1 OPTIONS
1425
1426 =over 8
1427
1428 =item B<--all>
1429
1430 Force check for all +all (+pie, +bindnow) hardening flags. By default it's
1431 auto detected.
1432
1433 =item B<--arch> I<architecture>
1434
1435 Set the specific architecture (e.g. amd64, armel, etc.), automatically
1436 disables hardening flags not available on this architecture. Is detected
1437 automatically if dpkg-buildpackage is used.
1438
1439 =item B<--bindnow>
1440
1441 Force check for all +bindnow hardening flags. By default it's auto detected.
1442
1443 =item B<--buildd>
1444
1445 Special mode for buildds when automatically parsing log files. The following
1446 changes are in effect:
1447
1448 =over 2
1449
1450 =item *
1451
1452 Print tags instead of normal warnings, see L</"BUILDD TAGS"> for a list of
1453 possible tags.
1454
1455 =item *
1456
1457 Don't check hardening flags in old log files (if dpkg-dev << 1.16.1 is
1458 detected).
1459
1460 =item *
1461
1462 Don't require Term::ANSIColor.
1463
1464 =item *
1465
1466 Return exit code 0, unless there was a error (-I, -W messages don't count as
1467 error).
1468
1469 =back
1470
1471 =item B<--color>
1472
1473 Use colored (ANSI) output for warning messages.
1474
1475 =item B<--ignore-arch> I<arch>
1476
1477 Ignore build logs from architectures matching I<arch>. I<arch> is a string.
1478
1479 Used to prevent false positives. This option can be specified multiple times.
1480
1481 =item B<--ignore-arch-flag> I<arch>:I<flag>
1482
1483 Like B<--ignore-flag>, but only ignore flag on I<arch>.
1484
1485 =item B<--ignore-arch-line> I<arch>:I<line>
1486
1487 Like B<--ignore-line>, but only ignore line on I<arch>.
1488
1489 =item B<--ignore-flag> I<flag>
1490
1491 Don't print an error when the specific flag is missing in a compiler line.
1492 I<flag> is a string.
1493
1494 Used to prevent false positives. This option can be specified multiple times.
1495
1496 =item B<--ignore-line> I<regex>
1497
1498 Ignore lines matching the given Perl regex. I<regex> is automatically anchored
1499 at the beginning and end of the line to prevent false negatives.
1500
1501 B<NOTE>: Not the input lines are checked, but the lines which are displayed in
1502 warnings (which have line continuation resolved).
1503
1504 Used to prevent false positives. This option can be specified multiple times.
1505
1506 =item B<--pie>
1507
1508 Force check for all +pie hardening flags. By default it's auto detected.
1509
1510 =item B<-h -? --help>
1511
1512 Print available options.
1513
1514 =item B<--version>
1515
1516 Print version number and license.
1517
1518 =back
1519
1520 Auto detection for B<--pie> and B<--bindnow> only works if at least one
1521 command uses the required hardening flag (e.g. -fPIE). Then it's required for
1522 all other commands as well.
1523
1524 =head1 EXAMPLES
1525
1526 Normal usage, parse a single log file.
1527
1528     blhc path/to/log/file
1529
1530 If there's no output, no flags are missing and the build log is fine.
1531
1532 Parse multiple log files. The exit code is ORed over all files.
1533
1534     blhc path/to/directory/with/log/files/*
1535
1536 Don't treat missing C<-g> as error:
1537
1538     blhc --ignore-flag -g path/to/log/file
1539
1540 Don't treat missing C<-pie> on kfreebsd-amd64 as error:
1541
1542     blhc --ignore-arch-flag kfreebsd-amd64:-pie path/to/log/file
1543
1544 Ignore lines consisting exactly of C<./script gcc file> which would cause a
1545 false positive.
1546
1547     blhc --ignore-line '\./script gcc file' path/to/log/file
1548
1549 Ignore lines matching C<./script gcc file> somewhere in the line.
1550
1551     blhc --ignore-line '.*\./script gcc file.*' path/to/log/file
1552
1553 Use blhc with pbuilder.
1554
1555     pbuilder path/to/package.dsc | tee path/log/file
1556     blhc path/to/file || echo flags missing
1557
1558 =head1 BUILDD TAGS
1559
1560 The following tags are used in I<--buildd> mode. In braces the additional data
1561 which is displayed.
1562
1563 =over 2
1564
1565 =item B<I-hardening-wrapper-used>
1566
1567 The package uses hardening-wrapper which intercepts calls to gcc and adds
1568 hardening flags. The build log doesn't contain any hardening flags and thus
1569 can't be checked by blhc.
1570
1571 =item B<W-compiler-flags-hidden> (summary of hidden lines)
1572
1573 Build log contains lines which hide the real compiler flags. For example:
1574
1575     CC test-a.c
1576     CC test-b.c
1577     CC test-c.c
1578     LD test
1579
1580 Most of the time either C<export V=1> or C<export verbose=1> in
1581 F<debian/rules> fixes builds with hidden compiler flags. Sometimes C<.SILENT>
1582 in a F<Makefile> must be removed. And as last resort the F<Makefile> must be
1583 patched to remove the C<@>s hiding the real compiler commands.
1584
1585 =item B<W-dpkg-buildflags-missing> (summary of missing flags)
1586
1587 CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS missing.
1588
1589 =item B<I-invalid-cmake-used> (version)
1590
1591 By default CMake ignores CPPFLAGS thus missing those hardening flags. Debian
1592 patched CMake in versions 2.8.7-1 and 2.8.7-2 to respect CPPFLAGS, but this
1593 patch was rejected by upstream and later reverted in Debian. Thus those two
1594 versions show correct usage of CPPFLAGS even if the package doesn't correctly
1595 handle them (for example by passing them to CFLAGS). To prevent false
1596 negatives just blacklist those two versions.
1597
1598 =item B<I-no-compiler-commands>
1599
1600 No compiler commands were detected. Either the log contains none or they were
1601 not correctly detected by blhc (please report the bug in this case).
1602
1603 =back
1604
1605 =head1 EXIT STATUS
1606
1607 The exit status is a "bit mask", each listed status is ORed when the error
1608 condition occurs to get the result.
1609
1610 =over 4
1611
1612 =item B<0>
1613
1614 Success.
1615
1616 =item B<1>
1617
1618 No compiler commands were found.
1619
1620 =item B<2>
1621
1622 Invalid arguments/options given to blhc.
1623
1624 =item B<4>
1625
1626 Non verbose build.
1627
1628 =item B<8>
1629
1630 Missing hardening flags.
1631
1632 =item B<16>
1633
1634 Hardening wrapper detected, no tests performed.
1635
1636 =item B<32>
1637
1638 Invalid CMake version used. See B<I-invalid-cmake-used> under L</"BUILDD
1639 TAGS"> for a detailed explanation.
1640
1641 =back
1642
1643 =head1 AUTHOR
1644
1645 Simon Ruderich, E<lt>simon@ruderich.orgE<gt>
1646
1647 Thanks to to Bernhard R. Link E<lt>brlink@debian.orgE<gt> and Jaria Alto
1648 E<lt>jari.aalto@cante.netE<gt> for their valuable input and suggestions.
1649
1650 =head1 LICENSE AND COPYRIGHT
1651
1652 Copyright (C) 2012-2017 by Simon Ruderich
1653
1654 This program is free software: you can redistribute it and/or modify
1655 it under the terms of the GNU General Public License as published by
1656 the Free Software Foundation, either version 3 of the License, or
1657 (at your option) any later version.
1658
1659 This program is distributed in the hope that it will be useful,
1660 but WITHOUT ANY WARRANTY; without even the implied warranty of
1661 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1662 GNU General Public License for more details.
1663
1664 You should have received a copy of the GNU General Public License
1665 along with this program.  If not, see <http://www.gnu.org/licenses/>.
1666
1667 =head1 SEE ALSO
1668
1669 L<hardening-check(1)>, L<dpkg-buildflags(1)>
1670
1671 =cut