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