From 71e37a784a76544d72e19fcb9369462ca6d4bc70 Mon Sep 17 00:00:00 2001 From: Translator Date: Sat, 12 Jul 2025 18:08:22 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/ios-pentesting/ios-pentesting-without --- .../ios-pentesting-without-jailbreak.md | 26 ++--- .../request-smuggling-in-http-2-downgrades.md | 97 ++++++++++++++++++- 2 files changed, 108 insertions(+), 15 deletions(-) diff --git a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md index 4fd66e7c5..b50973eb8 100644 --- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md +++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -## Ideia principal +## Main idea Aplicativos assinados com a **entitlement `get_task_allow`** permitem que aplicativos de terceiros executem uma função chamada **`task_for_pid()`** com o ID do processo do aplicativo inicial como argumento para obter a porta da tarefa sobre ele (ser capaz de controlá-lo e acessar sua memória). @@ -10,20 +10,20 @@ No entanto, não é tão fácil quanto apenas puxar o IPA, re-assiná-lo com a e Com um dispositivo antigo com jailbreak, é possível instalar o IPA, **descriptografá-lo usando sua ferramenta favorita** (como Iridium ou frida-ios-dump) e retirá-lo do dispositivo. Embora, se possível, é recomendável pedir ao cliente o IPA descriptografado. -## Obter IPA descriptografado +## Obtain decrypted IPA -### Obtenha da Apple +### Get it from Apple 1. Instale o aplicativo para pentest no iPhone -2. Instale e inicie o [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) no seu macos -3. Abra o `Terminal` no seu Mac e vá para `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. O IPA aparecerá nesta pasta mais tarde. +2. Instale e inicie [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) no seu macos +3. Abra o `Terminal` no seu Mac e cd para `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. O IPA aparecerá nesta pasta mais tarde. 4. Você deve ver seu dispositivo iOS. Clique duas vezes nele e, em seguida, clique em Adicionar + → Apps na barra de menu superior. 5. Após clicar em Adicionar, o Configurator fará o download do IPA da Apple e tentará enviá-lo para o seu dispositivo. Se você seguiu minha recomendação anterior e já instalou o IPA, um aviso pedindo para reinstalar o aplicativo aparecerá. 6. O IPA deve ser baixado dentro de `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`, de onde você pode pegá-lo. -Verifique [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) para mais informações detalhadas sobre esse processo. +Verifique [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) para mais informações detalhadas sobre este processo. -### Descriptografando o aplicativo +### Decrypting the app Para descriptografar o IPA, vamos instalá-lo. No entanto, se você tiver um iPhone antigo com jailbreak, potencialmente sua versão não será suportada pelo aplicativo, pois geralmente os aplicativos só suportam as versões mais recentes. @@ -49,7 +49,7 @@ Uma vez instalado, você pode usar o **Iridium tweak** do Cydia para obter o IPA ### Patch de permissões & re-assinatura -Para re-assinar o aplicativo com a permissão `get-task-allow`, existem várias ferramentas disponíveis, como `app-signer`, `codesign` e `iResign`. O `app-signer` possui uma interface muito amigável que permite re-assinar um arquivo IPA de forma muito fácil, indicando o IPA a ser re-assinado, para **colocá-lo como `get-task-allow`** e o certificado e perfil de provisionamento a serem usados. +Para re-assinar o aplicativo com a permissão `get-task-allow`, existem várias ferramentas disponíveis, como `app-signer`, `codesign` e `iResign`. O `app-signer` tem uma interface muito amigável que permite re-assinar facilmente um arquivo IPA, indicando o IPA a ser re-assinado, para **colocá-lo como `get-task-allow`** e o certificado e perfil de provisionamento a serem usados. Quanto ao certificado e perfis de assinatura, a Apple oferece **perfis de assinatura de desenvolvedor gratuitos** para todas as contas através do Xcode. Basta criar um aplicativo e configurar um. Em seguida, configure o **iPhone para confiar nos aplicativos do desenvolvedor** navegando até `Settings` → `Privacy & Security`, e clique em `Developer Mode`. @@ -61,22 +61,22 @@ ideviceinstaller -i resigned.ipa -w ### Ativar Modo Desenvolvedor (iOS 16+) -Desde o iOS 16, a Apple introduziu o **Modo Desenvolvedor**: qualquer binário que carregue `get_task_allow` *ou* que seja assinado com um certificado de desenvolvimento se recusará a iniciar até que o Modo Desenvolvedor esteja ativado no dispositivo. Você também não poderá anexar Frida/LLDB a menos que essa opção esteja ativada. +Desde o iOS 16, a Apple introduziu o **Modo Desenvolvedor**: qualquer binário que contenha `get_task_allow` *ou* que seja assinado com um certificado de desenvolvimento se recusará a iniciar até que o Modo Desenvolvedor esteja ativado no dispositivo. Você também não poderá anexar Frida/LLDB a menos que essa opção esteja ativada. 1. Instale ou envie **qualquer** IPA assinada por desenvolvedor para o telefone. 2. Navegue até **Ajustes → Privacidade e Segurança → Modo Desenvolvedor** e ative-o. 3. O dispositivo será reiniciado; após inserir o código de acesso, você será solicitado a **Ativar** o Modo Desenvolvedor. -O Modo Desenvolvedor permanece ativo até que você o desative ou limpe o telefone, então este passo precisa ser realizado apenas uma vez por dispositivo. [Documentação da Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explica as implicações de segurança. +O Modo Desenvolvedor permanece ativo até que você o desative ou limpe o telefone, então esta etapa precisa ser realizada apenas uma vez por dispositivo. [Documentação da Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explica as implicações de segurança. ### Opções modernas de sideloading -Agora existem várias maneiras maduras de sideload e manter IPAs re-assinadas atualizadas sem jailbreak: +Agora existem várias maneiras maduras de fazer sideload e manter IPAs re-assinados atualizados sem jailbreak: | Ferramenta | Requisitos | Forças | Limitações | |------------|------------|--------|------------| | **AltStore 2 / SideStore** | Companheiro macOS/Windows/Linux que re-assina a IPA a cada 7 dias com um perfil de desenvolvedor gratuito | Recarga automática via Wi-Fi, funciona até iOS 17 | Necessita de computador na mesma rede, limite de 3 aplicativos imposto pela Apple | -| **TrollStore 1/2** | Dispositivo em iOS 14 – 15.4.1 vulnerável ao bug do CoreTrust | Assinatura *permanente* (sem limite de 7 dias); nenhum computador necessário uma vez instalado | Não suportado em iOS 15.5+ (bug corrigido) | +| **TrollStore 1/2** | Dispositivo com iOS 14 – 15.4.1 vulnerável ao bug do CoreTrust | Assinatura *permanente* (sem limite de 7 dias); nenhum computador necessário uma vez instalado | Não suportado no iOS 15.5+ (bug corrigido) | Para pentests rotineiros em versões atuais do iOS, Alt/Side-Store geralmente são a escolha mais prática. @@ -94,7 +94,7 @@ Recentes lançamentos do Frida (>=16) lidam automaticamente com a autenticação ### Análise dinâmica automatizada com MobSF (sem jailbreak) -[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) pode instrumentar um IPA assinado por desenvolvedor em um dispositivo real usando a mesma técnica (`get_task_allow`) e fornece uma interface web com navegador de sistema de arquivos, captura de tráfego e console do Frida【】. A maneira mais rápida é executar o MobSF no Docker e, em seguida, conectar seu iPhone via USB: +[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) pode instrumentar um IPA assinado por desenvolvedor em um dispositivo real usando a mesma técnica (`get_task_allow`) e fornece uma interface web com navegador de sistema de arquivos, captura de tráfego e console do Frida【†L2-L3】. A maneira mais rápida é executar o MobSF no Docker e, em seguida, conectar seu iPhone via USB: ```bash docker pull opensecurity/mobile-security-framework-mobsf:latest docker run -p 8000:8000 --privileged \ diff --git a/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md b/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md index 4f9c8dab5..bf51cd208 100644 --- a/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md +++ b/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md @@ -1,7 +1,100 @@ -# Request Smuggling em Downgrades HTTP/2 +# Request Smuggling em Downgrades de HTTP/2 {{#include ../../banners/hacktricks-training.md}} -**Verifique o post [https://portswigger.net/research/http-2-downgrades](https://portswigger.net/research/http-2-downgrades)** +HTTP/2 é geralmente considerado imune a classic request-smuggling porque o comprimento de cada quadro DATA é explícito. **Essa proteção desaparece assim que um proxy de front-end “faz downgrade” da solicitação para HTTP/1.x antes de encaminhá-la para um back-end**. No momento em que dois parsers diferentes (o front-end HTTP/2 e o back-end HTTP/1) tentam concordar sobre onde uma solicitação termina e a próxima começa, todos os velhos truques de desincronização voltam – além de alguns novos. + +--- +## Por que os downgrades acontecem + +1. Os navegadores já falam HTTP/2, mas muita infraestrutura de origem legada ainda entende apenas HTTP/1.1. +2. Proxies reversos (CDNs, WAFs, balanceadores de carga) portanto terminam TLS + HTTP/2 na borda e **reescrevem cada solicitação como HTTP/1.1** para a origem. +3. A etapa de tradução precisa criar *tanto* os cabeçalhos `Content-Length` **e/ou** `Transfer-Encoding: chunked` para que a origem possa determinar o comprimento do corpo. + +Sempre que o front-end confia no comprimento do quadro HTTP/2 **mas** o back-end confia no CL ou TE, um atacante pode forçá-los a discordar. + +--- +## Duas classes primitivas dominantes + +| Variante | Comprimento do front-end | Comprimento do back-end | Payload típico | +|---------|-------------------------|------------------------|-----------------| +| **H2.TE** | Quadro HTTP/2 | `Transfer-Encoding: chunked` | Embutir um corpo de mensagem chunked extra cujo final `0\r\n\r\n` *não* é enviado, fazendo com que o back-end aguarde a “próxima” solicitação fornecida pelo atacante. | +| **H2.CL** | Quadro HTTP/2 | `Content-Length` | Enviar um CL *menor* do que o corpo real, fazendo com que o back-end leia além do limite na solicitação seguinte. | + +> Estes são idênticos em espírito aos clássicos TE.CL / CL.TE, apenas com HTTP/2 substituindo um dos parsers. + +--- +## Identificando uma cadeia de downgrade + +1. Use **ALPN** em um handshake TLS (`openssl s_client -alpn h2 -connect host:443`) ou **curl**: +```bash +curl -v --http2 https://target +``` +Se `* Using HTTP2` aparecer, a borda fala H2. +2. Envie uma solicitação CL/TE deliberadamente malformada *sobre* HTTP/2 (Burp Repeater agora tem um dropdown para forçar HTTP/2). Se a resposta for um erro HTTP/1.1 como `400 Bad chunk`, você tem prova de que a borda converteu o tráfego para um parser HTTP/1 a jusante. + +--- +## Fluxo de exploração (exemplo H2.TE) +```http +:method: POST +:path: /login +:scheme: https +:authority: example.com +content-length: 13 # ignored by the edge +transfer-encoding: chunked + +5;ext=1\r\nHELLO\r\n +0\r\n\r\nGET /admin HTTP/1.1\r\nHost: internal\r\nX: X +``` +1. O **front-end** lê exatamente 13 bytes (`HELLO\r\n0\r\n\r\nGE`), pensa que a solicitação está finalizada e encaminha essa quantidade para a origem. +2. O **back-end** confia no cabeçalho TE, continua lendo até ver o *segundo* `0\r\n\r\n`, consumindo assim o prefixo da segunda solicitação do atacante (`GET /admin …`). +3. O restante (`GET /admin …`) é tratado como uma *nova* solicitação enfileirada atrás da da vítima. + +Substitua a solicitação disfarçada por: +* `POST /api/logout` para forçar a fixação de sessão +* `GET /users/1234` para roubar um recurso específico da vítima + +--- +## h2c smuggling (atualizações em texto claro) + +Um estudo de 2023 mostrou que se um front-end passar o cabeçalho HTTP/1.1 `Upgrade: h2c` para um back-end que suporta HTTP/2 em texto claro, um atacante pode tunelar *frames* HTTP/2 *brutos* através de uma borda que apenas validou HTTP/1.1. Isso contorna a normalização de cabeçalhos, regras de WAF e até mesmo a terminação TLS. + +Requisitos principais: +* A borda encaminha **tanto** `Connection: Upgrade` quanto `Upgrade: h2c` inalterados. +* A origem incrementa para HTTP/2 e mantém a semântica de reutilização de conexão que permite o enfileiramento de solicitações. + +A mitigação é simples – remova ou codifique o cabeçalho `Upgrade` na borda, exceto para WebSockets. + +--- +## CVEs notáveis do mundo real (2022-2025) + +* **CVE-2023-25690** – As regras de reescrita do mod_proxy do Apache HTTP Server poderiam ser encadeadas para divisão e contrabando de solicitações. (corrigido na 2.4.56) +* **CVE-2023-25950** – Contrabando de solicitações/respostas do HAProxy 2.7/2.6 quando o parser HTX manipulava incorretamente solicitações em pipeline. +* **CVE-2022-41721** – O `MaxBytesHandler` do Go fez com que bytes de corpo restantes fossem analisados como **frames HTTP/2**, permitindo contrabando entre protocolos. + +--- +## Ferramentas + +* **Burp Request Smuggler** – desde a v1.26, testa automaticamente H2.TE/H2.CL e suporte ALPN oculto. Ative “HTTP/2 probing” nas opções da extensão. +* **h2cSmuggler** – PoC em Python da Bishop Fox para automatizar o ataque de atualização em texto claro: +```bash +python3 h2csmuggler.py -u https://target -x 'GET /admin HTTP/1.1\r\nHost: target\r\n\r\n' +``` +* **curl**/`hyper` – criando cargas úteis manuais: `curl --http2-prior-knowledge -X POST --data-binary @payload.raw https://target`. + +--- +## Medidas defensivas + +1. **HTTP/2 de ponta a ponta** – elimine completamente a tradução de downgrade. +2. **Fonte única de verdade sobre o comprimento** – ao rebaixar, *sempre* gere um `Content-Length` válido **e** **remova** quaisquer cabeçalhos `Content-Length`/`Transfer-Encoding` fornecidos pelo usuário. +3. **Normalize antes da rota** – aplique a sanitização de cabeçalhos *antes* da lógica de roteamento/reescrita. +4. **Isolamento de conexão** – não reutilize conexões TCP de back-end entre usuários; “uma solicitação por conexão” derrota explorações baseadas em fila. +5. **Remova `Upgrade` a menos que seja WebSocket** – previne o tunelamento h2c. + +--- +## Referências + +* PortSwigger Research – “HTTP/2: The Sequel is Always Worse” +* Bishop Fox – “h2c Smuggling: request smuggling via HTTP/2 clear-text” {{#include ../../banners/hacktricks-training.md}}