bin/blhc

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