Jump to content

Leandro Fróes

Mente Binária
  • Content Count

    166
  • Joined

  • Last visited

  • Country

    Brazil

Community Reputation

17 Good

Personal Information

Recent Profile Visitors

3,000 profile views
  1. @Quer Vinho Opa, na verdade você esqueceu de colocar o \n (isto é, o caracter que representa uma nova linha) dentro das aspas para que o printf interprete o resultado propriamente. Por padrão a printf entende o que você passar como primeiro parâmetro pra função como um const char *, então neste caso você não precisa especificar %s como o "formatador": printf("Mente Binaria eh foda! =)\n");
  2. Opa, poderia ser mais específico? O que quer saber exatamente? Dependendo do que você quer saber não tem necessidade de ler toda uma documentação.
  3. Opa, Eu acredito que antes de usar qualquer ferramenta é importante entender o que ela está fazendo e como ela faz. Se você está tendo dificuldade em entender o que está rolando quer dizer que tem algo faltando, algum entendimento sobre algo. Exatamente como você falou, você precisa entender melhor o que está rolando "por trás dos panos". É super normal estarmos mexendo em algo e não entendermos direito aquilo, e é justamente por isso que temos que focar na base da computação e no seu caso, a base de redes, coisa que nenhum "curso de hacking" vai ti ensinar 🙂. Acho legal você dar uma estudada na base de redes: o que é um IP, o que é uma porta, por que eles são assim, o que é um socket e por ai vai. Com o tempo você vai ver que ferramentas são só ferramentas, que ajudam a gente a fazer um trabalho, tornam ele mais prático, mas pra saber exatamente o que está acontecendo, pra utilizar a ferramenta direito, só entendendo de fato os conceitos que a envolvem. Queria ti indicar esse arquivo aqui que temos no portal sobre como se tornar um bom profissional de segurança, isto é, como começar em tudo! Espero ter ajudado em algo. Abs.
  4. Faz algum tempo que ando botando mais a mão na massa na parte prática da análise de malware e nos conceitos que a envolvem. Este fato somado com minha paixão por tomar notas nos meus estudos acaba resultando na criação de alguns relatórios. Com isto em mente, decidi colocar aqui a análise do último sample no qual trabalhei, de um ransomware chamado Nephilin. Overview O Nephilin é uma variante do Nefilim, um Ransomware que acabou ficando bem conhecido no mês de fevereiro/março devido ao fato de ser uma variante do conhecido Nemty, que costumava trabalhar com operações de RaaS (Ransomware as a Service - um modelo de negócio utilizado por criminosos que facilita muito a distribuição de Ransomwares. Basicamente o criador do malware recruta pessoas para usarem o Ransomware e recebe uma parte de seus lucros, facilitando assim a distribuição e a entrada de pessoas não experientes no crime). Por mais que as formas de operação sejam diferentes, há similaridades de código entre essas três famílias de malware. Análise Estática O sample analisado foi compilado para x86 e não possui nenhuma técnica que possa dificultar nossa análise como por exemplo packers/protectors e o uso de ASLR. No entanto, este binário é assinado com um certificado válido: Olhando os imports podemos notar que a Import Directory Table possui apenas uma entrada, a da kernel32.dll, levantando a suspeita da utilização de runtime linking, ou seja, o loader não resolve o endereço das funções em tempo de carregamento, pois eles são resolvidos em tempo de execução: Podemos suspeitar ainda mais pelo fato do nome algumas DLLs estarem na lista de strings do binário, assim como o nome de algumas funções que não são exportadas pela kernel32.dll: Não vou me preocupar muito com esta parte estática da análise, tendo em vista que a ideia deste artigo é cair de cabeça em cada funcionalidade do malware, isto é, executá-lo e ir analisando seu comportamento. Análise Dinâmica A primeira função que o malware chama é a que vai criar todo o contexto de criptografia para gerar uma chave que será a chave utilizada para descriptografar a Ransom Note: Dentro desta função existem várias funções que permitem trabalhar com criptografia no Windows. A primeira função criptográfica chamada é a CryptAcquireContext, responsável por criar um handle para um key container dentro de um Cryptographic Service Provider (CSP). Após pegar o handle, o tamanho de uma string é calculado para posteriormente se criar e retornar um Hash Object dentro do CSP criado anteriormente. Esta string tem 66 bytes de tamanho (0x42 em hexa) e é uma string lotada de "a". A função CryptCreateHash cria o Hash Object especificando o tipo como SHA1 e, logo depois, a função CryptHashData tira o hash do que está dentro de um buffer de tamanho 66 bytes sendo passado como parâmetro: Por fim, o SHA1 gerado é derivado, para a geração de uma chave RC4. Como podemos ver quase todas as funções estão sendo importadas dinamicamente. 🙂 O que acontece após a função que gera esta chave RC4 é a criação de um Mutex com o nome "sofos delaet sosos": Em seguida, uma string em base64 aparece e é decodada com a função CryptStringToBinary, resultando em uma chave pública RSA: "BgIAAACkAABSU0ExAAgAAAEAAQDNFw18bUF1x32DZaZt4gnQtAnv5XH60d9B6UgIbVfRdHPeyEljZLKlGBKFPTsh+8xsDHe/9vynuOlnuPt91grReMAwcTDVkxBh/PDkf3Jq0bnFgZAWbgMvGX6lApXTDcTArf4US63VI3z8YPyDNJwEvBEWI13ywob8ECLsrD/C6BPkYG0mBU1ccixzOgkgad0iDvwS/C8iyW1Mi0PCoBa+3TCTVwt0Zpy/HceV5U7SevG7RRN5HrErv54Ihg6kTPPhdxkYdO+CUND19aLqh8MAVLRuP5hR6b6r7cjBNAW2+USaaMyT/llNXdPdySbatLlH6Mau4z1eqzYc7hMB2f+6" Há depois uma tentativa de pegar um handle para um CSP onde o key container tem o nome "rsa session" e, sem sucesso, o binário cria um novo chamado "skr skr skr": Agora a chave pública decodada anteriormente será importada para o contexto "skr skr skr": Ações padrão da maioria dos ransomwares incluem desabilitar a checagem de erros durante o boot, desabilitar o modo de recuperação, deletar backups, etc. O Nephlin faz isso através de uma chamada à função ShellExecuteA() passando uma linha com o cmd.exe como parâmetro: "C:\\asdfgsdgasd\\..\\Windows\\asdgagsahsfahfhasahfsd\\..\\System32\\cmd.exe" "/c bcdedit /set {default} bootstatuspolicy ignoreallfailures & bcdedit /set {default} recoveryenabled no & wbadmin delete catalog -quiet & wmic shadowcopy delete" Aqui foi utilizada uma abordagem um tanto curiosa, tendo em vista que o malware considera diretórios que provavelmente não existirão no sistema de arquivos da vítima ("asdgagsahsfahfhasahfsd", por exemplo) e sobe um nível no filesystem utilizando ".." para acessar de fato o que importa, ou seja, o caminho real seria simplesmente "C:\Windows\System32\cmd.exe" 🙂 Neste momento acontece uma checagem em relação à como o malware foi executado na linha de comando. Se foi passado algum parâmetro, ele checa pra ver se é um arquivo ou diretório. Se for um arquivo, ele chama direto a função que encripta. Caso seja um diretório, ele chama a função que checa uma lista de exclusão dos tipos de arquivos que ele não quer encriptar e esta função chama então a função que encripta. É interessante notar que com essas checagens o ransomware pode ser usado em diversos cenários e não simplesmente para encriptar o sistema completamente. Ex: para manualmente testar se ele está funcionando (antes da possível invasão), ser executado manualmente após a invasão visando diretórios/arquivos específicos, etc: Se nenhum parâmetro for passado via linha de comando, o binário começa a mapear os drives que estão no sistema e pegar seus tipos, buscando especificamente por drives fixos, removíveis (pen drives, etc) e mapeamentos de rede: Após pegar o drive o seu nome é concatenado com a string "NEPHILIN-DECRYPT.txt", à fim de criar a Ransom Note na raiz do Drive em questão: Após a chamada à CreateFile, podemos ver a Ransom Note sendo criada, mas vazia por enquanto: Antes do conteúdo ser de fato escrito no arquivo, ele precisa ser decodado, tendo em vista que é uma string em base64 (sim, outra string em base64): Abaixo está o buffer que contém o conteúdo da Ransom Note em base64: Após decodar o base64 o buffer aparenta estar encriptado, e de fato está: A função CryptDecrypt utiliza a chave RC4 gerada anteriormente para decriptar o conteúdo do buffer em questão. Podemos ver o conteúdo em clear text após a execução da função: Por fim podemos ver a função WriteFile, que irá escrever o conteúdo no arquivo "NEPHILIN-DECRYPT.txt" criado anteriormente: Agora que a Ransom Note foi criada, o processo de criptografia começa. O meio utilizado é através da criação de outra thread, isto é, para cada drive encontrado, uma nova thread é criada. A função CreateThread recebe como parâmetro para indicar seu início o endereço de uma função, que por sua vez chama a função que checa a lista de exclusão e depois começa a criptografia. Além disso, o nome do drive escolhido no momento é passado como parâmetro para esta função. Esta lista de exclusão é basicamente um lista que contém nomes de arquivos, diretórios e extensões das quais o malware não irá encriptar. Para cada arquivo encontrado o malware irá comparar com as especificações desta lista e, caso não bata, a função de criptografia será chamada: Criptografia A criptografia pode começar de 3 formas diferentes, como mencionado anteriormente: passando um arquivo como parâmetro pela linha de comando, passando um diretório ou mapeando os drives e criando threads. Um trecho da função que faz as devidas checagens pode ser observada abaixo: Se o arquivo checado não estiver na lista de exclusão, a função de criptografia é chamada: O processo de criptografia se inicia com a abertura do arquivo em questão e a obtenção do seu tamanho. Depois disso, há duas chamadas para a função SystemFunction036 para gerar números aleatórios. Basicamente esta função é um alias para a função RtlGenRandom, que recebe como parâmetro um buffer e o tamanho do número aleatório que você quer gerar. O tamanho escolhido são 16 bytes (0x10): Tendo 2 buffers de 10 bytes de tamanho cada, com os devidos números aleatórios gerados anteriormente, há duas chamadas à CryptEncrypt, uma para cada buffer. Aqui a chave pública RSA é utilizada para encriptar o buffer em questão, resultando em outros dois buffers de 256 bytes cada. O conjunto de funções a seguir faz a mesma operação, mas apontando para lugares diferentes. A função SetFilePointerEx é utilizada para apontar para o fim do arquivo (baseando-se no tamanho obtido anteriormente) e depois a função WriteFile é utilizada para escrever os 256 bytes encriptados lá. A próxima chamada à SetFilePointerEx agora aponta para o fim do arquivo + 256 bytes e então escreve o segundo buffer encriptado onde o ponteiro está apontando. Neste momento as checagens de tamanho de arquivo começam, assim como as chamadas de função e loops que envolvem a criptografia. A primeira checagem feita é se o arquivo é maior que 64MB e, caso seja, as funções que criptografam o arquivo começam a ser chamadas de 125KB em 125KB. Caso o arquivo seja menor há uma outra checagem para ver se ele é menor que 1.2MB e caso ele não seja as funções de criptografia rodam em cima de 600KB apenas e finalizam. Caso o arquivo seja menor que 1.2MB ele é encriptado "de uma vez" e depois finaliza. A criptografia é feita utilizando uma série de operações matemáticas em cima de cada buffer que é mapeado e passado como parâmetro para as funções que realizam a criptografia. É interessante notar aqui que a criptografia é customizada, isto é, não utiliza a chave pública com um algoritmo conhecido. Por fim a extensão ".NEPHILIN" é adicionada ao arquivo aberto: Uma coisa importante a se notar é que se a criptografia foi executada para um arquivo ou diretório específico tanto a Ransom Note quanto o wallpaper do Ransomware não são criados. Podemos observar que as funções de mapeamento de drives (que contém a criação da Ransom Note) e criação do papel de parede são ignoradas devido ao salto incondicional JMP: E por fim... Considerando ainda que não foram especificados arquivos e diretórios, a função responsável por criar a imagem do papel de parede é chamada. Há várias funções aqui e estas utilizam funções gráficas do Windows para editar a imagem em questão: Uma das funções chamadas nesta função responsável por criar a imagem é justamente a função de decoda o base64 da Ransom Note, pois o que é escrito no papel de parede é a mesma coisa da Ransom Note. Após várias funções gráficas para preparar a imagem o arquivo é finalmente criado em %TEMP%, com nome god.jpg e seu conteúdo é escrito no arquivo: Após configurar a imagem como papel de parede, o malware chama sua última função, que é responsável por fechar todos os handles e contextos de criptografia ainda pendentes: Depois disso, o processo simplesmente sai retornando 0. Lista de exclusão: NEPHILIN-DECRYPT.txt $RECYCLE.BIN NTDETECT.COM MSDOS.SYS IO.SYS boot.ini AUTOEXEC.BAT ntuser.dat desktop.ini CONFIG.SYS BOOTSECT.BAK program files program files (x86) windows ntldr RECYCLER bootmgr programdata appdata .dll .NEPHILIM .exe .log .cab .cmd .com .cpl .ini .url .ttf .mp3 .pif .mp4 .msi .lnk Espero que o estudo desta análise seja proveitoso assim como foi para mim e qualquer dúvida/feedback estou à disposição! Abraços!
  5. Faz algum tempo que o Mente Binária está com uma nova área de artigos, isto é, uma parte especial do site que reúne todos os artigos escritos por membros da nossa comunidade. A submissão é livre, ou seja, qualquer pessoa pode submeter um artigo e teremos o prazer de ajudar no desenvolvimento e revisão até o momento da publicação. Por onde eu começo? Comece pelo começo! 😀 A primeira coisa que você precisa ter é uma ideia de assunto para ser abordado e, após tê-la, se faça a seguinte pergunta: já existem artigos/tutoriais sobre este assunto? Eu domino minimamente este assunto? Vale a pena? Se procurarmos no google por "Introdução à linguagem Python", por exemplo, teremos um número incontável de resultados explicando de várias formas diferentes, então este talvez seja um tipo de texto "mais do mesmo", mas se sua abordagem é diferente ou o assunto é novo, certamente vale a pena. De forma alguma estamos dizendo que não é interessante você fazer suas próprias anotações sobre um assunto que seja objetivo do seu estudo, mesmo que já haja muito material sobre, mas a ideia aqui é tentarmos trazer coisas novas ou até mesmo coisas já abordadas, mas de uma forma diferente, mais fácil e direcionada para o nosso público. 😉 Ok, e depois? Após ter a ideia e responder as perguntas fale com a gente! Seja por mensagem aqui no portal ou pelo Discord, nos contacte e conte sua ideia de artigo. Depois de tudo acordado é só começar a escrever! O caminho mais rápido é um documento no Google Drive ou Office 360 compartilhado com a gente, para usarmos os recursos de revisão. Recomendações Tendo em vista que nosso portal recebe pessoas de vários níveis técnicos e áreas, é importante seguirmos algumas boas práticas e mantermos algumas coisas em mente ao escrevermos um artigo. São elas: Cuidado com o nível técnico: se o seu artigo for um artigo técnico, ótimo, só preste atenção para esclarecer nomenclaturas, siglas e conceitos que talvez o leitor não tenha. Nunca esqueça de dar referências: é de extrema importância para o leitor saber de onde você tirou as informações que estão no artigo. É interessante também adicionar locais para se aprender melhor sobre o assunto (isto pode incluir perfis de redes sociais quando estamos referenciando alguma pessoa que domine o assunto: Twitter, Github, blogs, etc). Sempre demonstre a prova de conceito (PoC): no mínimo demonstre uma prova (captura de tela, vídeo, etc) de que o que você está falando é de fato verdade. Mostre seu código: não é obrigatório, até porque ninguém é obrigado a mostrar seus códigos, mas saibam que apoiamos e muito aqueles que mostram. Demonstrando o seu código você permite que o leitor entenda melhor o que você quer dizer e abre possibilidades para contribuições, sugestões, etc (incrível, não?!). Se for o caso, coloque uma referência para o seu Github caso o código de PoC esteja lá e/ou coloque trechos de código/comandos no próprio artigo usando as tags de "Código". Tente ser o mais claro possível: parece uma afirmação óbvia, mas as vezes é extremamente difícil ser claro, principalmente com assuntos de alta complexidade. Cuidado com a ortografia: fique tranquilo que nós vamos revisar o seu artigo antes dele ser publicado, mas ainda assim, reserve um tempinho para revisar a escrita. Pense no leitor: você escreve para os outros, não para si. Sendo assim, é importante se colocar no lugar do leitor, fazendo com o que o texto antecipe suas principais dúvidas. O foco é o leitor e um artigo de sucesso é quando é útil para ele. 🙂 Terminei, e agora? Envie para a gente o artigo em formato Word (pode ser via Google Drive / Office 360 ou mesmo o documento do LibreOffice, Office, Pages, etc) que a gente vai revisar para você e com você. Talvez surjam situações onde você precisará fazer alterações e nos enviar de volta até que este fique pronto para publicação, mas, fique tranquilo, estamos acostumados com este processo e este só será publicado após sua aprovação final! Qualquer dúvida, fique à vontade para falar com a gente, dar ideias, feedbacks, etc. Esperamos que este post tenha esclarecido algumas dúvidas sobre a criação e submissão de artigos para o portal e repito, conteúdo novo é sempre bem-vindo! 🤓 Um abraço!
  6. Só adicionando em cima do assunto de "menor PE possível", tem uma pesquisa inteira sobre PE do corkami no github dele e lá tem todas as PoCs dele, incluindo um PE com a menor quantidade de elementos definidos que ele conseguiu criar considerando um contexto de execução. abs!
  7. Na minha opinião a melhor é aquela que você se sente mais confortável. Não sei se é o caso dessa Olimpíada, mas o que vejo dessas competições são desafios de lógica, ou seja, todas as linguagens conseguem atender a necessidade. A diferença ai vai ser o número de linhas que você usa pra resolver um desafio ou outro, talvez até alguma funcionalidade de uma linguagem em particular (paradigma funcional em linguagens como python, por exemplo), mas até ai nada que não possa ser feito de outro jeito com C, por exemplo. Acho que vale você optar pela que você mais tem facilidade porque independente se ela tem recurso X ou Y você vai pensar mais rápido usando ela do que outra na competição. Espero ter ajudado, abs.
  8. Nós temos o nosso curso do Pythonicos também no canal do Papo Binário. Se quiser saber um pouco sobre você pode dar uma olhada aqui. Eu fiz umas 2x e recomendo de verdade. Por mais que seja sobre Python 2.7 a ideia geral não muda muito e o curso não fala só sobre o Python em si, mas também sobre APIs e um pouco de pentest também! Abs.
  9. Fala Helder, blz? Isso é definido pelo próprio formato do arquivo e é possível sim achar só olhando pro dump em hexa. Da certo "trabalho" ficar procurando os campos olhando direto pro hexa, mas tenho que dizer, é super divertido e se aprende muito 😁. Bom, olhando para o dump do arquivo em hexa a primeira coisa que vemos é o DOS Header, que representa os primeiros 64 bytes do arquivo e nele há um campo chamado e_lfanew, que define o offset para a assinatura PE. Esta assinatura é o primeiro campo de outro header chamado NT Header: typedef struct _IMAGE_NT_HEADERS { DWORD Signature; IMAGE_FILE_HEADER FileHeader; IMAGE_OPTIONAL_HEADER OptionalHeader; } IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS; Como podemos ver a assinatura PE tem o tamanho de uma DWORD, isto é, 4 bytes de acordo com a Microsoft e os campos seguintes são: um outro cabeçalho completo (os bytes dele em si) chamado File Header: typedef struct _IMAGE_FILE_HEADER { WORD Machine; WORD NumberOfSections; DWORD TimeDateStamp; DWORD PointerToSymbolTable; DWORD NumberOfSymbols; WORD SizeOfOptionalHeader; WORD Characteristics; } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER; E logo depois um cabeçalhado chamado Optional Header, que é um dos mais importantes do formato PE. Este cabeçalho possui dentro dele um campo chamado ImageBase, que é justamente o que você está procurando. Eu lembro que você parecia estar estudando pelo tutorial que eu fiz sobre o formato PE aqui, certo? No post de número 3 do tutorial eu falo sobre os campos do NT Header e do Optional Header. De qualquer forma, saiba que é sim possível, é só questão de ler o formato da struct na documentação e ir contando byte a byte até chegar lá!! Abs
  10. Opa, na verdade ele não mostra a quantidade de strings distintas não. Peguei um binário qualquer aqui como exemplo e rodei readelf -h arquivo pra pegar as informações do ELF Header: Cabeçalho ELF: Magia: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 Classe: ELF64 Dados: complemento 2, little endian Versão: 1 (current) OS/ABI: UNIX - System V Versão ABI: 0 Tipo: EXEC (ficheiro executável) Máquina: Advanced Micro Devices X86-64 Versão: 0x1 Endereço do ponto de entrada: 0x453140 Início dos cabeçalhos do programa: 64 (bytes no ficheiro) Início dos cabeçalhos de secção: 456 (bytes no ficheiro) Bandeiras: 0x0 Tamanho deste cabeçalho: 64 (bytes) Tamanho dos cabeçalhos do programa:56 (bytes) Nº de cabeçalhos do programa: 7 Tamanho dos cabeçalhos de secção: 64 (bytes) Nº dos cabeçalhos de secção: 24 Índice de tabela de cadeias da secção: 3 Como podemos ver o valor do campo e_shstrndx ali é 3 (última linha). Agora para printar os Section Headers usei readelf -S arquivo: Há 24 cabeçalhos de secção, começando no desvio 0x1c8: Cabeçalhos de secção: [Nr] Nome Tipo Endereço Desvio Tam. Tam.Ent Bands Lig. Info Alinh [ 0] NULL 0000000000000000 00000000 0000000000000000 0000000000000000 0 0 0 [ 1] .text PROGBITS 0000000000401000 00001000 00000000000b140b 0000000000000000 AX 0 0 16 [ 2] .rodata PROGBITS 00000000004b3000 000b3000 000000000004fa5d 0000000000000000 A 0 0 32 [ 3] .shstrtab STRTAB 0000000000000000 00102a60 0000000000000193 0000000000000000 0 0 1 [ 4] .typelink PROGBITS 0000000000502c00 00102c00 0000000000000d2c 0000000000000000 A 0 0 32 [ 5] .itablink PROGBITS 0000000000503930 00103930 0000000000000080 0000000000000000 A 0 0 8 [ 6] .gosymtab PROGBITS 00000000005039b0 001039b0 0000000000000000 0000000000000000 A 0 0 1 [ 7] .gopclntab PROGBITS 00000000005039c0 001039c0 0000000000086003 0000000000000000 A 0 0 32 [ 8] .noptrdata PROGBITS 000000000058a000 0018a000 ... Omiti a saída completa, mas já deu pra ver que tem mais de 3 seções, como estava dizendo no primeiro comando rodado. O que rola na verdade é que campo e_shstrndx possui o índice da Section Header Table de uma seção chamada .shstrtab (da pra ver ali na saída do segundo comando), que por sua vez possui dentro dela a Section String Table. Quanto ao sh_name, é simplesmente o índice (offset em hexa) da respectiva seção dentro da Section String Table. Pra ficar mais claro vou fazer igual você disse que estava fazendo, ver os bytes diretamente. Deu pra ver pela saída do comando que o array de Section Headers começa no offset 0x1c8. Cada Section Header possui 64 bytes de tamanho e podemos ver que o primeiro elemento deste array está todo zerado, então vou pular 0x1c8 + 0x40 (64 em hexa) com o comando hd -s 0x208 arquivo e ver no que da: 00000208 01 00 00 00 01 00 00 00 06 00 00 00 00 00 00 00 |................| 00000218 00 10 40 00 00 00 00 00 00 10 00 00 00 00 00 00 |..@.............| 00000228 0b 14 0b 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 00000238 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| ... Os primeiros 4 bytes (lembrando do endianess) representam o índice (isto é, o offset em hexa) do nome desta seção dentro da Section String Table. Se formos até esta suposta table (offset 0x102a60 segundo readelf -S), veremos o seguinte: 00102a60 00 2e 74 65 78 74 00 2e 6e 6f 70 74 72 64 61 74 |..text..noptrdat| 00102a70 61 00 2e 64 61 74 61 00 2e 62 73 73 00 2e 6e 6f |a..data..bss..no| 00102a80 70 74 72 62 73 73 00 2e 6e 6f 74 65 2e 67 6f 2e |ptrbss..note.go.| 00102a90 62 75 69 6c 64 69 64 00 2e 65 6c 66 64 61 74 61 |buildid..elfdata| ... De fato, no índice 00 00 00 01 (ou simplesmente 1, em hexa) está o nome da nossa seção .text na Section String Table. Abs.
  11. Me diz uma coisa, algum motivo pra você ter feito em Go? Ou foi só preferência msm? Vi que você tem bastante coisa com Go no seu git, vou dar uma olhada o/. Btw, quando comecei a estudar fiz isso aqui https://github.com/leandrofroes/gohunting , é uma toolzinha bem simples pra pegar algumas infos de processos em ambiente *nix com uma saída limpa . Se alguém tiver qualquer feedback vou adorar ouvir.
  12. Eu não lembro porque postei isso na época, mas deve ter sido pelo fato de um tempo atrás eu ter um preconceito muito grande quanto à certificações. Hoje eu posso dizer que continuo com o pensamento de que elas não podem provar seu conhecimento de fato, mas admito que elas ajudam um pouco dependendo do caso 😃 .
  13. Opa, vou reviver esse post aqui. De uns tempos pra cá as vezes ando brincando com Go e tenho que dizer, a linguagem é muito interessante. Eu curti muito essa pegada única dela de interagir com API e ao mesmo tempo ser robusta e bem estruturada. Vocês fizeram algo com Golang? Acho que até agora só fiz scripts pra interagir com API e uns programas pra agilizar meu trabalho 😅. Abs.
  14. Opa, vamos lá: Isso aqui de fato não temos, mas parece ser uma boa. Há um espaço no seu perfil onde você pode colocar o link do seu website, github, gitlab, linkedin, etc. Mesma coisa que o número 2. Abs!!
  15. Fala @HelderPereira. Os primeiros 64 bytes de um arquivo no formato PE pertencem ao DOS-Header. Os primeiros passos do loader são: Checar se os dois primeiros bytes do arquivo são iguais à "MZ". Ir até o campo e_lfanew do DOS-Header (offset 0x3c) e ler a DWORD dentro dele, isto é, os 4 bytes deste campo. Pular para o offset lido e ver se ele é igual à "PE\0\0", ou seja, a assinatura PE. Notou alguma coisa? O campo e_lfanew fica dentro do DOS-Header e ele possui o offset para a assinatura PE. Caso ela não exista, o arquivo é considerado um "não PE", do contrário, o loader continua seu trabalho analisando os outros cabelhos. Obrigado pela pergunta e qualquer coisa só mandar bala. Abs.
×
×
  • Create New...