Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
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.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE-2022-22057_SM-F926U — Qualcomm kgsl driver exploit (CVE-2022-22057) para dispositivos Samsung Galaxy que alcança leitura/escrita arbitrária de memória do kernel, bypass do SELinux e acesso root temporário via condição de corrida. | Kitploit
Ferramentas/GitHubGitHub/diabl0w/cve-2022-22057_sm-f926u
Segurança AndroidEscalada de PrivilégiosFrameworks de ExploraçãoAnálise de VulnerabilidadesExploraçãoSegurança MóvelExploração de Binários
GitHubdiabl0w/cve-2022-22057_sm-f926u

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

CVE-2022-22057_SM-F926U

Qualcomm kgsl driver exploit (CVE-2022-22057) para dispositivos Samsung Galaxy que alcança leitura/escrita arbitrária de memória do kernel, bypass do SELinux e acesso root temporário via condição de corrida.

Ver Repositório
1012há 3 anosAinda não revisado

Fork

A minha adaptação para o SM-F926U a partir do exploit original aqui
MUITO obrigado ao m-y-mo por descobrir o exploit e pela sua extrema paciência com todas as minhas perguntas para portar isto para o SM-F926U e torná-lo utilizável

Adicionei um daemon de inicialização (libtimeline.so) baseado em código do Shizuku

Adicionei um truque sujo para permitir que a solução de root temporária seja estável (ver abaixo)

Aviso: Não sou responsável por dispositivos destruídos, dados perdidos, dados roubados, segurança do dispositivo
Aviso 2: Não sou programador, sou mais um experimentador profissional. Posso tentar ajudar se você encontrar problemas, posso nunca mais olhar para este tópico, prossiga por sua conta e risco

Requisitos:

  • Versão do firmware igual ou próxima de F926UXXS1BUL6 devido a offsets específicos do kallsym (apenas F926USQS1BUL6 testado)

Instruções:

  • Leia todas as instruções, o aviso acima e as ressalvas abaixo primeiro
  • Compile o libtimeline.so (usando ndk-build) e o timeline (usando make)
  • Copie ambos para /data/local/tmp
  • Para depuração: você pode querer executar /data/local/tmp/timeline diretamente, pois pode ver se o exploit está sendo executado ou travado (veja as ressalvas abaixo)
  • Para produção: execute /data/local/tmp/libtimeline.so
  • Aviso: O seu dispositivo pode entrar em kernel panic e reiniciar; se isso acontecer, espere inicializar, desbloqueie o dispositivo, dê alguns minutos para o dispositivo "se acalmar" da inicialização e tente novamente -- teoricamente, o pior que deve acontecer é perder quaisquer dados que ainda estejam na memória. Portanto, salve todos os dados importantes antes de executar o exploit
  • Depois que o exploit terminar e o processo de inicialização entrar em seu loop (veja as ressalvas abaixo para saber por que fazemos isso):
    • Conecte-se a um shell root digitando netcat 127.0.0.1 6969 em uma sessão adb
    • Se conectar, você deve então conseguir digitar id e ele mostrará suas credenciais de root
    • Você também pode emitir comandos via: `echo 'YOUR COMMAND' | netcat 127.0.0.1 6969

Mais ressalvas:

  • Atualmente não há implementação para mostrar que o exploit foi executado com sucesso. Por outro lado, você pode executar o binário timeline diretamente (/data/local/tmp/timeline) e isso mostrará se o exploit teve sucesso, mas logo após encerrar sua sessão adb, o dispositivo irá travar, e é por isso que executamos a partir do libtimeline.so
  • Mesmo executando a partir do libtimeline.so, se o Android matar o processo timeline em segundo plano, isso também fará o telefone reiniciar. Meu telefone normalmente dura de 8 horas a alguns dias antes de o processo ser morto
  • libtimeline.so carrega cpu a 100%: você notará em top que o timeline está executando com cerca de 100% de uso de cpu. Não tenho certeza se isso é legítimo ou não. Na verdade, ele está apenas sentado em um estado while(1) para evitar que feche e trave o dispositivo, então não encontrei o que está causando o alto uso de cpu ou se é um falso positivo corrigido
  • Esta é uma solução de root temporária, o que significa: sem magisk, sem gerenciador de su, e o defex ainda está habilitado
  • AVISO: ** Este método de root é muito inseguro **
    • Ele deixa um shell root em execução na porta 6969 via netcat e qualquer serviço que escreva um comando nessa porta poderá executar comandos com privilégios de root

Original

Exploit para Qualcomm CVE-2022-22057

O artigo pode ser encontrado aqui. Este é um bug no driver kgsl da Qualcomm que reportei em novembro de 2021. O bug pode ser usado para obter leitura e escrita arbitrárias de memória do kernel a partir do domínio de aplicativos não confiáveis, que é então usado para desabilitar o SELinux e obter root.

O exploit foi testado no Samsung Galaxy Z Flip 3 (versão europeia SM-F711B) com versão de firmware F711BXXS2BUL6, baseband F711BXXU2BUL4 e versão de kernel 5.4.86-qgki-23063627-abF711BXXS2BUL6 (região EUX). Os offsets no exploit referem-se a essa versão do firmware. Além dos offsets habituais na imagem do kernel, vários endereços dos pools de memória ion em ion_utils.c também são específicos do firmware. Para referência, usei o seguinte comando para compilar com clang no ndk-21:

root@kitploit:~
android-ndk-r21d-linux-x86_64/android-ndk-r21d/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android30-clang -O2 timeline_wait.c sendmsg_spray.c signalfd_spray.c cpu_utils.c ion_utils.c fake_obj_util.c work_queue_utils.c -o timeline

O exploit é razoavelmente confiável (~70% no dispositivo testado), embora precise esperar alguns minutos após a inicialização antes de executar, pois há muitas chamadas binder quebradas/falhas durante os primeiros minutos após a inicialização. (Não tenho total certeza se é um problema da Qualcomm ou da Samsung)

Para testar, faça a compilação cruzada do arquivo e depois execute com adb:

root@kitploit:~
adb push timeline /data/local/tmp
adb shell
b2q:/ $ /data/local/tmp/timeline

Se tiver sucesso, ele desabilitará o SELinux e executará o comando id como root e gravará os resultados no arquivo /data/local/tmp/id.txt:

root@kitploit:~
b2q:/ $ /data/local/tmp/timeline
heap_id_mask 40
ion region 0x75a0ccf000
region start addr: ffffff8071800000
fence kernel addr: ffffff8071fe0040 192
created fake slab at ffffff8071840100
[+] reallocation data initialized!
[ ] initializing reallocation threads, please wait...
[+] 40 reallocation threads ready!
timeline_wait start
readpipe start
destroy start
readpipe
Caught signal: 10
 wait complete -1
readpipe finished
destroy finished
cb_list ffffffc02d943bf8 temp ffffffc02d943c48
mask 52424242 60
cpu_id 0
interval number 1
mask 7f8e7bfeff 7
thread number 0 7 20014
thread batch number 0
new mask 7f8e7bfeff ffffff8071840100
region_offset 40100
sprayed 1024 ion buffer
start searching for buffer
Found 7 ion regions
heap_ops ffffffc012e17180, kernel base: a00b8000
set enforcing to permissive
[+] successfully overwritten selinux_enforcing
wq_ptr_addr: ffffffc012dc2518
wq_addr: ffffff81f4cf1200
pwq_addr ffffff81e24ea100
pool_addr ffffff805ff7c000
worklist ffffff805ff7c020 ffffff805ff7c020
queue work
max_active 256 nr_active 0
queuing work, waiting to aquire spin lock
work_queued
work processed
complete 0
ret 0
nr_active 0
worklist ffffff805ff7c020
work next ffffff8071842c08
[+] successfully run command and added id.txt in /data/local/tmp
finished queue work
freeing ion dma fd
finished freeing ion dma fd
finished spraying
finished

Há uma longa pausa após wait complete -1 ser impresso, que deve ser inferior a um minuto; isso é normal. Às vezes, também pode demorar um pouco para enfileirar o trabalho (depois que queuing work, waiting to aquire spin lock é impresso, podem ser alguns minutos, basta ter paciência, embora isso não seja comum). O exploit normalmente completa em alguns minutos.

O arquivo /data/local/tmp/id.txt deve confirmar que o comando foi executado como root:

root@kitploit:~
b2q:/ $ cat /data/local/tmp/id.txt
uid=0(root) gid=0(root) groups=0(root) context=u:r:kernel:s0

Um comando diferente pode ser executado alterando a variável cmd em setup_sub_info em work_queue_utils.c. (Por exemplo, para abrir uma shell root reversa).

Baixar ferramenta