lib/File/Find/taint.t

   1 #!./perl -T
   2
   3
   4 my %Expect_File = (); # what we expect for $_
   5 my %Expect_Name = (); # what we expect for $File::Find::name/fullname
   6 my %Expect_Dir  = (); # what we expect for $File::Find::dir
   7 my $symlink_exists = eval { symlink("",""); 1 };
   8 my $cwd;
   9 my $cwd_untainted;
  10
  11 use Config;
  12
  13 BEGIN {
  14     chdir 't' if -d 't';
  15     unshift @INC => '../lib';
  16
  17     for (keys %ENV) { # untaint ENV
  18         ($ENV{$_}) = $ENV{$_} =~ /(.*)/;
  19     }
  20
  21     # Remove insecure directories from PATH
  22     my @path;
  23     my $sep = $Config{path_sep};
  24     foreach my $dir (split(/\Q$sep/,$ENV{'PATH'}))
  25     {
  26         ##
  27         ## Match the directory taint tests in mg.c::Perl_magic_setenv()
  28         ##
  29         push(@path,$dir) unless (length($dir) >= 256
  30                                  or
  31                                  substr($dir,0,1) ne "/"
  32                                  or
  33                                  (stat $dir)[2] & 002);
  34     }
  35     $ENV{'PATH'} = join($sep,@path);
  36 }
  37
  38
  39 if ( $symlink_exists ) { print "1..45\n"; }
  40 else                   { print "1..27\n";  }
  41
  42 use File::Find;
  43 use File::Spec;
  44 use Cwd;
  45
  46
  47 my $NonTaintedCwd = $^O eq 'MSWin32' || $^O eq 'cygwin' || $^O eq 'os2';
  48
  49 cleanup();
  50
  51 find({wanted => sub { print "ok 1\n" if $_ eq 'commonsense.t'; },
  52       untaint => 1, untaint_pattern => qr|^(.+)$|}, File::Spec->curdir);
  53
  54 finddepth({wanted => sub { print "ok 2\n" if $_ eq 'commonsense.t'; },
  55            untaint => 1, untaint_pattern => qr|^(.+)$|},
  56            File::Spec->curdir);
  57
  58 my $case = 2;
  59 my $FastFileTests_OK = 0;
  60
  61 sub cleanup {
  62     if (-d dir_path('for_find')) {
  63         chdir(dir_path('for_find'));
  64     }
  65     if (-d dir_path('fa')) {
  66         unlink file_path('fa', 'fa_ord'),
  67                file_path('fa', 'fsl'),
  68                file_path('fa', 'faa', 'faa_ord'),
  69                file_path('fa', 'fab', 'fab_ord'),
  70                file_path('fa', 'fab', 'faba', 'faba_ord'),
  71                file_path('fb', 'fb_ord'),
  72                file_path('fb', 'fba', 'fba_ord');
  73         rmdir dir_path('fa', 'faa');
  74         rmdir dir_path('fa', 'fab', 'faba');
  75         rmdir dir_path('fa', 'fab');
  76         rmdir dir_path('fa');
  77         rmdir dir_path('fb', 'fba');
  78         rmdir dir_path('fb');
  79         chdir File::Spec->updir;
  80         rmdir dir_path('for_find');
  81     }
  82 }
  83
  84 END {
  85     cleanup();
  86 }
  87
  88 sub Check($) {
  89     $case++;
  90     if ($_[0]) { print "ok $case\n"; }
  91     else       { print "not ok $case\n"; }
  92
  93 }
  94
  95 sub CheckDie($) {
  96     $case++;
  97     if ($_[0]) { print "ok $case\n"; }
  98     else       { print "not ok $case\n"; exit 0; }
  99 }
 100
 101 sub Skip($) {
 102     $case++;
 103     print "ok $case # skipped: ",$_[0],"\n";
 104 }
 105
 106 sub touch {
 107     CheckDie( open(my $T,'>',$_[0]) );
 108 }
 109
 110 sub MkDir($$) {
 111     CheckDie( mkdir($_[0],$_[1]) );
 112 }
 113
 114 sub wanted_File_Dir {
 115     print "# \$File::Find::dir => '$File::Find::dir'\n";
 116     print "# \$_ => '$_'\n";
 117     s#\.$## if ($^O eq 'VMS' && $_ ne '.');
 118     Check( $Expect_File{$_} );
 119     if ( $FastFileTests_OK ) {
 120         delete $Expect_File{ $_}
 121           unless ( $Expect_Dir{$_} && ! -d _ );
 122     } else {
 123         delete $Expect_File{$_}
 124           unless ( $Expect_Dir{$_} && ! -d $_ );
 125     }
 126 }
 127
 128 sub wanted_File_Dir_prune {
 129     &wanted_File_Dir;
 130     $File::Find::prune=1 if  $_ eq 'faba';
 131 }
 132
 133
 134 sub simple_wanted {
 135     print "# \$File::Find::dir => '$File::Find::dir'\n";
 136     print "# \$_ => '$_'\n";
 137 }
 138
 139
 140 # Use dir_path() to specify a directory path that's expected for
 141 # $File::Find::dir (%Expect_Dir). Also use it in file operations like
 142 # chdir, rmdir etc.
 143 #
 144 # dir_path() concatenates directory names to form a _relative_
 145 # directory path, independant from the platform it's run on, although
 146 # there are limitations.  Don't try to create an absolute path,
 147 # because that may fail on operating systems that have the concept of
 148 # volume names (e.g. Mac OS). Be careful when you want to create an
 149 # updir path like ../fa (Unix) or ::fa: (Mac OS). Plain directory
 150 # names will work best. As a special case, you can pass it a "." as
 151 # first argument, to create a directory path like "./fa/dir" on
 152 # operating systems other than Mac OS (actually, Mac OS will ignore
 153 # the ".", if it's the first argument). If there's no second argument,
 154 # this function will return the empty string on Mac OS and the string
 155 # "./" otherwise.
 156
 157 sub dir_path {
 158     my $first_item = shift @_;
 159
 160     if ($first_item eq '.') {
 161         if ($^O eq 'MacOS') {
 162             return '' unless @_;
 163             # ignore first argument; return a relative path
 164             # with leading ":" and with trailing ":"
 165             return File::Spec->catdir("", @_);
 166         } else { # other OS
 167             return './' unless @_;
 168             my $path = File::Spec->catdir(@_);
 169             # add leading "./"
 170             $path = "./$path";
 171             return $path;
 172         }
 173
 174     } else { # $first_item ne '.'
 175         return $first_item unless @_; # return plain filename
 176         if ($^O eq 'MacOS') {
 177             # relative path with leading ":" and with trailing ":"
 178             return File::Spec->catdir("", $first_item, @_);
 179         } else { # other OS
 180             return File::Spec->catdir($first_item, @_);
 181         }
 182     }
 183 }
 184
 185
 186 # Use topdir() to specify a directory path that you want to pass to
 187 #find/finddepth Basically, topdir() does the same as dir_path() (see
 188 #above), except that there's no trailing ":" on Mac OS.
 189
 190 sub topdir {
 191     my $path = dir_path(@_);
 192     $path =~ s/:$// if ($^O eq 'MacOS');
 193     return $path;
 194 }
 195
 196
 197 # Use file_path() to specify a file path that's expected for $_ (%Expect_File).
 198 # Also suitable for file operations like unlink etc.
 199
 200 # file_path() concatenates directory names (if any) and a filename to
 201 # form a _relative_ file path (the last argument is assumed to be a
 202 # file). It's independant from the platform it's run on, although
 203 # there are limitations (see the warnings for dir_path() above). As a
 204 # special case, you can pass it a "." as first argument, to create a
 205 # file path like "./fa/file" on operating systems other than Mac OS
 206 # (actually, Mac OS will ignore the ".", if it's the first
 207 # argument). If there's no second argument, this function will return
 208 # the empty string on Mac OS and the string "./" otherwise.
 209
 210 sub file_path {
 211     my $first_item = shift @_;
 212
 213     if ($first_item eq '.') {
 214         if ($^O eq 'MacOS') {
 215             return '' unless @_;
 216             # ignore first argument; return a relative path
 217             # with leading ":", but without trailing ":"
 218             return File::Spec->catfile("", @_);
 219         } else { # other OS
 220             return './' unless @_;
 221             my $path = File::Spec->catfile(@_);
 222             # add leading "./"
 223             $path = "./$path";
 224             return $path;
 225         }
 226
 227     } else { # $first_item ne '.'
 228         return $first_item unless @_; # return plain filename
 229         if ($^O eq 'MacOS') {
 230             # relative path with leading ":", but without trailing ":"
 231             return File::Spec->catfile("", $first_item, @_);
 232         } else { # other OS
 233             return File::Spec->catfile($first_item, @_);
 234         }
 235     }
 236 }
 237
 238
 239 # Use file_path_name() to specify a file path that's expected for
 240 # $File::Find::Name (%Expect_Name). Note: When the no_chdir => 1
 241 # option is in effect, $_ is the same as $File::Find::Name. In that
 242 # case, also use this function to specify a file path that's expected
 243 # for $_.
 244 #
 245 # Basically, file_path_name() does the same as file_path() (see
 246 # above), except that there's always a leading ":" on Mac OS, even for
 247 # plain file/directory names.
 248
 249 sub file_path_name {
 250     my $path = file_path(@_);
 251     $path = ":$path" if (($^O eq 'MacOS') && ($path !~ /:/));
 252     return $path;
 253 }
 254
 255
 256
 257 MkDir( dir_path('for_find'), 0770 );
 258 CheckDie(chdir( dir_path('for_find')));
 259
 260 $cwd = cwd(); # save cwd
 261 ( $cwd_untainted ) = $cwd =~ m|^(.+)$|; # untaint it
 262
 263 MkDir( dir_path('fa'), 0770 );
 264 MkDir( dir_path('fb'), 0770  );
 265 touch( file_path('fb', 'fb_ord') );
 266 MkDir( dir_path('fb', 'fba'), 0770  );
 267 touch( file_path('fb', 'fba', 'fba_ord') );
 268 if ($^O eq 'MacOS') {
 269       CheckDie( symlink(':fb',':fa:fsl') ) if $symlink_exists;
 270 } else {
 271       CheckDie( symlink('../fb','fa/fsl') ) if $symlink_exists;
 272 }
 273 touch( file_path('fa', 'fa_ord') );
 274
 275 MkDir( dir_path('fa', 'faa'), 0770  );
 276 touch( file_path('fa', 'faa', 'faa_ord') );
 277 MkDir( dir_path('fa', 'fab'), 0770  );
 278 touch( file_path('fa', 'fab', 'fab_ord') );
 279 MkDir( dir_path('fa', 'fab', 'faba'), 0770  );
 280 touch( file_path('fa', 'fab', 'faba', 'faba_ord') );
 281
 282 print "# check untainting (no follow)\n";
 283
 284 # untainting here should work correctly
 285
 286 %Expect_File = (File::Spec->curdir => 1, file_path('fsl') =>
 287                 1,file_path('fa_ord') => 1, file_path('fab') => 1,
 288                 file_path('fab_ord') => 1, file_path('faba') => 1,
 289                 file_path('faa') => 1, file_path('faa_ord') => 1);
 290 delete $Expect_File{ file_path('fsl') } unless $symlink_exists;
 291 %Expect_Name = ();
 292
 293 %Expect_Dir = ( dir_path('fa') => 1, dir_path('faa') => 1,
 294                 dir_path('fab') => 1, dir_path('faba') => 1,
 295                 dir_path('fb') => 1, dir_path('fba') => 1);
 296
 297 delete @Expect_Dir{ dir_path('fb'), dir_path('fba') } unless $symlink_exists;
 298
 299 File::Find::find( {wanted => \&wanted_File_Dir_prune, untaint => 1,
 300                    untaint_pattern => qr|^(.+)$|}, topdir('fa') );
 301
 302 Check( scalar(keys %Expect_File) == 0 );
 303
 304
 305 # don't untaint at all, should die
 306 %Expect_File = ();
 307 %Expect_Name = ();
 308 %Expect_Dir  = ();
 309 undef $@;
 310 eval {File::Find::find( {wanted => \&simple_wanted}, topdir('fa') );};
 311 Check( $@ =~ m|Insecure dependency| );
 312 chdir($cwd_untainted);
 313
 314
 315 # untaint pattern doesn't match, should die
 316 undef $@;
 317
 318 eval {File::Find::find( {wanted => \&simple_wanted, untaint => 1,
 319                          untaint_pattern => qr|^(NO_MATCH)$|},
 320                          topdir('fa') );};
 321
 322 Check( $@ =~ m|is still tainted| );
 323 chdir($cwd_untainted);
 324
 325
 326 # untaint pattern doesn't match, should die when we chdir to cwd
 327 print "# check untaint_skip (No follow)\n";
 328 undef $@;
 329
 330 eval {File::Find::find( {wanted => \&simple_wanted, untaint => 1,
 331                          untaint_skip => 1, untaint_pattern =>
 332                          qr|^(NO_MATCH)$|}, topdir('fa') );};
 333
 334 print "# $@" if $@;
 335 #$^D = 8;
 336 if ($NonTaintedCwd) {
 337         Skip("$^O does not taint cwd");
 338     }
 339 else {
 340         Check( $@ =~ m|insecure cwd| );
 341 }
 342 chdir($cwd_untainted);
 343
 344
 345 if ( $symlink_exists ) {
 346     print "# --- symbolic link tests --- \n";
 347     $FastFileTests_OK= 1;
 348
 349     print "# check untainting (follow)\n";
 350
 351     # untainting here should work correctly
 352     # no_chdir is in effect, hence we use file_path_name to specify the expected paths for %Expect_File
 353
 354     %Expect_File = (file_path_name('fa') => 1,
 355                     file_path_name('fa','fa_ord') => 1,
 356                     file_path_name('fa', 'fsl') => 1,
 357                     file_path_name('fa', 'fsl', 'fb_ord') => 1,
 358                     file_path_name('fa', 'fsl', 'fba') => 1,
 359                     file_path_name('fa', 'fsl', 'fba', 'fba_ord') => 1,
 360                     file_path_name('fa', 'fab') => 1,
 361                     file_path_name('fa', 'fab', 'fab_ord') => 1,
 362                     file_path_name('fa', 'fab', 'faba') => 1,
 363                     file_path_name('fa', 'fab', 'faba', 'faba_ord') => 1,
 364                     file_path_name('fa', 'faa') => 1,
 365                     file_path_name('fa', 'faa', 'faa_ord') => 1);
 366
 367     %Expect_Name = ();
 368
 369     %Expect_Dir = (dir_path('fa') => 1,
 370                    dir_path('fa', 'faa') => 1,
 371                    dir_path('fa', 'fab') => 1,
 372                    dir_path('fa', 'fab', 'faba') => 1,
 373                    dir_path('fb') => 1,
 374                    dir_path('fb', 'fba') => 1);
 375
 376     File::Find::find( {wanted => \&wanted_File_Dir, follow_fast => 1,
 377                        no_chdir => 1, untaint => 1, untaint_pattern =>
 378                        qr|^(.+)$| }, topdir('fa') );
 379
 380     Check( scalar(keys %Expect_File) == 0 );
 381
 382
 383     # don't untaint at all, should die
 384     undef $@;
 385
 386     eval {File::Find::find( {wanted => \&simple_wanted, follow => 1},
 387                             topdir('fa') );};
 388
 389     Check( $@ =~ m|Insecure dependency| );
 390     chdir($cwd_untainted);
 391
 392     # untaint pattern doesn't match, should die
 393     undef $@;
 394
 395     eval {File::Find::find( {wanted => \&simple_wanted, follow => 1,
 396                              untaint => 1, untaint_pattern =>
 397                              qr|^(NO_MATCH)$|}, topdir('fa') );};
 398
 399     Check( $@ =~ m|is still tainted| );
 400     chdir($cwd_untainted);
 401
 402     # untaint pattern doesn't match, should die when we chdir to cwd
 403     print "# check untaint_skip (Follow)\n";
 404     undef $@;
 405
 406     eval {File::Find::find( {wanted => \&simple_wanted, untaint => 1,
 407                              untaint_skip => 1, untaint_pattern =>
 408                              qr|^(NO_MATCH)$|}, topdir('fa') );};
 409     if ($NonTaintedCwd) {
 410         Skip("$^O does not taint cwd");
 411     }
 412     else {
 413         Check( $@ =~ m|insecure cwd| );
 414     }
 415     chdir($cwd_untainted);
 416 }
 417