Jump to content

gzn

Membros
  • Content Count

    112
  • Joined

  • Last visited

Everything posted by gzn

  1. Tem ferramentas que ajudam nessas coisas, uma delas é o astyle. Se você estiver usando uma distribuição como Ubuntu basta digitar no terminal: sudo apt -y install astyle Aí é só você ter um arquivo de configuração pessoal, ex.: > $ cat ~/.astylerc --style=java --indent=spaces=4 --indent-preprocessor --pad-oper --pad-header --max-instatement-indent=40 --align-pointer=name --align-reference=name --keep-one-line-statements --convert-tabs --max-code-length=79 --pad-method-colon=none Original: // main.c int teste(int a, int b) { return a+b; } int main(void) { int a=1; char b = 'a'; } Modificado: astyle main.c // main.c int teste(int a, int b) { return a + b; } int main(void) { int a = 1; char b = 'a'; } O arquivo original por padrão é renomeado para main.c.orig. Eu particularmente gosto do estilo Java porque foi a primeira linguagem de programação que realmente aprendi (e estou aprendendo!) a programar. Acostumei muito a colocar as chaves desse jeito aí acima como ficou formatado e outras coisas. Se você quiser mudar é só alterar o parâmetro --style ou usar as opções disponíveis e personalizar seu estilo particular.
  2. Parece que você está começando a programar... Conhece o stackoverflow? Try it: https://stackoverflow.com/search?q=Checking+if+a+registry+key+exists+[c]
  3. Como procurar por instruções? vagrant@ubuntu-bionic:/vagrant$ r2 /bin/ls -- This is just an existentialist experiment. [0x00005850]> /a push 0 Searching 2 bytes in [0x0-0x1e6e8] hits: 10 Searching 2 bytes in [0x21eff0-0x221560] hits: 2 0x000010b8 hit0_0 6a00 0x00001b79 hit0_1 6a00 0x00001cf9 hit0_2 6a00 0x0000365c hit0_3 6a00 0x00003e27 hit0_4 6a00 0x0000442b hit0_5 6a00 0x000082db hit0_6 6a00 0x00012d15 hit0_7 6a00 0x0001d0dc hit0_8 6a00 0x0001e2c4 hit0_9 6a00 0x0021f089 hit0_10 6a00 0x0021f129 hit0_11 6a00 Veja que foi gerado uma lista com algumas informações: o endereço onde foi encontrado a instrução, uma flag associada ao endereço, os bytes da instrução. Com isso nós podemos por exemplo, imprimir o disassembly da instrução em cada um desses endereços: [0x00005850]> pd 1 @@ hit0* ;-- hit0_0: 0x000010b8 6a00 push 0 ;-- hit0_1: 0x00001b79 6a00 push 0 ;-- hit0_2: 0x00001cf9 6a00 push 0 ;-- hit0_3: 0x0000365c 6a00 push 0 ;-- hit0_4: 0x00003e27 6a00 push 0 ;-- hit0_5: 0x0000442b 6a00 push 0 ;-- hit0_6: 0x000082db 6a00 push 0 ;-- hit0_7: 0x00012d15 6a00 push 0 ;-- hit0_8: 0x0001d0dc 6a00 push 0 ;-- hit0_9: 0x0001e2c4 6a00 push 0 ;-- hit0_10: 0x0021f089 6a00 push 0 ;-- hit0_11: 0x0021f129 6a00 push 0 [0x00005850]> O padrão hit0* expande para todos as flags que começam com hit0. O comando pd 1 imprime o disassembly de uma instrução no endereço atual. Veja, essa técnica é útil também para casos em que você quer aplicar um simples patch em vários endereços que tenham uma dada instrução (talvez uma chamada de função, um salto condicional, etc.). Dá também para procurar pelo tipo de instrução: [0x00005850]> /A push 0x000002b0 5 push 0xd0 0x00000f48 5 push 0x2202 0x000010b8 2 push 0 0x00001211 5 push 0x72747300 0x00001236 5 push 0x61657200 0x0000126e 5 push 0x6c6e755f 0x000014c6 5 push 0x6b6e75 0x0000174d 5 push 0x6569645f 0x00001b08 5 push 0x21f0 0x00001b79 2 push 0 0x00001c28 4 enter 0x21f0, 0 0x00001da8 5 push 0x21f1 0x00001ec8 4 enter 0x21f1, 0 0x000020f0 4 enter 0x21f2, 0 0x00002130 2 push 0xffffffffffffff80 0x00002990 5 push 0x2200 0x00002a98 5 push 0x2201 0x00003338 5 push 0x21fe 0x00003638 5 push 0x21ff 0x00003786 5 push 0 0x00003796 5 push 1 0x000037a6 5 push 2 0x000037b6 5 push 3 0x000037c6 5 push 4 0x000037d6 5 push 5 0x000037e6 5 push 6 0x000037f6 5 push 7 0x00003806 5 push 8 0x00003816 5 push 9 ... Se for a primeira vez que você faz esse tipo de pesquisa as flags começarão com hit0, se for a segunda, hit1, e assim por diante: [0x00005850]> pd 1 @@ hit0* ;-- hit0_0: 0x000002b0 68d0000000 push 0xd0 ;-- hit0_1: 0x00000f48 6802220000 push 0x2202 ;-- hit0_2: 0x000010b8 6a00 push 0 ;-- hit0_3: 0x00001211 6800737472 push 0x72747300 ;-- hit0_4: 0x00001236 6800726561 push 0x61657200 ;-- hit0_5: 0x0000126e 685f756e6c push 0x6c6e755f ;-- hit0_6: 0x000014c6 68756e6b00 push 0x6b6e75 ;-- hit0_7: 0x0000174d 685f646965 push 0x6569645f ;-- hit0_8: 0x00001b08 68f0210000 push 0x21f0 ;-- hit0_9: 0x00001b79 6a00 push 0 ;-- hit0_10: 0x00001c28 c8f02100 enter 0x21f0, 0 ... Quais são os tipos suportados para passar para /A? [0x00005850]> /A?|sort|column -c80 acmp cmp io mod not ret shl switch unk add cpl jmp mov null rol shr sync upush and crypto lea mul or ror store trap xchg call div leave new pop sal sub ucall xor case ill load nop push sar swi ujmp
  4. Como usar um decompilador com radare2? Um dos melhores decompiladores que já testei até o momento foi o retdec, segue abaixo um simples script que pode ser adaptado para você instalar o retdec na sua máquina. # retdec [ -d retdec ] || git clone https://github.com/avast-tl/retdec.git pushd retdec sudo apt-get install build-essential cmake git perl python3 bash bison flex autoconf automake libtool pkg-config m4 coreutils zlib1g-dev libtinfo-dev wget bc upx doxygen graphviz nodejs npm cd retdec mkdir build && cd build cmake .. -DCMAKE_INSTALL_PREFIX=/opt/retdec make sudo make install for f in /opt/retdec/bin/* do sudo ln -s $f /bin/$(basename $f) done echo /opt/retdec/bin/retdec-decompiler.sh | tee ~/.r2retdec r2pm init r2pm -i r2retdec popd https://asciinema.org/a/QbyBxxgTKy9oL6uw3aP0lDVhD
  5. Gerando assinaturas de funções Já teve casos em que você queria analisar um binário ligado estaticamente cujos símbolos foram removidos? Vamos a um exemplo de caso: // main.c int main(int argc, char *argv[]){ puts("Olá"); return 0; } Vamos gerar um executável dele com os símbolos e um sem. $ gcc -static -o main main.c $ cp main{,2} $ strip -s main2 Vamos abrir o main (que tem os símbolos) e gerar assinaturas com base nas funções encontradas nele: $ r2 -qc 'aaf;zg;z* > main.r2' main $ head main.r2 zs * za fcn.0047f498 b e8........4883c4084889c34889df5b5de9........ za fcn.0047f498 g cc=2 nbbs=1 edges=1 ebbs=0 za fcn.0047f498 o 0x0047f498 za fcn.0047f498 r sym._dl_allocate_tls_storage sym._dl_allocate_tls_storage sym._dl_allocate_tls_init zs * za fcn.0041f650 b 4883c41831d24889d05b5dc3 za fcn.0041f650 g cc=1 nbbs=1 edges=0 ebbs=1 za fcn.0041f650 o 0x0041f650 zs * aaf: tenta encontrar todas as funções zg: gera as assinaturas z*: mostra na tela (stdout) as assinaturas com a sintaxe do radare, redirecionamos para o arquivo main.r2 Agora vamos abrir o binário que está sem símbolos (main2) mas que sabemos usar a mesma bibliotecas que usamos no que está com símbolos (main): r2 -qc '. main.r2;z/;aaa;pdf @ `axt @ sign.bytes.sym.puts_0 ~[1]`' main2 ;-- main: ┌ (fcn) sign.bytes.sym.main_0 34 │ sign.bytes.sym.main_0 (); │ ; var int local_10h @ rbp-0x10 │ ; var int local_4h @ rbp-0x4 │ ; DATA XREF from 0x00400a4d (entry0) │ 0x00400b4d 55 push rbp │ 0x00400b4e 4889e5 mov rbp, rsp │ 0x00400b51 4883ec10 sub rsp, 0x10 │ 0x00400b55 897dfc mov dword [local_4h], edi │ 0x00400b58 488975f0 mov qword [local_10h], rsi │ 0x00400b5c 488d3da11509. lea rdi, [0x00492104] ; "Ol\u00e1" │ 0x00400b63 e8a8f60000 call sign.bytes.sym.puts_0 │ 0x00400b68 b800000000 mov eax, 0 │ 0x00400b6d c9 leave └ 0x00400b6e c3 ret . main.r2: carrega as assinaturas z/: analisa a memória a procura das assinaturas aaa: encontra funções e nomeia elas automaticamente pdf @ `axt @ sign.bytes.sym.puts_0 ~[1]`': mostra o disassembly da função que tiver o endereço sign.bytes.sym.puts_0 Para ver as assinaturas e fazer um grep, faça o seguinte: fs sign f ~puts 0x00410210 407 sign.bytes.sym.puts_0 0x0046f6d0 311 sign.bytes.sym._IO_fputs_0
  6. @Leandro Fróes, sim, só presencial. Infelizmente eu também não vou poder participar, pois me convidaram muito em cima da hora e quanto fui me inscrever, descobri que já tinha esgotado as vagas dias atrás... É meu amigo, fica para uma próxima ocasião! 😐 Mas, quem sabe eles disponibilizam os desafios no https://ctf-br.org/, porque são eles é que tão organizando isso parece...
  7. Olá meus amigos, meu prof. divulgou hoje para os alunos da minha classe que teremos um evento bacana em Uberlândia/MG sobre várias áreas ligadas a TI, mas principalmente programação. Olhei a programação dos eventos e vi que terá um CTF, semana que vem, dia 23/05 as 21:00 no Campus Santa Mônica! Se quiser participar, acesse o site da inscrição para maiores informações: http://www.techweek.facom.ufu.br/inscricoes-2018 Não sei ainda como vai ser esse CTF, mas fiquei curioso para saber o nível de dificuldade que seriam os desafios e se seria acessível para quem está começando (eu!) Não posso dizer que estarei presente nesse dia, no entanto, recomendo a participação! Abraço galera, valeu! 😃
  8. @Lucas Rodrigues muito interessante esse seu comentário amigo. Segue um trecho da conversa que tive com @Fernando Mercês no discord sobre edição colaborativa: gzn - Ontem às 16:24 permite la uns PR que a galera quando ver algo envia a correção:grinning: :ok_hand: fernandom - Ontem às 18:42 tenho pensado nisso mas ainda não achei um jeito muito simples vou integrar com o github em breve... to indo devagar, até porque tem todo um estilo de escrita que não quero quebrar. Nunca escrevi um livro à várias mãos, então não sei como seria.
  9. Só o >= que deveria ser <= mesmo. Testa aí meu amigo, clica nesse link aqui (testei no site que o @Felipe.Silva falou). Aperte Run lá que você verá que funciona normalmente. Outra coisa... Melhora o nome das suas variáveis amigo: renomeie reprovados para nota ou nota_aluno (use reprovados para contar o número de reprovados, veja abaixo) como na string de apresentação dos dados você usou a terminologia total ao invés de quantidade total, renomeie essa variável qntd_alunos para total e incremente reprovados ao invés de j Lembre-se de que quanto melhor ficar o seu código, quanto mais inteligível, melhor. A primeira coisa é inteligibilidade, depois vem a otimização e outros ajustes. Sempre que você usar nas tuas mensagens um termo, tenta usar esse mesmo termo para dar nome as variáveis, esse é um bom início. 😀 Ex. de como ficaria seu printf no final com essas mudanças: printf("A quantidade de alunos reprovados foi de(reprovados/total): %d/%d",reprovados,total);
  10. gzn

    Conversor de bases

    Ficou bom o código, obrigado por compartilhar! No trecho: case 'A' : num = 10; break; case 'a' : num = 10; break; Será que daria para usar só um break? case 'A' : num = 10; case 'a' : num = 10; break; Ou então talvez usar a função tolower/toupper (ctype.h) . Talvez ficaria mais elegante, não sei rsrs Ah, também poderia ter usado funções como strlen: size_t tam = strlen(array);
  11. Como fazer um simples patch com radare? Asciinema: https://asciinema.org/a/180843. Como exemplo foi usado o seguinte desafio: https://shellterlabs.com/pt/questions/quals-2009/access-pass/. Comandos novos utilizados: wa[?] push ebp write opcode, separated by ';' (use '"' around the command) Comandos que poderiam ser utilizados: Para saber quantos bytes o opcode jmp 0x62d e seu argumento ocuparia: !rasm2 jmp 0x62d|egrep -o '.{2}'|wc -l Para saber quantos bytes tem uma instrução faça um seek em algum endereço onde há a instrução que você quer e digite: ? $l
  12. Muito bom o curso, não tem igual em PT-BR meu amigo! rs Eu particularmente gosto muito quando você explica como resolver crackmes ou desafios de CTF, se puder incluir mais explicações com esses desafios seria muito bom. Bom, sou apoiador do projeto e recomendo a todos que sejam! Obrigado!
  13. Uma boa introdução para quem está começando a programar nessa linguagem! Parabéns! Futuros cursos em vídeo sobre C? Bom, minha sugestão talvez seria falar um pouco mais sobre como evitar que o software escrito em C fique inseguro, pois já vi algumas pessoas dizendo que isso é bem difícil de se fazer com C.
  14. gzn

    NoREpls

    Ei, muito bacana vocês publicarem os desafios aqui! ☺️ Só uma coisa! Por favor, quando forem colocar um binário em sites de upload comprimam o arquivo executável e coloquem uma senha nele (para não termos que desabilitar a proteção de nossos sistemas antes de passar para VM que faremos análise). Eu por exemplo tenho uma VM só com console para análise. Geralmente baixo o binário pelo host (porque nele eu tenho um navegador que suporta javascript) e passo o binário para analisar na VM. rs, aproveitei pra testar e ver se o olly 32bit roda no reactos https://prnt.sc/jf36yl @sombrakey se você resolveu depois escreve um write up aí para galera 😆
  15. É, esse negócio é complicado, já vai fazer uns dois meses que reportei um problema de segurança no site da minha faculdade e até agora não foi mudado nada... E é uma coisa tão simples que eu penso: onde está a dificuldade em mudar isso? É difícil entender...
  16. Caro leitor, você gosta de desafios? Neste artigo vou contar como resolvi um desafio de engenharia reversa do Shellterlabs, mas sem usar um disassembly! Para quem não é acostumado com o termo, de acordo com o grupo CTF-BR!, um CTF (Capture The Flag) nada mais é do que uma competição que envolve diversas áreas mas principalmente as áreas ligadas à segurança da informação. No Papo Binário também há um vídeo sobre o assunto. O desafio em questão é o Shellter Hacking Express Acidentalmente. Em sua descrição, há a seguinte frase: Acidentalmente codificamos a chave. Isso não diz muita coisa mas ao baixar o binário, percebemos que há dois arquivos: tar tf ~/Downloads/e74a74b5-86cf-4cb3-a5bb-18a36ef067cf.tgz RevEng400/ RevEng400/encoder RevEng400/key.enc Usando o comando file, verifiquei de que tipo são os arquivos extraídos: cd RevEng400/ $ file * encoder: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.2.5, stripped key.enc: data Ao ver que o encoder é um binário ELF, fui direto analisar seu código num disassembler usando objdump e gdb, mas percebi que o binário não continha os símbolos, o que torna sua análise um pouco mais difícil. Sendo iniciante em engenharia reversa e depois de horas analisando a função de cifragem, confesso que fiquei sem saber para onde ir (já viu algum apressadinho tentando aprender a tocar guitarra? Pois é, já quer ir lá tocar aquele solo, e na velocidade Steve Vai, aí não dá né? rs) e desisti, mas não por muito tempo (ei crianças, nunca desistam dos seus sonhos viu! rs), e procurei o nosso querido prof. @Fernando Mercês lá no servidor do Discord, que me deu umas dicas. Segue trecho da conversa: > @fernandom @gzn sei que vc ta treinando ER, mas nem precisa disassemblar esse binario pra esse desafio nego > se vc olhar bem, vai ver que a saída do encoder tem o tamanho da string de entrada + o byte 0x03 no final > olhando a chave encodada (key.enc), é razoável admitir que ela tenha 16 caracteres então > você só precisa encontrar qual deles é o 0xef .. um loop com bash mata > supondo que seja o 'A'... então 'A' -> 0xef, aí você vai precisar da letra que gera o 0xf9 e assim sucessivamente, até chegar em 16 Já ouviu a expressão "pensar fora da caixa"? Pois é! Por que eu fui direto disassemblar? Esse é um dos problemas quando nós estamos começando: às vezes a gente acha que o método mais difícil deve ser o único ou o melhor para se resolver problemas, mas nem sempre é assim. Daí pensei: se o Mercês falou que não é muito difícil, vamos ao menos tentar não é? Bem, a primeira coisa que fiz foi ver uma maneira de imprimir o conteúdo do binário em hexadecimal. Para isso criei um pequeno script que usa o hexdump para me dar uma saída somente com os bytes em hexadecimal do parâmetro que receber. Chamei o script de hexdump.sh e depois dei permissão de execução nele (chmod +x). Seu conteúdo é o seguinte: #!/bin/sh hexdump -v -e '/1 "%02X "' $1 Então comecei os testes: for letra in 0 A a; do echo -n "$letra "; ./encoder $letra | ./hexdump.sh; echo; done 0 7F 01 A F7 02 a F7 03 Parece que nem sempre o final é 0x03... Bem, fui verificar o conteúdo do arquivo key.enc e encontrei isso: ./hexdump.sh < key.enc EF F9 42 09 A3 1A 43 F7 8C 8B BB 22 2A C2 A3 14 03 Pela lógica, já que essa é a chave codificada, se eu passar a chave correta original em texto como parâmetro para o binário encode ele terá que gerar a sequência acima. Seguindo a dica do Mercês, usei o próprio bash para tentar quebrar o desafio, primeiro mostrando o conteúdo em hexadecimal da chave codificada, depois iterando pelos caracteres possíveis e filtrando pelo primeiro byte dela: hexdump.sh < key.enc; echo for ((i=32;i<=126;i++)); do > l=$(printf "\x$(printf "%x" $i)") > echo -n "$l " > ./encoder "$l" | ./hexdump.sh > echo done | grep 'EF' Este código basicamente faz: Mostra os bytes em hexadecimal da chave a cada vez que executarmos esse comando (só pra saber qual byte é o próximo). Itera por todos caracteres imprimíveis da tabela ASCII (faixa de 32 à 126 em decimal). Imprime o caractere na tela sem a quebra de linha. Passa essa letra para como argumento para o binário encode e imprime a saída dele em hexadecimal. Por fim, usa o grep para encontrar uma combinação que tenha o próximo byte da chave. Partindo para um exemplo prático, fui tentar encontrar a primeira letra dessa chave, sabendo que sua versão codificada deve resultar no byte 0xEF: ./hexdump.sh < key.enc; echo EF F9 42 09 A3 1A 43 F7 8C 8B BB 22 2A C2 A3 14 03 for ((i=32;i<=126;i++)); do > caractere=$(printf "\x$(printf "%x" $i)") > echo -n "$caractere ";./encoder "$l" | ./hexdump > echo done | grep 'EF' " EF 01 B EF 02 b EF 03 Conforme pode ver acima, encontrei três caracteres diferentes que, quando encodados pelo encoder, geram o byte 0xEF: ", B, e b. Escolhi seguir com o B, prefixando-o na chave para dar sequência ao script e ver se encontramos o caractere que resulta no próximo byte da chave codificada (0xF9): ./hexdump.sh < key.enc; echo EF F9 42 09 A3 1A 43 F7 8C 8B BB 22 2A C2 A3 14 03 for ((i=32;i<=126;i++)); do > caractere=$(printf "\x$(printf "%x" $i)") > echo -n "B${caractere} " > ./encoder "B$l" | ./hexdump > echo done | grep 'EF F9' % EF F9 01 E EF F9 02 e EF F9 03 Mais uma vez encontrei três opções. Foi só continuar este processo até encontrar a chave que gera os exatos 16 bytes do arquivo key.enc. Aproveitei e automatizei um brute forcer com Python: #!/usr/bin/env python3 # -*- coding: utf-8 -*- import subprocess def encode(arg): result = subprocess.run(['./encoder', arg], stdout=subprocess.PIPE) return result.stdout def loadKey(): key_enc = [] with open('./key.enc', 'rb') as file: while True: byte = file.read(1) if byte: # a ordem dos bytes aqui não importa (porque trata-se apenas de 1 byte), mas é necessário especificar key_enc.append(int.from_bytes(byte, byteorder='little')) else: break return key_enc def permutations(key='', key_enc=loadKey(), key_i=0): if key_i == len(key_enc) - 1: print(key) return for char in (chr(i) for i in range(32, 127)): result = encode(key + char) if result[key_i] == key_enc[key_i] and key_i < len(key_enc): permutations(key=key + char, key_enc=key_enc, key_i=key_i + 1) def main(): permutations() if __name__ == "__main__": main() Saída codificada em base64 (pra não estragar a brincadeira de quem vai tentar resolver o desafio por conta própria): QmV3aXRjaGluZyBTZXh0LwpCZXdpdGNoaW5nIFNleHRPCkJld2l0Y2hpbmcgU2V4dG8K Segue vídeo do canal com a explicação do algortimo de encoding desse desafio:
  17. gzn

    NAT Virtualbox

    ei @gnoo! se vc pretende uma hora acessar sua máquina nessa rede mantendo o NAT faz um encaminhamento de portas (em inglês, port mapping ou port forwarding). Nesses casos recomendo vc usar o vagrant porque é bem facinho configurar isso em várias vms Vagrant.configure("2") do |config| config.vm.box = "ubuntu/xenial64" [...] config.vm.network "forwarded_port", guest: 3002, host: 3002 end O que eu fiz acima? Eu expus a porta 3002 da VM como 3002 no host. Essa porta aí eu uso para acessar o qira.
  18. Bacana sr. Mercês! Haha, já vi um pouco disso daí alguma vezes. Só um comentário: https://pt.wikipedia.org/wiki/Compressão_sem_perda_de_dados (lossless no inglês) Outra coisa que eu posso acrescentar que tem uma relação indireta com a TI é o inglês técnico do pessoal da área. Eu não sou um cara avançado inglês (talvez, nem intermediário rsrs), mas da pra notar que o pessoal não estuda muito inglês! Algumas palavras que o pessoal sempre tem dificuldade em pronuncia (muitas vezes bem diferente do ideal) são Apple, mobile. Ate no curso que estou fazendo o pessoal dá um vacilo (até professores rsrs). "Mobaiol" (vídeo já ta no tempo certo, 13s) "Mobol" Já com a palavra Apple as pessoas no Brasil costumam falar "eipoul", mas o mais correto (creio eu) é "épol". Falou em TI é bom investir um pouco no inglês (eu faço isso com aplicativos igual duolingo rsrs) Mas todo mundo comete erros! é natural do ser, humano!
  19. Assembly com descrição Digite e asm.describe=true [0x0804845c]> pdf / (fcn) main 94 | main (int arg_ch); | ; var int local_8h @ ebp-0x8 | ; var int local_4h @ ebp-0x4 | ; arg int arg_ch @ ebp+0xc | ; DATA XREF from 0x080483af (entry0) | 0x0804845c b 55 push ebp ; push word, doubleword or quadword onto the stack | 0x0804845d 89e5 mov ebp, esp ; moves data from src to dst | 0x0804845f 83ec18 sub esp, 0x18 ; substract src and dst, stores result on dst | 0x08048462 83e4f0 and esp, 0xfffffff0 ; binary and operation between src and dst, stores result on dst | 0x08048465 b800000000 mov eax, 0 ; moves data from src to dst | 0x0804846a 83c00f add eax, 0xf ; adds src and dst, stores result on dst | 0x0804846d 83c00f add eax, 0xf ; adds src and dst, stores result on dst | 0x08048470 c1e804 shr eax, 4 ; logic right shift (0 padding) | 0x08048473 c1e004 shl eax, 4 ; logic left shift (0 padding) | 0x08048476 29c4 sub esp, eax ; substract src and dst, stores result on dst | 0x08048478 c745f8000000. mov dword [local_8h], 0 ; moves data from src to dst | 0x0804847f c745fcdec052. mov dword [local_4h], 0x5e52c0de ; moves data from src to dst | 0x08048486 8b450c mov eax, dword [arg_ch] ; [0xc:4]=-1 ; 12 ; moves data from src to dst | 0x08048489 83c004 add eax, 4 ; adds src and dst, stores result on dst | 0x0804848c 8b00 mov eax, dword [eax] ; moves data from src to dst [...] Essa configuração é muito útil para quando a gente está começando a entender código assembly.
  20. Como visualizar as configurações em uso no radare? É só digitar e*~padrão. Obs.: substitua padrão por qualquer texto que queira encontrar (é uma expressão regular). [0x0804845c]> e*~symbol "e asm.symbol = false" "e asm.symbol.col = 40" "e pdb.server = https://msdl.microsoft.com/download/symbols" Para listar todas as configurações e usar o paginador interno apenas digite e*~.. "e anal.a2f = false" "e anal.afterjmp = true" "e anal.arch = x86" "e anal.armthumb = false" "e anal.autoname = true" "e anal.bb.align = 0x10" "e anal.bb.maxsize = 1024" "e anal.bb.split = true" "e anal.brokenrefs = false" "e anal.calls = false" "e anal.cjmpref = false" "e anal.cpp.abi = itanium" "e anal.cpu = x86" "e anal.datarefs = false" "e anal.depth = 64" "e anal.eobjmp = false" "e anal.esil = false" "e anal.fcnprefix = fcn" "e anal.from = 0xffffffffffffffff" "e anal.gp = 0" "e anal.gp2 = 0" "e anal.hasnext = false" "e anal.hpskip = false" "e anal.ijmp = false" "e anal.in = io.maps" [...]
  21. kkkkkkk valeu meu amigo @Fernando Mercês! sou só um pequeno gafanhoto rsrs vlw pelas palavras de motivação!
  22. GSoC 2018 do radare Esse ano o negócio promete mesmo! Esse ano são seis participantes que vão trabalhar no radare2, no radeco também no cutter (a interface gráfica do radare ). Dois vão estar trabalhando na biblioteca de decompilação radeco-lib e integrando ela ao radare2 Outros dois vão estar trabalhando no radare2 um na interface e o outro melhorando o suporte a estruturas E um vai estar trabalhando na GUI do radare (você que tem medo do radare porque ele opera principalmente pela CLI agora vai poder usar melhor a GUI dele!)
  23. Integrando o snowman com radare2 r2pm init sudo apt-get install libboost-dev libqt4-dev cmake build-essential r2pm install r2snow Se você usa o vagrant lembre-se de adicionar mais memória porque o padrão de 1 GiB não é suficiente para compilar o snowman, coloque uns 2 GiB e as chances serão maiores de você compilar esse negócio. Depois de compilar ele você simplesmente carrega seu binário no radare e digita !r2snow. No diretório em que você executou esse script aparecerá alguns arquivos como: r2snow-addrof.txt, r2snow-source.c e r2snow-source.c.txt.
  24. @gerardo-junior também pensei nisso amigo. Com técnicas de esteganografia dá para usar quase qualquer tipo de mídia e em que qualquer lugar para essa finalidade. Até daria para usar comentários de sites como YouTube para controlar as máquinas infectadas... enfim, qualquer lugar em que alguém possa se cadastrar e expor algum tipo de dado seria um potencial alvo para isso.
  25. gzn

    duvida

    Se você pretende alterar um binário no formato PE você pode pesquisar pelos termos "infect PE", "binary code injection PE". Acho que cada formato de arquivo executável tem lá suas particularidades. Por exemplo, você pode pensar no seguinte (se meu raciocínio estiver errado alguém me corrija! rs): Crie um programa normal em C com os comandos que você quer utilizar. Compile ele e retire o código da seção .text dele. Analise as bibliotecas que ele precisa. Crie uma nova seção executável no binário que você quer colocar esse código e "cole" lá. Atualize as bibliotecas que o binário precisa com base no seu código e veja se está faltando alguma biblioteca. Mude o ponto de entrada do binário para seu código e do seu código desvie para o ponto de entrada original do binário que você quer modificar. Essas 6 etapas podem ser divididas em subetapas e o negócio não é simples porque você vai precisar saber como funciona o carregamento de um binário variando o formato (ELF, PE-COFF, PE). KKKK no mais, não tenho condições de prosseguir e te ajudar porque também... não sei sei! Siga o método cartesiano e divida esse problema em problemas simples! Quem sabe outros experientes que trabalham na área e lidam com infecções possa ajudá-lo a entender isso... E... ouvintes de Sócrates ficavam surpresos ao pensar nas perguntas que ele fazia a fim de demonstrar que eles não sabiam o que diziam saber, mas quando supunham que Sócrates sabia das respostas ele mesmo dizia: "Eu também não sei, por isso estou perguntando"! Daí surgiu a expressão que resume esse pensamento dele, só sei que nada sei! Eu também digo o mesmo!
×
×
  • Create New...