]> ruderich.org/simon Gitweb - blhc/blhc.git/blob - bin/blhc
Change !~ to not =~ for consistency.
[blhc/blhc.git] / 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