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 = (
  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
 706     my $continuation = 0;
 707     my $complete_line = undef;
 708     while (my $line = <$fh>) {
 709         # And stop at the end of the build log. Package details (reported by
 710         # the buildd logs) are not important for us. This also prevents false
 711         # positives.
 712         last if $line =~ /^Build finished at \d{8}-\d{4}$/;
 713
 714         # Detect architecture automatically unless overridden.
 715         if (not $arch
 716                 and $line =~ /^dpkg-buildpackage: host architecture (.+)$/) {
 717             $arch = $1;
 718         }
 719
 720         # Ignore compiler warnings for now.
 721         next if $line =~ /$warning_regex/o;
 722
 723         if (not $option_buildd and index($line, "\033") != -1) { # \033 = esc
 724             # Remove all ANSI color sequences which are sometimes used in
 725             # non-verbose builds.
 726             $line = Term::ANSIColor::colorstrip($line);
 727             # Also strip '\0xf' (delete previous character), used by Elinks'
 728             # build system.
 729             $line =~ s/\x0f//g;
 730             # And "ESC(B" which seems to be used on armhf and hurd (not sure
 731             # what it does).
 732             $line =~ s/\033\(B//g;
 733         }
 734
 735         # Check if this line indicates a non verbose build.
 736         my $non_verbose = is_non_verbose_build($line);
 737
 738         # One line may contain multiple commands (";"). Treat each one as
 739         # single line. parse_line() is slow, only use it when necessary.
 740         my @line = (index($line, ';') == -1)
 741                  ? ($line)
 742                  : map {
 743                        # Ensure newline at the line end - necessary for
 744                        # correct parsing later.
 745                        $_ =~ s/\s+$//;
 746                        $_ .= "\n";
 747                    } Text::ParseWords::parse_line(';', 1, $line);
 748         foreach my $line (@line) {
 749             if ($continuation) {
 750                 $continuation = 0;
 751
 752                 # Join lines, but leave the "\" in place so it's clear where
 753                 # the original line break was.
 754                 chomp $complete_line;
 755                 $complete_line .= ' ' . $line;
 756             }
 757             # Line continuation, line ends with "\".
 758             if ($line =~ /\\$/) {
 759                 $continuation = 1;
 760                 # Start line continuation.
 761                 if (not defined $complete_line) {
 762                     $complete_line = $line;
 763                 }
 764                 next;
 765             }
 766
 767             # Use the complete line if a line continuation occurred.
 768             if (defined $complete_line) {
 769                 $line = $complete_line;
 770                 $complete_line = undef;
 771             }
 772
 773             # Ignore lines with no compiler commands.
 774             next if not $non_verbose
 775                     and not $line =~ /$cc_regex_normal/o;
 776             # Ignore lines with no filenames with extensions. May miss some
 777             # non-verbose builds (e.g. "gcc -o test" [sic!]), but shouldn't be
 778             # a problem as the log will most likely contain other non-verbose
 779             # commands which are detected.
 780             next if not $non_verbose
 781                     and not $line =~ /$file_extension_regex/o;
 782
 783             # Ignore false positives.
 784             #
 785             # `./configure` output.
 786             next if not $non_verbose
 787                     and $line =~ /^(?:checking|[Cc]onfigure:) /;
 788             next if $line =~ /^\s*(?:Host\s+)?(?:C(?:\+\+)?\s+)?
 789                                 [Cc]ompiler[\s.]*:?\s+
 790                                 /x;
 791             next if $line =~ /^\s*(?:- )?(?:HOST_)?(?:CC|CXX)\s*=\s*$cc_regex_full\s*$/o;
 792             # `moc-qt4`, contains '-I/usr/share/qt4/mkspecs/linux-g++' (or
 793             # similar for other architectures) which gets recognized as a
 794             # compiler line. Ignore it.
 795             next if $line =~ m{^/usr/bin/moc-qt4
 796                                \s.+\s
 797                                -I/usr/share/qt4/mkspecs/[a-z]+-g\++(?:-64)?
 798                                \s}x;
 799             # Ignore false positives when the line contains only CC=gcc but no
 800             # other gcc command.
 801             if ($line =~ /(.*)CC=$cc_regex_full(.*)/o) {
 802                 my $before = $1;
 803                 my $after  = $2;
 804                 next if     not $before =~ /$cc_regex_normal/o
 805                         and not $after  =~ /$cc_regex_normal/o;
 806             }
 807
 808             # Check if additional hardening options were used. Used to ensure
 809             # they are used for the complete build.
 810             $harden_pie     = 1 if any_flags_used($line, @def_cflags_pie,
 811                                                          @def_ldflags_pie);
 812             $harden_bindnow = 1 if any_flags_used($line, @def_ldflags_bindnow);
 813
 814             push @input, $line;
 815         }
 816     }
 817
 818     close $fh or die $!;
 819
 820     # Ignore arch if requested.
 821     if (scalar @option_ignore_arch > 0 and $arch) {
 822         foreach my $ignore (@option_ignore_arch) {
 823             if ($arch eq $ignore) {
 824                 print "ignoring architecture '$arch'\n";
 825                 next FILE;
 826             }
 827         }
 828     }
 829
 830     if (scalar @input == 0) {
 831         if (not $option_buildd) {
 832             print "No compiler commands!\n";
 833             $exit |= $exit_code{no_compiler_commands};
 834         } else {
 835             print "$buildd_tag{no_compiler_commands}||\n";
 836         }
 837         next FILE;
 838     }
 839
 840     if ($option_buildd) {
 841         $statistics{commands} += scalar @input;
 842     }
 843
 844     # Option or auto detected.
 845     if ($arch) {
 846         # The following was partially copied from dpkg-dev 1.16.4.3
 847         # (/usr/share/perl5/Dpkg/Vendor/Debian.pm, add_hardening_flags()),
 848         # copyright Raphaël Hertzog <hertzog@debian.org>, Kees Cook
 849         # <kees@debian.org>, Canonical, Ltd. licensed under GPL version 2 or
 850         # later. Keep it in sync.
 851
 852         require Dpkg::Arch;
 853         my ($abi, $os, $cpu) = Dpkg::Arch::debarch_to_debtriplet($arch);
 854
 855         # Disable unsupported hardening options.
 856         if ($cpu =~ /^(?:ia64|alpha|mips|mipsel|hppa)$/ or $arch eq 'arm') {
 857             $harden_stack = 0;
 858         }
 859         if ($cpu =~ /^(?:ia64|hppa|avr32)$/) {
 860             $harden_relro   = 0;
 861             $harden_bindnow = 0;
 862         }
 863     }
 864
 865     # Default values.
 866     my @cflags   = @def_cflags;
 867     my @cxxflags = @def_cxxflags;
 868     my @cppflags = @def_cppflags;
 869     my @ldflags  = @def_ldflags;
 870     # Check the specified hardening options, same order as dpkg-buildflags.
 871     if ($harden_pie) {
 872         @cflags   = (@cflags,   @def_cflags_pie);
 873         @cxxflags = (@cxxflags, @def_cflags_pie);
 874         @ldflags  = (@ldflags,  @def_ldflags_pie);
 875     }
 876     if ($harden_stack) {
 877         @cflags   = (@cflags,   @def_cflags_stack);
 878         @cxxflags = (@cxxflags, @def_cflags_stack);
 879     }
 880     if ($harden_fortify) {
 881         @cflags   = (@cflags,   @def_cflags_fortify);
 882         @cxxflags = (@cxxflags, @def_cflags_fortify);
 883         @cppflags = (@cppflags, @def_cppflags_fortify);
 884     }
 885     if ($harden_format) {
 886         @cflags   = (@cflags,   @def_cflags_format);
 887         @cxxflags = (@cxxflags, @def_cflags_format);
 888     }
 889     if ($harden_relro) {
 890         @ldflags = (@ldflags, @def_ldflags_relro);
 891     }
 892     if ($harden_bindnow) {
 893         @ldflags = (@ldflags, @def_ldflags_bindnow);
 894     }
 895
 896     # Hack to fix cppflags_fortify_broken() if --ignore-flag
 897     # -D_FORTIFY_SOURCE=2 is used to ignore missing fortification. Only works
 898     # as long as @def_cppflags_fortify contains only one variable.
 899     if (scalar @def_cppflags_fortify == 0) {
 900         $harden_fortify = 0;
 901     }
 902
 903     # Ignore flags for this arch if requested.
 904     if ($arch and exists $option_ignore_arch_flag{$arch}) {
 905         my @flag_refs = (\@cflags, \@cxxflags, \@cppflags, \@ldflags);
 906
 907         remove_flags(\@flag_refs,
 908                      \%flag_renames,
 909                      @{$option_ignore_arch_flag{$arch}});
 910     }
 911
 912     my @ignore_line = @option_ignore_line;
 913     # Ignore lines for this arch if requested.
 914     if ($arch and exists $option_ignore_arch_line{$arch}) {
 915         @ignore_line = (@ignore_line, @{$option_ignore_arch_line{$arch}});
 916     }
 917
 918 LINE:
 919     for (my $i = 0; $i < scalar @input; $i++) {
 920         my $line = $input[$i];
 921
 922         # Ignore line if requested.
 923         foreach my $ignore (@ignore_line) {
 924             next LINE if $line =~ /$ignore/;
 925         }
 926
 927         my $skip = 0;
 928         if (is_non_verbose_build($line, $input[$i + 1], \$skip)) {
 929             if (not $option_buildd) {
 930                 error_non_verbose_build($line);
 931                 $exit |= $exit_code{non_verbose_build};
 932             } else {
 933                 $statistics{commands_nonverbose}++;
 934             }
 935             next;
 936         }
 937         # Even if it's a verbose build, we might have to skip this line.
 938         next if $skip;
 939
 940         # Remove everything until and including the compiler command. Makes
 941         # checks easier and faster.
 942         $line =~ s/^.*?$cc_regex//o;
 943         # "([...] test.c)" is not detected as 'test.c' - fix this by removing
 944         # the brace and similar characters at the line end.
 945         $line =~ s/['")]+$//;
 946
 947         # Skip unnecessary tests when only preprocessing.
 948         my $flag_preprocess = 0;
 949
 950         my $dependency = 0;
 951         my $preprocess = 0;
 952         my $compile    = 0;
 953         my $link       = 0;
 954
 955         # Preprocess, compile, assemble.
 956         if ($line =~ /\s(-E|-S|-c)\b/) {
 957             $preprocess      = 1;
 958             $flag_preprocess = 1 if $1 eq '-E';
 959             $compile         = 1 if $1 eq '-S' or $1 eq '-c';
 960         # Dependency generation for Makefiles. The other flags (-MF -MG -MP
 961         # -MT -MQ) are always used with -M/-MM.
 962         } elsif ($line =~ /\s(?:-M|-MM)\b/) {
 963             $dependency = 1;
 964         # Otherwise assume we are linking.
 965         } else {
 966             $link = 1;
 967         }
 968
 969         # -MD/-MMD also cause dependency generation, but they don't imply -E!
 970         if ($line =~ /\s(?:-MD|-MMD)\b/) {
 971             $dependency      = 0;
 972             $flag_preprocess = 0;
 973         }
 974
 975         # Dependency generation for Makefiles, no preprocessing or other flags
 976         # needed.
 977         next if $dependency;
 978
 979         # Get all file extensions on this line.
 980         my @extensions = $line =~ /$file_extension_regex/go;
 981         # Ignore all unknown extensions to speedup the search below.
 982         @extensions = grep { exists $extension{$_} } @extensions;
 983
 984         # These file types don't require preprocessing.
 985         if (extension_found(\%extensions_no_preprocess, @extensions)) {
 986             $preprocess = 0;
 987         }
 988         # These file types require preprocessing.
 989         if (extension_found(\%extensions_preprocess, @extensions)) {
 990             $preprocess = 1;
 991         }
 992
 993         if (not $flag_preprocess) {
 994             # If there are source files then it's compiling/linking in one
 995             # step and we must check both. We only check for source files
 996             # here, because header files cause too many false positives.
 997             if (extension_found(\%extensions_compile_link, @extensions)) {
 998                 # Assembly files don't need CFLAGS.
 999                 if (not extension_found(\%extensions_compile, @extensions)
1000                         and extension_found(\%extensions_no_compile, @extensions)) {
1001                     $compile = 0;
1002                 # But the rest does.
1003                 } else {
1004                     $compile = 1;
1005                 }
1006             # No compilable extensions found, either linking or compiling
1007             # header flags.
1008             #
1009             # If there are also no object files we are just compiling headers
1010             # (.h -> .h.gch). Don't check for linker flags in this case. Due
1011             # to our liberal checks for compiler lines, this also reduces the
1012             # number of false positives considerably.
1013             } elsif ($link
1014                     and not extension_found(\%extensions_object, @extensions)) {
1015                 $link = 0;
1016             }
1017         }
1018
1019         # Assume CXXFLAGS are required when a C++ file is specified in the
1020         # compiler line.
1021         my $compile_cpp = 0;
1022         if ($compile
1023                 and extension_found(\%extensions_compile_cpp, @extensions)) {
1024             $compile     = 0;
1025             $compile_cpp = 1;
1026         }
1027
1028         if ($option_buildd) {
1029             $statistics{preprocess}++  if $preprocess;
1030             $statistics{compile}++     if $compile;
1031             $statistics{compile_cpp}++ if $compile_cpp;
1032             $statistics{link}++        if $link;
1033         }
1034
1035         # Check hardening flags.
1036         my @missing;
1037         if ($compile and not all_flags_used($line, \@missing, @cflags)
1038                 # Libraries linked with -fPIC don't have to (and can't) be
1039                 # linked with -fPIE as well. It's no error if only PIE flags
1040                 # are missing.
1041                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1042                 # Assume dpkg-buildflags returns the correct flags.
1043                 and index($line, '`dpkg-buildflags --get CFLAGS`') == -1) {
1044             if (not $option_buildd) {
1045                 error_flags('CFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1046                 $exit |= $exit_code{flags_missing};
1047             } else {
1048                 $statistics{compile_missing}++;
1049             }
1050         } elsif ($compile_cpp and not all_flags_used($line, \@missing, @cflags)
1051                 # Libraries linked with -fPIC don't have to (and can't) be
1052                 # linked with -fPIE as well. It's no error if only PIE flags
1053                 # are missing.
1054                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1055                 # Assume dpkg-buildflags returns the correct flags.
1056                 and index($line, '`dpkg-buildflags --get CXXFLAGS`') == -1) {
1057             if (not $option_buildd) {
1058                 error_flags('CXXFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1059                 $exit |= $exit_code{flags_missing};
1060             } else {
1061                 $statistics{compile_cpp_missing}++;
1062             }
1063         }
1064         if ($preprocess
1065                 and (not all_flags_used($line, \@missing, @cppflags)
1066                     # The fortify flag might be overwritten, detect that.
1067                      or ($harden_fortify
1068                          and cppflags_fortify_broken($line, \@missing)))
1069                 # Assume dpkg-buildflags returns the correct flags.
1070                 and index($line, '`dpkg-buildflags --get CPPFLAGS`') == -1) {
1071             if (not $option_buildd) {
1072                 error_flags('CPPFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1073                 $exit |= $exit_code{flags_missing};
1074             } else {
1075                 $statistics{preprocess_missing}++;
1076             }
1077         }
1078         if ($link and not all_flags_used($line, \@missing, @ldflags)
1079                 # Same here, -fPIC conflicts with -fPIE.
1080                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_ldflags_pie)
1081                 # Assume dpkg-buildflags returns the correct flags.
1082                 and index($line, '`dpkg-buildflags --get LDFLAGS`') == -1) {
1083             if (not $option_buildd) {
1084                 error_flags('LDFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1085                 $exit |= $exit_code{flags_missing};
1086             } else {
1087                 $statistics{link_missing}++;
1088             }
1089         }
1090     }
1091 }
1092
1093 # Print statistics for buildd mode, only output in this mode.
1094 if ($option_buildd) {
1095     my @warning;
1096
1097     if ($statistics{preprocess_missing}) {
1098         push @warning, sprintf 'CPPFLAGS %d (of %d)',
1099                                $statistics{preprocess_missing},
1100                                $statistics{preprocess};
1101     }
1102     if ($statistics{compile_missing}) {
1103         push @warning, sprintf 'CFLAGS %d (of %d)',
1104                                $statistics{compile_missing},
1105                                $statistics{compile};
1106     }
1107     if ($statistics{compile_cpp_missing}) {
1108         push @warning, sprintf 'CXXFLAGS %d (of %d)',
1109                                $statistics{compile_cpp_missing},
1110                                $statistics{compile_cpp};
1111     }
1112     if ($statistics{link_missing}) {
1113         push @warning, sprintf 'LDFLAGS %d (of %d)',
1114                                $statistics{link_missing},
1115                                $statistics{link};
1116     }
1117     if (scalar @warning) {
1118         local $" = ', '; # array join string
1119         print "$buildd_tag{flags_missing}|@warning missing|\n";
1120     }
1121
1122     if ($statistics{commands_nonverbose}) {
1123         printf "$buildd_tag{non_verbose_build}|%d (of %d) hidden|\n",
1124                $statistics{commands_nonverbose},
1125                $statistics{commands},
1126     }
1127 }
1128
1129
1130 exit $exit;
1131
1132
1133 __END__
1134
1135 =head1 NAME
1136
1137 blhc - build log hardening check, checks build logs for missing hardening flags
1138
1139 =head1 SYNOPSIS
1140
1141 B<blhc> [I<options>] I<< <dpkg-buildpackage build log file>.. >>
1142
1143 =head1 DESCRIPTION
1144
1145 blhc is a small tool which checks build logs for missing hardening flags. It's
1146 licensed under the GPL 3 or later.
1147
1148 It's designed to check build logs generated by Debian's dpkg-buildpackage (or
1149 tools using dpkg-buildpackage like pbuilder or the official buildd build logs)
1150 to help maintainers detect missing hardening flags in their packages.
1151
1152 Only gcc is detected as compiler at the moment. If other compilers support
1153 hardening flags as well, please report them.
1154
1155 If there's no output, no flags are missing and the build log is fine.
1156
1157 =head1 OPTIONS
1158
1159 =over 8
1160
1161 =item B<--all>
1162
1163 Force check for all +all (+pie, +bindnow) hardening flags. By default it's
1164 auto detected.
1165
1166 =item B<--arch> I<architecture>
1167
1168 Set the specific architecture (e.g. amd64, armel, etc.), automatically
1169 disables hardening flags not available on this architecture. Is detected
1170 automatically if dpkg-buildpackage is used.
1171
1172 =item B<--bindnow>
1173
1174 Force check for all +bindnow hardening flags. By default it's auto detected.
1175
1176 =item B<--buildd>
1177
1178 Special mode for buildds when automatically parsing log files. The following
1179 changes are in effect:
1180
1181 =over 2
1182
1183 =item *
1184
1185 Print tags instead of normal warnings, see L</"BUILDD TAGS"> for a list of
1186 possible tags.
1187
1188 =item *
1189
1190 Don't check hardening flags in old log files (if dpkg-dev << 1.16.1 is
1191 detected).
1192
1193 =item *
1194
1195 Don't require Term::ANSIColor.
1196
1197 =item *
1198
1199 Return exit code 0, unless there was a error (-I, -W messages don't count as
1200 error).
1201
1202 =back
1203
1204 =item B<--color>
1205
1206 Use colored (ANSI) output for warning messages.
1207
1208 =item B<--ignore-arch> I<arch>
1209
1210 Ignore build logs from architectures matching I<arch>. I<arch> is a string.
1211
1212 Used to prevent false positives. This option can be specified multiple times.
1213
1214 =item B<--ignore-arch-flag> I<arch>:I<flag>
1215
1216 Like B<--ignore-flag>, but only ignore flag on I<arch>.
1217
1218 =item B<--ignore-arch-line> I<arch>:I<line>
1219
1220 Like B<--ignore-line>, but only ignore line on I<arch>.
1221
1222 =item B<--ignore-flag> I<flag>
1223
1224 Don't print an error when the specific flag is missing in a compiler line.
1225 I<flag> is a string.
1226
1227 Used to prevent false positives. This option can be specified multiple times.
1228
1229 =item B<--ignore-line> I<regex>
1230
1231 Ignore lines matching the given Perl regex. I<regex> is automatically anchored
1232 at the beginning and end of the line to prevent false negatives.
1233
1234 B<NOTE>: Not the input lines are checked, but the lines which are displayed in
1235 warnings (which have line continuation resolved).
1236
1237 Used to prevent false positives. This option can be specified multiple times.
1238
1239 =item B<--pie>
1240
1241 Force check for all +pie hardening flags. By default it's auto detected.
1242
1243 =item B<-h -? --help>
1244
1245 Print available options.
1246
1247 =item B<--version>
1248
1249 Print version number and license.
1250
1251 =back
1252
1253 Auto detection for B<--pie> and B<--bindnow> only works if at least one
1254 command uses the required hardening flag (e.g. -fPIE). Then it's required for
1255 all other commands as well.
1256
1257 =head1 EXAMPLES
1258
1259 Normal usage, parse a single log file.
1260
1261     blhc path/to/log/file
1262
1263 If there's no output, no flags are missing and the build log is fine.
1264
1265 Parse multiple log files. The exit code is ORed over all files.
1266
1267     blhc path/to/directory/with/log/files/*
1268
1269 Don't treat missing C<-g> as error:
1270
1271     blhc --ignore-flag -g path/to/log/file
1272
1273 Don't treat missing C<-pie> on kfreebsd-amd64 as error:
1274
1275     blhc --ignore-arch-flag kfreebsd-amd64:-pie path/to/log/file
1276
1277 Ignore lines consisting exactly of C<./script gcc file> which would cause a
1278 false positive.
1279
1280     blhc --ignore-line '\./script gcc file' path/to/log/file
1281
1282 Ignore lines matching C<./script gcc file> somewhere in the line.
1283
1284     blhc --ignore-line '.*\./script gcc file.*' path/to/log/file
1285
1286 Use blhc with pbuilder.
1287
1288     pbuilder path/to/package.dsc | tee path/log/file
1289     blhc path/to/file || echo flags missing
1290
1291 =head1 BUILDD TAGS
1292
1293 The following tags are used in I<--buildd> mode. In braces the additional data
1294 which is displayed.
1295
1296 =over 2
1297
1298 =item B<I-hardening-wrapper-used>
1299
1300 The package uses hardening-wrapper which intercepts calls to gcc and adds
1301 hardening flags. The build log doesn't contain any hardening flags and thus
1302 can't be checked by blhc.
1303
1304 =item B<W-compiler-flags-hidden> (summary of hidden lines)
1305
1306 Build log contains lines which hide the real compiler flags. For example:
1307
1308     CC test-a.c
1309     CC test-b.c
1310     CC test-c.c
1311     LD test
1312
1313 Most of the time either C<export V=1> or C<export verbose=1> in
1314 F<debian/rules> fixes builds with hidden compiler flags. Sometimes C<.SILENT>
1315 in a F<Makefile> must be removed. And as last resort the F<Makefile> must be
1316 patched to remove the C<@>s hiding the real compiler commands.
1317
1318 =item B<W-dpkg-buildflags-missing> (summary of missing flags)
1319
1320 CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS missing.
1321
1322 =item B<I-invalid-cmake-used> (version)
1323
1324 By default CMake ignores CPPFLAGS thus missing those hardening flags. Debian
1325 patched CMake in versions 2.8.7-1 and 2.8.7-2 to respect CPPFLAGS, but this
1326 patch was rejected by upstream and later reverted in Debian. Thus those two
1327 versions show correct usage of CPPFLAGS even if the package doesn't correctly
1328 handle them (for example by passing them to CFLAGS). To prevent false
1329 negatives just blacklist those two versions.
1330
1331 =item B<I-no-compiler-commands>
1332
1333 No compiler commands were detected. Either the log contains none or they were
1334 not correctly detected by blhc (please report the bug in this case).
1335
1336 =back
1337
1338 =head1 EXIT STATUS
1339
1340 The exit status is a "bit mask", each listed status is ORed when the error
1341 condition occurs to get the result.
1342
1343 =over 4
1344
1345 =item B<0>
1346
1347 Success.
1348
1349 =item B<1>
1350
1351 No compiler commands were found.
1352
1353 =item B<2>
1354
1355 Invalid arguments/options given to blhc.
1356
1357 =item B<4>
1358
1359 Non verbose build.
1360
1361 =item B<8>
1362
1363 Missing hardening flags.
1364
1365 =item B<16>
1366
1367 Hardening wrapper detected, no tests performed.
1368
1369 =item B<32>
1370
1371 Invalid CMake version used. See B<I-invalid-cmake-used> under L</"BUILDD
1372 TAGS"> for a detailed explanation.
1373
1374 =back
1375
1376 =head1 AUTHOR
1377
1378 Simon Ruderich, E<lt>simon@ruderich.orgE<gt>
1379
1380 Thanks to to Bernhard R. Link E<lt>brlink@debian.orgE<gt> and Jaria Alto
1381 E<lt>jari.aalto@cante.netE<gt> for their valuable input and suggestions.
1382
1383 =head1 COPYRIGHT AND LICENSE
1384
1385 Copyright (C) 2012 by Simon Ruderich
1386
1387 This program is free software: you can redistribute it and/or modify
1388 it under the terms of the GNU General Public License as published by
1389 the Free Software Foundation, either version 3 of the License, or
1390 (at your option) any later version.
1391
1392 This program is distributed in the hope that it will be useful,
1393 but WITHOUT ANY WARRANTY; without even the implied warranty of
1394 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1395 GNU General Public License for more details.
1396
1397 You should have received a copy of the GNU General Public License
1398 along with this program.  If not, see <http://www.gnu.org/licenses/>.
1399
1400 =head1 SEE ALSO
1401
1402 L<hardening-check(1)>, L<dpkg-buildflags(1)>
1403
1404 =cut