#!/usr/bin/env perl# SPDX-License-Identifier: GPL-2.0-only## (c) 2017 Tobin C. Harding <me@tobin.cc>## leaking_addresses.pl: Scan the kernel for potential leaking addresses.#  - Scans dmesg output.#  - Walks directory tree and parses each file (for each directory in @DIRS).## Use --debug to output path before parsing, this is useful to find files that# cause the script to choke. ## When the system is idle it is likely that most files under /proc/PID will be# identical for various processes.  Scanning _all_ the PIDs under /proc is# unnecessary and implies that we are thoroughly scanning /proc.  This is _not_# the case because there may be ways userspace can trigger creation of /proc# files that leak addresses but were not present during a scan.  For these two# reasons we exclude all PID directories under /proc except '1/' use warnings;use strict;use POSIX;use File::Basename;use File::Spec;use Cwd 'abs_path';use Term::ANSIColor qw(:constants);use Getopt::Long qw(:config no_auto_abbrev);use Config;use bigint qw/hex/;use feature 'state'; my $P = $0; # Directories to scan.my @DIRS = ('/proc', '/sys'); # Timer for parsing each file, in seconds.my $TIMEOUT = 10; # Kernel addresses vary by architecture.  We can only auto-detect the following# architectures (using `uname -m`).  (flag --32-bit overrides auto-detection.)my @SUPPORTED_ARCHITECTURES = ('x86_64', 'ppc64', 'x86'); # Command line options.my $help = 0;my $debug = 0;my $raw = 0;my $output_raw = "";	# Write raw results to file.my $input_raw = "";	# Read raw results from file instead of scanning.my $suppress_dmesg = 0;		# Don't show dmesg in output.my $squash_by_path = 0;		# Summary report grouped by absolute path.my $squash_by_filename = 0;	# Summary report grouped by filename.my $kernel_config_file = "";	# Kernel configuration file.my $opt_32bit = 0;		# Scan 32-bit kernel.my $page_offset_32bit = 0;	# Page offset for 32-bit kernel. # Skip these absolute paths.my @skip_abs = (	'/proc/kmsg',	'/proc/device-tree',	'/proc/1/syscall',	'/sys/firmware/devicetree',	'/sys/kernel/debug/tracing/trace_pipe',	'/sys/kernel/security/apparmor/revision'); # Skip these under any subdirectory.my @skip_any = (	'pagemap',	'events',	'access',	'registers',	'snapshot_raw',	'trace_pipe_raw',	'ptmx',	'trace_pipe',	'fd',	'usbmon'); sub help{	my ($exitcode) = @_; 	print << "EOM"; Usage: $P [OPTIONS] Options: 	-o, --output-raw=<file>		Save results for future processing.	-i, --input-raw=<file>		Read results from file instead of scanning.	      --raw			Show raw results (default).	      --suppress-dmesg		Do not show dmesg results.	      --squash-by-path		Show one result per unique path.	      --squash-by-filename	Show one result per unique filename.	--kernel-config-file=<file>     Kernel configuration file (e.g /boot/config)	--32-bit			Scan 32-bit kernel.	--page-offset-32-bit=o		Page offset (for 32-bit kernel 0xABCD1234).	-d, --debug			Display debugging output.	-h, --help			Display this help and exit. Scans the running kernel for potential leaking addresses. EOM	exit($exitcode);} GetOptions(	'd|debug'		=> \$debug,	'h|help'		=> \$help,	'o|output-raw=s'        => \$output_raw,	'i|input-raw=s'         => \$input_raw,	'suppress-dmesg'        => \$suppress_dmesg,	'squash-by-path'        => \$squash_by_path,	'squash-by-filename'    => \$squash_by_filename,	'raw'                   => \$raw,	'kernel-config-file=s'	=> \$kernel_config_file,	'32-bit'		=> \$opt_32bit,	'page-offset-32-bit=o'	=> \$page_offset_32bit,) or help(1); help(0) if ($help); if ($input_raw) {	format_output($input_raw);	exit(0);} if (!$input_raw and ($squash_by_path or $squash_by_filename)) {	printf "\nSummary reporting only available with --input-raw=<file>\n";	printf "(First run scan with --output-raw=<file>.)\n";	exit(128);} if (!(is_supported_architecture() or $opt_32bit or $page_offset_32bit)) {	printf "\nScript does not support your architecture, sorry.\n";	printf "\nCurrently we support: \n\n";	foreach(@SUPPORTED_ARCHITECTURES) {		printf "\t%s\n", $_;	}	printf("\n"); 	printf("If you are running a 32-bit architecture you may use:\n");	printf("\n\t--32-bit or --page-offset-32-bit=<page offset>\n\n"); 	my $archname = `uname -m`;	printf("Machine hardware name (`uname -m`): %s\n", $archname); 	exit(129);} if ($output_raw) {	open my $fh, '>', $output_raw or die "$0: $output_raw: $!\n";	select $fh;} parse_dmesg();walk(@DIRS); exit 0; sub dprint{	printf(STDERR @_) if $debug;} sub is_supported_architecture{	return (is_x86_64() or is_ppc64() or is_ix86_32());} sub is_32bit{	# Allow --32-bit or --page-offset-32-bit to override	if ($opt_32bit or $page_offset_32bit) {		return 1;	} 	return is_ix86_32();} sub is_ix86_32{       state $arch = `uname -m`;        chomp $arch;       if ($arch =~ m/i[3456]86/) {               return 1;       }       return 0;} sub is_arch{       my ($desc) = @_;       my $arch = `uname -m`;        chomp $arch;       if ($arch eq $desc) {               return 1;       }       return 0;} sub is_x86_64{	state $is = is_arch('x86_64');	return $is;} sub is_ppc64{	state $is = is_arch('ppc64');	return $is;} # Gets config option value from kernel config file.# Returns "" on error or if config option not found.sub get_kernel_config_option{	my ($option) = @_;	my $value = "";	my $tmp_file = "";	my @config_files; 	# Allow --kernel-config-file to override.	if ($kernel_config_file ne "") {		@config_files = ($kernel_config_file);	} elsif (-R "/proc/config.gz") {		my $tmp_file = "/tmp/tmpkconf"; 		if (system("gunzip < /proc/config.gz > $tmp_file")) {			dprint("system(gunzip < /proc/config.gz) failed\n");			return "";		} else {			@config_files = ($tmp_file);		}	} else {		my $file = '/boot/config-' . `uname -r`;		chomp $file;		@config_files = ($file, '/boot/config');	} 	foreach my $file (@config_files) {		dprint("parsing config file: $file\n");		$value = option_from_file($option, $file);		if ($value ne "") {			last;		}	} 	if ($tmp_file ne "") {		system("rm -f $tmp_file");	} 	return $value;} # Parses $file and returns kernel configuration option value.sub option_from_file{	my ($option, $file) = @_;	my $str = "";	my $val = ""; 	open(my $fh, "<", $file) or return "";	while (my $line = <$fh> ) {		if ($line =~ /^$option/) {			($str, $val) = split /=/, $line;			chomp $val;			last;		}	} 	close $fh;	return $val;} sub is_false_positive{	my ($match) = @_; 	if (is_32bit()) {		return is_false_positive_32bit($match);	} 	# 64 bit false positives. 	if ($match =~ '\b(0x)?(f|F){16}\b' or	    $match =~ '\b(0x)?0{16}\b') {		return 1;	} 	if (is_x86_64() and is_in_vsyscall_memory_region($match)) {		return 1;	} 	return 0;} sub is_false_positive_32bit{       my ($match) = @_;       state $page_offset = get_page_offset();        if ($match =~ '\b(0x)?(f|F){8}\b') {               return 1;       }        if (hex($match) < $page_offset) {               return 1;       }        return 0;} # returns integer valuesub get_page_offset{       my $page_offset;       my $default_offset = 0xc0000000;        # Allow --page-offset-32bit to override.       if ($page_offset_32bit != 0) {               return $page_offset_32bit;       }        $page_offset = get_kernel_config_option('CONFIG_PAGE_OFFSET');       if (!$page_offset) {	       return $default_offset;       }       return $page_offset;} sub is_in_vsyscall_memory_region{	my ($match) = @_; 	my $hex = hex($match);	my $region_min = hex("0xffffffffff600000");	my $region_max = hex("0xffffffffff601000"); 	return ($hex >= $region_min and $hex <= $region_max);} # True if argument potentially contains a kernel address.sub may_leak_address{	my ($line) = @_;	my $address_re; 	# Signal masks.	if ($line =~ '^SigBlk:' or	    $line =~ '^SigIgn:' or	    $line =~ '^SigCgt:') {		return 0;	} 	if ($line =~ '\bKEY=[[:xdigit:]]{14} [[:xdigit:]]{16} [[:xdigit:]]{16}\b' or	    $line =~ '\b[[:xdigit:]]{14} [[:xdigit:]]{16} [[:xdigit:]]{16}\b') {		return 0;	} 	$address_re = get_address_re();	while ($line =~ /($address_re)/g) {		if (!is_false_positive($1)) {			return 1;		}	} 	return 0;} sub get_address_re{	if (is_ppc64()) {		return '\b(0x)?[89abcdef]00[[:xdigit:]]{13}\b';	} elsif (is_32bit()) {		return '\b(0x)?[[:xdigit:]]{8}\b';	} 	return get_x86_64_re();} sub get_x86_64_re{	# We handle page table levels but only if explicitly configured using	# CONFIG_PGTABLE_LEVELS.  If config file parsing fails or config option	# is not found we default to using address regular expression suitable	# for 4 page table levels.	state $ptl = get_kernel_config_option('CONFIG_PGTABLE_LEVELS'); 	if ($ptl == 5) {		return '\b(0x)?ff[[:xdigit:]]{14}\b';	}	return '\b(0x)?ffff[[:xdigit:]]{12}\b';} sub parse_dmesg{	open my $cmd, '-|', 'dmesg';	while (<$cmd>) {		if (may_leak_address($_)) {			print 'dmesg: ' . $_;		}	}	close $cmd;} # True if we should skip this path.sub skip{	my ($path) = @_; 	foreach (@skip_abs) {		return 1 if (/^$path$/);	} 	my($filename, $dirs, $suffix) = fileparse($path);	foreach (@skip_any) {		return 1 if (/^$filename$/);	} 	return 0;} sub timed_parse_file{	my ($file) = @_; 	eval {		local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n required.		alarm $TIMEOUT;		parse_file($file);		alarm 0;	}; 	if ($@) {		die unless $@ eq "alarm\n";	# Propagate unexpected errors.		printf STDERR "timed out parsing: %s\n", $file;	}} sub parse_file{	my ($file) = @_; 	if (! -R $file) {		return;	} 	if (! -T $file) {		return;	} 	open my $fh, "<", $file or return;	while ( <$fh> ) {		if (may_leak_address($_)) {			print $file . ': ' . $_;		}	}	close $fh;} # Checks if the actual path name is leaking a kernel address.sub check_path_for_leaks{	my ($path) = @_; 	if (may_leak_address($path)) {		printf("Path name may contain address: $path\n");	}} # Recursively walk directory tree.sub walk{	my @dirs = @_; 	while (my $pwd = shift @dirs) {		next if (!opendir(DIR, $pwd));		my @files = readdir(DIR);		closedir(DIR); 		foreach my $file (@files) {			next if ($file eq '.' or $file eq '..'); 			my $path = "$pwd/$file";			next if (-l $path); 			# skip /proc/PID except /proc/1			next if (($path =~ /^\/proc\/[0-9]+$/) &&				 ($path !~ /^\/proc\/1$/)); 			next if (skip($path)); 			check_path_for_leaks($path); 			if (-d $path) {				push @dirs, $path;

Lines 1–500 of 646. Load more