segurança-perl

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

• Manipulando entrada de usuário em aplicações Perl
• Construindo aplicações web Perl (CGI, Mojolicious, Dancer2, Catalyst)
• Revisando código Perl em busca de vulnerabilidades de segurança
• Realizando operações de arquivo com caminhos fornecidos pelo usuário
• Executando comandos de sistema a partir do Perl
• Escrevendo consultas a banco de dados com DBI

Como Funciona

Comece com limites de entrada que respeitam o modo taint, depois expanda: valide e descontamine entradas, mantenha o sistema de arquivos e a execução de processos restritos, e use consultas parametrizadas do DBI em todos os lugares. Os exemplos abaixo mostram os padrões seguros que esta skill espera que você aplique antes de enviar código Perl que toque em 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;

# Contaminado: qualquer coisa vinda de fora do programa
my $input    = $ARGV[0];        # Contaminado
my $env_path = $ENV{PATH};      # Contaminado
my $form     = <STDIN>;         # Contaminado
my $query    = $ENV{QUERY_STRING}; # Contaminado

# Sanitize PATH cedo (obrigatório no modo taint)
$ENV{PATH} = '/usr/local/bin:/usr/bin:/bin';
delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};

Padrão de Descontaminação

use v5.36;

# Bom: Validar e descontaminar com uma expressão regular específica
sub descontaminar_nome_usuario($input) {
    if ($input =~ /^([a-zA-Z0-9_]{3,30})$/) {
        return $1;  # $1 está descontaminado
    }
    die "Nome de usuário inválido: deve ter de 3 a 30 caracteres alfanuméricos\n";
}

# Bom: Validar e descontaminar um caminho de arquivo
sub descontaminar_nome_arquivo($input) {
    if ($input =~ m{^([a-zA-Z0-9._-]+)$}) {
        return $1;
    }
    die "Nome de arquivo inválido: contém caracteres inseguros\n";
}

# Ruim: Descontaminação excessivamente permissiva (anula o propósito)
sub descontaminar_ruim($input) {
    $input =~ /^(.*)$/s;
    return $1;  # Aceita QUALQUER COISA — inútil
}

Validação de Entrada

Lista de Permissões em Vez de Lista de Bloqueios

use v5.36;

# Bom: Lista de permissões — define exatamente o que é permitido
sub validar_campo_ordenacao($campo) {
    my %permitidos = map { $_ => 1 } qw(nome email criado_em atualizado_em);
    die "Campo de ordenação inválido: $campo\n" a menos que $permitidos{$campo};
    return $campo;
}

# Bom: Validar com padrões específicos
sub validar_email($email) {
    if ($email =~ /^([a-zA-Z0-9._%+-]+\@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})$/) {
        return $1;
    }
    die "Endereço de email inválido\n";
}

sub validar_inteiro($input) {
    if ($input =~ /^(-?\d{1,10})$/) {
        return $1 + 0;  # Coagir a número
    }
    die "Inteiro inválido\n";
}

# Ruim: Lista de bloqueios — sempre incompleta
sub validar_ruim($input) {
    die "Inválido" if $input =~ /[<>"';&|]/;  # Perde ataques codificados
    return $input;
}

Restrições de Comprimento

use v5.36;

sub validar_comentario($texto) {
    die "Comentário é obrigatório\n"        a menos que length($texto) > 0;
    die "Comentário excede 10000 caracteres\n" if length($texto) > 10_000;
    return $texto;
}

Expressões Regulares Seguras

Prevenção de ReDoS

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

use v5.36;

# Ruim: Vulnerável a ReDoS (retrocesso exponencial)
my $re_ruim = qr/^(a+)+$/;           # Quantificadores aninhados
my $re_ruim2 = qr/^([a-zA-Z]+)*$/;   # Quantificadores aninhados em classe
my $re_ruim3 = qr/^(.*?,){10,}$/;    # Combinação repetida gananciosa/preguiçosa

# Bom: Reescrever sem aninhamento
my $re_bom = qr/^a+$/;             # Quantificador único
my $re_bom2 = qr/^[a-zA-Z]+$/;     # Quantificador único em classe

# Bom: Usar quantificadores possessivos ou grupos atômicos para evitar retrocesso
my $re_seguro = qr/^[a-zA-Z]++$/;             # Possessivo (5.10+)
my $re_seguro2 = qr/^(?>a+)$/;                # Grupo atômico

# Bom: Aplicar tempo limite em padrões não confiáveis
use POSIX qw(alarm);
sub correspondencia_segura($string, $padrao, $tempo_limite = 2) {
    my $correspondeu;
    eval {
        local $SIG{ALRM} = sub { die "Tempo limite da regex excedido\n" };
        alarm($tempo_limite);
        $correspondeu = $string =~ $padrao;
        alarm(0);
    };
    alarm(0);
    die $@ if $@;
    return $correspondeu;
}

Operações Seguras de Arquivo

Abertura com Três Argumentos

use v5.36;

# Bom: Abertura com três argumentos, filehandle lexical, verificar retorno
sub ler_arquivo($caminho) {
    open my $fh, '<:encoding(UTF-8)', $caminho
        or die "Não foi possível abrir '$caminho': $!\n";
    local $/;
    my $conteudo = <$fh>;
    close $fh;
    return $conteudo;
}

# Ruim: Abertura com dois argumentos e dados do usuário (injeção de comando)
sub ler_ruim($caminho) {
    open my $fh, $caminho;        # Se $caminho = "|rm -rf /", executa comando!
    open my $fh, "< $caminho";   # Injeção de metacaractere do shell
}

Prevenção de TOCTOU e Path Traversal

use v5.36;
use Fcntl qw(:DEFAULT :flock);
use File::Spec;
use Cwd qw(realpath);

# Criação atômica de arquivo
sub criar_arquivo_seguro($caminho) {
    sysopen(my $fh, $caminho, O_WRONLY | O_CREAT | O_EXCL, 0600)
        or die "Não foi possível criar '$caminho': $!\n";
    return $fh;
}

# Validar que o caminho permanece dentro do diretório permitido
sub caminho_seguro($diretorio_base, $caminho_usuario) {
    my $real = realpath(File::Spec->catfile($diretorio_base, $caminho_usuario))
        // die "O caminho não existe\n";
    my $base_real = realpath($diretorio_base)
        // die "O diretório base não existe\n";
    die "Path traversal bloqueado\n" a menos que $real =~ /^\Q$base_real\E(?:\/|\z)/;
    return $real;
}

Use File::Temp para arquivos temporários (tempfile(UNLINK => 1)) e flock(LOCK_EX) para evitar condições de corrida.

Execução Segura de Processos

system e exec no Formato de Lista

use v5.36;

# Bom: Formato de lista — sem interpolação do shell
sub executar_comando(@cmd) {
    system(@cmd) == 0
        or die "Comando falhou: @cmd\n";
}

executar_comando('grep', '-r', $padrao_usuario, '/var/log/app/');

# Bom: Capturar saída com segurança usando IPC::Run3
use IPC::Run3;
sub capturar_saida(@cmd) {
    my ($stdout, $stderr);
    run3(\@cmd, \undef, \$stdout, \$stderr);
    if ($?) {
        die "Comando falhou (código $?): $stderr\n";
    }
    return $stdout;
}

# Ruim: Formato de string — injeção de shell!
sub busca_ruim($padrao) {
    system("grep -r '$padrao' /var/log/app/");  # Se $padrao = "'; rm -rf / #"
}

# Ruim: Backticks com interpolação
my $saida = `ls $diretorio_usuario`;   # Risco de injeção de shell

Use também Capture::Tiny para capturar stdout/stderr de comandos externos com segurança.

Prevenção de Injeção SQL

Placeholders do DBI

use v5.36;
use DBI;

my $dbh = DBI->connect($dsn, $user, $pass, {
    RaiseError => 1,
    PrintError => 0,
    AutoCommit => 1,
});

# Bom: Consultas parametrizadas — sempre usar placeholders
sub encontrar_usuario($dbh, $email) {
    my $sth = $dbh->prepare('SELECT * FROM users WHERE email = ?');
    $sth->execute($email);
    return $sth->fetchrow_hashref;
}

sub buscar_usuarios($dbh, $nome, $status) {
    my $sth = $dbh->prepare(
        'SELECT * FROM users WHERE name LIKE ? AND status = ? ORDER BY name'
    );
    $sth->execute("%$nome%", $status);
    return $sth->fetchall_arrayref({});
}

# Ruim: Interpolação de string no SQL (vulnerabilidade SQLi!)
sub encontrar_ruim($dbh, $email) {
    my $sth = $dbh->prepare("SELECT * FROM users WHERE email = '$email'");
    # Se $email = "' OR 1=1 --", retorna todos os usuários
    $sth->execute;
    return $sth->fetchrow_hashref;
}

Listas de Permissões para Colunas Dinâmicas

use v5.36;

# Bom: Validar nomes de colunas contra uma lista de permissões
sub ordenar_por($dbh, $coluna, $direcao) {
    my %colunas_permitidas = map { $_ => 1 } qw(name email created_at);
    my %direcoes_permitidas = map { $_ => 1 } qw(ASC DESC);

    die "Coluna inválida: $coluna\n"    a menos que $colunas_permitidas{$coluna};
    die "Direção inválida: $direcao\n" a menos que $direcoes_permitidas{uc $direcao};

    my $sth = $dbh->prepare("SELECT * FROM users ORDER BY $coluna $direcao");
    $sth->execute;
    return $sth->fetchall_arrayref({});
}

# Ruim: Interpolação direta de coluna escolhida pelo usuário
sub ordenar_ruim($dbh, $coluna) {
    $dbh->prepare("SELECT * FROM users ORDER BY $coluna");  # SQLi!
}

DBIx::Class (Segurança ORM)

use v5.36;

# DBIx::Class gera consultas parametrizadas seguras
my @usuarios = $schema->resultset('User')->search({
    status => 'active',
    email  => { -like => '%@example.com' },
}, {
    order_by => { -asc => 'name' },
    rows     => 50,
});

Segurança Web

Prevenção de XSS

use v5.36;
use HTML::Entities qw(encode_entities);
use URI::Escape qw(uri_escape_utf8);

# Bom: Codificar saída para contexto HTML
sub html_seguro($entrada_usuario) {
    return encode_entities($entrada_usuario);
}

# Bom: Codificar para contexto URL
sub parametro_url_seguro($valor) {
    return uri_escape_utf8($valor);
}

# Bom: Codificar para contexto JSON
use JSON::MaybeXS qw(encode_json);
sub json_seguro($dados) {
    return encode_json($dados);  # Lida com escape
}

# Escape automático em templates (Mojolicious)
# <%= $entrada_usuario %>   — escapado automaticamente (seguro)
# <%== $html_cru %>         — saída crua (perigoso, use apenas para conteúdo confiável)

# Escape automático em templates (Template Toolkit)
# [% entrada_usuario | html %]  — codificação HTML explícita

# Ruim: Saída crua em HTML
sub html_ruim($entrada) {
    print "<div>$entrada</div>";  # XSS se $entrada contiver <script>
}

Proteção CSRF

use v5.36;
use Crypt::URandom qw(urandom);
use MIME::Base64 qw(encode_base64url);

sub gerar_token_csrf() {
    return encode_base64url(urandom(32));
}

Use comparação em tempo constante ao verificar tokens. A maioria dos frameworks web (Mojolicious, Dancer2, Catalyst) fornece proteção CSRF embutida — prefira essas soluções em vez de implementações manuais.

Segurança de Sessão e Cabeçalhos

use v5.36;

# Mojolicious sessão + cabeçalhos
$app->secrets(['segredo-longo-aleatorio-rodado-regularmente']);
$app->sessions->secure(1);          # Apenas HTTPS
$app->sessions->samesite('Lax');

$app->hook(after_dispatch => sub ($c) {
    $c->res->headers->header('X-Content-Type-Options' => 'nosniff');
    $c->res->headers->header('X-Frame-Options'        => 'DENY');
    $c->res->headers->header('Content-Security-Policy' => "default-src 'self'");
    $c->res->headers->header('Strict-Transport-Security' => 'max-age=31536000; includeSubDomains');
});

Codificação de Saída

Sempre codifique a saída para seu contexto: HTML::Entities::encode_entities() para HTML, URI::Escape::uri_escape_utf8() para URLs, JSON::MaybeXS::encode_json() para JSON.

Segurança de Módulos CPAN

• Fixar versões no cpanfile: requires 'DBI', '== 1.643';
• Preferir módulos mantidos: Verifique MetaCPAN para lançamentos recentes
• Minimizar dependências: Cada dependência é uma superfície de ataque

Ferramentas de Segurança

Políticas de Segurança do perlcritic

# .perlcriticrc — configuração focada em segurança
severity = 3
theme = security + core

# Exigir abertura com três argumentos
[InputOutput::RequireThreeArgOpen]
severity = 5

# Exigir chamadas de sistema verificadas
[InputOutput::RequireCheckedSyscalls]
functions = :builtins
severity = 4

# Proibir eval de string
[BuiltinFunctions::ProhibitStringyEval]
severity = 5

# Proibir operadores de backtick
[InputOutput::ProhibitBacktickOperators]
severity = 4

# Exigir verificação de taint em CGI
[Modules::RequireTaintChecking]
severity = 5

# Proibir abertura com dois argumentos
[InputOutput::ProhibitTwoArgOpen]
severity = 5

# Proibir filehandles como palavras soltas
[InputOutput::ProhibitBarewordFileHandles]
severity = 5

Executando perlcritic

# Verificar um arquivo
perlcritic --severity 3 --theme security lib/MyApp/Handler.pm

# Verificar o projeto inteiro
perlcritic --severity 3 --theme security lib/

# Integração CI
perlcritic --severity 4 --theme security --quiet lib/ || exit 1

Checklist Rápida de Segurança

Verificação	O Que Verificar
Modo taint	Flag -T em scripts CGI/web
Validação de entrada	Padrões de lista de permissões, limites de comprimento
Operações de arquivo	Abertura com três argumentos, verificação de path traversal
Execução de processo	system no formato de lista, sem interpolação de shell
Consultas SQL	Placeholders DBI, nunca interpolar
Saída HTML	encode_entities(), escape automático em templates
Tokens CSRF	Gerados, verificados em requisições que alteram estado
Configuração de sessão	Cookies Secure, HttpOnly, SameSite
Cabeçalhos HTTP	CSP, X-Frame-Options, HSTS
Dependências	Versões fixadas, módulos auditados
Segurança de regex	Sem quantificadores aninhados, padrões ancorados
Mensagens de erro	Nenhum stack trace ou caminho vazado para o usuário

Anti-Padrões

# 1. Abertura com dois argumentos e dados do usuário (injeção de comando)
open my $fh, $entrada_usuario;               # Vulnerabilidade CRÍTICA

# 2. system no formato de string (injeção de shell)
system("convert $arquivo_usuario output.png"); # Vulnerabilidade CRÍTICA

# 3. Interpolação de string SQL
$dbh->do("DELETE FROM users WHERE id = $id");  # SQLi

# 4. eval com entrada do usuário (injeção de código)
eval $codigo_usuario;                         # Execução remota de código

# 5. Confiar em $ENV sem sanitizar
my $caminho = $ENV{UPLOAD_DIR};             # Pode ser manipulado
system("ls $caminho");                      # Vulnerabilidade dupla

# 6. Desabilitar taint sem validação
($entrada) = $entrada =~ /(.*)/s;           # Descontaminação preguiçosa — anula o propósito

# 7. Dados crus do usuário em HTML
print "<div>Bem-vindo, $nome_usuario!</div>";  # XSS

# 8. Redirecionamentos não validados
print $cgi->redirect($url_usuario);         # Redirecionamento aberto

Lembre-se: A flexibilidade do Perl é poderosa, mas requer disciplina. Use o modo taint em código voltado para a web, valide toda entrada com listas de permissões, use placeholders DBI em todas as consultas e codifique toda saída para seu contexto. Defesa em profundidade — nunca confie em uma única camada.