bin/blhc

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