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