bin/blhc

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