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