Padrões de Segurança em Perl

Diretrizes abrangentes de segurança para aplicações Perl cobrindo validação de entrada, prevenção de injeção e práticas de codificação segura.

Quando Ativar

• Ao lidar com entrada do usuário em aplicações Perl
• Ao construir aplicações web em Perl (CGI, Mojolicious, Dancer2, Catalyst)
• Ao revisar código Perl em busca de vulnerabilidades de segurança
• Ao realizar operações de arquivo com caminhos fornecidos pelo usuário
• Ao executar comandos do sistema a partir do Perl
• Ao escrever consultas de banco de dados DBI

Como Funciona

Comece com limites de entrada cientes de "taint", depois avance: valide e "des-taint" as entradas, mantenha o sistema de arquivos e a execução de processos restritos, e use consultas DBI parametrizadas em todos os lugares. Os exemplos abaixo mostram as configurações padrão seguras que esta habilidade espera que você aplique antes de enviar código Perl que toque na entrada do usuário, no shell ou na rede.

Modo Taint

O modo taint do Perl (-T) rastreia dados de fontes externas e impede que sejam usados em operações inseguras sem validação explícita.

Habilitando o Modo Taint

#!/usr/bin/perl -T
use v5.36;

# Tainted: anything from outside the program
my $input    = $ARGV[0];        # Tainted
my $env_path = $ENV{PATH};      # Tainted
my $form     = <STDIN>;         # Tainted
my $query    = $ENV{QUERY_STRING}; # Tainted

# Sanitize PATH early (required in taint mode)
$ENV{PATH} = '/usr/local/bin:/usr/bin:/bin';
delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};

Padrão de Des-tainting

use v5.36;

# Good: Validate and untaint with a specific regex
sub untaint_username($input) {
    if ($input =~ /^([a-zA-Z0-9_]{3,30})$/) {
        return $1;  # $1 is untainted
    }
    die "Invalid username: must be 3-30 alphanumeric characters\n";
}

# Good: Validate and untaint a file path
sub untaint_filename($input) {
    if ($input =~ m{^([a-zA-Z0-9._-]+)$}) {
        return $1;
    }
    die "Invalid filename: contains unsafe characters\n";
}

# Bad: Overly permissive untainting (defeats the purpose)
sub bad_untaint($input) {
    $input =~ /^(.*)$/s;
    return $1;  # Accepts ANYTHING — pointless
}

Validação de Entrada

Lista de Permissões Sobre Lista de Bloqueio

use v5.36;

# Good: Allowlist — define exactly what's permitted
sub validate_sort_field($field) {
    my %allowed = map { $_ => 1 } qw(name email created_at updated_at);
    die "Invalid sort field: $field\n" unless $allowed{$field};
    return $field;
}

# Good: Validate with specific patterns
sub validate_email($email) {
    if ($email =~ /^([a-zA-Z0-9._%+-]+\@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})$/) {
        return $1;
    }
    die "Invalid email address\n";
}

sub validate_integer($input) {
    if ($input =~ /^(-?\d{1,10})$/) {
        return $1 + 0;  # Coerce to number
    }
    die "Invalid integer\n";
}

# Bad: Blocklist — always incomplete
sub bad_validate($input) {
    die "Invalid" if $input =~ /[<>"';&|]/;  # Misses encoded attacks
    return $input;
}

Restrições de Comprimento

use v5.36;

sub validate_comment($text) {
    die "Comment is required\n"        unless length($text) > 0;
    die "Comment exceeds 10000 chars\n" if length($text) > 10_000;
    return $text;
}

Expressões Regulares Seguras

Prevenção de ReDoS

O backtracking catastrófico ocorre com quantificadores aninhados em padrões sobrepostos.

use v5.36;

# Bad: Vulnerable to ReDoS (exponential backtracking)
my $bad_re = qr/^(a+)+$/;           # Nested quantifiers
my $bad_re2 = qr/^([a-zA-Z]+)*$/;   # Nested quantifiers on class
my $bad_re3 = qr/^(.*?,){10,}$/;    # Repeated greedy/lazy combo

# Good: Rewrite without nesting
my $good_re = qr/^a+$/;             # Single quantifier
my $good_re2 = qr/^[a-zA-Z]+$/;     # Single quantifier on class

# Good: Use possessive quantifiers or atomic groups to prevent backtracking
my $safe_re = qr/^[a-zA-Z]++$/;             # Possessive (5.10+)
my $safe_re2 = qr/^(?>a+)$/;                # Atomic group

# Good: Enforce timeout on untrusted patterns
use POSIX qw(alarm);
sub safe_match($string, $pattern, $timeout = 2) {
    my $matched;
    eval {
        local $SIG{ALRM} = sub { die "Regex timeout\n" };
        alarm($timeout);
        $matched = $string =~ $pattern;
        alarm(0);
    };
    alarm(0);
    die $@ if $@;
    return $matched;
}

Operações de Arquivo Seguras

open com Três Argumentos

use v5.36;

# Bom: open com três argumentos, filehandle lexical, verifica o retorno
sub read_file($path) {
    open my $fh, '<:encoding(UTF-8)', $path
        or die "Não é possível abrir '$path': $!\n";
    local $/;

…