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