Jump to content

Lincoln Arantes

Membros
  • Content Count

    18
  • Joined

  • Last visited

Community Reputation

8 Neutral

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. Olá a todos! Hoje venho trazer a vocês uma ferramenta bastante útil para quem trabalha com Pentest. Para ser mais exato a ferramenta procura diretórios que estão no servidor. Primeiro passo: Baixe os arquivos usando o código abaixo: Abra o terminal e digite: git clone https://github.com/maurosoria/dirsearch O projeto pode ser encontrado no: github.com/maurosoria/dirsearch Segundo passo: Entre na pasta usando o comando cd dirsearch e depois liste os arquivos usando o comando ls Terceiro passo: Execute o dirsearch.py usando o comando: ./dirsearch.py -u tcctestes.000webhostapp.com -e * -u : URL Alvo: tcctestes.000webhostapp.com -e : Extensão: * = Tudo, .php, .aspx, e outros Quarto passo: Aguarde o começo da pesquisa Quinto passo: Visualize os diretórios retornados Conclusão Apesar de ser uma ferramenta com seu uso bastante simples, ela expõe umas das 10 principais falhas criticas de segurança da informação. Essa vulnerabilidade nos permite conhecer os arquivos que está por trás do site e até baixar - los. Essa vulnerabilidade pode ser evitada se o analista de segurança da informação fizer a configuração necessária no servidor para desativar a mostragem de diretórios. Enfim, essa ferramenta é bastante útil. Espero que tenham gostado! Autor: Lincoln César dos Reis Arantes - Analista de Sistema(graduado) Contato: lincolnsetelagoas@yahoo.com.br
  2. Olá meus queridos escovadores de bytes! Estamos aqui hoje para falar um pouco mais sobre os queridos exploits: queridos para quem os desenvolve e temido por muitas empresas e raças humanas. Em uma terra onde bytes são importantes, um bom escovador de bytes é rei! Então chega de delongas e vamos ao que interessa: Na primeira parte desse tutorial mostramos que podemos fazer um programa feito em S.O Linux se comportar incorretamente, mas não debugamos os resultados, aqui procuraremos desenvolver o mesmo assunto porém mostraremos com maior riqueza de detalhes os registradores que foram modificados. Bem, utilizaremos o mesmo programa vulnerável a buffer overflow, o código é esse: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //Programa vulnerável para teste de exploit #include <stdio.h> int main() { char login[15]; char senha[6]; printf(" Login: "); gets(login); printf(" Senha: "); gets(senha); printf("Login %s!!\n\n", login); printf("Senha %s!!\n\n", senha); } ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Graças ao compilador c, tanto no S.O Linux quanto no S.O Windows o código compila sem alteração. Note abaixo que compilaremos o código no Dev C++ Depois foi salvo o código e criado o vuln2.exe Depois abrimos o vuln2.exe no debug Immunity debugger E começamos a entrar dados. Nesse momento nosso objetivo é descobrir se os registradores serão alterados, para que isso ocorra entramos com muitos A que em hexadecimal é 0x41 ou no debug apenas 41. Na primeira entrada de A notamos que não houve alteração. Então continuamos na execução do programa onde o programa nos solicitou que seja teclado uma senha. Daí eu pensei vamos ver o que acontece se colocamos varios A, após a entrada dos mesmo verificamos no nosso debug e constatamos que os registrados ESP e EIP foram alterados para 41414141 conforme mostrado na foto seguinte. O que isso significa para nós? Para alguns isso significa apenas um programa em colapso, mas para nós que seremos escovadores mundiais de bytes, isso significa que você pode carregar um lindo shellcode nessa oportunidade. Bem explicarei mais um pouco para que você entenda a coisa: o registrador EIP de 32 bits é parte do nosso alvo principal pois é nele que alteraremos o ponto da próxima instrução para algo que queremos. Ficou curioso, fique de olho nos outros posts... Por hoje é só, espero que tenha gostado e até a próxima... Autor: Lincoln César dos Reis Arantes - Analista de Sistema(graduado) Contato: lincolnsetelagoas@yahoo.com.br
  3. Vamos a pequena e importante dica! Em algumas distribuições Linux já vem instalado o compilador Assembly, como no caso do Fedora 29, bastando apenas o usuário desenvolver seu código e compilar.. Nesse exemplo mando para você um código simples que fiz. Espero que goste! =================================================== .section .data mensagem: .ascii "Lincoln Arantes\n" .section .text .globl _start _start: movq $1, %rax movq $1, %rdi movq $mensagem, %rsi movq $15, %rdx syscall movq $60, %rax movq $0, %rdi syscall ================================================== Desconsidere os sinais de = (igual) Copie o código e salve com o nome hello.s Depois abra o terminal do Linux na pasta onde você salvou o arquivo e compile usando cada linha e teclando [enter] no teclado. # as hello.s -o hello.o # ld -s hello.o -o hello.x Pronto! Para executar digite: ./hello.x Autor: Lincoln César dos Reis Arantes (ADS - graduado) E-mail: lincolnsetelagoas@yahoo.com.br
  4. Ola, a todos que gostam de pentear bytes! Fico alegre de ver que estão visualizando meus posts. Hoje trago a vocês o debug de dois programas feitos em duas linguagens diferentes, acompanhe: Um exemplo simples de engenharia reversa. Veja o código no compilador Assembly On line: Para entender melhor, foi criado um executável no Nasm exatamente na syntax Intel: Depois debugamos o arquivo hello no edb debuger. Note que o código é o mesmo, porém nos registradores que possuem textos são colocadas outras informações. como no caso do registrador edx que é observado o hexadecimal 0xe, que significa o número decimal 14. No registrador ecx é colocado um endereço de memória que está associado à mensagem mente binaria que é mostrada na tela do programa. Agora vamos criar um executável na linguagem de programação c e comparar os dois resultados do final do post. Veja o código: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #include <stdio.h> int main (void){ printf("mente binaria"); return 0; } ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Note que o código é bastante simples, para que fique mais fácil de entender. Abaixo, observe o programa rodando normalmente. Agora vamos debugá - lo: Agora observe que o programa nos mostrou os códigos Assembly, note que são diferentes. Podemos concluir que ambos os programas fazem a mesma coisa, porém quando são debugados trazem códigos diferentes, isso ocorre porque eles foram compilados em compiladores diferentes. Portando é possível observar também que quando o programa é feito na linguagem Assembly, o debugue nos mostra códigos mais limpos e fáceis de ser entendidos. Se você gosta de programar, aprenda a programar em Assembly e seja um grande escovador de bytes! Autor: Lincoln César dos Reis Arantes (ADS - Graduado) E-mail: lincolnsetelagoas@yahoo.com.br
  5. Nos dias atuais, um dos maiores problemas existentes na web são os exploits.! Conhecidos por conseguir acessos não autorizados a determinados lugares, esses exploradores são capazes de fazer diversas coisas diferentes, iniciando por um travamento simples na aplicação que esta rodando remotamente, localmente ou ainda conseguindo acesso total a aplicação que possui a vulnerabilidade. No nosso exemplo faremos a aplicação entrar em travamento e finalizar. Para entender melhor, veja o código vulnerável abaixo: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //Programa vulnerável para teste de exploit #include <stdio.h> int main() { char login[15]; char senha[6]; printf(" Login: "); gets(login); printf(" Senha: "); gets(senha); printf("Login %s!!\n\n", login); printf("Senha %s!!\n\n", senha); } ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Observe que tanto na variável login como na variável senha foram setados um número x de tamanho da variável. A quebra do programa pode ocorrer quando passamos o tamanho das variáveis. Tal parte vulnerabilidade é chamada overflow. Para que você consiga entender melhor, fiz um exemplo na prática.. Vamos fazer, copie o código acima e salve um arquivo com o nome vulneravel.c Segundo passo, compile esse arquivo usando o gcc do terminal Linux Comando: gcc vulneravel.c -o vulneravel Terceiro passo: Veja os detalhes da compilação, que o próprio compilador nos avisa sobre o perigo de usar o gets. Observe também que o compilador já criou o executável para nós. Quarto passo: Agora que já temos o executável, vamos abri -lo e vamos ver se ele quebra com mais caracteres. Observe a imagem anterior e veja que o programa sofreu um ataque quando colocados diversos DDDDDDDD e que o programa foi terminado, causando uma falha de segmentação. Ao visualizar o programa podemos pensar que se trata de algo bastante simples e na verdade é, mas não podemos esquecer que esse tutorial é apenas o início de vários que você terá que estudar para se tornar grande na área. Enfim estude muito que um dia você chega lá! Esse tutorial nos mostra que é possível explorar através de exploit uma aplicação desde que ela tenha uma vulnerabilidade ou seja muitos programas podem ser encontrados porém somente aqueles que possui suas falhas poderão ser explorados! Autor: Lincoln César dos Reis Arantes - Analista de Sistema(graduado) Contato: lincolnsetelagoas@yahoo.com.br
  6. Para alguns iniciantes, a compilação de um programa é um problema, porém se você seguir os passos que irei te passar agora, com certeza, você conseguirá! Respire fundo e siga em frente que você vai conseguir! Para compilar códigos em Assembly são usados alguns comandos no terminal Linux! Para facilitar a vida de todos, estou postando os dois mais usados! Para nosso exemplo, o arquivo chama hello e tem a extensão .s , o que forma hello.s Para usar é bastante simples, basta abrir o terminal e alterar o nome do arquivo, digitar as linhas seguidas apertando a tecla [enter] no final de cada linha. Atenção não coloque #, coloque apenas os comandos as hello.s -o hello.o e ld -s hello.o -o hello.x , um em cada linha. O # é apenas 'caractere que diz ao compilador que se trata de um comentário. CUIDADO COM ISSO! Syntax: AT&T ############################################################################################ # # as hello.s -o hello.o # ld -s hello.o -o hello.x # ############################################################################################ Agora vamos para a Syntax Intel: Conforme falado anteriormente, basta trocar o nome do arquivo e digitar os comandos, depois basta ir apertando a tecla [enter] no final de cada linha! ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; nasm -f elf32 hello.asm ; ld hello.o -o hello.x ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Observação: Se sua CPU for 64 utilize: nasm -f elf64 hello.asm EM AMBOS OS CASOS PARA EXECUTAR DIGITE: ./hello.x Esse pequeno tutorial foi feito com muito carinho para você! Espero que tenha gostado! Autor: Lincoln César dos Reis Arantes(Graduado) Contato: lincolnsetelagoas@yahoo.com.br
  7. Primeiramente gostaria de dizer a todos que vale a pena programar na linguagem Assembly. No exemplo abaixo estou usando o S.O Linux para fazer a instalação do Assembler Nasm O compilador está disponível no site do fabricante: https://www.nasm.us/ , porém para simplificar faremos a instalação da maneira mais correta e mais simples. A instalação no Linux Fedora 29 é bastante simples! Tudo vai acontecer pelo próprio terminal. Para esse exemplo estou utilizando o computador da Julia. Primeiro passo: Abra o terminal do Linux e altere seu usuário para Root ou #. Segundo passo: Depois digite o comando: yum install nasm e tecle [enter] no teclado. Terceiro passo: Verifique se os dados estão corretos e autorize a instalação colocando S e apertando a tecla [enter] no teclado: Quarto e último passo: Aguarde o termino da instalação e divirta - se: Obrigado! Espero que tenha ajudado! Autor: Lincoln César dos Reis Arantes - Analista de Sistema (graduado) Contato: lincolnsetelagoas@yahoo.com.br
  8. A numeração do código está correta, o que foi consertado foi apenas uma pequena descrição.. Obrigado de coração pelo olho clinico! Sem você ia passar despercebido! valeu amigo - estamos juntos! CONSERTADO!!!
  9. A resposta certa Shellcode! Parabéns a todos que participaram!
  10. Sou apaixonado pela linguagem Assembly e espero que você goste também! Autor: Lincoln César dos Reis Arantes - Analista de Sistema (graduado) Registradores x86 – IA 32 Registradores são memórias rápidas que ficam no processador com uma finalidade especifica. Registradores para uso geral! Segue abaixo os principais registradores para uso geral: De 16 bits: AX – Acumulador BX – Base CX – Contador DX – Dados SI – Source Index –índice de origem de dados DI – Destination Index – índice de destino BP – Base Pointer – Apontador de base SP – Stack Pointer – Apontador para o topo da pilha IP – Instruction Pointer – Apontador de próxima instrução a ser executada. De 32 bits: EAX - Acumulador Pode ser usado em operações aritméticas. EBX - Base Pode ser usado para apontar para dados. ECX - Contador Pode ser usado em alguns casos em loops para contar os laços de repetição. EDX - Registrador de Dados em geral Vários casos, pode ser usado em multiplicações e divisões e em outros casos como entrada e saída. Perceba que no caso de 32 bits foi adicionado o E na frente do registrador! ESP - Apontador da Pilha -Stack pointer. EBP - Apontador da base - Base pointer. ESI - Índice de origem. EDI - Índice do destino. Registradores de Segmentos CS-Segmento do código (Code segment) DS-Segmento de dados (Data segment) SS-Segmento de Pilha (Stack segment) ES-Segmento com dados extra (Extra segment) FS-Segmento com dados extra (Extra segment) GS-Segmento com dados extra (Extra segment) Registradores de Flags São registros de controles ou melhor sinalizadores para o processador, geralmente funcionam como testadores. Tabela de Flags de 16 bits. Observação: 7 bits não são usados Flag: OF DF IF TF SF ZF AF PF CF Ordem bits: 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Overflow Flag (OF) - Exibe o estouro de um bit de alta ordem após uma operação matemática. Direction Flag (DF) - Determina a direção esquerda ou direita para mover ou comparar dados de string. Interrupt Flag (IF) - Determina se as interrupções externas, como entrada de teclado e outros devem ser ignoradas ou processadas. Trap Flag (TF) - Deixa configurar uma operação do processador de uma única vez. Sign Flag (SF) - Exibe o sinal do resultado de uma operação matemática. Zero Flag (ZF) - Indica o resultado de uma operação matemática ou de comparação. Auxiliary Carry Flag (AF) - Contém o carry do bit 3 ao bit 4 após uma operação matemática; usado para aritmética especializada. Parity Flag (PF) - Mostra o número total de 1-bit no resultado obtido de uma operação matemática. Carry Flag (CF) - Contém o carry de 0 ou 1 de um bit de alta ordem (mais à esquerda) após uma operação matemática. Apesar de existirem registradores de 64 bits, não focaremos nele no momento, mas só por efeito de sabedoria os básicos deles são eles: rax, rbx, rcx, rdx. Estrutura de um código Assembly Seção de texto: section .text Na linguagem c, o main informa onde começar o programa, no assembly, na seção text deve ter a declaração global _start para que o kernel entenda onde iniciar o programa. Aqui é colocado o código do programa Seção de dados: section .data Geralmente usado para declarar constantes e dados em geral. (Dados não mudam) Seção de informações de variáveis: section .bss Geralmente usada para declaração de variáveis. Chamadas de sistema Chamadas de sistema (System Calls) são APIS que serve de interface entre programador e o kernel do Sistema Operacional. Quando estamos programando utilizamos bastante de chamadas de sistema. Para facilitar o entendimento colocarei aqui as chamadas mais comuns. Observe o exemplo: Exemplo o abaixo é um sys_write ou chamada de sistema de escrita. mov edx,4 ; Tamanho da mensagem mov ecx, mensagem ; mensagem a ser escrita mov ebx,1 ; file descriptor (stdout) mov eax,4 ; Número da chamada do sistema int 0x80 ; Chamada no kernel Usado quando precisamos mostrar uma mensagem na tela ou em outros casos para mostrar variáveis em geral. Agora, vejamos uma outra chamada também bastante usada, no caso é a sys_read ou chamada de leitura para os menos íntimos, também conhecida no ramo de programação como campo de entrada de dados ou input. Exemplo o abaixo é um sys_read ou chamada de sistema de leitura. mov eax, 3 ; Número da chamada do sistema mov ebx, 2 ; file descriptor (stdin) mov ecx, numero ; valor da variável a ser pegada mov edx, 5 ; Tamanho da mensagem a ser mostrada em bytes int 80h ; Chamada no kernel Usado quando queremos pegar dados que usuário digitou. Agora disponibilizarei aqui uma pequena tabela com os exemplos que falei e outros mais. Fique à vontade e use sua imaginação para criação de novas chamadas. Nome eax ebx ecx edx Sys_exit 1 int sys_fork 2 struct pt_regs sys_read 3 unsigned int Char * Size_t sys_write 4 unsigned int Const char * Size_t sys_open 5 const char * int int sys_close 6 unsigned int Na tabela acima de inicial procure focar sua atenção no eax, pois é ele a opção mais importante que temos que trocar para mudamos as chamadas. Veja que no exemplo mostrado na tabela acima os registradores eax, ebx, ecx, edx são de 32 bits. Como compilar e linkar um código Assembly para geração de um executável? Atenção: certifique-se o Nasm está instalado primeiro, se estiver instalado siga os passos seguintes: 1° Crie um arquivo com o código Assembly utilizando um editor .txt e depois salve-o com a extensão .asm Ex: programa1.asm 2º Abra o terminal do Linux, na linha de comando e digite: nasm -f elf32 programa1.asm Observação: Após utilizar do comando acima, se tudo der certo, será gerado um arquivo programa1.o 3° Crie o executável com o comando abaixo: ld programa1.o -o programa1.x 3° Para executar, digite: ./programa1.x
  11. ;Fiz esse código para a gente se diverti um pouco! ;Fique a vontade para alteração ou dar sua opinião! ; Exemplo de uma comparação de if se menor ou se maior e igual ; Escrito por Lincoln Cesar dos Reis Arantes section .text global _start ;must be declared for using gcc _start: ;tell linker entry point mov eax, 0x4 ;numero 4 em hexadecimal (nao mexar aqui) mov ebx, 0x1 ;numero 1 em hexadecimal (mexa aqui) cmp ebx, eax jl mostra2 ; menor que jg mostra1 ; maior e igual a mostra1: mov edx, len1 ;message length mov ecx, msg1 ;message to write mov ebx, 1 ;file descriptor (stdout) mov eax, 4 ;system call number (sys_write) int 0x80 ;call kernel mov eax, 1 ;system call number (sys_exit) int 0x80 ;call kernel mostra2: mov edx, len ;message length mov ecx, msg ;message to write mov ebx, 1 ;file descriptor (stdout) mov eax, 4 ;system call number (sys_write) int 0x80 ;call kernel mov eax, 1 ;system call number (sys_exit) int 0x80 ;call kernel section .data msg1 db 'Maior ou igual que 4!',0xa ;our dear string len1 equ $ - msg1 ;length of our dear string msg db 'Menor que 4!',0xa ;our dear string len equ $ - msg ;length of our dear string
  12. Segue códigos em linguagem Assembly
×
×
  • Create New...