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)['"]?(?:\.\.\.)?$/;
 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.1
 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|arm64)$/
 977                 or $arch eq 'arm') {
 978             $harden_stack = 0;
 979         }
 980         if ($cpu =~ /^(?:ia64|hppa|avr32)$/) {
 981             $harden_relro   = 0;
 982             $harden_bindnow = 0;
 983         }
 984     }
 985
 986     # Default values.
 987     my @cflags   = @def_cflags;
 988     my @cxxflags = @def_cxxflags;
 989     my @cppflags = @def_cppflags;
 990     my @ldflags  = @def_ldflags;
 991     # Check the specified hardening options, same order as dpkg-buildflags.
 992     if ($harden_pie) {
 993         @cflags   = (@cflags,   @def_cflags_pie);
 994         @cxxflags = (@cxxflags, @def_cflags_pie);
 995         @ldflags  = (@ldflags,  @def_ldflags_pie);
 996     }
 997     if ($harden_stack) {
 998         @cflags   = (@cflags,   @def_cflags_stack);
 999         @cxxflags = (@cxxflags, @def_cflags_stack);
1000     }
1001     if ($harden_fortify) {
1002         @cflags   = (@cflags,   @def_cflags_fortify);
1003         @cxxflags = (@cxxflags, @def_cflags_fortify);
1004         @cppflags = (@cppflags, @def_cppflags_fortify);
1005     }
1006     if ($harden_format) {
1007         @cflags   = (@cflags,   @def_cflags_format);
1008         @cxxflags = (@cxxflags, @def_cflags_format);
1009     }
1010     if ($harden_relro) {
1011         @ldflags = (@ldflags, @def_ldflags_relro);
1012     }
1013     if ($harden_bindnow) {
1014         @ldflags = (@ldflags, @def_ldflags_bindnow);
1015     }
1016
1017     # Stores normal CFLAGS when @cflags_ada are temporarily used.
1018     my @cflags_backup;
1019     # Ada CFLAGS, only set if ada is used.
1020     my @cflags_ada;
1021     # Ada doesn't support format hardening flags, see #680117 for more
1022     # information. Filter them out if ada is used.
1023     if ($ada and $harden_format) {
1024         @cflags_ada = grep {
1025             my $ok = 1;
1026             foreach my $flag (@def_cflags_format) {
1027                 $ok = 0 if $_ eq $flag;
1028             }
1029             $ok;
1030         } @cflags;
1031     }
1032
1033     # Hack to fix cppflags_fortify_broken() if --ignore-flag
1034     # -D_FORTIFY_SOURCE=2 is used to ignore missing fortification. Only works
1035     # as long as @def_cppflags_fortify contains only one variable.
1036     if (scalar @def_cppflags_fortify == 0) {
1037         $harden_fortify = 0;
1038     }
1039
1040     # Ignore flags for this arch if requested.
1041     if ($arch and exists $option_ignore_arch_flag{$arch}) {
1042         my @local_flag_refs = (\@cflags, \@cxxflags, \@cppflags, \@ldflags);
1043
1044         remove_flags(\@local_flag_refs,
1045                      \%flag_renames,
1046                      @{$option_ignore_arch_flag{$arch}});
1047     }
1048
1049     my @ignore_line = @option_ignore_line;
1050     # Ignore lines for this arch if requested.
1051     if ($arch and exists $option_ignore_arch_line{$arch}) {
1052         @ignore_line = (@ignore_line, @{$option_ignore_arch_line{$arch}});
1053     }
1054
1055 LINE:
1056     for (my $i = 0; $i < scalar @input; $i++) {
1057         my $line = $input[$i];
1058
1059         # Ignore line if requested.
1060         foreach my $ignore (@ignore_line) {
1061             next LINE if $line =~ /$ignore/;
1062         }
1063
1064         my $skip = 0;
1065         if ($input_nonverbose[$i]
1066                 and is_non_verbose_build($line, $input[$i + 1], \$skip)) {
1067             if (not $option_buildd) {
1068                 error_non_verbose_build($line);
1069                 $exit |= $exit_code{non_verbose_build};
1070             } else {
1071                 $statistics{commands_nonverbose}++;
1072             }
1073             next;
1074         }
1075         # Even if it's a verbose build, we might have to skip this line (see
1076         # is_non_verbose_build()).
1077         next if $skip;
1078
1079         # Remove everything until and including the compiler command. Makes
1080         # checks easier and faster.
1081         $line =~ s/^.*?$cc_regex//o;
1082         # "([...] test.c)" is not detected as 'test.c' - fix this by removing
1083         # the brace and similar characters at the line end.
1084         $line =~ s/['")]+$//;
1085
1086         # Skip unnecessary tests when only preprocessing.
1087         my $flag_preprocess = 0;
1088
1089         my $dependency = 0;
1090         my $preprocess = 0;
1091         my $compile    = 0;
1092         my $link       = 0;
1093
1094         # Preprocess, compile, assemble.
1095         if ($line =~ /\s(-E|-S|-c)\b/) {
1096             $preprocess      = 1;
1097             $flag_preprocess = 1 if $1 eq '-E';
1098             $compile         = 1 if $1 eq '-S' or $1 eq '-c';
1099         # Dependency generation for Makefiles. The other flags (-MF -MG -MP
1100         # -MT -MQ) are always used with -M/-MM.
1101         } elsif ($line =~ /\s(?:-M|-MM)\b/) {
1102             $dependency = 1;
1103         # Otherwise assume we are linking.
1104         } else {
1105             $link = 1;
1106         }
1107
1108         # -MD/-MMD also cause dependency generation, but they don't imply -E!
1109         if ($line =~ /\s(?:-MD|-MMD)\b/) {
1110             $dependency      = 0;
1111             $flag_preprocess = 0;
1112         }
1113
1114         # Dependency generation for Makefiles, no preprocessing or other flags
1115         # needed.
1116         next if $dependency;
1117
1118         # Get all file extensions on this line.
1119         my @extensions = $line =~ /$file_extension_regex/go;
1120         # Ignore all unknown extensions to speedup the search below.
1121         @extensions = grep { exists $extension{$_} } @extensions;
1122
1123         # These file types don't require preprocessing.
1124         if (extension_found(\%extensions_no_preprocess, @extensions)) {
1125             $preprocess = 0;
1126         }
1127         # These file types require preprocessing.
1128         if (extension_found(\%extensions_preprocess, @extensions)) {
1129             $preprocess = 1;
1130         }
1131
1132         if (not $flag_preprocess) {
1133             # If there are source files then it's compiling/linking in one
1134             # step and we must check both. We only check for source files
1135             # here, because header files cause too many false positives.
1136             if (extension_found(\%extensions_compile_link, @extensions)) {
1137                 # Assembly files don't need CFLAGS.
1138                 if (not extension_found(\%extensions_compile, @extensions)
1139                         and extension_found(\%extensions_no_compile, @extensions)) {
1140                     $compile = 0;
1141                 # But the rest does.
1142                 } else {
1143                     $compile = 1;
1144                 }
1145             # No compilable extensions found, either linking or compiling
1146             # header flags.
1147             #
1148             # If there are also no object files we are just compiling headers
1149             # (.h -> .h.gch). Don't check for linker flags in this case. Due
1150             # to our liberal checks for compiler lines, this also reduces the
1151             # number of false positives considerably.
1152             } elsif ($link
1153                     and not extension_found(\%extensions_object, @extensions)) {
1154                 $link = 0;
1155             }
1156         }
1157
1158         my $compile_cpp = 0;
1159         my $compile_ada = 0;
1160         # Assume CXXFLAGS are required when a C++ file is specified in the
1161         # compiler line.
1162         if ($compile
1163                 and extension_found(\%extensions_compile_cpp, @extensions)) {
1164             $compile     = 0;
1165             $compile_cpp = 1;
1166         # Ada needs special CFLAGS, use them if only ada files are compiled.
1167         } elsif ($ada
1168                     and $compile
1169                     and array_equal(\@extensions,
1170                                     \@source_no_preprocess_compile_ada)) {
1171             $compile_ada = 1;
1172             @cflags_backup = @cflags;
1173             @cflags        = @cflags_ada;
1174         }
1175
1176         if ($option_buildd) {
1177             $statistics{preprocess}++  if $preprocess;
1178             $statistics{compile}++     if $compile;
1179             $statistics{compile_cpp}++ if $compile_cpp;
1180             $statistics{link}++        if $link;
1181         }
1182
1183         # Check if there are flags indicating a debug build. If that's true,
1184         # skip the check for -O2. This prevents fortification, but that's fine
1185         # for a debug build.
1186         if (any_flags_used($line, @def_cflags_debug)) {
1187             remove_flags([\@cflags], \%flag_renames, $def_cflags[1]);
1188         }
1189
1190         # Check hardening flags.
1191         my @missing;
1192         if ($compile and not all_flags_used($line, \@missing, @cflags)
1193                 # Libraries linked with -fPIC don't have to (and can't) be
1194                 # linked with -fPIE as well. It's no error if only PIE flags
1195                 # are missing.
1196                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1197                 # Assume dpkg-buildflags returns the correct flags.
1198                 and index($line, '`dpkg-buildflags --get CFLAGS`') == -1) {
1199             if (not $option_buildd) {
1200                 error_flags('CFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1201                 $exit |= $exit_code{flags_missing};
1202             } else {
1203                 $statistics{compile_missing}++;
1204             }
1205         } elsif ($compile_cpp and not all_flags_used($line, \@missing, @cflags)
1206                 # Libraries linked with -fPIC don't have to (and can't) be
1207                 # linked with -fPIE as well. It's no error if only PIE flags
1208                 # are missing.
1209                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
1210                 # Assume dpkg-buildflags returns the correct flags.
1211                 and index($line, '`dpkg-buildflags --get CXXFLAGS`') == -1) {
1212             if (not $option_buildd) {
1213                 error_flags('CXXFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1214                 $exit |= $exit_code{flags_missing};
1215             } else {
1216                 $statistics{compile_cpp_missing}++;
1217             }
1218         }
1219         if ($preprocess
1220                 and (not all_flags_used($line, \@missing, @cppflags)
1221                     # The fortify flag might be overwritten, detect that.
1222                      or ($harden_fortify
1223                          and cppflags_fortify_broken($line, \@missing)))
1224                 # Assume dpkg-buildflags returns the correct flags.
1225                 and index($line, '`dpkg-buildflags --get CPPFLAGS`') == -1) {
1226             if (not $option_buildd) {
1227                 error_flags('CPPFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1228                 $exit |= $exit_code{flags_missing};
1229             } else {
1230                 $statistics{preprocess_missing}++;
1231             }
1232         }
1233         if ($link and not all_flags_used($line, \@missing, @ldflags)
1234                 # Same here, -fPIC conflicts with -fPIE.
1235                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_ldflags_pie)
1236                 # Assume dpkg-buildflags returns the correct flags.
1237                 and index($line, '`dpkg-buildflags --get LDFLAGS`') == -1) {
1238             if (not $option_buildd) {
1239                 error_flags('LDFLAGS missing', \@missing, \%flag_renames, $input[$i]);
1240                 $exit |= $exit_code{flags_missing};
1241             } else {
1242                 $statistics{link_missing}++;
1243             }
1244         }
1245
1246         # Restore normal CFLAGS.
1247         if ($compile_ada) {
1248             @cflags = @cflags_backup;
1249         }
1250     }
1251 }
1252
1253 # Print statistics for buildd mode, only output in this mode.
1254 if ($option_buildd) {
1255     my @warning;
1256
1257     if ($statistics{preprocess_missing}) {
1258         push @warning, sprintf 'CPPFLAGS %d (of %d)',
1259                                $statistics{preprocess_missing},
1260                                $statistics{preprocess};
1261     }
1262     if ($statistics{compile_missing}) {
1263         push @warning, sprintf 'CFLAGS %d (of %d)',
1264                                $statistics{compile_missing},
1265                                $statistics{compile};
1266     }
1267     if ($statistics{compile_cpp_missing}) {
1268         push @warning, sprintf 'CXXFLAGS %d (of %d)',
1269                                $statistics{compile_cpp_missing},
1270                                $statistics{compile_cpp};
1271     }
1272     if ($statistics{link_missing}) {
1273         push @warning, sprintf 'LDFLAGS %d (of %d)',
1274                                $statistics{link_missing},
1275                                $statistics{link};
1276     }
1277     if (scalar @warning) {
1278         local $" = ', '; # array join string
1279         print "$buildd_tag{flags_missing}|@warning missing|\n";
1280     }
1281
1282     if ($statistics{commands_nonverbose}) {
1283         printf "$buildd_tag{non_verbose_build}|%d (of %d) hidden|\n",
1284                $statistics{commands_nonverbose},
1285                $statistics{commands},
1286     }
1287 }
1288
1289
1290 exit $exit;
1291
1292
1293 __END__
1294
1295 =head1 NAME
1296
1297 blhc - build log hardening check, checks build logs for missing hardening flags
1298
1299 =head1 SYNOPSIS
1300
1301 B<blhc> [I<options>] I<< <dpkg-buildpackage build log file>.. >>
1302
1303 =head1 DESCRIPTION
1304
1305 blhc is a small tool which checks build logs for missing hardening flags. It's
1306 licensed under the GPL 3 or later.
1307
1308 It's designed to check build logs generated by Debian's dpkg-buildpackage (or
1309 tools using dpkg-buildpackage like pbuilder or sbuild (which is used for the
1310 official buildd build logs)) to help maintainers detect missing hardening
1311 flags in their packages.
1312
1313 Only gcc is detected as compiler at the moment. If other compilers support
1314 hardening flags as well, please report them.
1315
1316 If there's no output, no flags are missing and the build log is fine.
1317
1318 See F<README> for details about performed checks, auto-detection and
1319 limitations.
1320
1321 =head1 OPTIONS
1322
1323 =over 8
1324
1325 =item B<--all>
1326
1327 Force check for all +all (+pie, +bindnow) hardening flags. By default it's
1328 auto detected.
1329
1330 =item B<--arch> I<architecture>
1331
1332 Set the specific architecture (e.g. amd64, armel, etc.), automatically
1333 disables hardening flags not available on this architecture. Is detected
1334 automatically if dpkg-buildpackage is used.
1335
1336 =item B<--bindnow>
1337
1338 Force check for all +bindnow hardening flags. By default it's auto detected.
1339
1340 =item B<--buildd>
1341
1342 Special mode for buildds when automatically parsing log files. The following
1343 changes are in effect:
1344
1345 =over 2
1346
1347 =item *
1348
1349 Print tags instead of normal warnings, see L</"BUILDD TAGS"> for a list of
1350 possible tags.
1351
1352 =item *
1353
1354 Don't check hardening flags in old log files (if dpkg-dev << 1.16.1 is
1355 detected).
1356
1357 =item *
1358
1359 Don't require Term::ANSIColor.
1360
1361 =item *
1362
1363 Return exit code 0, unless there was a error (-I, -W messages don't count as
1364 error).
1365
1366 =back
1367
1368 =item B<--color>
1369
1370 Use colored (ANSI) output for warning messages.
1371
1372 =item B<--ignore-arch> I<arch>
1373
1374 Ignore build logs from architectures matching I<arch>. I<arch> is a string.
1375
1376 Used to prevent false positives. This option can be specified multiple times.
1377
1378 =item B<--ignore-arch-flag> I<arch>:I<flag>
1379
1380 Like B<--ignore-flag>, but only ignore flag on I<arch>.
1381
1382 =item B<--ignore-arch-line> I<arch>:I<line>
1383
1384 Like B<--ignore-line>, but only ignore line on I<arch>.
1385
1386 =item B<--ignore-flag> I<flag>
1387
1388 Don't print an error when the specific flag is missing in a compiler line.
1389 I<flag> is a string.
1390
1391 Used to prevent false positives. This option can be specified multiple times.
1392
1393 =item B<--ignore-line> I<regex>
1394
1395 Ignore lines matching the given Perl regex. I<regex> is automatically anchored
1396 at the beginning and end of the line to prevent false negatives.
1397
1398 B<NOTE>: Not the input lines are checked, but the lines which are displayed in
1399 warnings (which have line continuation resolved).
1400
1401 Used to prevent false positives. This option can be specified multiple times.
1402
1403 =item B<--pie>
1404
1405 Force check for all +pie hardening flags. By default it's auto detected.
1406
1407 =item B<-h -? --help>
1408
1409 Print available options.
1410
1411 =item B<--version>
1412
1413 Print version number and license.
1414
1415 =back
1416
1417 Auto detection for B<--pie> and B<--bindnow> only works if at least one
1418 command uses the required hardening flag (e.g. -fPIE). Then it's required for
1419 all other commands as well.
1420
1421 =head1 EXAMPLES
1422
1423 Normal usage, parse a single log file.
1424
1425     blhc path/to/log/file
1426
1427 If there's no output, no flags are missing and the build log is fine.
1428
1429 Parse multiple log files. The exit code is ORed over all files.
1430
1431     blhc path/to/directory/with/log/files/*
1432
1433 Don't treat missing C<-g> as error:
1434
1435     blhc --ignore-flag -g path/to/log/file
1436
1437 Don't treat missing C<-pie> on kfreebsd-amd64 as error:
1438
1439     blhc --ignore-arch-flag kfreebsd-amd64:-pie path/to/log/file
1440
1441 Ignore lines consisting exactly of C<./script gcc file> which would cause a
1442 false positive.
1443
1444     blhc --ignore-line '\./script gcc file' path/to/log/file
1445
1446 Ignore lines matching C<./script gcc file> somewhere in the line.
1447
1448     blhc --ignore-line '.*\./script gcc file.*' path/to/log/file
1449
1450 Use blhc with pbuilder.
1451
1452     pbuilder path/to/package.dsc | tee path/log/file
1453     blhc path/to/file || echo flags missing
1454
1455 =head1 BUILDD TAGS
1456
1457 The following tags are used in I<--buildd> mode. In braces the additional data
1458 which is displayed.
1459
1460 =over 2
1461
1462 =item B<I-hardening-wrapper-used>
1463
1464 The package uses hardening-wrapper which intercepts calls to gcc and adds
1465 hardening flags. The build log doesn't contain any hardening flags and thus
1466 can't be checked by blhc.
1467
1468 =item B<W-compiler-flags-hidden> (summary of hidden lines)
1469
1470 Build log contains lines which hide the real compiler flags. For example:
1471
1472     CC test-a.c
1473     CC test-b.c
1474     CC test-c.c
1475     LD test
1476
1477 Most of the time either C<export V=1> or C<export verbose=1> in
1478 F<debian/rules> fixes builds with hidden compiler flags. Sometimes C<.SILENT>
1479 in a F<Makefile> must be removed. And as last resort the F<Makefile> must be
1480 patched to remove the C<@>s hiding the real compiler commands.
1481
1482 =item B<W-dpkg-buildflags-missing> (summary of missing flags)
1483
1484 CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS missing.
1485
1486 =item B<I-invalid-cmake-used> (version)
1487
1488 By default CMake ignores CPPFLAGS thus missing those hardening flags. Debian
1489 patched CMake in versions 2.8.7-1 and 2.8.7-2 to respect CPPFLAGS, but this
1490 patch was rejected by upstream and later reverted in Debian. Thus those two
1491 versions show correct usage of CPPFLAGS even if the package doesn't correctly
1492 handle them (for example by passing them to CFLAGS). To prevent false
1493 negatives just blacklist those two versions.
1494
1495 =item B<I-no-compiler-commands>
1496
1497 No compiler commands were detected. Either the log contains none or they were
1498 not correctly detected by blhc (please report the bug in this case).
1499
1500 =back
1501
1502 =head1 EXIT STATUS
1503
1504 The exit status is a "bit mask", each listed status is ORed when the error
1505 condition occurs to get the result.
1506
1507 =over 4
1508
1509 =item B<0>
1510
1511 Success.
1512
1513 =item B<1>
1514
1515 No compiler commands were found.
1516
1517 =item B<2>
1518
1519 Invalid arguments/options given to blhc.
1520
1521 =item B<4>
1522
1523 Non verbose build.
1524
1525 =item B<8>
1526
1527 Missing hardening flags.
1528
1529 =item B<16>
1530
1531 Hardening wrapper detected, no tests performed.
1532
1533 =item B<32>
1534
1535 Invalid CMake version used. See B<I-invalid-cmake-used> under L</"BUILDD
1536 TAGS"> for a detailed explanation.
1537
1538 =back
1539
1540 =head1 AUTHOR
1541
1542 Simon Ruderich, E<lt>simon@ruderich.orgE<gt>
1543
1544 Thanks to to Bernhard R. Link E<lt>brlink@debian.orgE<gt> and Jaria Alto
1545 E<lt>jari.aalto@cante.netE<gt> for their valuable input and suggestions.
1546
1547 =head1 LICENSE AND COPYRIGHT
1548
1549 Copyright (C) 2012-2013 by Simon Ruderich
1550
1551 This program is free software: you can redistribute it and/or modify
1552 it under the terms of the GNU General Public License as published by
1553 the Free Software Foundation, either version 3 of the License, or
1554 (at your option) any later version.
1555
1556 This program is distributed in the hope that it will be useful,
1557 but WITHOUT ANY WARRANTY; without even the implied warranty of
1558 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1559 GNU General Public License for more details.
1560
1561 You should have received a copy of the GNU General Public License
1562 along with this program.  If not, see <http://www.gnu.org/licenses/>.
1563
1564 =head1 SEE ALSO
1565
1566 L<hardening-check(1)>, L<dpkg-buildflags(1)>
1567
1568 =cut