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