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 ($line =~ /^checking if you want to see long compiling messages\.\.\. no/
 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 ($next_line =~ /\Q$file\E/ 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 and $line =~ /^Toolchain package versions: /) {
 543             require Dpkg::Version;
 544             if ($line !~ /\bdpkg-dev_(\S+)/
 545                     or Dpkg::Version::version_compare($1, '1.16.1') < 0) {
 546                 $harden_format  = 0;
 547                 $harden_fortify = 0;
 548                 $harden_stack   = 0;
 549                 $harden_relro   = 0;
 550                 $harden_bindnow = 0;
 551                 $harden_pie     = 0;
 552             }
 553         }
 554
 555         # The following two versions of CMake in Debian obeyed CPPFLAGS, but
 556         # this was later dropped because upstream rejected the patch. Thus
 557         # build logs with these versions will have fortify hardening flags
 558         # enabled, even though they may be not correctly set and are missing
 559         # when build with later CMake versions. Thanks to Aron Xu for letting
 560         # me know.
 561         if ($line =~ /^Package versions: /
 562                 and $line =~ /\bcmake_(\S+)/
 563                 and ($1 eq '2.8.7-1' or $1 eq '2.8.7-2')) {
 564             if (not $option_buildd) {
 565                 error_invalid_cmake($1);
 566             } else {
 567                 print "W-invalid-cmake-used $1\n";
 568             }
 569             $exit |= $exit_code{invalid_cmake};
 570         }
 571
 572         # If hardening wrapper is used (wraps calls to gcc and adds hardening
 573         # flags automatically) we can't perform any checks, abort.
 574         if ($line =~ /^Build-Depends: .*\bhardening-wrapper\b/) {
 575             if (not $option_buildd) {
 576                 error_hardening_wrapper();
 577             } else {
 578                 print "I-hardening-wrapper-used\n";
 579             }
 580             $exit |= $exit_code{hardening_wrapper};
 581             next FILE;
 582         }
 583
 584         # We skip over unimportant lines at the beginning of the log to
 585         # prevent false positives.
 586         last if $line =~ /^dpkg-buildpackage:/;
 587     }
 588
 589     # Input lines, contain only the lines with compiler commands.
 590     my @input = ();
 591
 592     my $continuation = 0;
 593     my $complete_line = undef;
 594     while (my $line = <$fh>) {
 595         # And stop at the end of the build log. Package details (reported by
 596         # the buildd logs) are not important for us. This also prevents false
 597         # positives.
 598         last if $line =~ /^Build finished at \d{8}-\d{4}$/;
 599
 600         # Detect architecture automatically unless overridden.
 601         if (not $arch
 602                 and $line =~ /^dpkg-buildpackage: host architecture (.+)$/) {
 603             $arch = $1;
 604         }
 605
 606         # Ignore compiler warnings for now.
 607         next if $line =~ /$warning_regex/o;
 608
 609         if (not $option_buildd and $line =~ /\033/) { # esc
 610             # Remove all ANSI color sequences which are sometimes used in
 611             # non-verbose builds.
 612             $line = Term::ANSIColor::colorstrip($line);
 613             # Also strip '\0xf' (delete previous character), used by Elinks'
 614             # build system.
 615             $line =~ s/\x0f//g;
 616             # And "ESC(B" which seems to be used on armhf and hurd (not sure
 617             # what it does).
 618             $line =~ s/\033\(B//g;
 619         }
 620
 621         # Check if this line indicates a non verbose build.
 622         my $non_verbose = is_non_verbose_build($line);
 623
 624         # One line may contain multiple commands (";"). Treat each one as
 625         # single line. parse_line() is slow, only use it when necessary.
 626         my @line = (not $line =~ /;/)
 627                  ? ($line)
 628                  : map {
 629                        # Ensure newline at the line end - necessary for
 630                        # correct parsing later.
 631                        $_ =~ s/\s+$//;
 632                        $_ .= "\n";
 633                    } Text::ParseWords::parse_line(';', 1, $line);
 634         foreach $line (@line) {
 635             if ($continuation) {
 636                 $continuation = 0;
 637
 638                 # Join lines, but leave the "\" in place so it's clear where
 639                 # the original line break was.
 640                 chomp $complete_line;
 641                 $complete_line .= ' ' . $line;
 642             }
 643             # Line continuation, line ends with "\".
 644             if ($line =~ /\\\s*$/) {
 645                 $continuation = 1;
 646                 # Start line continuation.
 647                 if (not defined $complete_line) {
 648                     $complete_line = $line;
 649                 }
 650                 next;
 651             }
 652
 653             # Use the complete line if a line continuation occurred.
 654             if (defined $complete_line) {
 655                 $line = $complete_line;
 656                 $complete_line = undef;
 657             }
 658
 659             # Ignore lines with no compiler commands.
 660             next if not $non_verbose
 661                     and not $line =~ /\b$cc_regex(?:\s|\\)/o;
 662             # Ignore lines with no filenames with extensions. May miss some
 663             # non-verbose builds (e.g. "gcc -o test" [sic!]), but shouldn't be
 664             # a problem as the log will most likely contain other non-verbose
 665             # commands which are detected.
 666             next if not $non_verbose
 667                     and not $line =~ /$file_extension_regex/o;
 668
 669             # Ignore false positives.
 670             #
 671             # `./configure` output.
 672             next if not $non_verbose
 673                     and $line =~ /^(?:checking|(?:C|c)onfigure:) /;
 674             next if $line =~ /^\s*(?:Host\s+)?(?:C(?:\+\+)?\s+)?
 675                                 (?:C|c)ompiler[\s.]*:?\s+
 676                                 /xo;
 677             next if $line =~ /^\s*(?:- )?(?:HOST_)?(?:CC|CXX)\s*=\s*$cc_regex_full\s*$/o;
 678
 679             # Check if additional hardening options were used. Used to ensure
 680             # they are used for the complete build.
 681             $harden_pie     = 1 if any_flags_used($line, @def_cflags_pie, @def_ldflags_pie);
 682             $harden_bindnow = 1 if any_flags_used($line, @def_ldflags_bindnow);
 683
 684             push @input, $line;
 685         }
 686     }
 687
 688     close $fh;
 689
 690     if (scalar @input == 0) {
 691         if (not $option_buildd) {
 692             print "No compiler commands!\n";
 693         } else {
 694             print "W-no-compiler-commands\n";
 695         }
 696         $exit |= $exit_code{no_compiler_commands};
 697         next FILE;
 698     }
 699
 700     if ($option_buildd) {
 701         $statistics{commands} += scalar @input;
 702     }
 703
 704     # Option or auto detected.
 705     if ($arch) {
 706         # The following was partially copied from dpkg-dev 1.16.1.2
 707         # (/usr/share/perl5/Dpkg/Vendor/Debian.pm, add_hardening_flags()),
 708         # copyright Raphaël Hertzog <hertzog@debian.org>, Kees Cook
 709         # <kees@debian.org>, Canonical, Ltd. licensed under GPL version 2 or
 710         # later. Keep it in sync.
 711
 712         require Dpkg::Arch;
 713         my ($abi, $os, $cpu) = Dpkg::Arch::debarch_to_debtriplet($arch);
 714
 715         # Disable unsupported hardening options.
 716         if ($cpu =~ /^(?:ia64|alpha|mips|mipsel|hppa)$/ or $arch eq 'arm') {
 717             $harden_stack = 0;
 718         }
 719         if ($cpu =~ /^(?:ia64|hppa|avr32)$/) {
 720             $harden_relro   = 0;
 721             $harden_bindnow = 0;
 722         }
 723     }
 724
 725     # Default values.
 726     my @cflags   = @def_cflags;
 727     my @cxxflags = @def_cxxflags;
 728     my @cppflags = @def_cppflags;
 729     my @ldflags  = @def_ldflags;
 730     # Check the specified hardening options, same order as dpkg-buildflags.
 731     if ($harden_pie) {
 732         @cflags   = (@cflags,   @def_cflags_pie);
 733         @cxxflags = (@cxxflags, @def_cflags_pie);
 734         @ldflags  = (@ldflags,  @def_ldflags_pie);
 735     }
 736     if ($harden_stack) {
 737         @cflags   = (@cflags,   @def_cflags_stack);
 738         @cxxflags = (@cxxflags, @def_cflags_stack);
 739     }
 740     if ($harden_fortify) {
 741         @cflags   = (@cflags,   @def_cflags_fortify);
 742         @cxxflags = (@cxxflags, @def_cflags_fortify);
 743         @cppflags = (@cppflags, @def_cppflags_fortify);
 744     }
 745     if ($harden_format) {
 746         @cflags   = (@cflags,   @def_cflags_format);
 747         @cxxflags = (@cxxflags, @def_cflags_format);
 748     }
 749     if ($harden_relro) {
 750         @ldflags = (@ldflags, @def_ldflags_relro);
 751     }
 752     if ($harden_bindnow) {
 753         @ldflags = (@ldflags, @def_ldflags_bindnow);
 754     }
 755
 756 LINE:
 757     for (my $i = 0; $i < scalar @input; $i++) {
 758         my $line = $input[$i];
 759
 760         # Ignore line if requested.
 761         foreach my $ignore (@option_ignore_line) {
 762             next LINE if $line =~ /$ignore/;
 763         }
 764
 765         my $skip = 0;
 766         if (is_non_verbose_build($line, $input[$i + 1], \$skip)) {
 767             if (not $option_buildd) {
 768                 error_non_verbose_build($line);
 769             } else {
 770                 $statistics{commands_nonverbose}++;
 771             }
 772             $exit |= $exit_code{non_verbose_build};
 773             next;
 774         }
 775         # Even if it's a verbose build, we might have to skip this line.
 776         next if $skip;
 777
 778         # Remove everything until and including the compiler command. Makes
 779         # checks easier and faster.
 780         $line =~ s/^.*?$cc_regex//o;
 781         # "([...] test.c)" is not detected as 'test.c' - fix this by removing
 782         # the brace and similar characters.
 783         $line =~ s/['")]+$//;
 784
 785         # Skip unnecessary tests when only preprocessing.
 786         my $flag_preprocess = 0;
 787
 788         my $dependency = 0;
 789         my $preprocess = 0;
 790         my $compile    = 0;
 791         my $link       = 0;
 792
 793         # Preprocess, compile, assemble.
 794         if ($line =~ /\s(-E|-S|-c)\b/) {
 795             $preprocess      = 1;
 796             $flag_preprocess = 1 if $1 eq '-E';
 797             $compile         = 1 if $1 eq '-S' or $1 eq '-c';
 798         # Dependency generation for Makefiles. The other flags (-MF -MG -MP
 799         # -MT -MQ) are always used with -M/-MM.
 800         } elsif ($line =~ /\s(?:-M|-MM)\b/) {
 801             $dependency = 1;
 802         # Otherwise assume we are linking.
 803         } else {
 804             $link = 1;
 805         }
 806
 807         # -MD/-MMD also cause dependency generation, but they don't imply -E!
 808         if ($line =~ /\s(?:-MD|-MMD)\b/) {
 809             $dependency      = 0;
 810             $flag_preprocess = 0;
 811         }
 812
 813         # Dependency generation for Makefiles, no preprocessing or other flags
 814         # needed.
 815         next if $dependency;
 816
 817         # Get all file extensions on this line.
 818         my @extensions = $line =~ /$file_extension_regex/go;
 819         # Ignore all unknown extensions to speedup the search below.
 820         @extensions = grep { exists $extension{$_} } @extensions;
 821
 822         # These file types don't require preprocessing.
 823         if (extension_found(\%extensions_no_preprocess, @extensions)) {
 824             $preprocess = 0;
 825         }
 826         # These file types require preprocessing.
 827         if (extension_found(\%extensions_preprocess, @extensions)) {
 828             $preprocess = 1;
 829         }
 830
 831         # If there are source files then it's compiling/linking in one step
 832         # and we must check both. We only check for source files here, because
 833         # header files cause too many false positives.
 834         if (not $flag_preprocess
 835                 and extension_found(\%extensions_compile_link, @extensions)) {
 836             # Assembly files don't need CFLAGS.
 837             if (not extension_found(\%extensions_compile, @extensions)
 838                     and extension_found(\%extensions_no_compile, @extensions)) {
 839                 $compile = 0;
 840             # But the rest does.
 841             } else {
 842                 $compile = 1;
 843             }
 844         }
 845
 846         # Assume CXXFLAGS are required when a C++ file is specified in the
 847         # compiler line.
 848         my $compile_cpp = 0;
 849         if ($compile
 850                 and extension_found(\%extensions_compile_cpp, @extensions)) {
 851             $compile     = 0;
 852             $compile_cpp = 1;
 853         }
 854
 855         if ($option_buildd) {
 856             $statistics{preprocess}++  if $preprocess;
 857             $statistics{compile}++     if $compile;
 858             $statistics{compile_cpp}++ if $compile_cpp;
 859             $statistics{link}++        if $link;
 860         }
 861
 862         # Check hardening flags.
 863         my @missing;
 864         if ($compile and not all_flags_used($line, \@missing, @cflags)
 865                 # Libraries linked with -fPIC don't have to (and can't) be
 866                 # linked with -fPIE as well. It's no error if only PIE flags
 867                 # are missing.
 868                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
 869                 # Assume dpkg-buildflags returns the correct flags.
 870                 and not $line =~ /`dpkg-buildflags --get CFLAGS`/) {
 871             if (not $option_buildd) {
 872                 error_flags('CFLAGS missing', \@missing, \%flag_renames, $input[$i]);
 873             } else {
 874                 $statistics{compile_missing}++;
 875             }
 876             $exit |= $exit_code{flags_missing};
 877         } elsif ($compile_cpp and not all_flags_used($line, \@missing, @cflags)
 878                 # Libraries linked with -fPIC don't have to (and can't) be
 879                 # linked with -fPIE as well. It's no error if only PIE flags
 880                 # are missing.
 881                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_cflags_pie)
 882                 # Assume dpkg-buildflags returns the correct flags.
 883                 and not $line =~ /`dpkg-buildflags --get CXXFLAGS`/) {
 884             if (not $option_buildd) {
 885                 error_flags('CXXFLAGS missing', \@missing, \%flag_renames, $input[$i]);
 886             } else {
 887                 $statistics{compile_cpp_missing}++;
 888             }
 889             $exit |= $exit_code{flags_missing};
 890         }
 891         if ($preprocess and not all_flags_used($line, \@missing, @cppflags)
 892                 # Assume dpkg-buildflags returns the correct flags.
 893                 and not $line =~ /`dpkg-buildflags --get CPPFLAGS`/) {
 894             if (not $option_buildd) {
 895                 error_flags('CPPFLAGS missing', \@missing, \%flag_renames, $input[$i]);
 896             } else {
 897                 $statistics{preprocess_missing}++;
 898             }
 899             $exit |= $exit_code{flags_missing};
 900         }
 901         if ($link and not all_flags_used($line, \@missing, @ldflags)
 902                 # Same here, -fPIC conflicts with -fPIE.
 903                 and not pic_pie_conflict($line, $harden_pie, \@missing, @def_ldflags_pie)
 904                 # Assume dpkg-buildflags returns the correct flags.
 905                 and not $line =~ /`dpkg-buildflags --get LDFLAGS`/) {
 906             if (not $option_buildd) {
 907                 error_flags('LDFLAGS missing', \@missing, \%flag_renames, $input[$i]);
 908             } else {
 909                 $statistics{link_missing}++;
 910             }
 911             $exit |= $exit_code{flags_missing};
 912         }
 913     }
 914 }
 915
 916 # Print statistics for buildd mode, only output in this mode.
 917 if ($option_buildd) {
 918     my @warning;
 919
 920     if ($statistics{preprocess_missing}) {
 921         push @warning, sprintf "CPPFLAGS %d (of %d)",
 922                                $statistics{preprocess_missing},
 923                                $statistics{preprocess};
 924     }
 925     if ($statistics{compile_missing}) {
 926         push @warning, sprintf "CFLAGS %d (of %d)",
 927                                $statistics{compile_missing},
 928                                $statistics{compile};
 929     }
 930     if ($statistics{compile_cpp_missing}) {
 931         push @warning, sprintf "CXXFLAGS %d (of %d)",
 932                                $statistics{compile_cpp_missing},
 933                                $statistics{compile_cpp};
 934     }
 935     if ($statistics{link_missing}) {
 936         push @warning, sprintf "LDFLAGS %d (of %d)",
 937                                $statistics{link_missing},
 938                                $statistics{link};
 939     }
 940     if (scalar @warning) {
 941         local $" = ', '; # array join string
 942         print "W-dpkg-buildflags-missing @warning missing\n";
 943     }
 944
 945     if ($statistics{commands_nonverbose}) {
 946         printf "W-compiler-flags-hidden %d (of %d) hidden\n",
 947                $statistics{commands_nonverbose},
 948                $statistics{commands},
 949     }
 950 }
 951
 952
 953 exit $exit;
 954
 955
 956 __END__
 957
 958 =head1 NAME
 959
 960 blhc - build log hardening check, checks build logs for missing hardening flags
 961
 962 =head1 SYNOPSIS
 963
 964 B<blhc> [I<options>] I<E<lt>dpkg-buildpackage build log fileE<gt>..>
 965
 966 =head1 DESCRIPTION
 967
 968 blhc is a small tool which checks build logs for missing hardening flags. It's
 969 licensed under the GPL 3 or later.
 970
 971 It's designed to check build logs generated by Debian's dpkg-buildpackage (or
 972 tools using dpkg-buildpackage like pbuilder or the official buildd build logs)
 973 to help maintainers detect missing hardening flags in their packages.
 974
 975 =head1 OPTIONS
 976
 977 =over 8
 978
 979 =item B<--all>
 980
 981 Force check for all +all (+pie, +bindnow) hardening flags. By default it's
 982 auto detected.
 983
 984 =item B<--arch> I<architecture>
 985
 986 Set the specific architecture (e.g. amd64, armel, etc.), automatically
 987 disables hardening flags not available on this architecture. Is detected
 988 automatically if dpkg-buildpackage is used.
 989
 990 =item B<--bindnow>
 991
 992 Force check for all +bindnow hardening flags. By default it's auto detected.
 993
 994 =item B<--buildd>
 995
 996 Special mode for buildds when automatically parsing log files. The following
 997 changes are in effect:
 998
 999 =over 2
1000
1001 =item
1002
1003 Print tags instead of normal warnings, see L</"BUILDD TAGS"> for a list of
1004 possible tags.
1005
1006 =item
1007
1008 Don't check hardening flags in old log files (if dpkg-dev << 1.16.1 is
1009 detected).
1010
1011 =item
1012
1013 Don't require Term::ANSIColor.
1014
1015 =back
1016
1017 =item B<--color>
1018
1019 Use colored (ANSI) output for warning messages.
1020
1021 =item B<--ignore-flag> I<flag>
1022
1023 Don't print an error when the specific flag is missing in a compiler line.
1024 I<flag> is a string.
1025
1026 Used to prevent false positives. This option can be specified multiple times.
1027
1028 =item B<--ignore-line> I<regex>
1029
1030 Ignore lines matching the given Perl regex. I<regex> is automatically anchored
1031 at the beginning and end of the line to prevent false negatives.
1032
1033 B<NOTE>: Not the input lines are checked, but the lines which are displayed in
1034 warnings (which have line continuation resolved).
1035
1036 Used to prevent false positives. This option can be specified multiple times.
1037
1038 =item B<--pie>
1039
1040 Force check for all +pie hardening flags. By default it's auto detected.
1041
1042 =item B<-h -? --help>
1043
1044 Print available options.
1045
1046 =item B<--version>
1047
1048 Print version number and license.
1049
1050 =back
1051
1052 Auto detection for B<--pie> and B<--bindnow> only works if at least one
1053 command uses the required hardening flag (e.g. -fPIE). Then it's required for
1054 all other commands as well.
1055
1056 =head1 EXAMPLES
1057
1058 Normal usage, parse a single log file.
1059
1060     blhc path/to/log/file
1061
1062 Parse multiple log files. The exit code is ORed over all files.
1063
1064     blhc path/to/directory/with/log/files/*
1065
1066 Don't treat missing C<-g> as error:
1067
1068     blhc --ignore-flag -g path/to/log/file
1069
1070 Ignore lines consisting exactly of C<./script gcc file> which would cause a
1071 false positive.
1072
1073     blhc --ignore-line '\./script gcc file' path/to/log/file
1074
1075 Ignore lines matching C<./script gcc file> somewhere in the line.
1076
1077     blhc --ignore-line '.*\./script gcc file.*' path/to/log/file
1078
1079 Use blhc with pbuilder.
1080
1081     pbuilder path/to/package.dsc | tee path/log/file
1082     blhc path/to/file || echo flags missing
1083
1084 =head1 BUILDD TAGS
1085
1086 The following tags are used in I<--buildd> mode. In braces the additional data
1087 which is displayed.
1088
1089 =over 2
1090
1091 =item
1092
1093 B<I-hardening-wrapper-used>
1094
1095 The package uses hardening-wrapper which intercepts calls to gcc and adds
1096 hardening flags. The build log doesn't contain any hardening flags and thus
1097 can't be checked by blhc.
1098
1099 =item
1100
1101 B<W-compiler-flags-hidden> (summary of hidden lines)
1102
1103 Build log contains lines which hide the real compiler flags. For example:
1104
1105     CC test-a.c
1106     CC test-b.c
1107     CC test-c.c
1108     LD test
1109
1110 Most of the time either C<export V=1> or C<export verbose=1> in
1111 F<debian/rules> fixes builds with hidden compiler flags. Sometimes C<.SILENT>
1112 in a F<Makefile> must be removed. And as last resort the F<Makefile> must be
1113 patched to remove the C<@>s hiding the real compiler commands.
1114
1115 =item
1116
1117 B<W-dpkg-buildflags-missing> (summary of missing flags)
1118
1119 CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS missing.
1120
1121 =item
1122
1123 B<W-invalid-cmake-used> (version)
1124
1125 =item
1126
1127 B<W-no-compiler-commands>
1128
1129 No compiler commands were detected. Either the log contains none or they were
1130 not correctly detected by blhc (please report the bug in this case).
1131
1132 =back
1133
1134 =head1 EXIT STATUS
1135
1136 The exit status is a "bit mask", each listed status is ORed when the error
1137 condition occurs to get the result.
1138
1139 =over 4
1140
1141 =item B<0>
1142
1143 Success.
1144
1145 =item B<1>
1146
1147 No compiler commands were found.
1148
1149 =item B<2>
1150
1151 Invalid arguments/options given to blhc.
1152
1153 =item B<4>
1154
1155 Non verbose build.
1156
1157 =item B<8>
1158
1159 Missing hardening flags.
1160
1161 =item B<16>
1162
1163 Hardening wrapper detected, no tests performed.
1164
1165 =back
1166
1167 =head1 AUTHOR
1168
1169 Simon Ruderich, E<lt>simon@ruderich.orgE<gt>
1170
1171 Thanks to to Bernhard R. Link E<lt>brlink@debian.orgE<gt> and Jaria Alto
1172 E<lt>jari.aalto@cante.netE<gt> for their valuable input and suggestions.
1173
1174 =head1 COPYRIGHT AND LICENSE
1175
1176 Copyright (C) 2012 by Simon Ruderich
1177
1178 This program is free software: you can redistribute it and/or modify
1179 it under the terms of the GNU General Public License as published by
1180 the Free Software Foundation, either version 3 of the License, or
1181 (at your option) any later version.
1182
1183 This program is distributed in the hope that it will be useful,
1184 but WITHOUT ANY WARRANTY; without even the implied warranty of
1185 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1186 GNU General Public License for more details.
1187
1188 You should have received a copy of the GNU General Public License
1189 along with this program.  If not, see <http://www.gnu.org/licenses/>.
1190
1191 =head1 SEE ALSO
1192
1193 L<hardening-check(1)>, L<dpkg-buildflags(1)>
1194
1195 =cut