Jump to content

Fernando Mercês

Administradores
  • Content Count

    705
  • Joined

  • Last visited

Everything posted by Fernando Mercês

  1. Oi @kassane. Eu não tenho usado o Telegram mas se puder compartilhar lá, agradecemos! 😉
  2. O que é Análise de Malware? É o processo de entender como um malware funciona, o que faz e qual seu impacto no ambiente alvo. Pode envolver análise de toda a campanha ou infraestrutura do malware e até mesmo chegar em atribuição. Como funciona? Com conhecimentos de engenharia reversa, análise estática e dinâmica, além de algum conhecimento específico da comunidade de investigação, é possível mapear as rotinas maliciosas de um arquivo, entender seu funcionamento e até mesmo gerar assinaturas para deteção, prevenção e mitigação de ataques de malware. O treinamento O AMO (Análise de Malware Online) é um treinamento básico gratuito publicado no nosso canal no YouTube Papo Binário, graças ao suporte dos nossos apoiadores. A ideia é formar um analista de malware júnior, que possa atuar com análise em empresas ocupando cargos na área de análise de malware, resposta à incidentes, SOC, analista forense, entre outros. As aulas publicadas estão abaixo. Pré-requisitos Conhecimento em criação de máquinas virtuais. Ter assistido o Curso de Engenharia Reversa Online (CERO). Ter assistido o Programação Moderna em C. Instrutor @Fernando Mercês Aulas publicadas Aula 0 +1 - Preparando o ambiente e analise inicial do primeiro malware!
  3. Saudações, gnoo. É, verifiquei aqui no sistema e não tem essa opção, não sei o motivo, já que é possível editar os posts no fórum e as avaliações feitas, por exemplo. O jeito é comentar de novo com a ratificação. Não é a solução mais adequada, entendo, mas não vejo outra alternativa rápida. Abraço.
  4. É nóis! Obrigado pelas perguntas também! 😉 Sim, os endereços nela são resolvidos em loading time e o loader a preenche. Eu não lembro se falo especificamente desta seção, mas já viu esta aula do CERO? De qualquer forma, tem o livro "Learning Linux Binary Analysis" do elfmaster que tem mais informações. Eu sei pouco sobre este processo, só entendo o básico mesmo. Sinceramente, eu encontrei esse arquivo por minha conta quando tava tentando dumpar a memória de um processo no contexto de forense. Nunca vi documentação sobre ele, mas acho que o comando pmap o utiliza, então pode ser outra forma de buscar também, além do fonte do kernel em si claro. Abraço!
  5. Olá, bom dia! Estamos buscando um Desenvolvedor com conhecimento de C++ que tenha experiência com framework Qt, Git e MySQL para atuar em uma empresa de tecnologia especializada em Engenharia Submarina localizada na Barra da Tijuca. Inglês de intermediário a avançado é importante. Você tem interesse? Pode encaminhar seu CV com atual salário? Caso não, posso contar com a sua indicação de bons profissionais? Aguardo seu retorno. Obrigada, isabelle.teixeira @ beexecutive.com . br
  6. Olha, eu não sou um grande especialista e toda vez que olho no Linux parece que tá tudo diferente mas acho que só tá te faltando o conceito de mapeamento (mapping). No caso do ELF os segmentos (no arquivo) são mapeados para a memória, ou seja, têm seu conteúdo copiado e ganham endereços lá. Só que cada segmento pode possuir várias seções. Por exemplo, vou compilar um programa que imprime seu próprio PID e também tem uma string (pra forçar a criação da seção .data no binário): #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main(void) { char s[] = "Meu PID:"; printf("%s %d\n", s, getpid()); while (1); return 0; } Podemos compilar e analisar como ficaram os segmentos e as seções no binário (no arquivo, antes de ser carregado, ou seja, antes de ter suas seções mapeadas para a memória): $ gcc -no-pie -o hello hello.c $ readelf -l hello Elf file type is EXEC (Executable file) Entry point 0x401050 There are 11 program headers, starting at offset 64 Program Headers: Type Offset VirtAddr PhysAddr FileSiz MemSiz Flags Align PHDR 0x0000000000000040 0x0000000000400040 0x0000000000400040 0x0000000000000268 0x0000000000000268 R 0x8 INTERP 0x00000000000002a8 0x00000000004002a8 0x00000000004002a8 0x000000000000001c 0x000000000000001c R 0x1 [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2] LOAD 0x0000000000000000 0x0000000000400000 0x0000000000400000 0x0000000000000470 0x0000000000000470 R 0x1000 LOAD 0x0000000000001000 0x0000000000401000 0x0000000000401000 0x00000000000001dd 0x00000000000001dd R E 0x1000 LOAD 0x0000000000002000 0x0000000000402000 0x0000000000402000 0x0000000000000148 0x0000000000000148 R 0x1000 LOAD 0x0000000000002e10 0x0000000000403e10 0x0000000000403e10 0x0000000000000228 0x0000000000000230 RW 0x1000 DYNAMIC 0x0000000000002e20 0x0000000000403e20 0x0000000000403e20 0x00000000000001d0 0x00000000000001d0 RW 0x8 NOTE 0x00000000000002c4 0x00000000004002c4 0x00000000004002c4 0x0000000000000044 0x0000000000000044 R 0x4 GNU_EH_FRAME 0x000000000000200c 0x000000000040200c 0x000000000040200c 0x000000000000003c 0x000000000000003c R 0x4 GNU_STACK 0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000 RW 0x10 GNU_RELRO 0x0000000000002e10 0x0000000000403e10 0x0000000000403e10 0x00000000000001f0 0x00000000000001f0 R 0x1 Section to Segment mapping: Segment Sections... 00 01 .interp 02 .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt 03 .init .plt .text .fini 04 .rodata .eh_frame_hdr .eh_frame 05 .init_array .fini_array .dynamic .got .got.plt .data .bss 06 .dynamic 07 .note.ABI-tag .note.gnu.build-id 08 .eh_frame_hdr 09 10 .init_array .fini_array .dynamic .got Perceba que os segmentos de 02 a 05 são do tipo LOAD. Isto significa que eles serão mapeados/carregados/copiados para a memória. Na sequência você qual seção pertence a cada segmento. Daria pra dizer o seguinte então: A .text tá no segmento 03, vai ser mapeada em 401000, que tem permissão de leitura e execução (R E). A .rodata tá no segmento 04, vai ser mapeada em 402000, que tem permissão de leitura somente (R). A .data e .bss estão no segmento 05, vão ser mapeadas em 403e10, que tem permissão de leitura e escrita (R W). Só que seções diferentes vão para regiões diferentes da memória do processo, como a imagem que você postou ilustra, então esse mapeamento não é um pra um. Pra checar, executa o programa e pega o PID: $ ./hello Meu PID: 2186 Noutra aba: $ cat /proc/2186/maps 00400000-00401000 r--p 00000000 08:01 131608 /tmp/hello 00401000-00402000 r-xp 00001000 08:01 131608 /tmp/hello 00402000-00403000 r--p 00002000 08:01 131608 /tmp/hello 00403000-00404000 r--p 00002000 08:01 131608 /tmp/hello 00404000-00405000 rw-p 00003000 08:01 131608 /tmp/hello 01620000-01641000 rw-p 00000000 00:00 0 [heap] 7f9efaa89000-7f9efaaab000 r--p 00000000 08:01 664113 /usr/lib/x86_64-linux-gnu/libc-2.28.so 7f9efaaab000-7f9efabf3000 r-xp 00022000 08:01 664113 /usr/lib/x86_64-linux-gnu/libc-2.28.so 7f9efabf3000-7f9efac3f000 r--p 0016a000 08:01 664113 /usr/lib/x86_64-linux-gnu/libc-2.28.so 7f9efac3f000-7f9efac40000 ---p 001b6000 08:01 664113 /usr/lib/x86_64-linux-gnu/libc-2.28.so 7f9efac40000-7f9efac44000 r--p 001b6000 08:01 664113 /usr/lib/x86_64-linux-gnu/libc-2.28.so 7f9efac44000-7f9efac46000 rw-p 001ba000 08:01 664113 /usr/lib/x86_64-linux-gnu/libc-2.28.so 7f9efac46000-7f9efac4c000 rw-p 00000000 00:00 0 7f9efac71000-7f9efac72000 r--p 00000000 08:01 664105 /usr/lib/x86_64-linux-gnu/ld-2.28.so 7f9efac72000-7f9efac90000 r-xp 00001000 08:01 664105 /usr/lib/x86_64-linux-gnu/ld-2.28.so 7f9efac90000-7f9efac98000 r--p 0001f000 08:01 664105 /usr/lib/x86_64-linux-gnu/ld-2.28.so 7f9efac98000-7f9efac99000 r--p 00026000 08:01 664105 /usr/lib/x86_64-linux-gnu/ld-2.28.so 7f9efac99000-7f9efac9a000 rw-p 00027000 08:01 664105 /usr/lib/x86_64-linux-gnu/ld-2.28.so 7f9efac9a000-7f9efac9b000 rw-p 00000000 00:00 0 7ffcd5fbf000-7ffcd5fe0000 rw-p 00000000 00:00 0 [stack] 7ffcd5feb000-7ffcd5fee000 r--p 00000000 00:00 0 [vvar] 7ffcd5fee000-7ffcd5ff0000 r-xp 00000000 00:00 0 [vdso] Veja que temos 5 segmentos no hello, além de heap e stack. Mas eram 4 segmentos que seriam mapeados né? É, mas algumas seções deles foram mapeadas com permissões diferentes, exigindo outros segmentos. Para ver quais, pode usar o gdb, attachando no processo: $ gdb -q -p 2186 Attaching to process 2186 Reading symbols from /tmp/hello...(no debugging symbols found)...done. Reading symbols from /lib/x86_64-linux-gnu/libc.so.6...(no debugging symbols found)...done. Reading symbols from /lib64/ld-linux-x86-64.so.2...(no debugging symbols found)...done. 0x000000000040116b in main () (gdb) info file Symbols from "/tmp/hello". Native process: Using the running image of attached process 2186. While running this, GDB does not access memory from... Local exec file: `/tmp/hello', file type elf64-x86-64. Entry point: 0x401050 0x00000000004002a8 - 0x00000000004002c4 is .interp 0x00000000004002c4 - 0x00000000004002e4 is .note.ABI-tag 0x00000000004002e4 - 0x0000000000400308 is .note.gnu.build-id 0x0000000000400308 - 0x0000000000400324 is .gnu.hash 0x0000000000400328 - 0x00000000004003a0 is .dynsym 0x00000000004003a0 - 0x00000000004003e6 is .dynstr 0x00000000004003e6 - 0x00000000004003f0 is .gnu.version 0x00000000004003f0 - 0x0000000000400410 is .gnu.version_r 0x0000000000400410 - 0x0000000000400440 is .rela.dyn 0x0000000000400440 - 0x0000000000400470 is .rela.plt 0x0000000000401000 - 0x0000000000401017 is .init 0x0000000000401020 - 0x0000000000401050 is .plt 0x0000000000401050 - 0x00000000004011d1 is .text 0x00000000004011d4 - 0x00000000004011dd is .fini 0x0000000000402000 - 0x000000000040200b is .rodata 0x000000000040200c - 0x0000000000402048 is .eh_frame_hdr 0x0000000000402048 - 0x0000000000402148 is .eh_frame 0x0000000000403e10 - 0x0000000000403e18 is .init_array 0x0000000000403e18 - 0x0000000000403e20 is .fini_array 0x0000000000403e20 - 0x0000000000403ff0 is .dynamic 0x0000000000403ff0 - 0x0000000000404000 is .got 0x0000000000404000 - 0x0000000000404028 is .got.plt 0x0000000000404028 - 0x0000000000404038 is .data 0x0000000000404038 - 0x0000000000404040 is .bss Taí, todas as seç˜ões daqueles 4 segmentos do tipo LOAD (PT_LOAD o nome certo hehe) e seus devidos endereços de início e sim. Você pode fazer um paralelo com o conteúdo do /proc/<pid>/maps e ver que faz sentido, por exemplo, a .data estar em 404028 já que a .got.plt também precisa ficar numa região com leitura e escrita e esta é listada antes da data no segmento 05. Já a .got, originalmente (no arquivo), num segmento com rw, foi para uma região somente com leitura. Resumindo, na prática o número de regiões de memória (segmentos na imagem que você postou) pode ser outro. Pode ser confuso mesmo, porque tem segmento e seção no arquivo, depois segmento em memória e seção na memória, ou seja, 4 coisas, mas o mapeamento não é um pra um. Espero que ajude. Brincando mais com gdb, readelf, etc aí e fazendo mais testes tenho certeza que vai ficar mais claro. 👍 Abraço!
  7. Opa, tem várias coisas incorretas aí. O certo seria imprimir a. O tamanho do array é 5, mas você tá passando 10. Essa linha diz "enquanto 10 for menor que 10", então nem nada neste bloco será executado... A sua função sort também tá meio confusa. Não entendi bem como você quis fazer. O bubble sort consiste simplesmente em percorrer o array n-1 vezes, onde n é o tamanho do array (ou seja, seu número de elementos) testando se o elemento é menor que o anterior. Se sim, trocam-se. Recomendo estudar mais o bubble sort. Tem muito material na web sobre, além de vídeos no YouTube, etc. Só não pegue nada pronto, do contrário você não aprende e daí seu tempo de estudo é jogado no lixo e a grana e o tempo que você tá investindo neste curso/faculdade também. 😉 Abraço!
  8. Opa! Na verdade a função compara o argumento recebido (char param_1) com os elementos de um array (eu prefiro chamar assim, pra não confundir com os tipos vector em algumas lingaugens). Só pra ficar mais preciso, pois não é "um valor de um vetor". Mas eu entendi o que você quis dizer. 😉 O array tem que estar pronto quando essa função é chamada. Logo, basta colocar um breakpoint logo no início dessa função e olhar o conteúdo do array. Não lembro se o Ghidra já tem debugger, mas você pode usar o gdb. Na real, podemos assumir que não existem muitos "tipos" em baixo nível. É tudo número mesmo e o tamanho é que importa. Se o Ghidra usou (int) e o tamanho do elemento é 4, é isso, estamos diante de um array de elementos do tipo int32 (4 bytes). É uma boa dedução, mas dá pra ver isso rápido porque o Ghidra já nomeou o vetor como DAT_. Este prefixo é para variáveis na seção .data (ou numa seção com as mesmas propriedades, já que o nome da seção em si não vale de muita coisa). A distância do endereço dele (301020) para a função (1007fa), que tá numa seção de código - normalmente a .text), também sugere que ele está em outra seção e se você for no "memory map" do Ghidra (entre aspas porque não lembro como o Ghidra chama), vai ver que 301020 está no range da seção .data (entre seu início e fim). Se você desconfiar das suposições do Ghidra, pode sempre checar o Assembly. De novo, o que vai definir o tipo é como o conteúdo é lido. Se são 4 bytes, é int32. Se as instruções de comparação são as que consideram sinal, então é signed. Do contrário, unsigned. E por aí vai. Ótimas perguntas! Abraço!
  9. Hackers To Hackers Conference (H2HC) é uma conferência organizada por pessoas que trabalham ou que estão diretamente envolvidas com pesquisas e desenvolvimento na área de segurança da informação, cujo principal objetivo é permitir a disseminação, discussão e a troca de conhecimento sobre segurança da informação entre os participantes e também entre as empresas envolvidas no evento. Com treinamentos e palestras apresentadas por membros respeitados do mundo corporativo, grupos de pesquisas e comunidade underground, neste ano a conferência promete demonstrar técnicas que nunca foram vistas ou discutidas com o público anteriormente. E por que realizar uma conferência onde podem ser demonstradas novas técnicas de ataque, novas ferramentas e pontos de inseguranças de sistemas? Porque queremos mostrar esse tipo de informação para o público, principalmente para pessoas cujo trabalho é proteger e aumentar a segurança dos sistemas e fazer com que elas entendam melhor como os outros atacam os seus computadores. As pessoas que atacam normalmente conhecem diversas técnicas e é importante que analistas de segurança, auditores de sistemas entre outras pessoas responsáveis pela segurança também saibam como se defender. Como pode ser percebido ao acessar os melhores fóruns, sites e listas de e-mail sobre o assunto, encontrar falhas de segurança não é uma tarefa muito difícil. Para cada falha descoberta por um pesquisador e enviada a um fabricante, provavelmente existem outras que já são conhecidas por pesquisadores que não notificam o fabricante. E nós acreditamos que a melhor maneira para se proteger contra essas falhas desconhecidas é entender profundamente como os problemas acontecem e criar mecanismos de segurança para impedir uma classe de falhas, e não apenas aplicar as correções publicadas pelo fabricante e esperar que ninguém ataque seu sistema com 0day. Mais informações: https://www.h2hc.com.br/h2hc/pt/
  10. until
    Linux Developer Conference Brazil aims to take the Brazilian Linux development community to the international level. Whether you are just curious and want to understand the Linux ecosystem, someone seeking to contribute to FOSS projects, or a seasoned collaborator, this conference is for you. https://linuxdev-br.net
  11. @SodaSodaBashi opa, infelizmente não tem um log no Discord pra saber que mensagem que causou isso.. pode ter sido algum spam? De qualquer forma, tá de volta. Desculpe o inconveniente. 😌
  12. Animal, Frederico. Parabéns e obrigado por isso!
  13. Sempre penso que, se foi criado o comando na linguagem, deve haver algum motivo e não consigo aceitar um simplesmente "não use", a não ser que seja algo de fato que os desenvolvedores recomendem parar de usar porque será removido nas próximas versões da especificação e tal. Não é o caso do "goto". Ele continua lá e os compiladores todos suportam, logo, que seja usado hehe. Boas práticas de programação vão sempre existir, no entanto. =)
  14. Bem vindo, @Wellington Rocha! Obrigado pelo feedback! Espero que curta a comunidade aqui! 🙂
  15. Eu conduzi uma OBI quando era professor de um colégio e os alunos curtiram muito. Seu professor vai inscrever a escola @Exodia? Se sim, cai dentro! É uma competição muito legal de programação que sempre vem com problemas novos. Busque os problemas das anteriores e treine com eles, acho que você vai gostar. Outro bom lugar pra treinar é o https://br.spoj.com 😉 Na época os alunos todos fizeram com C, mas é que nem existia Python ainda (ou não era popular). Em tese qualquer linguagem serve, mas se você escolher a que já está tendo aulas, pode ser mais fácil pra trocar ideias com outros alunos, com o professor, etc. Abraço!
  16. Fernando Mercês

    resolvido

    Não precisava ter editado o texto e título do tópico para "resolvido", @Fabricio, porque pode ser que a tua dúvida fosse a de outros membros que passassem por aqui. 😉
  17. Parabéns pela paciência e ímpeto de compartilhar, @gnoo!
  18. Dá uma olhada também nestes vídeos ó: Ambos são parte do nosso curso gratuito de engenharia reversa, o CERO. 😉 Abraço!
  19. Não sei como o @fredericopissarra gerou os PDF's, mas talvez seja possível usar algum conversor?
  20. O time de desenvolvimento do Ghidra anunciou a versão 9.1 do software, agora com suporte aos processadores SH1/2/2a, Tricore, HCS12X, HCS08, SH4 e MCS-48. Podem parecer muito exóticos, mas SH4 por exemplo é uma das plataformas alvejadas por malwares para IoT como Mirai e outras botnets. Dentre os novos recursos, tem o suporte à edição de estruturas (structs) e uniões (unions) nos Data Types, assunto que cobrimos na aula 08 do treinamento de Ghidra aqui do Mente Binária. 😉 Lista completa das alterações e links para download no site oficial.
  21. Oi @diego.rax! Os slides vão estar disponíveis pra download no site da H2HC em breve. 😉 Abraço!
  22. Fernando Mercês

    Meetup C/C++

    until
    From: Lauro Moura Pessoal, estamos tentando organizar um encontro da comunidade C/C++ em Floripa. Ao invés de palestras, seria mais um momento p/ conversar, trocar idéias, confraternizar, falar das palestras da CppCon, planejar outros encontros, etc. O evento está marcado para a sexta feira 8 de novembro no meetup mas estamos discutindo entre o dia 8 e a quinta feira 7. Também estamos decidindo o local, entre Coqueiros e (por enquanto o favorito) Centro.
  23. O pesquisador Fermín J. Serna, keynote speaker na H2HC este ano, iniciou sua palestra intitulada OSS Security: Here be dragons falando sobre a lendária edição da H2HC em Cancún realizada há 10 anos. "Eram umas 25 pessoas, sendo que 10 eram palestrantes", brincou. 😁 Fermín foi o principal desenvolvedor do já descontinuado EMET e sua paixão por segurança defensiva é notória. Hoje, CSO na Semmle, empresa agora parte do Github, ele afirmou que o software livre venceu e hoje 90% dos softwares utilizam outros, de código aberto. Fermín lembra que software livre é gratuito do ponto de vista monetário, mas não vem com segurança grátis. "Software livre de segurança vem com desafios. Você consome, mas precisa investir". Vários exemplos de vulnerabilidades foram mostrados durante a palestra, inclusive uma tentativa de se colocar uma backdoor no kernel Linux que aconteceu em 2003. Tudo isso antes de apresentar o projeto CodeQL, que consiste num esforço de criar uma linguagem de query para encontrar bugs (principalmente de segurança, mas expansível a quaisquer outros tipos) em códigos-fonte. O projeto já encontrou vulnerabilidades em softwares de código aberto, incluindo o U-Boot e o próprio kernel Linux. "Dá trabalho confirmar as vulnerabilidades, mas só de atribuições indevidas, já encontramos umas 1300 no kernel Linux", contou. Apesar de tantos bugs, Fermín fez questão de dizer que isso não é culpa dos programadores: "software de código aberto é ótimo e está aqui pra ficar. Não devemos culpar os desenvolverdes. Devemos nos culpar, porque não os ajudamos", reiterou. Parabéns, Fermín! 👏
×
×
  • Create New...