Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
TheLastBundleMismatch — Writeup e exploit para CVE-2023-45777, bypass para validação de Intent dentro do AccountManagerService no Android 13 apesar da mitigação "Lazy Bundle" | Kitploit
Ferramentas/GitHubGitHub/michalbednarski/thelastbundlemismatch
Segurança AndroidAnálise de VulnerabilidadesExploraçãoAnálise de BináriosPapers e Pesquisa
GitHubmichalbednarski/thelastbundlemismatch

TheLastBundleMismatch

Writeup e exploit para CVE-2023-45777, bypass para validação de Intent dentro do AccountManagerService no Android 13 apesar da mitigação "Lazy Bundle"

Compartilhar
Ver Repositório
1031582há 7 diasRevisado pelo Kitploit

Patch misterioso

Vamos começar desta vez com o patch que apareceu como correção para CVE-2023-45777 no Android Security Bulletin:

diff --git a/services/core/java/com/android/server/accounts/AccountManagerService.java b/services/core/java/com/android/server/accounts/AccountManagerService.java
index 7a19d034c2c8..5238595fe2a2 100644
--- a/services/core/java/com/android/server/accounts/AccountManagerService.java
+++ b/services/core/java/com/android/server/accounts/AccountManagerService.java
@@ -4923,7 +4923,7 @@ public class AccountManagerService
             p.setDataPosition(0);
             Bundle simulateBundle = p.readBundle();
             p.recycle();
-            Intent intent = bundle.getParcelable(AccountManager.KEY_INTENT);
+            Intent intent = bundle.getParcelable(AccountManager.KEY_INTENT, Intent.class);
             if (intent != null && intent.getClass() != Intent.class) {
                 return false;
             }

Poucas pessoas ficaram intrigadas o suficiente para me perguntar; anteriormente, respondi a elas com algumas dicas e agora estou publicando o writeup completo sobre este problema

Mas primeiro, vamos fornecer algum contexto sobre o que está acontecendo neste patch

Esta é uma mudança no método checkKeyIntent(). Este método realiza múltiplas verificações para garantir que o Intent fornecido pela aplicação seja seguro para o sistema iniciar (usando privilégios do sistema)

Primeiro, este método usa checkKeyIntentParceledCorrectly() que serializa e desserializa novamente o Bundle que estamos verificando e checa se o Intent obtido do Bundle antes disso corresponde ao Intent do Bundle após tal ciclo. Como o lançamento do Intent ocorre em outros processos de aplicativos do sistema diferentes daquele que realiza a validação, anteriormente era possível construir Bundles que pareciam seguros durante a validação dentro do AccountManagerService, mas continham um Intent diferente após serem enviados para o próximo processo. Isso simula o envio do Bundle para o próximo processo a fim de detectar tais situações.

Após checkKeyIntentParceledCorrectly() temos a chamada bundle.getParcelable(), que este patch altera da versão obsoleta que poderia construir qualquer objeto para uma que valida que o objeto prestes a ser desserializado é do tipo especificado no segundo parâmetro

Essa versão com parâmetro de tipo foi introduzida no Android 13, como parte de um endurecimento maior de Parcel/Bundle. Em particular, antes do Android 13, quando um Bundle era enviado entre processos, ele mantinha uma cópia bruta de todos os dados serializados até que qualquer item fosse acessado, momento em que cada valor era desserializado. Agora, quando qualquer valor é acessado pela primeira vez após o Bundle ter sido recebido, apenas as chaves String e os valores de tipos primitivos são desserializados, enquanto os valores não primitivos são deixados como LazyValues, que têm seu comprimento armazenado como parte dos dados serializados para garantir que, mesmo quando a lógica de serialização/desserialização estiver incompatível, tais incompatibilidades não afetem outras entradas

Antes de mergulharmos, vamos dar uma olhada em LazyValue: em seu código-fonte temos um belo comentário explicando sua estrutura de dados

                     |   4B   |   4B   |
mSource = Parcel{... |  type  | length | object | ...}
                     a        b        c        d
length = d - c
mPosition = a
mLength = d - a

mPosition e mLength descrevem a localização de todos os dados de LazyValue no Parcel original, incluindo type e length. "length" (sem o "m" no início) refere-se ao valor de comprimento conforme escrito no Parcel e exclui o cabeçalho (type e length)

Se um Bundle contendo LazyValue estiver sendo encaminhado para outro processo, todo o LazyValue, incluindo os campos type e length, é copiado literalmente de Bundle.mParcelledData para o Parcel de destino

Quando um item de Bundle representado por LazyValue é acessado, o Parcel é rebobinado para mPosition e readValue() é chamado. Se o argumento de tipo for passado para bundle.getParcelable(), ele é propagado para readValue(), que garantirá que o tipo prestes a ser desempacotado é o esperado, bem como verificará após o desempacotamento que o tipo do valor desempacotado é o esperado. Após o desempacotamento, o LazyValue é substituído, de modo que, na próxima vez que o Bundle for escrito no Parcel, o valor será serializado novamente por meio de writeValue()

O uso do parâmetro tipado de Bundle.get*()/Parcel.read*() é relevante principalmente para métodos como Parcel.readParcelableList(), que retorna um ArrayList e, devido ao Java Type Erasure, mesmo que você fizesse algo como List<SomeParcelableType> field = parcel.readParcelableList();, a parte <SomeParcelableType> não era imposta em tempo de execução e tal List poderia conter quaisquer classes Parcelable disponíveis no sistema e, portanto, todos os createFromParcel/writeToParcel disponíveis no sistema poderiam ser usados como parte da serialização/desserialização de um tipo que contivesse tal List

Você também pode querer conferir a apresentação da equipe de Segurança e Privacidade do Android sobre a introdução desses mecanismos (slides, vídeo)

Aqui, no entanto, o uso da versão tipada parece ser redundante, pois também verificamos explicitamente o tipo do objeto retornado. Então, o que está acontecendo e qual vulnerabilidade está sendo corrigida aqui?

Efeitos colaterais

Dê uma olhada novamente no patch do início

  • Se o valor desserializado sob a chave "intent" for um Intent
    • Ele será validado para apontar para o componente que é seguro para o sistema iniciar
    • Se uma incompatibilidade pudesse ser acionada a partir do objeto Intent, teríamos um problema muito maior
  • Se o valor sendo desserializado não for um Intent
    • Para fazer qualquer coisa ruim, precisaríamos ter um Intent dentro do Bundle depois que ele for enviado para outro processo, mas o tipo do Parcelable é salvo em um offset anterior a qualquer possível incompatibilidade e o prefixo de comprimento do LazyValue nos impede de modificar os próximos pares chave-valor em caso de incompatibilidade de writeToParcel/createFromParcel
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Sem dados de popularidade ainda.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →