PERLSEC 7

中文man手册

PERLSEC

NAME
DESCRIPTION æè¿°
SEE ALSO åè§
ä¸æçç»´æ¤äºº
ä¸æçææ°æ´æ°
ä¸ææåé¡µç¿»è¯è®¡å

NAME

perlsec - Perl å®å¨

DESCRIPTION æè¿°

	•		printåsyswriteçåæ°ä¸è¢«æ£æ¥æ¯å¦è¢«æ±¡æã
	•		ç¬¦å·æ¹æ³

$obj->$method(@args);

ä»¥åç¬¦å·çåå¼ç¨

&{$foo}(@args);
$foo->(@args);

ä¾å¦ï¼

$arg = shift; # $arg æ¯æ±¡æç
$hid = $arg, ’bar’; # $hid ä¹æ¯æ±¡æç
$line = <>; # æ±¡æç
$line = <STDIN>; # ä»æ§æ¯æ±¡æç
open FOO, "/home/me/bar" or die $!;
$line = <FOO>; # è¿æ¯æ±¡æç
$path = $ENV{’PATH’}; # æ±¡æç, ä½æ¯è¯·çä¸é¢
$data = ’abc’; # éæ±¡æç

system "echo $arg"; # ä¸å®å¨ç
system "/bin/echo", $arg; # è®¤ä¸ºä¸å®å¨
# (Perl ä¸ç¥é /bin/echo)
system "echo $hid"; # ä¸å®å¨ç
system "echo $data"; # å¦æPATHè¢«è®¾å®ï¼é£ä¹ææ¯å®å¨ç

$path = $ENV{’PATH’}; # $path ç°å¨æ¯æ±¡æç

$ENV{’PATH’} = ’/bin:/usr/bin’;
delete @ENV{’IFS’, ’CDPATH’, ’ENV’, ’BASH_ENV’};

$path = $ENV{’PATH’}; # $path ç°å¨ä¸æ¯æ±¡æç
system "echo $data"; # ç°å¨æ¯å®å¨ç!

open(FOO, "< $arg"); # OK - åªè¯»æä»¶
open(FOO, "> $arg"); # Not OK - è¯å¾å»å

open(FOO,"echo $arg⎪"); # Not OK
open(FOO,"-⎪")
or exec ’echo’, $arg; # åæ · not OK

$shout = ‘echo $arg‘; # ä¸å®å¨ç, $shout ç°å¨æ¯æ±¡æç

unlink $data, $arg; # ä¸å®å¨ç
umask $arg; # ä¸å®å¨ç

exec "echo $arg"; # ä¸å®å¨ç
exec "echo", $arg; # ä¸å®å¨ç
exec "sh", ’-c’, $arg; # éå¸¸ä¸å®å¨ï¼

@files = <*.c>; # ä¸å®å¨ç (ä½¿ç¨ readdir() æå¶ä»)
@files = glob(’*.c’); # ä¸å®å¨ç (ä½¿ç¨ readdir() æå¶ä»)

# In Perl releases older than 5.6.0 the <*.c> and glob(’*.c’) would
# have used an external program to do the filename expansion; but in
# either case the result is tainted since the list of filenames comes
# from outside of the program.

$bad = ($arg, 23); # $bad will be tainted
$arg, ‘true‘; # Insecure (although it isn’t really)

å¦æä½ è¯å¾åä¸äºä¸å®å¨çäºæï¼ä½ ä¼å¾å°ç±»ä¼¼"Insecure dependency"æ"Insecure $ENV{PATH}"çè´å½éè¯¯ã

Laundering and Detecting Tainted Data æ¸æ´åæ£æµæ±¡ææ°æ®

sub is_tainted {
return ! eval { eval("#" . substr(join("", @_), 0, 0)); 1 };
}

if ($data =˜ /ˆ([-\@\w.]+)$/) {
$data = $1; # $data now untainted
} else {
die "Bad data in ’$data’"; # log this somewhere
}

Taint mode and @INC

When the taint mode ("-T") is in effect, the "." directory is removed from @INC, and the environment variables "PERL5LIB" and "PERLLIB" are ignored by Perl. You can still adjust @INC from outside the program by using the "-I" command line option as explained in perlrun. The two environment variables are ignored because they are obscured, and a user running a program could be unaware that they are set, whereas the "-I" option is clearly visible and therefore permitted.

Another way to modify @INC without modifying the program, is to use the "lib" pragma, e.g.:

perl -Mlib=/foo program

The benefit of using "-Mlib=/foo" over "-I/foo", is that the former will automagically remove any duplicated directories, while the later will not.

Cleaning Up Your Path æ¸çè·¯å¾

delete @ENV{qw(IFS CDPATH ENV BASH_ENV)}; # ä½¿ %ENV æ´å®å¨

use English ’-no_match_vars’;
die "Can’t fork: $!" unless defined($pid = open(KID, "-⎪"));
if ($pid) { # parent
while (<KID>) {
# do something
}
close KID;
} else {
my @temp = ($EUID, $EGID);
my $orig_uid = $UID;
my $orig_gid = $GID;
$EUID = $UID;
$EGID = $GID;
# Drop privileges
$UID = $orig_uid;
$GID = $orig_gid;
# Make sure privs are really gone
($EUID, $EGID) = @temp;
die "Can’t drop privileges"
unless $UID == $EUID && $GID eq $EGID;
$ENV{PATH} = "/bin:/usr/bin"; # Minimal PATH.
# Consider sanitizing the environment even more.
exec ’myprog’, ’arg1’, ’arg2’
or die "can’t exec myprog: $!";
}

Security Bugs å®å¨é®é¢

#define REAL_PATH "/path/to/script"
main(ac, av)
char **av;
{
execv(REAL_PATH, av);
}

Protecting Your Programs ä¿æ¤ä½ çç¨åº

Unicode

Unicode is a new and complex technology and one may easily overlook certain security pitfalls. See perluniintro for an overview and perlunicode for details, and "Security Implications of Unicode" in perlunicode for security implications in particular.

Algorithmic Complexity Attacks

Certain internal algorithms used in the implementation of Perl can be attacked by choosing the input carefully to consume large amounts of either time or space or both. This can lead into the so-called Denial of Service (DoS) attacks.

•

Hash Function - the algorithm used to "order" hash elements has been changed several times during the development of Perl, mainly to be reasonably fast. In Perl 5.8.1 also the security aspect was taken into account.

In Perls before 5.8.1 one could rather easily generate data that as hash keys would cause Perl to consume large amounts of time because internal structure of hashes would badly degenerate. In Perl 5.8.1 the hash function is randomly perturbed by a pseudorandom seed which makes generating such naughty hash keys harder. See " PERL_HASH_SEED " in perlrun for more information.

The random perturbation is done by default but if one wants for some reason emulate the old behaviour one can set the environment variable PERL_HASH_SEED to zero (or any other integer). One possible reason for wanting to emulate the old behaviour is that in the new behaviour consecutive runs of Perl will order hash keys differently, which may confuse some applications (like Data::Dumper: the outputs of two different runs are no more identical).

Perl has never guaranteed any ordering of the hash keys, and the ordering has already changed several times during the lifetime of Perl 5. Also, the ordering of hash keys has always been, and continues to be, affected by the insertion order.

Also note that while the order of the hash elements might be randomised, this "pseudoordering" should not be used for applications like shuffling a list randomly (use List::Util::shuffle() for that, see List::Util, a standard core module since Perl 5.8.0; or the CPAN module Algorithm::Numerical::Shuffle), or for generating permutations (use e.g. the CPAN modules Algorithm::Permute or Algorithm::FastPermute), or for any cryptographic applications.

	•		Regular expressions - Perl’s regular expression engine is so called NFA (Non-Finite Automaton), which among other things means that it can rather easily consume large amounts of both time and space if the regular expression may match in several ways. Careful crafting of the regular expressions can help but quite often there really isn’t much one can do (the book "Mastering Regular Expressions" is required reading, see perlfaq2). Running out of space manifests itself by Perl running out of memory.
	•		Sorting - the quicksort algorithm used in Perls before 5.8.0 to implement the sort() function is very easy to trick into misbehaving so that it consumes a lot of time. Nothing more is required than resorting a list already sorted. Starting from Perl 5.8.0 a different sorting algorithm, mergesort, is used. Mergesort is insensitive to its input data, so it cannot be similarly fooled.

See <http://www.cs.rice.edu/˜scrosby/hash/> for more information, and any computer science text book on the algorithmic complexity.

ä¸æçç»´æ¤äºº

nan1nan1 <nan1nan1@hotmail.com>

ä¸æçææ°æ´æ°

2001å¹´12æ23æ¥æææ¥

ä¸ææåé¡µç¿»è¯è®¡å

http://cmpp.linuxforum.net

è·

æ¬é¡µé¢ä¸æçç±ä¸æ man æåé¡µè®¡åæä¾ã
ä¸æ man æåé¡µè®¡åï¼https://github.com/man-pages-zh/manpages-zh

手册导航

man1

man2

man3

man4

man5

man6

man7

man8