bin/blhc

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