flawopen.com/Diretório/Referências

Guias de Referência de Segurança

Consulte estas referências para verificar pressupostos de segurança em frameworks, ORMs, autenticação, aplicações serverless e agentes de IA. Cada guia relaciona a explicação e a correção aos detalhes técnicos.

• Claude Code MemoryTrap: memória de agente — flawopen.com

  A divulgação MemoryTrap da Cisco: memória persistente do Claude Code, correção na v2.1.50 e controles para agentes.

• Sandbox de agentes IA: Docker, gVisor e microVMs

  Compare as fronteiras de isolamento de contêineres, gVisor e microVMs para agentes de IA.

• Escopo de ferramentas IA: privilégio mínimo

  Como reduzir a agência excessiva em agentes de IA com ferramentas específicas, autorização por usuário e privilégio mínimo.

• Bots de PR com IA: prevenção de SSRF — flawopen.com

  Como texto não confiável de pull requests pode influenciar ferramentas de IA e como limitar permissões do bot e acesso à rede.

• Riscos de segurança do addJavascriptInterface no Android

  Veja como bridges do WebView expõem métodos nativos a todos os frames, quando XSS alcança recursos do app e como isolar páginas não confiáveis.

• Proteção XSS do Angular: padrões seguros e APIs de bypass

  Angular escapa a interpolação e sanitiza bindings de HTML e URL. Saiba onde bypassSecurityTrust* desativa a proteção e como auditar sinks XSS.

• XSS por MIME sniffing: Content-Type e nosniff

  Entenda como o MIME sniffing pode transformar uploads em documentos do navegador, o que nosniff faz e como servir arquivos com segurança.

• strncpy() é mais segura que strcpy()?

  strncpy() é mais segura que strcpy() em C? É menos arriscada, mas não garante o terminador nulo. Veja por que verificar snprintf e strlcpy importa.

• CSP e escape de saída: você precisa dos dois?

  A codificação de saída previne XSS conforme o contexto; CSP limita parte do impacto se houver uma falha. Saiba como combinar as duas defesas.

• Token CSRF em GET: quando é necessário?

  GET seguro não deve alterar estado. Saiba quando proteger métodos inseguros com token CSRF e como corrigir GET legado que altera estado.

• CWE vs. CVE: qual é a diferença?

  CWE vs. CVE: qual é a diferença?: CWE é a categoria — um tipo de bug, como "SQL Injection" (CWE-89). CVE é a instância — uma ocorrência específica e documentada

• dangerouslySetInnerHTML do React é seguro?

  O React escapa texto JSX, mas dangerouslySetInnerHTML interpreta HTML. Saiba como revisar esse ponto de XSS e renderizar rich text com segurança.

• Dependency Confusion: riscos e defesas

  Entenda como a ambiguidade na origem de pacotes introduz dependências inesperadas e como políticas de registry e controles de CI reduzem o risco.

• Django ORM e SQL Injection: padrões seguros

  QuerySets do Django parametrizam valores. Veja os riscos de SQL bruto, expressões dinâmicas e como revisar consultas.

• Exposição do Socket Docker: riscos e defesas

  Expor o socket do daemon Docker pode conceder autoridade no nível do daemon. Entenda os limites, os riscos de capacidades e configurações mais seguras.

• Injeção SQL no Doctrine ORM: consultas seguras

  Vincule valores DQL/SQL com parâmetros. Saiba onde o QueryBuilder segue vulnerável e como permitir ordenação dinâmica.

• DOMPurify basta para proteger innerHTML?

  DOMPurify protege HTML rico no sink correto. Veja limites de contexto, riscos após a limpeza, Trusted Types e controles de produção.

• .NET BinaryFormatter: riscos e migração

  A Microsoft afirma que BinaryFormatter não pode ser protegido. Veja o risco, o comportamento no .NET 9 e como migrar.

• XmlReader do .NET é seguro contra XXE?

  O XmlReader rejeita DTDs por padrão. Veja a mudança no .NET Framework 4.5.2, as diferenças das APIs legadas e como proteger a análise XML.

• EF Core FromSqlRaw: SQL parametrizado seguro

  Use FromSqlRaw com parâmetros separados, não entradas concatenadas. Veja FromSqlInterpolated, versões do EF Core e SQL dinâmico seguro.

• Node.js exec() vs execFile(): diferenças e segurança

  Compare exec() e execFile() no Node.js: shell, argumentos, injeção de comandos e quando usar cada API.

• FastAPI e SQL Injection: o que o Pydantic protege

  FastAPI valida dados de entrada, mas a segurança SQL depende da consulta. Veja parâmetros do SQLAlchemy e identificadores dinâmicos seguros.

• SSRF no fetch() do Node.js: como buscar URLs com segurança

  O fetch() no servidor pode alcançar destinos escolhidos pelo usuário. Veja mapeamentos fixos, redirects, DNS e limites de saída.

• FreeMarker e Velocity SSTI: segurança de templates

  Controle a origem do template, limite objetos Java expostos e isole a renderização para reduzir o risco de SSTI em FreeMarker e Velocity.

• Injeção de scripts no GitHub Actions: entradas seguras

  Valores de contexto podem virar comandos shell quando interpolados em run. Veja como usar env, limitar permissões e proteger pull_request_target.

• GORM Raw SQL: evite injeção SQL em Go

  Use GORM Raw com parâmetros vinculados. Entenda por que valores são seguros, por que identificadores SQL exigem allowlists e como revisar consultas.

• É suficiente escapar aspas contra SQL Injection?

  Não. Consultas parametrizadas separam dados do SQL; escaping depende do banco e é frágil. Use allowlists para identificadores.

• Usar um ORM basta para prevenir SQL Injection?

  Usar um ORM basta para prevenir SQL Injection?: para a API de consulta padrão, sim. Todo ORM popular também traz uma saída para SQL bruto, e essas carregam

• XXE em Java: DocumentBuilderFactory é segura por padrão?

  Os parsers JDK limitam alguns ataques, mas não bloqueiam o acesso externo por padrão. Veja configurações seguras e diferenças entre provedores.

• ObjectInputStream Java: desserialização segura

  Dados Java não confiáveis podem acionar gadgets em readObject(). Veja filtros, formatos seguros e controles para fluxos legados.

• Java Runtime.exec() e Command Injection: o que muda?

  Runtime.exec(String) não inicia um shell, mas a entrada pode alterar argumentos. Use ProcessBuilder e valide cada valor.

• ReDoS no Node.js: regex e CVE-2026-83606

  Veja como backtracking de regex bloqueia o Node.js, o caso CVE-2026-83606 e as correções.

• O render_template_string() do Jinja2 é seguro?

  Use uma string de template literal e passe dados do usuário pelo contexto. Entenda SSTI, autoescape e a condição específica da CVE-2024-56201.

• JSON.parse() causa poluição de protótipo?

  JSON.parse() não polui protótipos. Veja como mesclagens inseguras e chaves controladas por atacantes criam o risco.

• JSON.parse() é mais seguro que eval()?

  Veja por que JSON.parse() trata entrada como dados, como eval() pode executá-la e como avaliar o callback reviver.

• JWT no localStorage vs. cookies HttpOnly: o que é mais seguro? — flawopen.com

  Comparação arquitetural entre JWT no localStorage e cookies HttpOnly SameSite: roubo de token por XSS, compensações de CSRF e arquiteturas de autenticação recomendadas.

• Knex.js é seguro contra SQL Injection?

  Knex vincula valores. Use bindings em knex.raw() e allowlists para identificadores SQL dinâmicos.

• lodash.merge() é seguro contra poluição de protótipo?

  As correções de poluição de protótipo do Lodash variam por função e versão. Confira os limites afetados e a correção atual.

• Markdown é seguro contra XSS?

  Markdown não torna o HTML seguro automaticamente. Veja quando HTML bruto passa pelo parser e como sanitizar a saída.

• Mass assignment: riscos e listas seguras de campos

  Mass assignment permite que requisições alterem campos que o usuário não deveria controlar. Veja listas permitidas e autorização.

• Segurança MCP: limites das ferramentas | FlawOpen

  Entenda os limites de confiança do MCP e como restringir ferramentas locais, permissões e consentimento para evitar exposição de dados.

• MyBatis ${} vs #{}: evitar SQL Injection

  No MyBatis, #{} vincula valores via JDBC; ${} insere texto SQL bruto. Use binding seguro e allowlist para identificadores dinâmicos.

• MySQLi vs PDO: prepared statements seguros

  MySQLi e PDO podem prevenir SQL injection com prepared statements. Compare binding de valores, drivers e padrões de consulta seguros.

• Newtonsoft.Json TypeNameHandling: configuração segura?

  Json.NET lê nomes CLR de $type. Mantenha TypeNameHandling como None para JSON não confiável; caso contrário, valide os tipos com um binder restrito.

• Next.js Server Actions CSRF: Origin e configuração segura

  Entenda a verificação de Origin do Next.js, os riscos de confiança no proxy e em allowedOrigins e como autorizar cada ação.

• Vazamento de estado serverless: isole dados por requisição

  Veja como runtimes serverless reutilizados podem expor dados antigos de usuários e como isolar identidade e estado por requisição.

• NHibernate protege contra SQL Injection?

  Parâmetros HQL do NHibernate separam valores da sintaxe. Veja os riscos de interpolação e identificadores dinâmicos.

• Risco de command injection em Node.js exec()

  Node.js exec() usa um shell. Veja quando dados não confiáveis causam command injection e como execFile() e validação mudam o fluxo.

• O que é uma consulta parametrizada?

  O que é uma consulta parametrizada?: uma consulta parametrizada é como preencher um formulário com campos rotulados em vez de escrever uma carta inteira à mão. O banco de dados rec

• Prisma $queryRaw: é seguro contra SQL Injection?

  Prisma parametriza valores em tagged templates. Veja quando consultas raw são seguras e por que identificadores SQL exigem allowlists.

• Interpolação em where() do Rails é segura?

  Interpolar dados da requisição em where() pode causar SQL Injection. Use condições hash ou parâmetros vinculados.

• Segurança de agentes IA: ferramentas e isolamento

  Proteja ferramentas de agentes de IA com autorização por usuário, aprovação de ações críticas e execução isolada. Entenda limites de sandbox e rede.

• Sequelize query() é seguro contra SQL Injection?

  Consultas raw no Sequelize exigem parâmetros separados. Entenda replacements, bind e identificadores SQL.

• SQLAlchemy text() é seguro contra SQL Injection?

  SQLAlchemy text() aceita SQL raw; vincule valores em execute(). Veja por que interpolação e identificadores dinâmicos precisam de revisão.

• SSRF e metadados de nuvem: riscos e defesas

  Veja como SSRF pode alcançar metadados de nuvem e como controles do provedor, mínimo privilégio e regras de saída reduzem riscos de credenciais.

• Svelte é seguro contra XSS por padrão?

  Svelte escapa expressões de texto comuns. Veja por que {@html} exige HTML confiável ou sanitizado e como localizar seu uso.

• O QueryBuilder do TypeORM é seguro contra SQL Injection?

  TypeORM vincula parâmetros no QueryBuilder. Saiba por que condições interpoladas, SQL raw e identificadores dinâmicos exigem revisão.

• Risco de XSS no Vue v-html

  Vue escapa texto em {{ }} por padrão, mas v-html renderiza HTML bruto. Entenda o risco de XSS, rich text seguro e como auditar arquivos .vue.

• Cosign GHSA-fx35-mq7g-6g98: bypass de bundle legado

  Como bundles antigos do Cosign contornavam a identidade keyless, quais versões corrigem o problema e como proteger a verificação no CI.

• MongoDB NoSQL Injection: filtros de consulta seguros

  Entenda como objetos JSON não validados alteram filtros MongoDB, como validar tipos e testar a correção.

• String de IDs numéricos também pode causar SQL Injection?

  Mesmo IDs numéricos podem ser explorados quando entram na consulta por formatação de strings. Entenda o risco e use parâmetros.

• Object.assign() e Prototype Pollution: o que é seguro?

  Object.assign() pode alterar o protótipo do alvo por meio de __proto__. Entenda a diferença em relação ao spread e proteja merges profundos.

• Node.js path.join() não impede Path Traversal

  path.join() normaliza caminhos, mas permite ..; resolva e verifique a contenção e avalie symlinks.

• PHP include() e caminhos controlados pelo usuário

  Quando include() expõe arquivos ou executa código, por que RFI depende da configuração e como corrigir com uma lista permitida.

• PHP == e comparações de magic hash

  No PHP 8, duas strings numéricas ainda são comparadas como números; hashes 0e podem coincidir. Valide tipos e use hash_equals() para segredos.

• PHP unserialize() e entrada não confiável

  PHP desaconselha unserialize() com dados não confiáveis. Use JSON; autentique dados serializados confiáveis antes de analisá-los.

• Correção de path traversal em Python os.path.join()

  Entenda como os.path.join() trata caminhos absolutos e ..; resolva o caminho e valide a contenção com commonpath().

• Segurança do pickle.load() em Python: riscos de dados não confiáveis

  O pickle do Python pode executar código ao carregar dados. Entenda CWE-502 e substitua entradas não confiáveis por JSON validado.

• Segurança XML XXE em Python: ElementTree, Expat e lxml

  O ElementTree do Python evita XXE? Veja riscos por versão do Expat, opções do lxml e práticas seguras para XML não confiável.

• O que é ReDoS (backtracking catastrófico)?

  Como regex ambíguas causam negação de serviço e como limitar o custo de correspondência.

• Ruby YAML.load é seguro? Versões do Psych e safe_load

  Verifique a versão do Psych, use safe_load e nunca desserialize YAML ou Marshal não confiável com APIs inseguras.

• O bloco unsafe do Rust ainda é seguro?

  Entenda os limites de unsafe no Rust, contratos de soundness e como CVE-2021-25900 expôs um bug de memória.

• SameSite=Strict substitui tokens CSRF?

  Entenda o que SameSite=Strict e Lax protegem, suas limitações entre subdomínios e quando combinar cookies com tokens CSRF.

• A verificação de consultas do sqlx em compilação evita SQL injection?

  Saiba o que a macro query! verifica, como usar parâmetros vinculados para evitar SQL injection e quando query().bind() é seguro.

• O que é injeção de template no servidor?

  Como a injeção de template no servidor funciona, por que seu impacto varia e como separar modelos de dados não confiáveis.

• Procedimentos armazenados evitam SQL injection?

  Procedimentos armazenados só evitam SQL injection quando usam parâmetros vinculados; veja como tratar SQL dinâmico e identificadores.

• Upload de SVG pode causar XSS?

  Entenda quando scripts em SVG executam e como sanitizar, rasterizar e isolar arquivos enviados por usuários.

• WKWebView: HTML não confiável é seguro?

  WKWebView exibe HTML e scripts recebidos. Saiba quando sanitizar o conteúdo e como proteger a ponte com código nativo.

• XSS refletido, armazenado e baseado em DOM: quais são as diferenças?

  Compare os caminhos de XSS refletido, armazenado e baseado em DOM e corrija cada falha no ponto de renderização.

• O que é uma vulnerabilidade Zip Slip?

  Entenda como nomes de arquivos manipulados em arquivos ZIP podem escapar do diretório de extração e como validar cada caminho com segurança.