░░░ ░░░ ▀▄
▄ ▀▀▄ ░░░ ■ ▒ ░░░
▄ ▒ ▄▄ ▒ ▄▀ ▒ ▄ ▀▄▄
▄▄ ▄ ▄█ █ ▄▀ ▄█▀▀▀ ▀▀ ▄
▀▄▀█▄▄▄▄▄▄██▀ ▀▄▀███▄▄▄ ▄▄█▄▄▄ █▄▄▄ ▄▀▄▄▀ ▄▄▄▄▄ ▀▄▀ ▒ ▄▄▄▄▀
▀▀▄▄ █▄▀▀▄ ▄▀ ▄▄ ▀▄ ▄▀▄▀▀▀▀▄ ▀▄▀▀▄██▀█ █▀▌ ▐▄ ▄█▀▀▀▀▄▄
█▀ ▄▄ ▒ ░░ █ █▀ ▄▄▀ ■▀ ▀▄ ▒ ▀▄▀▄▀ █ ▀▄ ██▄ ▓ ▄█ ▄▀▀ ██▀▄
▄ ▒ ██ ▄ ▓▓ ▒ █▄ ██ █ ██ █▄ ▀ ▀▒ ██ ▐▌██ █ ▒ ▄█ ▓ ██ ▄
▀ ▒ ▀█ ▄ ██ █ ░░ ▒ ▓▓ █▄ ██ ▓▓ █ ░█ ▄ ▄ ██ ▒ ▀▄ ▀
▀▄ ▓ ▓█ ▀▀█▀▄▄▄▄▀ ▒▒ ░░▀ ▒▒ ░ ▒▒ ░░ ▐▌ ██ █ ▒ ▀▀ ▄▄▄▄▄ ▄ ▄▀
░█▀ █ █▓ ▒ ▓ ▀▀▄ ▄▄▄▄▄▓▓▀▄█ ░▓ ▒ ▓░▐ █▓ ▓ ▌▓ ░▒░ ▄▀██ ▄▄▄▀▀ ▀█░
▄╬▄ ▓ ▓▒ █ █▓ ▀▒▄ ▀░▀▀ █▓ ▓█ █ █▓ ▓█ ▐▌ ▓▓ ▓▓█ ▄▀█▓ ▄█ ▒ ▄╬▄
, ▌█▌ , ▓ ░▀ ░ ▓█ ▀ ▀░░▄▄ ░▓ █▓ █ ▒█▐ ▌▓ █ ▌▒ █▓█ ░█ ▒ █▓ █ , ▐█▐ ,
▄ ▄ ═▌█▌═ ▄ ▄ ░░▀▀▀▀ ██ ░ █▒ ▀▄ ▀▓░░░▄▄ █░ ▓░ ▓ ▀█▐ █░▐▌ ▌█ ░░░ ▀░ ▓ ░█ ▀ ▄ ▄ ═▐█▐═ ▄ ▄
▀▀█▓▄▓█▓█▀▀ ▀▄ ▀░░░░ ▒ ▀▄▓▀▒ █ █▓▄▀▀▀░▄▀░░█ █ ░░█▀▀▓█ █ ░▓█ ▀▄▓█ ▓ ░ ▄▄ ▀▀█▓█▓▄▓█▀▀
▀▓▄% ▀ ▀▄ ▀░░▀ ▄ ▄▀ ▄▀ █▀ ▀█ ▓ ░▀▄▄ ▀ ▄▄▀ ▒▀ █▄ ▀█ █ ▓▄▀ ▀ %▄▓▀
▒ •▀▒ ▀▄ ▄▄▀ ▒ ▄▀ ▀▄ ▓ ▄▀ ▀ ▄▄ ▀ ▄▀ ■▄ ░ ▀ ▒▀• ▒
▄▀▀▀▀▄▄▄█▄▄▒ ■ ░ ▒ ▀█ ■ ▄▀ ▀▄░ ▒▄▄█▄▄▄▀▀▀▀▄
░ ░ •▀ ▀ ▄▄▀ ▒ ▀ ▀• ░ ░
█ ▒▄▀ [ Arte por L.Ayres ] ▀▄▒ █
█ ▒ ▒ █
█ █ █ █
█ ▒ _____ _____ _ ____ _ ▒ █
█▒▒ / ____| / ____| | | / __ \| | ▒▒█
█ ▒ | (___ _ _ _ __ | | ___ __| | ___| | | | | ▒ █
█ █ \___ \| | | | '_ \| | / _ \ / _` |/ _ \ | | | | █ █
█ ▒ ____) | |_| | | | | |___| (_) | (_| | __/ |__| | |____ ▒ █
█▒▒ |_____/ \__,_|_| |_|\_____\___/ \__,_|\___|\___\_\______| ▒▒█
█ ▒ ▒ █
█ █ █ █
█ ▒ ▒ █
█▒▒ Resolvendo a Complexidade do Frontend com Análise Estática de Código (SAST) ▒▒█
█ ▒ ▒ █
█ █ https://github.com/sunsecrn/SunCodeQL █ █
█▒▒ ¡ ▒▒█
█ ▒,█▄ Introdução by hackaponey ▒ █
█ █▀▀° ========== █ █
█▒▒ ▒▒█
█ ▒ A jornada da Sunsec no campo da segurança de aplicações começou com uma base ▒ █
█ █ sólida e fundamental: o estudo de patches de vulnerabilidades conhecidas (CVEs) █ █
█ ▒ e o aprimoramento contínuo dos processos de code review. Este período inicial, ▒ █
█▒▒ marcado por revisões manuais exaustivas, a frustração com bugs reincidentes e ▒▒█
█ ▒ incontáveis noites de trabalho nos mostrou uma necessidade urgente: a de ▒ █
█ █ melhorar a análise reativa e incorporar a automação com ferramentas que já nós █ █
█ ▒ ajudava em outros cenários. Foi nesse contexto que M4Z4R0P3, um dos membros da ▒ █
█▒▒ equipe, mergulhou no CodeQL. A motivação não era apenas acelerar a detecção de ▒▒█
█ ▒ falhas, mas sim obter uma compreensão profunda e estruturada do gap existente ▒ █
█ █ entre a aplicação de um patch de segurança e a raiz de um código vulnerável. O █ █
█ ▒ objetivo central passou a ser visualizar o ciclo de vida do bug, rastrear a ▒ █
█▒▒ causa raiz com precisão e, fundamentalmente, transformar o processo de code ¡ ▒▒█
█ ▒ review em uma atividade visível, rápida, interativa e, acima de tudo, escalável. ▄█,▒ █
█ █ Desta visão e da união entre a expertise em segurança e a automação, nasceu a °▀▀█ █
█▒▒ SunCodeQL: uma extensão de navegador para análises de javascript no front end. ▒▒█
█ ▒ Sua função é ser uma ponte direta entre o frontend executado pelo usuário e o ▒ █
█ █ motor de análise do CodeQL, montando um repositório de código "on-the-fly" que █ █
█ ▒ contém apenas os recursos (JavaScript, CSS, Source Maps) que o navegador carrega ▒ █
█▒▒ no momento da navegação. ▒▒█
█ ▒ ▒ █
█ █ Por que a Metodologia Padrão Falhou █ █
█ ▒ =================================== ▒ █
█▒▒ ▒▒█
█ ▒ A identificação de parâmetros ocultos e vetores de ataque em aplicações web é um ▒ █
█ █ componente vital em atividades de Bug Bounty e Pentests, especialmente na busca █ █
█ ▒ por vulnerabilidades críticas de Cross-Site Scripting (XSS). No entanto, a ▒ █
█▒▒ ¡ aderência à metodologia padrão, historicamente centrada em fuzzing e scraping de ▒▒█
█ ▒,█▄ ativos, revelou-se insustentável diante da complexidade do desenvolvimento ▒ █
█ █▀▀° frontend atual. Os métodos iniciais focavam em extrair todo o código JavaScript █ █
█▒▒ de uma página e aplicar Expressões Regulares (Regex) para tentar capturar ▒▒█
█ ▒ strings que pudessem representar parâmetros de entrada de dados. ▒ █
█ █ █ █
█ ▒ - O Problema do Ruído: Esta abordagem gerava um volume proibitivo de falsos ▒ █
█▒▒ positivos. O esforço de filtragem e validação consumia tempo valioso. ▒▒█
█ ▒ - O Custo da Validação: A tentativa de validar esses achados utilizava ▒ █
█ █ ferramentas como o Chromedp (Go) para renderizar as páginas em um ambiente de █ █
█ ▒ browser real, injetando canary tokens (e.g., ?search=sun0sun#search=sun1sun) ▒ █
█▒▒ para rastrear o fluxo do dado. ▒▒█
█ ▒ - O Gargalo de Performance: A renderização programática de browsers é custosa em ▒ █
█ █ recursos e tempo. Adicionalmente, devido aos limites de tamanho de URL, era █ █
█ ▒ imperativo fragmentar os testes em múltiplos chunks, tipicamente de 8KB, ▒ █
█▒▒ diluindo significativamente o retorno sobre o investimento do nosso tempo ¡ ▒▒█
█ ▒ dedicado. ▄█,▒ █
█ █ °▀▀█ █
█▒▒ A Dificuldade da Análise de DOM Externa ▒▒█
█ ▒ --------------------------------------- ▒ █
█ █ █ █
█ ▒ Outras tentativas focaram na análise de objetos do Modelo de Objeto do Documento ▒ █
█▒▒ (DOM), como URLSearchParams ou location.href, na esperança de identificar fontes ▒▒█
█ ▒ de entrada. ▒ █
█ █ █ █
█ ▒ - A Falta de Padronização: Desenvolvedores frequentemente implementam lógicas ▒ █
█▒▒ personalizadas de manipulação de string (como split('&')) ou acessam ▒▒█
█ ▒ propriedades de objetos de configuração internos (e.g., config.search) que ▒ █
█ █ escapam totalmente da detecção via regex simples e de denylists de parâmetros █ █
█ ▒ conhecidos. ▒ █
█▒▒ ¡ - A Barreira do Rastreamento Externo: Ferramentas convencionais de scraping ▒▒█
█ ▒,█▄ (como gau) falhavam em cenários cruciais, como páginas protegidas por ▒ █
█ █▀▀° autenticação, CAPTCHAs ou que demandam interação específica do usuário para █ █
█▒▒ carregar o código relevante. ▒▒█
█ ▒ ▒ █
█ █ O Ecossistema Hostil: Bundles, Dependências e Minificação █ █
█ ▒ ========================================================= ▒ █
█▒▒ ▒▒█
█ ▒ Aplicações JavaScript atuais são construídas como vastos labirintos. Ferramentas ▒ █
█ █ de build (como Webpack, Vite e Rollup) têm a função de fundir centenas de █ █
█ ▒ arquivos e milhares de dependências de terceiros em artefatos monolíticos, ▒ █
█▒▒ conhecidos como bundles. ▒▒█
█ ▒ ▒ █
█ █ - Ocultação de Lógica: Uma falha de segurança crucial pode estar aninhada na █ █
█ ▒ linha 4.000 de uma biblioteca de terceiros obscura que foi empacotada ▒ █
█▒▒ automaticamente. A origem do código se torna irrelevante no arquivo final. ¡ ▒▒█
█ ▒ - Perda Crítica de Contexto: Ao analisar o bundle, o auditor perde a capacidade ▄█,▒ █
█ █ de discernir onde termina o código proprietário da aplicação e onde começa o °▀▀█ █
█▒▒ código de uma dependência externa. ▒▒█
█ ▒ ▒ █
█ █ O Pesadelo da Minificação: Destruição do Contexto Semântico █ █
█ ▒ ----------------------------------------------------------- ▒ █
█▒▒ ▒▒█
█ ▒ O desafio com a minificação, um processo de otimização que visa reduzir o ▒ █
█ █ tamanho do arquivo final. Variáveis descritivas como userPassword são █ █
█ ▒ substituídas por identificadores curtos e sem sentido como a ou x, espaços em ▒ █
█▒▒ branco são eliminados e funções são compactadas em linhas de código únicas. ▒▒█
█ ▒ ▒ █
█ █ - Contraste Semântico: No código manual do desenvolvedor, a leitura é trivial: █ █
█ ▒ const url = new URL(window.location). No bundle minificado, a clareza é ▒ █
█▒▒ ¡ removida: var u=new URL(w.location). ▒▒█
█ ▒,█▄ - A Cegueira da Análisa: A análise puramente baseada em texto ou regex é ▒ █
█ █▀▀° ineficaz neste ambiente, pois o contexto semântico e visual, essencial para o █ █
█▒▒ entendimento humano, foi completamente removido. Tentar rastrear o fluxo de ▒▒█
█ ▒ execução em um arquivo de 5MB contido em uma única linha é uma tarefa ▒ █
█ █ humanamente inviável. █ █
█ ▒ ▒ █
█▒▒ A Virada de Chave: CodeQL e Taint Analysis ▒▒█
█ ▒ ========================================== ▒ █
█ █ █ █
█ ▒ A introdução ao CodeQL representou uma revolução na perspectiva de auditoria. ▒ █
█▒▒ Embora a curva de aprendizado seja íngreme e a documentação para execução local ▒▒█
█ ▒ no client-side não existente, o potencial da ferramenta se mostrou muito bom. ▒ █
█ █ █ █
█ ▒ Por que o CodeQL Ignora a Minificação? ▒ █
█▒▒ ¡ ▒▒█
█ ▒ Ao contrário de um ser humano ou de ferramentas baseadas em grep que leem ▄█,▒ █
█ █ strings literais, o CodeQL opera em um nível muito mais profundo: °▀▀█ █
█▒▒ ▒▒█
█ ▒ - Árvore de Sintaxe Abstrata (AST): Ele interpreta a estrutura lógica do código, ▒ █
█ █ não seus nomes de variáveis. █ █
█ ▒ - Fluxo de Dados (Data Flow): Ele rastreia o movimento de dados através da ▒ █
█▒▒ aplicação. ▒▒█
█ ▒ ▒ █
█ █ Essencialmente, o CodeQL não precisa dos nomes originais. Mesmo que a variável █ █
█ ▒ searchParam tenha sido minificada para x, o CodeQL é capaz de identificar que x ▒ █
█▒▒ se originou de uma fonte (source) confiável ou perigosa (e.g., location.search) ▒▒█
█ ▒ e foi utilizada em um recetor (sink) de alto risco (e.g., element.innerHTML). ▒ █
█ █ █ █
█ ▒ O Poder do Rastreamento Step-by-Step: O CodeQL permite guiar a análise através ▒ █
█▒▒ ¡ de steps interligados, mesmo que o código seja minificado. Embora a visualização ▒▒█
█ ▒,█▄ das funções minificadas permaneça complexa, o auxílio de IA e a expertise humana ▒ █
█ █▀▀° para inferir a intenção da função tornam possível auditar fluxos de dados que █ █
█▒▒ antes eram fechados. ▒▒█
█ ▒ ▒ █
█ █ A Solução Definitiva: SunCodeQL █ █
█ ▒ =============================== ▒ █
█▒▒ ▒▒█
█ ▒ A SunCodeQL foi projetada para resolver o problema de segurança frontend no seu ▒ █
█ █ ponto de maior relevância: o contexto real da aplicação, muitas vezes com o █ █
█ ▒ usuário devidamente autenticado e logado. O processo é robusto e totalmente ▒ █
█▒▒ autocontido, garantindo privacidade e velocidade: ▒▒█
█ ▒ ▒ █
█ █ - Interceptação Inteligente: A extensão de navegador atua como um proxy local, █ █
█ ▒ capturando em tempo real todos os assets do frontend (JS, CSS, e os cruciais ▒ █
█▒▒ Source Maps) enquanto o analista navega pela aplicação. ¡ ▒▒█
█ ▒ - Containerização Segura: Os arquivos capturados são enviados de forma segura, ▄█,▒ █
█ █ via uma API interna e WebSocket, para um container Docker local. °▀▀█ █
█▒▒ - Reconstrução do Repositório (On-the-Fly): Dentro do container, é montada uma ▒▒█
█ ▒ estrutura de diretório que simula um repositório de código tradicional. Este ▒ █
█ █ ambiente é pré-configurado com o necessário Node.js e o ambiente CodeQL pronto █ █
█ ▒ para a execução. ▒ █
█▒▒ - Análise Estratégica: O CodeQL executa queries otimizadas especificamente para ▒▒█
█ ▒ a linguagem JavaScript, focadas na detecção de falhas críticas como XSS, ▒ █
█ █ Injections (ex: Template Injection) e Deserialização Insegura. █ █
█ ▒ ▒ █
█▒▒ Visualização e SARIF: Transformando Dados Brutos em Insight Acionável ▒▒█
█ ▒ --------------------------------------------------------------------- ▒ █
█ █ █ █
█ ▒ O CodeQL gera seus resultados em um formato de saída padronizado em metadados, o ▒ █
█▒▒ ¡ SARIF (Static Analysis Results Interchange Format). A SunCodeQL processa o ▒▒█
█ ▒,█▄ arquivo SARIF e o integra diretamente em uma interface visual de fácil uso: ela ▒ █
█ █▀▀° dispara um ambiente VSCode Web apontando para o diretório de código que acabou █ █
█▒▒ de ser gerado no container. ▒▒█
█ ▒ ▒ █
█ █ - Mapeamento de Vulnerabilidade: Dentro do VSCode, as vulnerabilidades são █ █
█ ▒ destacadas diretamente nas linhas de código, oferecendo uma experiência de ▒ █
█▒▒ code review familiar e eficiente. ▒▒█
█ ▒ - Rastreamento Source to Sink: O recurso mais poderoso é a capacidade de mostrar ▒ █
█ █ o caminho exato do dado vulnerável: desde o ponto de entrada (o Source - e.g., █ █
█ ▒ um parâmetro de URL) até o ponto de execução (o Sink - e.g., uma chamada ▒ █
█▒▒ eval() ou document.write()), permitindo ao analista entender a lógica da ▒▒█
█ ▒ falha, mesmo em código minificado. ▒ █
█ █ █ █
█ ▒ Como Funciona: ▒ █
█▒▒ ¡ ▒▒█
█ ▒ +--------------------------------------+ ▄█,▒ █
█ █ | Navegador | °▀▀█ █
█▒▒ | | ▒▒█
█ ▒ | | ▒ █
█ █ | +----------------------------------+ | █ █
█ ▒ | | Exntensao | | ▒ █
█▒▒ | | | | ▒▒█
█ ▒ | | | | ▒ █
█ █ | | +---------------+ +---------+ | | █ █
█ ▒ | | | | | | | | ▒ █
█▒▒ | | | ContentScript | | Alarm | | | ▒▒█
█ ▒ | | | | | | | | ▒ █
█ █ | | +---------------+ +---------+ | | █ █
█ ▒ | | | | | | ▒ █
█▒▒ ¡ | +---------|-----------------|------+ | ▒▒█
█ ▒,█▄ | | | | ▒ █
█ █▀▀° +-----------|-----------------|--------+ █ █
█▒▒ | | ▒▒█
█ ▒ +---------|-----------------|------------------------+ ▒ █
█ █ | v Container | █ █
█ ▒ | +---------------+ +---------+ | ▒ █
█▒▒ | | | | | | ▒▒█
█ ▒ | | Analyze |--+ | Webhook |-----------+ | ▒ █
█ █ | | | | | | | | █ █
█ ▒ | +---------------+ | +---------+ | | ▒ █
█▒▒ | | | | | ▒▒█
█ ▒ | | +------+ | | ▒ █
█ █ | v v v | █ █
█ ▒ | +---------------+ +---------+ +------------+ | ▒ █
█▒▒ | | | | | | | | ¡ ▒▒█
█ ▒ | | Storage |<-+ | Queue | +-| CodeServer | | ▄█,▒ █
█ █ | | | | | | | | | | °▀▀█ █
█▒▒ | +---------------+ | +---------+ | +------------+ | ▒▒█
█ ▒ | ^ | | | | ▒ █
█ █ | | +--------------+ | █ █
█ ▒ | | | | ▒ █
█▒▒ | +---------------+ | | ▒▒█
█ ▒ | | | | | ▒ █
█ █ | | CodeQL |<--------+ | █ █
█ ▒ | | | | ▒ █
█▒▒ | +---------------+ | ▒▒█
█ ▒ | | ▒ █
█ █ +----------------------------------------------------+ █ █
█ ▒ ▒ █
█▒▒ ¡ ▒▒█
█ ▒,█▄ - ContentScript coleta <script> inline/src da página e envia para o ▒ █
█ █▀▀° Background/Alarm. █ █
█▒▒ - Alarm roda a cada ciclo e consulta Webhook para ver novos resultados; também ▒▒█
█ ▒ aciona atualização do front da extensão. ▒ █
█ █ - Background agrupa URLs de scripts interceptados, cookies e user agent e █ █
█ ▒ dispara para Analyze no servidor. ▒ █
█▒▒ - Analyze recebe gzip, salva arquivos em Storage, enfileira o alvo em Queue e ▒▒█
█ ▒ responde imediato. ▒ █
█ █ - Queue coordena execuções; chama CodeQL sobre a pasta armazenada, gera SARIF e █ █
█ ▒ grava status/resultado em Redis. ▒ █
█▒▒ - Webhook lê Redis e devolve estados/resultados; usado pelo Alarm para atualizar ▒▒█
█ ▒ badge e popup. ▒ █
█ █ - CodeServer expõe a pasta analisada/SARIF via IDE web para abrir pelo link do █ █
█ ▒ popup. ▒ █
█▒▒ ¡ ▒▒█
█ ▒ -------------------------------------------------------------------------------- ▄█,▒ █
█ █ °▀▀█ █
█▒▒ --[ Print(ASCII) da Extensão ]-- ▒▒█
█ ▒ ▒ █
█ █ ################################################################################ █ █
█ ▒ # # ▒ █
█▒▒ # [O] SunCodeQL ≡ ≡ ≡ # ▒▒█
█ ▒ # # ▒ █
█ █ ################################################################################ █ █
█ ▒ # # ▒ █
█▒▒ # -------------------------------------------------------------------------- # ▒▒█
█ ▒ # # ▒ █
█ █ # [ Warning: 14 ] [ Error: 4 ] [ Access -> ] # █ █
█ ▒ # # ▒ █
█▒▒ ¡ # ▼ exemplo.com/chat?locale= # ▒▒█
█ ▒,█▄ # # ▒ █
█ █▀▀° # ▼ js/xss [ Error ] # █ █
█▒▒ # # ▒▒█
█ ▒ # Message: Cross-site scripting vulnerability due to [user- # ▒ █
█ █ # provided value](1). # █ █
█ ▒ # # ▒ █
█▒▒ # > js/incomplete-sanitization [ Warning ] # ▒▒█
█ ▒ # # ▒ █
█ █ # > js/remote-property-injection [ Warning ] # █ █
█ ▒ # # ▒ █
█▒▒ # > js/client-side-unvalidated-url-redirection [ Error ] # ▒▒█
█ ▒ # # ▒ █
█ █ # > js/client-side-request-forgery [ Error ] # █ █
█ ▒ # # ▒ █
█▒▒ ###########################################################@#################### ¡ ▒▒█
█ ▒ ▄█,▒ █
█ █ -------------------------------------------------------------------------------- °▀▀█ █
█▒▒ ▒▒█
█ ▒ --[ Casos de uso ]-- ▒ █
█ █ █ █
█ ▒ Bugbounty e Pentest, Abra um site vá navegando entre as páginas enquanto a ▒ █
█▒▒ SunCodeQL válida se é vulnerável. ▒▒█
█ ▒ ▒ █
█ █ Desafios Futuros █ █
█ ▒ ================ ▒ █
█▒▒ ▒▒█
█ ▒ O principal desafio atual com o CodeQL reside no seu consumo de recursos. Mesmo ▒ █
█ █ com um número selecionado de templates de vulnerabilidades em client side no █ █
█ ▒ javascript, o processo pode se tornar demorado, especialmente quando a página ▒ █
█▒▒ ¡ web analisada contém um grande volume de código JavaScript. e até atrapalhar o ▒▒█
█ ▒,█▄ uso do seu computador. Recomendo utilizar uma máquina dedicada para a execução ▒ █
█ █▀▀° do CodeQL, em vez de rodá-lo na máquina local do usuário. █ █
█▒▒ ▒▒█
█ ▒ Análise de Código Minificado ▒ █
█ █ ---------------------------- █ █
█ ▒ ▒ █
█▒▒ A presença de códigos excessivamente minificados aumenta significativamente a ▒▒█
█ ▒ complexidade da análise. Em certos casos, embora seja possível identificar a ▒ █
█ █ origem (source) e o destino (sink), a execução do source pode depender de █ █
█ ▒ condições específicas, como o nível de permissão do usuário. Para contornar ▒ █
█▒▒ isso, é essencial dedicar tempo à análise detalhada: ▒▒█
█ ▒ ▒ █
█ █ - Utilizar o debugger das devtools. █ █
█ ▒ - Configurar breakpoints. ▒ █
█▒▒ - Entender o fluxo de execução para identificar as condições necessárias para ¡ ▒▒█
█ ▒ que o source seja ativado. ▄█,▒ █
█ █ °▀▀█ █
█▒▒ Conclusão ▒▒█
█ ▒ ========= ▒ █
█ █ █ █
█ ▒ A SunCodeQL simplifica a análise de segurança no frontend ao permitir que o ▒ █
█▒▒ profissional trabalhe diretamente no contexto real da aplicação, superando ▒▒█
█ ▒ limitações comuns como autenticação, interações dinâmicas e páginas protegidas ▒ █
█ █ por CAPTCHAs. Ela coleta apenas o código realmente executado pelo navegador e █ █
█ ▒ aplica consultas do CodeQL sobre esse material, o que facilita a investigação de ▒ █
█▒▒ fluxos de dados sensíveis. Mesmo sem reduzir falsos positivos ou tornar o ▒▒█
█ ▒ processo totalmente previsível, a ferramenta ajuda a contornar dificuldades ▒ █
█ █ típicas da análise externa do DOM — onde lógicas personalizadas de string, █ █
█ ▒ parâmetros ocultos e fluxos não padronizados geralmente passam despercebidos — e ▒ █
█▒▒ ¡ também oferece suporte na leitura de bundles minificados, que normalmente ▒▒█
█ ▒,█▄ inviabilizam a compreensão manual do código. No conjunto, a SunCodeQL não ▒ █
█ █▀▀° resolve todos os desafios do frontend moderno, mas torna o trabalho mais direto, █ █
█▒▒ acessível e menos dependente de tentativas manuais pouco eficientes. ▒▒█
█ ▒ ▒ █
█ █ Links: █ █
█ ▒ ▒ █
█▒▒ - Vários artigos e tutoriais sobre o CodeQL: ▒▒█
█ ▒ https://github.com/sunsecrn/awesome-codeql ▒ █
█ █ - SARIF: https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html █ █
█ ▒ - VSCodeWeb: https://github.com/coder/code-server ▒ █
█▒▒ - SunCodeQL: https://github.com/sunsecrn/SunCodeQL ▒▒█
█ ▒ ▒ █
█ █ █ █
█▒▒▒▒▒ ░░ ▒▒▒▒▒▒▒▒█
█ ▒ ▓▄█
█ █ T R A M O I A · Z I N E · 2 0 2 6 gld ██
▀▄▄▄▄ ▒▒▄▄▀