Ir para conteúdo

Leandro Fróes

Apoiadores
  • Total de itens

    79
  • Registro em

  • Última visita

Reputação

17 Good

6 Seguidores

Sobre Leandro Fróes

Últimos Visitantes

566 visualizações
  1. Leandro Fróes

    duvida

    Bom dia mano! Antes de qualquer coisa, por que você não testa e caso dê algum erro (ou até mesmo se der certo) você coloca aqui pra galera? abs
  2. Leandro Fróes

    Computador travando

    Boa noite! Qual o SO?
  3. Leandro Fróes

    Browser Brave

    Boa noite mano, tudo bem? Bacana o post, mas posso dar uma sugestão? Acho que além de postar o link é interessante dar uma breve explicação sobre o que se trata. As vezes quem lê não quer clicar, só simplesmente saber o que é ou algo assim (além do post ficar mais completo). Abraço!!
  4. Leandro Fróes

    Ajuda com provável erro de lógica (Python)

    Da uma olhada nas suas configurações de firewall então cara. Se for linux pode abrir uma porta com nc -lvp 8080 por exemplo e depois testar seu port scan, mas isso depois de verificar o firewall.
  5. Leandro Fróes

    Ajuda com provável erro de lógica (Python)

    Pera, resolveu o outro erro e agora ta com timeout? Poderia postar a saída?
  6. Leandro Fróes

    Lista de funções da API do Windows interessantes para ER

    Para um conhecimento adicional tem também o vídeo do CERO fresquinho de hoje sobre Windows API:
  7. Leandro Fróes

    Ajuda com provável erro de lógica (Python)

    Leia sim, redes é muito importante saber. Entendi, mas quando deu o problema você colocou qual IP?
  8. Leandro Fróes

    Ajuda com provável erro de lógica (Python)

    Boa noite! Acho que o problema ai são conceitos de redes mano. Considerando o fato de você estar scaneando sua rede interna o IP 192.0.0.x não é um IP privado, creio que você quis dizer 192.168.0.x. Não esqueça também que o 0 e o 255 no HostID são reservados para a rede e para broadcast, respectivamente. Abraços
  9. Leandro Fróes

    Redes

    Ta na mão https://www.mentebinaria.com.br/forums/forum/38-redes/ Só mandar bala
  10. Leandro Fróes

    [Pedido] material sobre router

    Boa noite, sobre roteador assim na lata eu não sei não (se você achar pf me passa que eu também quero), mas sobre redes no geral tem o citado ali em cima pelo manin e o "TCP/IP Illustrated". A questão é que este só tem em inglês Abs
  11. No dia 26 de fevereiro o usuário de nick Sai Lay publicou em seu Twitter um cheat sheet sobre segmentação de memória para o Linux : Afinal, o que é um cheat sheet? Basicamente um “guia rápido”, uma “folha de consulta” para possíveis dúvidas que você possa ter sobre o assunto abordado. Este tipo de guia pode abordar diversos assuntos, desde comandos/scripts específicos para pentest até definições rápidas sobre registradores e alinhamento de memória (que é o nosso caso). A quantidade de informações disponíveis em um cheat sheet é enorme, mas não há sentido em ter tanta informação se não entendermos de fato o que é aquilo. Tendo em vista isto detalharemos um pouco mais um ponto em específico deste guia, deixando o resto para a sua curiosidade Que tal darmos uma breve olhada em uma seção? Considere o código abaixo: #include <stdio.h> int main(void){ printf("Isto eh um teste\n"); return 0; } Se utilizarmos o comando readelf --sections test veremos que a seção .data(seção de dados inicializados), por exemplo, tem apenas 16 bytes (em hexa): ... [22] .got PROGBITS 0000000000200fd8 00000fd8 0000000000000028 0000000000000008 WA 0 0 8 [23] .got.plt PROGBITS 0000000000201000 00001000 0000000000000020 0000000000000008 WA 0 0 8 [24] .data PROGBITS 0000000000201020 00001020 0000000000000010 0000000000000000 WA 0 0 8 [25] .bss NOBITS 0000000000201030 00001030 0000000000000008 0000000000000000 WA 0 0 1 … Podemos verificar o que tem nestes bytes com objdump -d -j .data test: test: file format elf64-x86-64 Disassembly of section .data: 0000000000201020 <__data_start>: ... 0000000000201028 <__dso_handle>: 201028: 28 10 20 00 00 00 00 00 (. ..... Mas e se nosso código fosse da seguinte forma: #include <stdio.h> int a = 10; int main(void){ printf("Isto eh um teste\n"); return 0; } Note que o tamanho da seção aumentou em 4 bytes, que “coinscidentemente” é o tamanho de uma variável do tipo inteiro na arquitetura onde os testes foram feitos : ... [23] .got.plt PROGBITS 0000000000201000 00001000 0000000000000020 0000000000000008 WA 0 0 8 [24] .data PROGBITS 0000000000201020 00001020 0000000000000014 0000000000000000 WA 0 0 8 [25] .bss NOBITS 0000000000201034 00001034 0000000000000004 0000000000000000 WA 0 0 1 [26] .comment PROGBITS 0000000000000000 00001034 … Se olharmos o que há na seção veremos o seguinte resultado: test: file format elf64-x86-64 Disassembly of section .data: 0000000000201020 <__data_start>: ... 0000000000201028 <__dso_handle>: 201028: 28 10 20 00 00 00 00 00 (. ..... 0000000000201030 <a>: 201030: 0a 00 00 00 .... Agora temos um valor de 4 bytes disponível para nossa variável a que possui o valor 0a em hexa (ou seja, 10 como declarado anteriormente). Caso a variável fosse, por exemplo, long long a = 10 o resultado seria: est: file format elf64-x86-64 Disassembly of section .data: 0000000000201020 <__data_start>: ... 0000000000201028 <__dso_handle>: 201028: 28 10 20 00 00 00 00 00 (. ..... 0000000000201030 <a>: 201030: 0a 00 00 00 00 00 00 00 .....… 8 bytes disponíveis, exatamente o valor que sizeof(long long) representa nesta arquitetura. Não ficou satisfeito ainda? Você também pode olhar as seções com o gdb(GNU Debugger) utilizando o comando maintenance info sections: ... [22] 0x00201000->0x00201020 at 0x00001000: .got.plt ALLOC LOAD DATA HAS_CONTE---Type <return> to continue, or q <return> to quit--- NTS [23] 0x00201020->0x00201038 at 0x00001020: .data ALLOC LOAD DATA HAS_CONTENTS [24] 0x00201038->0x00201040 at 0x00001038: .bss ALLOC [25] 0x00000000->0x0000001c at 0x00001038: .comment READONLY HAS_CONTENTS ... É extremamente interessante ir a fundo em cheat sheets como este, mais interessante ainda é montar um você mesmo, seja para uso particular ou para disponibilizar para todos. Espera, não entendeu direito os comandos, ordenação dos bytes ou algo desta notícia? Que tal assistir ao curso do CERO? A última aula fala justamente sobre o formato ELF (executáveis Linux) e sua especificação. Agora que sua curiosidade foi instigada, que tal aplicar seus conhecimentos sobre arquitetura de computadores e mostrar pra gente?
  12. Leandro Fróes

    Desafio de ponteiros

    Boa tarde pessoal! Muito foda que vocês tentaram, deixaram o post muito completo. Bom, mas eai? Qual a diferença? Depende kkkkkkk Até onde eu sei (e se alguém souber mais por favor, compartilhe) o parênteses serve para dar ênfase. Na prática eu vejo algumas situações que fazem diferença e duas já foram citadas aqui. São elas: Incremento (ou decremento): aqui *p++ anda de acordo com o tipo de dado que o ponteiro aponta e (*p)++ da ênfase ao elemento apontado. Percorrendo um array: #include <stdio.h> int main(){ int v[] = {10,20,30}; int *p = v; int i; for(i=0;i<3;i++){ printf("Com parenteses: %d\n", *(p+i)); printf("Sem parenteses: %d\n", *p+i); } } Saída: Com parenteses: 10 Sem parenteses: 10 Com parenteses: 20 Sem parenteses: 11 Com parenteses: 30 Sem parenteses: 12 E um outro caso que não foi comentado aqui é para declaração de arrays. Quando usamos int *v[] estamos criando um array de ponteiros do tipo intero. Agora quando usamos int (*v)[] estamos criando um ponteiro para um array de inteiros. Mas é isso ai galera, desafio concluído e já achamos 3 coisas interessantes, alguém tem algo mais para mostrar para nós? Abraços!!
  13. Leandro Fróes

    Tabela Verdade.

    Boa tarde! No que exatamente você tem dificuldade? Se for em montar uma tabela verdade manda ai um exercício pra galera ti ajudar e tirar dúvidas. Abraços.
  14. Leandro Fróes

    Desafio de ponteiros

    Queria deixar uma pergunta interessante para se pensar antes de resolver o desafio. Considerando o ponteiro p: O que acontece se usarmos p++? E quando se usa (*p)++? Tente aplicar em um array e veja seus elementos =D Abraço!
  15. Em 2015 foi criado o projeto Kaitai Struct. Mantido até hoje o projeto engloba toda uma estrutura para trabalhar com a ideia de parsing de arquivos, tanto em disco quanto em memória. O segredo disto é a linguagem descritiva criada pelo projeto. O Kaitai utiliza um arquivo de texto com extensão .ksy para definir um formato. Este arquivo, após ser compilado pelo seu próprio compilador (ksc) gera um código em qualquer uma das linguagens aceitas para parsear o formato(CPP/STL, C#, Graphviz, Java, JavaScript, Perl, PHP, Python, Ruby e JSON). Ficou confuso? Aqui está um exemplo de um arquivo nesta linguagem descritiva: meta: id: microsoft_pe title: Microsoft PE (Portable Executable) file format application: Microsoft Windows endian: le ks-version: 0.7 doc-ref: http://www.microsoft.com/whdc/system/platform/firmware/PECOFF.mspx seq: - id: mz1 type: mz_placeholder - id: mz2 size: mz1.header_size - 0x40 - id: pe_signature contents: ["PE", 0, 0] - id: coff_hdr type: coff_header - id: optional_hdr type: optional_header size: coff_hdr.size_of_optional_header - id: sections repeat: expr repeat-expr: coff_hdr.number_of_sections type: section enums: pe_format: 0x107: rom_image 0x10b: pe32 0x20b: pe32_plus types: mz_placeholder: seq: - id: magic contents: "MZ" … Neste exemplo o arquivo está descrevendo os campos do formato PE (executáveis Windows). Alguns campos foram omitidos pois a especificação do formato PE é grande. Todos estes campos e suas definições podem ser encontrados na documentação oficial. Segue a definição de alguns campos: id: usado para identificação. doc-ref: usado para indicar a documentação do formato endian: usado para indicar o endianess (ordem dos bytes. Little-Endian no exemplo). seq: usado para indicar uma sequência de atributos e a ordem que serão lidos ou escritos. Sem mais delongas vamos ao que interessa, a prática. O exemplo abaixo usa a versão web do projeto: Para analisar um arquivo PE (que é o nosso exemplo) primeiro devemos ir no lado esquerdo onde há vários tipos de formatos em ksy, selecionar a pasta kaitai.oi/formats/executables e clicar duas vezes em microsoft_pe.ksy: Logo de cara podemos ver o arquivo .ksy, mas ainda não fizemos o parser. Para de fato conseguir analisar o nosso binário precisamos carregá-lo e isto é feito no botão abaixo de “Local Storage” (lugar este onde ficam os arquivos que carregamos). Há três botões, o primeiro cria um arquivo .ksy, o segundo carrega um arquivo seu para análise e o terceiro baixa um arquivo do repositório do KS: Aqui carreguei o Putty.exe (um binário PE) e olha só o resultado: uma árvore ao meio com todos os campos parseados e o dump do arquivo em disco à direita. Se clicarmos duas vezes em algum campo , como, por exemplo, ImageBase, podemos ver sua localização exata no arquivo, no dump: Legal, não é mesmo? Mais legal ainda é o fato dele gerar o código fonte usado para o parser e isso na linguagem que você escolher dentre das suportadas. No caso, escolhi C++: Aqui foram apresentadas apenas algumas funcionalidades deste projeto, mas fica claro o quanto isso é útil tanto para análises quanto para estudos de diversos formatos: executáveis, logs, cabeçalhos de protocolos e até mesmo arquivos .pcap. O Kaitai Struct também funciona em linha de comando em: Linux, Windows e macOS. Caso queira você também pode baixar o código direto do repositório do projeto e trabalhar como quiser, seja para engenharia reversa ou para aprender como programar um parser.
×