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