Usando esta ferramenta você pode rastrear qualquer IP e obter informações sobre todos e cada um sem procurar em torno em qualquer outro lugar, inclusive País, Cidade, Fuso Horário, região, Capital etc moedas, então vamos ver como ele funciona.
1. Primeiro de tudo baixar a aplicação [Final do topico] , e extrair o aplicativo e clique 2x nele ' Team Leak - IP Locate.exe'
2. Agora digite o IP (que pretende buscar informações) no "Past IP here" e clique em " Search " e aguarde alguns segundos, agora você vai ver todas as informações sobre esse IP como mostrado abaixo:
Ja fiz um topico sobre deixar um server FUD, mas ágora a maioria dos Crypters São desatualizadas. entao, Hoje Vou mostrar um Crypter FUD 2013 (indetectável Pelos anti-vírus)
Primeiro baixar Crypter [Final do Topico]
Aqui você pode Juntar (Combinar) com qualquer outro arquivo ex: Exe, Text com seu arquivo Crypt
Burlar o a extensão do arquivo Keylog de vírus...
Características: FUD Crypter de 0/35 Arquivo FUD 0/35 Extensão Spoofer Icon Changer
Neste Topico eu estou indo dar breve descrição de deixar indetectavel um KL(dedico ao -JσασGσмєs'), pois agora e mais difícil obter um crypter FUD free e na maioria das crypter não são free, edição Então Hex é a única maneira de fazer o nosso arquivo de keylogger totalmente undectable (FUD ).
O que é Hexing?
Hexing é o processo de modificação de arquivos de aplicativos usando editores Hex (softwares usados para editar arquivos em formato hexadecimal).
Como Antivirus funciona?
Antivirus funciona de forma bastante complexa. Para resumir seu trabalho, antivírus tem as definições de vírus (também chamado de assinaturas) armazenados em seu banco de dados. Ao digitalizar um arquivo, pesquisas de antivírus para estas definições de vírus ou assinaturas em um arquivo e, se encontrar estas assinaturas em um arquivo, ele sinaliza esses arquivos como vírus.
Como tornar o vírus indetectável?
Quando você criou o arquivo de vírus, basta abrir o arquivo trojan vírus no editor Hex e busca de assinatura que Antivirus tem sinalizado como de definição de vírus. Temos de mudar essa assinatura de tal forma que isso não afetará o funcionamento da nossa vírus trojan. Depois de ter alterado com êxito esta assinatura, o antivírus não vai detectar o vírus, tornando ele FUD .
Coisas que são necessários para Hexing
File Splitter : http://www.dekabyte....r/download.html Hex Editing Software : http://www.hhdsoftwa...free-hex-editor
Keylogger (A sua preferencia)
Agora siga os seguintes passos para fazer ele indetectavel para antivírus
Primeiro faça servidor de arquivos (file Keylog) usando keylogger depois que servidor servidor em uma pasta. Aqui eu criei pasta "A" e colocar esse servidor (Meu nome é servidor test.exe).
Ok, agora depois de ter colocado o servidor na pasta permite digitalizá-lo.
Aqui meu arquivo test.exe está infectado.
Agora, abra o File Splitter para dividir o arquivo.
No divisor de arquivo, navegue até o arquivo test.exe que você quer dividir e escolher a opção de tamanho personalizado.
Agora File Splitter me diz que este é exatamente test.exe 53.495 bytes e eu quero dividi-lo em 4 pedaços. Então eu dividi 53.495 por 4, agora colocar o número que você tem depois de dividi-la e colocá-lo na caixa de tamanho divisor de costume que tenho no fundo. Agora clique em Split.
Agora você vai obter os arquivos subdivididas no mesmo diretório como eu fiz abaixo que está na pasta "A".
Agora escanear cada um deles para descobrir qual arquivo está infectado e depois que nós temos que dividir esse arquivo infectado novamente. Agora, depois de ter descoberto que o arquivo infectado, faça uma nova pasta na mesma pasta. Aqui eu tenho test.exe.3 arquivo infectado, então eu vou fazer uma nova pasta com o nome de "3".
Agora, novamente dividir essa infectado arquivo test.exe.3 arquivo em 4 pedaços e mudar a pasta de saída a 3 como eu tenho na imagem abaixo.
Agora você vai ficar dividido arquivos dentro da pasta chamada "3".
Agora verificar todos os arquivos para descobrir qual arquivo está infectado e depois que nós temos que dividir esse arquivo infectado novamente.
Agora, depois de ter descoberto que o arquivo infectado, faça uma nova pasta na mesma pasta. Aqui eu tenho test.exe.3.3 arquivo infectado, então eu vou fazer uma nova pasta com o nome de "3" de novo na pasta "3". Uma vez que você fez nova pasta chamada "3", mais uma vez abrir divisor de arquivo e navegue até o arquivo que tem detectado, o meu era test.exe.3.3 e selecione o diretório de saída para a pasta que acabou de fazer o que era a pasta chamada "3" que está na pasta chamada "3".
Agora abra essa nova pasta, que é "3" e digitalizar todos os arquivos. Agora, depois de ter descoberto que o arquivo infectado, faça uma nova pasta na mesma pasta. Aqui eu tenho test.exe.3.3.4 arquivo infectado, então eu vou fazer uma nova pasta e nomeie-o "4".
Agora em arquivo divisor escolher o arquivo que foi detectado que era test.exe.3.3.4 para mim e para escolher a nova pasta que fizemos com o nome "4".
Agora vamos verificar todos os arquivos novos e ver qual foi detectado. Uma vez que encontramos o arquivo infectado, abra o arquivo infectado com o editor hexadecimal e ver se a sua ainda grande demais para descobrir o que precisamos mudar....
Ok, então aqui é test.3.3.4.1 que precisamos editar,abri-lo com o editor hexadecimal,
Agora, a assinatura de vírus é aqui no editor hexadecimal e não é muito difícil agora para encontrá-lo para fora. Eu dedo para fora procurando por algo que se destaca ou guesssing. Depois que você tem que fazer é mudar uma letra do capital para o menor caso. aqui no meu exemplo eu mudei a palavra D para uma minúscula do DLLHOOKSTRUCT .
Agora salve e saia e digitalizá-lo. Deve estar indetectável.
Finalmente FUD .. Agora você precisa fazer compilá-lo e digitalizá-lo mais uma vez e executá-lo para testar.
Como Complile: Aqui eu vou mostrar-lhe um exemplo e depois que você pode descobrir o resto por conta própria.
Agora você verá o ícone de divisão dentro da sua pasta, aqui no meu exemplo é create_test.exe.3.3, clique sobre ele e ele irá recompilar o arquivo, e criar um arquivo mais. Aqui no meu exemplo, criar o arquivo "test.exe.3.3.4"
Agora copie o arquivo recém-criado, que é "test.exe.3.3.4" e voltar um diretório e passado, então ele irá pedir para substituí-lo clique em sim e continue fazendo isso até você voltar ao primeiro diretório.
Depois de verificar que mais uma vez para verificar se o seu FUD ou não.
Update: Se você quer hackear senhas de contas do Gmail, Orkut e outros e-mail, por favor use os melhores Softwares Hacking, espero que agora você pode facilmente fazer seu arquivo keylog (servidor) totalmente indetectavel usando esta técnica Hexing sem usar qualquer keylogger PAGO!.
Nota: Esta é apenas para fins educacionais.
Requisitos: 1. FacebookPhisher atualizado.
http://epamtf.1fichier.com/
http://www.4shared.c...ber-Gamers.html
http://www.badongo.com/file/27827648
http://depositfiles....files/iv7z9wovs
http://www.digzip.co...ber-Gamers.html
http://bayfiles.com/...yber-Gamers.rar
http://www.mirrorcre...amers.rar_links
http://www.mediafire...ez8n7djhbd11bsq
http://rapidshare.co...yber-Gamers.rar
http://www.sendspace.com/file/znhhk5
http://ul.to/sv7lje65
http://www.ziddu.com...Gamers.rar.html
http://www10.zippysh...53839/file.html 2. Free Web servidor de hospedagem para carregar as páginas Phish. 3. URL Spoofing utilizando o Host técnica de mapeamento de nome.
Vou ensinar a vocês hoje. Sei que a maioria de vocês já sabem de phishing, mas para iniciantes, deixe-me explicar um pouco. Páginas Phish significa páginas falsas(fake) que se parece absolutamente semelhante às páginas originais ea técnica de usar essas páginas falsas para hack usuário e senha é chamada de phishing. E a técnica que usamos para enviar essas páginas falsas de vítima e levá-lo a acreditar que eles são reais é chamado de Engenharia Social. Mas eu acho que isso nós já sabemos, o que há de novo que vamos discutir hoje.
O que a de novo??
Nós todos sabemos que páginas falsas só pode ser detectada usando duas técnicas: 1. Verificando a URL na barra de endereços, se a sua página falsa então URL deve ser diferente do original.
2. O uso de qualquer barra de ferramentas de segurança web que avisa os usuários para páginas falsas, como AVG barra de ferramentas, barra de ferramentas Norton Online etc segurança. Mas e se você abrir www.facebook.com manualmente no seu navegador web e abre a página falsa e URL no navegador permanece www.facebook.com. Isso significa primeira técnica para detectar a página falsa. Agora, para segunda técnica, todas as ferramentas de segurança online web detectar páginas falsas, comparando a entrada pelo usuário na barra de endereço URL da URL da página original. Se os dois, em seguida, a sua não uma página falsa mais a sua página de um malware.
Passos para hackear conta no Facebook ou Senha:
1. Download Phisher Facebook. 2. Extraia os arquivos, você vera esses 4 arquivos abaixo:
index.php
facebook1.php
senha.html
Obrigado.php
3. Agora vá para qualquer servidor gratuito web hosting para fazer upload destas páginas falsas.
Observe tudo deve ser carregado na raiz não significa em qualquer pasta. Apenas no diretório de primeiro nível.
4. Agora você precisa encontrar o endereço IP correto da conta que você criou no servidor de hospedagem.
5. Quando você começa o seu endereço IP página falsa, agora o que precisamos fazer é que temos de adicionar a entrada do endereço IP contra o www.facebook.com no arquivo vítima host localizado abaixo do local.
C:WindowsSystem32driversetc
6. Existem várias maneiras de fazer isso, eu escrevi meu próprio scripts PHP para fazer o mesmo, mas eu não posso compartilhar isso com vocês porque há chances de fazer mau uso dela. Então eu explicar-lhe a lógica eo resto você precisa descobrir como vai editar vítimas em arquivo host e adicione seu endereço de IP Falso Página contra www.facebook.com.
7. Agora depois de fazer os passos 5 e 6, sempre que o usuário abrir a www.facebook.com , sua página no Facebook falso pode abrir e vítima nunca será capaz de visitar o Facebook original, então ele não pode sequer ser capaz de alterar sua senha ... <img src="http://cyber-gamers.org/public/style_emoticons/default/tongue.png" class="bbc_emoticon" alt=":tongue:">
8. Eu adicionei uma lógica extra para os meus scripts, sempre vítima digitar a senha e apertar ENTER, eu estou removendo a entrada de endereço IP Falso contra www.facebook.com do arquivo host, tornando-os espaços. Por isso, será para ele uma única vez que soa mais falso. Sua apenas um código de linha única, mas eu não posso dizer a vocês, porque ele vai fazer este artigo completamente anti-ético.
Eu vou ensinar técnicas, mas eu não vou dar de mala em cuia, porque se você quer se tornar hacker bom, então você precisa usar o seu cérebro também. Gosto de ser chamado destrutivo, mas eu faço obras construtivas .. <img src="http://cyber-gamers.org/public/style_emoticons/default/ph34r.png" class="bbc_emoticon" alt=":ph34r:">
9. Tudo além disso é semelhante à técnica de phishing normal ..
Eu usei esse host http://www.my3gb.com/ você pode usar outro em que você carregou seus arquivos.
Além disso, você deve saber é o endereço IP 127.0.0.1 localhost. Para você caso seu webhosting será o endereço IP que será usado para mapear contra facebook.
Demonstração:
https://www.virustot...sis/1342370458/
Nota: Esta é apenas para fins educacionais.Qualquer que você fizer to nen ai nen ti conheço
Windows XP : Sim Windowns 7 : Sim Windowns Vista : Sim Funcional : AL/NA/PH/FG/RU/EU/VN/FG/TW
1° Extraíar o Cheat 2° Abra o arquivo OneHitCF 11.9 (se usar Windows Vista ou 7 execute como administrador) 3° Clique em Ok Na imagem que irá aparecer 5° Espere 25 segundos 4° Abra o jogo normalmente
Windows XP : Sim Windowns 7 : Sim Windowns Vista : Sim Funcional : AL/NA/PH/FG/RU/EU/VN/FG/TW
1° Extraíar o Cheat 2° Abra o arquivo OneHitCF 11.9 (se usar Windows Vista ou 7 execute como administrador) 3° Clique em Ok Na imagem que irá aparecer 5° Espere 25 segundos 4° Abra o jogo normalmente
Windows XP : Sim Windowns 7 : Sim Windowns Vista : Sim Funcional : AL/NA/PH/FG/RU/EU/VN/FG/TW
1° Extraíar o Cheat 2° Abra o arquivo OneHitCF 11.9 (se usar Windows Vista ou 7 execute como administrador) 3° Clique em Ok Na imagem que irá aparecer 5° Espere 25 segundos 4° Abra o jogo normalmente
Windows XP : Sim Windowns 7 : Sim Windowns Vista : Sim Funcional : AL/NA/PH/FG/RU/EU/VN/FG/TW
1° Extraíar o Cheat 2° Abra o arquivo OneHitCF 11.9 (se usar Windows Vista ou 7 execute como administrador) 3° Clique em Ok Na imagem que irá aparecer 5° Espere 25 segundos 4° Abra o jogo normalmente
Esse e o modo mais facil e rapido que eu achei para mudar o IP. Bom para quem termina de fazer um Download, e quer fazer outro com o mesmo servidor e uma boa. Não precisa reiniciar o modem e nen esperar os minutos de espera do servidor de download. 1. Vá no seu [iNICIAR] 2. Clique no [EXECUTAR] e digite [CMD] 3. Ai vai aprir o [PROMPT] digite as linhas abaixo uma por uma [Copie e Cole no PROMPT]
Windows XP : Sim Windowns 7 : Sim Windowns Vista : Sim Funcional : AL/NA/PH/FG/RU/EU/VN/FG/TW
1° Extraíar o Cheat 2° Abra o arquivo OneHitCF 11.9 (se usar Windows Vista ou 7 execute como administrador) 3° Clique em Ok Na imagem que irá aparecer 5° Espere 25 segundos 4° Abra o jogo normalmente
Windows XP : Sim Windowns 7 : Sim Windowns Vista : Sim Funcional : AL/NA/PH/FG/RU/EU/VN/FG/TW
1° Extraíar o Cheat 2° Abra o arquivo OneHitCF 11.9 (se usar Windows Vista ou 7 execute como administrador) 3° Clique em Ok Na imagem que irá aparecer 5° Espere 25 segundos 4° Abra o jogo normalmente
Este artigo irá introduzir os conceitos de assembler em linha (inline
assembler) no Delphi. O artigo dará uma noção básica do assunto mas não
pretende oferecer, em hipótese alguma, detalhes da programação assembler
que, por si só, precisariam de um livro inteiro ou mais...
Por que e Quando
================
Se você der uma olhada no código fonte da RTL e da VCL, você encontrará
declarações assembler inline em vários pontos. Por que a Borland optou
por escrever partes do código da RTL e da VCL em assembler? A resposta
é bem simples: para alcançar velocidade na execução. Nós sabemos que o
compilador produz código rápido mas um compilador jamais será tão bom
quanto um programador assembler profissional.
Agora, se o assembler é tão bom, por que não foi utilizado em toda a RTL
e VCL? A resposta é igualmente simples: porque na programação de mais
alto nível, é mais fácil codificar, depurar, ler e manter o código, de
modo que o sacrifício em velocidade fica compensado pelas conveniências
decorrentes. Isso ajuda a explicar quando o assembler deve ser
utilizado. Para ser curto, além do acesso ao sistema em baixo nível, o
assembler inline deve ser utilizado quando a diferença na velocidade de
execução justifica o trabalho adicional da codificação em assembler. Por
exemplo, na unidade Math.pas, há muito assembler, basicamente para
chamadas de sistema em baixo nível (para acesso às funções do
coprocessador); em System.pas, SysUtils.pas e Classes.pas há também
diversos blocos em assembler, desta vez para priorizar velocidade; no
é estranho já que essas podem ser consideradas as unidades centrais da
RTL e VCL.
Em geral, procedimentos e funções que tendem a ser chamadas de forma
repetida por um programa devem ser altamente otimizadas, mas codificação
em assembler deve ser evitada tanto quanto possível. Se desejamos ganhos
em velocidade, antes de optar por assembler devemos otimizar o algoritmo
propriamente dito; depois, otimizamos o código Pascal. Se optarmos por
assembler, o código Pascal otimizado pode servir como documentação e
pode ser utilizado como "código de contigência" no caso de problemas com
a manutenção do código assembler.
Os Registradores da CPU
=======================
Os registradores da CPU são como variáveis predefinidas residindo na CPU
e, por vezes, têm tarefas especiais. Eles não têm tipo e podem ser
vistos como inteiros de 32 bits com ou sem sinal ou como ponteiros,
dependendo da situação.
Como estão na própria CPU, é muito mais rápido acessar valores contidos
nos registradores do que na memória, fazendo dos registros ideais para
fazer cache de valores.
Como variáveis, os registradores também possuem nomes. Os nomes daqueles
que usaremos são EAX, EBX, ECX, EDX, ESI, EDI, EBP e ESP. Cada
registrador tem uma particularidade que o distingue dos demais:
- Para algumas instruções, a CPU foi otimizada para utilizar o
registrador EAX (também conhecido como acumulador) ou ao menos os
opcodes são menores. EAX é usado nas multiplicações e as divisões,
intructions de string, instruções de I/O, instruções de ajuste ASCII
e decimal, e em algumas instruções especiais (como CDQ, LAHF, SAHF e
XLAT).
- EBX é um registrador de uso geral, e é usado implicitamente por XLAT.
- ECX (também conhecido como contador) tem emprego especial nas
instruções LOOP, de rotação e deslocamento de bits e de manipulação
de literais.
- EDX é utilizado para armazenar os 32 bits mais altos do resultado de
uma multiplicação ou os os 32 bits mais altos do dividendo e do resto
de uma divisão.
- ESI e EDI (conhecidos como índice de origem (source index) e índice
de destino ("destination index") respectivamente) são como ponteiros
utilizados em instruções envolvendo strings.
- EBP (conhecido como ponteiro base) é normalmente usado para endereçar
valores na pilha (parâmetros e variáveis locais).
- ESP (conhecido como ponteiro da pilha) é utilizado para controlar a
pilha. é alterado automaticamente por instruções como PUSH, POP, CALL
e RET.
Os registradores EBX, ESI, EDI, EBP e ESP devem ser preservados, o que
significa que antes de usá-los, devemos salvar seus valores em algum
lugar (normalmente na pilha ou outro registradores) e, quando
terminarmos de usá-los, devemos restaurar seus valores originais (essas
operações implicam no uso de instruções e perda de algum tempo) de modo
que o uso desses registradores será feito somente quando justificável ou
quando houver uma necessidade inevitável.
Provavelmente você percebeu que os nomes dos registradores iniciam com
a letra "E". O "E" representa "Extended", estendido. Nos tempos do Intel
80286, os registradores tinham 16 bits e eram chamados AX, BX, CX, etc.
Esses registradores ainda existem e são exatamente os 16 bits menos
significativos dos registradores EAX, EBX, ECX, etc., respectivamente. A
propósito disso, os registradores AX, BX, CX e DX são divididos em dois
registradores de 8 bits. AL, BL, CL e DL são os bytes menos
significativos de AX, BX, CX e DX respectivamente, enquanto AH, BH, CH e
DH são os bytes mais significativos de AX, BX, CX e DX respectivamente.
Por exemplo, se o valor de EAX é $7AFD503C, então o valor de AX é $503C,
o valor de AH é $50 e o valor de AL é $3C:
7A FD 50 3C
AH AL
/----/
AX
/------------/
EAX
Se, na situação acima, armazenarmos o valor $99 em AH, então EAX
passaria a ter o valor $7AFD993C.
Existe um registrador especial, o registrador de indicadores (flags),
que armazena indicadores binários alterados por instruções matemáticas
e lógicas ou explicitamente por código, e que são normalmente usados
em instruções de desvio condicional. O indicador carry também é usado
em algumas instruções de rotação e o indicador de direção é utilizado
em instruções envolvendo literais.
Esse registrador não é acessível por nome como os demais registradores;
mas pode ser copiado e restaurado através da pilha, utilizando PUSHF e
POPF respectivamente, e pode também ser copiado e restaurado
parcialmente através do registrador AH, utilizando LAHF e SAHF
respectivamente.
Instruções Assembler
====================
Instruções assembler são dispostas em blocos asm..end blocks e têm a
seguinte forma:
Onde opcode é o nome da instrução como MOV, ADD, PUSH, etc.
Instruções podem ser separadas por ponto e vírgula, quebras de linhas
ou comentários. A propósito, comentários são no formato do Object
Pascal, isto é, o ponto e vírgula não é considerado o início de um
comentário até o final da linha, como no assembler tradicional.
A seguir, um exemplo de bloco asm..end com vários dos possíveis tipos de
instruções e separadores de comentários:
asm
xchg ebx, edx; add eax, [ebx]; {ponto e vírgula separa declaração}
// quebra de linha separa declaração
mov ebx, p
sub eax, [ebx] (*comentário separa declaração*) mov ebx, edx
end;
A convenção é utilizar quebras d elinhas para separação:
asm
xchg ebx, edx
add eax, [ebx]
mov ebx, p
sub eax, [ebx]
mov ebx, edx
end;
No código da VCL, você verá que os opcodes e nomes de registradores são
escritos em maiúsculas e que instruções são indentadas em uma tabulação
(normalmente equivalente a oito caracteres), mas utilizaremos outra
convenção neste artigo.
Blocos asm..end podem ocorrer em qualquer ponto do código fonte onde uma
declaração Pascal ordinária puder aparecer; além disso, é possível
termos rotinas 100% assembler se, ao invés de "begin", utilizarmos
"asm":
Certas vezes, um ou mais operandos são implícitos. Por exemplo, a
instrução CDQ (Converta Dword para Qword) parece não utilizar operando
algum; entretanto, essa instrução utiliza EDX e EAX: o bit mais alto
de EAX, o bit de sinal, é copiado para EDX de forma que, EDX:EAX passa
a representar o inteiro em EAX convertido para Int64, onde EAX carrega
os 32 bits menos significativos e EDX os 32 bits mais significativos.
Para a maioria das instruções, os operandos são registradores. Por
exemplo:
mov eax, ecx
copia o valor de ECX para EAX.
Operandos podem conter valores imediatos:
mov eax, 5
mov eax, 2 + 3 // expressão constante, resolvida na compilação
mov al, 'A' // o código ASCII de 'A' é $41 (65)
mov eax, 'ABC' // equivalente a MOV EAX, $00414243
Operandos também podem conter referências de memória:
mov [ebx], eax // EBX^ := EAX;
Referências de memória aparecem de várias formas:
mov eax, [$000FFFC] // Endereço absoluto
mov eax, [ebx] // Registrador
mov eax, [ebp-12] // Registrador mais/menos deslocamento
// constante
mov eax, [ebp+ebx] // Registrador mais deslocamento em registro
mov eax, [ebp+ebx+8] // Registrador mais deslocamento em registro
// mais/menos deslocamento constante
mov eax, [ebp+ebx*4] // Registrador mais deslocamento em registro
// multiplicado por constante
mov eax, [ebp+ebx*4+8] // Registrador mais deslocamento em registro
// multiplicado por constante, mais/menos
// deslocamento constante
Os identificadores usuais do Pascal são traduzidos para uma das formas:
Agora que estamos prontos para aprender alguns opcodes, vamos aos
exemplos. Podemos começar com uma função simples:
function f(x: integer; y: integer): integer;
// f(x,y) = (-x-y+5)*7
{
begin
Result := (-x - y + 5) * 7;
end;
}
asm
// os parâmetros são passados em EAX (x) e EDX (y);
neg eax // EAX := -EAX; // EAX = -x
sub eax, edx // EAX := EAX - EDX; // EAX = -x-y
add eax, 5 // EAX := EAX + 5; // EAX = -x-y+5
imul 7 // EAX := EAX * 7; // EAX = (-x-y+5)*7
end;
Os três primeiros parâmetros (da esquerda para a direita) são passados
em EAX, EDX e ECX. Para métodos, o primeiro parâmetro é Self (passado
em EAX) e o primeiro parâmetro explicitamente declarado é, de fato, o
segundo parâmetro (passado em EDX) e o segundo parâmetro explícito é
de fato o terceiro parâmetro (passado em ECX).
O valor de retorno deve ser armazenado em EAX para valores ordinais de
32 bits (AX e AL devem ser utilizados para retornar valores de 16 e 8
bits respectivamente).
Os comentários explicam os opcodes de forma clara mas, para IMUL, temos
que acrescentar duas explicações:
* IMUL considera os operandos (EAX e 7 no exemplo) como inteiros com
sinal (devemos utilizar MUL quando os operandos não possuírem sinal).
* O resultado da multiplicação é um inteiro de 64 bits sendo que os 32
bits mais significativos do resultado são armazenados em EDX.
Multiplicações são relativamente caras em termos de tempo de CPU e, por
vezes, é mais fácil substitui-las por deslocamentos de bits (quando a
multiplicação ou divisão operarem com potências de dois), somas e
subtrações. Por exemplo:
a * 7 = a * (8 - 1)
= a * 8 - a
= a * 2^3 - a
a * 7 = a shl 3 - a
function resto(x: integer; y: integer): integer;
// Retorna o resto de x dividido por y
{
begin
Result := x mod y;
end;
}
asm
// os parâmetros são passados em EAX (x) e EDX (y);
mov ecx, edx // ECX := EDX; // EDX = y
cdq // EDX:EAX := Int64(EAX); // EAX = x
idiv ecx // divisão inteira com sinal em 32 bits:
// EAX := Int64(EDX:EAX) div integer(ECX);
// EDX := Int64(EDX:EAX) mod integer(ECX);
mov eax, edx // Result := EDX; // resto
end;
A Pilha
=======
Quando um programa é carregado, ele receve uma pilha, que é uma região
de memória utilizada como uma estrutura LIFO, "Last In, First Out"
(último a chegar, primeiro a sair), controlada pelo registrador ESP
que aponta para o topo dessa pilha. ESP inicia apontando para o final
da região de modo que, cada vez que empilhamos um novo valor de 32 bits,
o registrador ESP é decrementado em 4 (bytes) e o valor é armazenado no
local apontado por ESP.
A pilha é utilizada para armazenar endereços de retorno de rotinas,
parâmetros, variáveis locais e resultados intermediários. No exemplo
a seguir, utilizamos a pilha para salvar o valor de um registrador
para uso posterior:
function IntDiv(x: integer; y: integer; r: pinteger = NIL): integer;
// Retorna o quociente inteiro x / y e o resto em r
{
begin
Result := x div y;
if r <> NIL then r^ := x mod y;
end;
}
asm
// os parâmetros são passados em EAX (x), EDX (y) e ECX ®
push ecx // Salve ECX ® para uso posterior
mov ecx, edx // ECX := EDX; // ECX = y
cdq // EDX:EAX := Int64(EAX); // EAX = x
idiv ecx // divisão inteira com sinal em 32 bits:
// EAX := Int64(EDX:EAX) div integer(ECX);
// EDX := Int64(EDX:EAX) mod integer(ECX);
pop ecx // Restaura ECX (ECX := r)
cmp ecx, 0 // if ECX = NIL then
jz @@end // goto @@end;
mov [ecx], edx // ECX^ := EDX; // resto
@@end: // identificador local (precedido por "@@")
end;
Note que, para cada PUSH que executamos, temos que executar um POP
correspondente de modo que ESP fique inalterado (ESP é um dos
registradores que temos que preservar).
A instrução CMP subtrai o segundo operador do primeiro (ECX-0 nesse
caso), como a instrução SUB, mas o resultado não é armazenado em lugar
algum, ainda que o indicador de Zero (Zero flag) seja marcado (ligado)
ou limpo (desligado) dependendo do resultado ser zero ou não, como em
qualquer instrução lógica ou matemática (com a exceção de certos casos).
Podemos então tirar vantagem desse fato e, ao invés de escrevermos
cmp ecx, 0
podemos escrever
or ecx, ecx // ECX := ECX or ECX;
O resultado de ECX Or ECX é o próprio ECX; portanto, o valor armazenado
em ECX é o mesmo de antes, e como dissemos anteriormente o indicador de
Zero será marcado se o resultado for zero (isto é, se ECX era zero).
A instrução JZ, "Jump if Zero" (Desvie se Zero), desvia (salta) para o
identificador indicado como operando se o valor do indicador de Zero
estiver marcado (ligado) ou continua normalmente com o fluxo de execução
se o indicador de Zero estiver desmarcado (desligado).
Passando Parâmetros para a Pilha
--------------------------------
Voltemos para a pilha. Dissemos que os três primeiros parâmetros de
uma rotina são passados em EAX, EDX e ECX; mas, o que acontece quando
temos mais de três parâmetros? Parâmetros adicionais são passados na
pilha, da esquerda para a direita, de forma que o último parâmetro será
sempre o primeiro da pilha.
Suponha que temos a seguinte função
function Soma(a, b, c, d, e: integer): integer;
begin
Result := a + b + c + d + e;
end;
A instrução CALL empilha o endereço de retorno na pilha e salta para
(inicia a execução) da função. A instrução RET (RETorna) gerada pelo
compilador quando o final de uma função é alcançado desempilha esse
endereço da pilha e salta para ele para continuar a execução a partir
desse ponto.
Note que quando empilhamos parâmetros na pilha mas não os desempilhamos.
Isso acontece pois limpar a pilha é responsabilidade da função chamada e
não da função que chama (exceto na convenção de chamada CDECL). Para
limpar os parâmetros, a instrução RET é utilizada com um operando que
indica o número de bytes que ESP deve ser incrementado (8 nesse caso já
que ESP foi decrementado em 4 bytes para cada parâmetro empilhado). O
compilador fica encarregado dessa tarefa portanto não temos com que nos
preocupar; mas, se você utilizar a janela de depuração da CPU e
encontrar uma instrução RET $08, agora você já sabe do que se trata.
Na entrada para Soma, a pilha estaria, em teoria, da seguinte forma:
Quando uma função tem parâmetros na pilha (ou variáveis locais), o
compilador gera algumas instruções chamadas de "stack frame", quadro
da pilha. Na entrada da função (em "asm"), EBP é empilhado de modo a
ser preservado e ESP é atribuído a ele; e, antes de deixar a função,
(em "end"), o valor original de EBP é desempilhado:
function Soma(a, b, c, d, e: integer): integer;
asm // push ebp; mov ebp, esp;
....
end; // pop ebp; ret 8;
Assim, quando entramos em Soma, a pilha estaria de fato da seguinte
forma:
Em [EBP] encontramos o valor original de EBP que foi empilhado para
ser preservado quando da construção do quadro de pilha; em [EBP+4]
encontramos o endereço de retorno da rotina; em [EBP+8] encontramos
o último parâmetro (o último parâmetro é empilhado por último e, por
isso, é o primeiro da pilha). O parâmetro seguinte (da direita para
a esquerda) fica em [EBP+12], e assim por diante se houvesse outros
parâmetros.
Agora vamos escrever a rotina Soma em assembler:
function Soma(a, b, c, d, e: integer): integer;
{
begin
Result := a + b + c + d + e;
end;
}
asm
add eax, b
add eax, c
add eax, d
add eax, e
end;
Note que no bloco asm..end nós utilizamos "b", "c", "d" e "e" ao invés
de "EDX", "ECX", "[EBP+12]" e "[EBP+8]" respectivamente. Nós podemos
fazer assim já que o compilador fará as substituições adequadas.
Variáveis Locais na Pilha
-------------------------
Se nossa função assembler inline tiver variáveis locais, o compilador
criará espaço para essas variáveis na pilha, movendo o ponteiro da pilha
de modo que o quadro da pilha para uma função com duas variáveis locais
inteiras seria:
push ebp
mov ebp, esp
sub esp, 8 // Desloca ESP como se empilhássemos 8 bytes
...
add esp, 8 // Desloca ESP como se desempilhássemos 8 bytes
pop ebp
Para o propósito do exemplo, aqui vai uma variação da rotina Soma acima,
utilizando duas variáveis locais:
function SomaL(a, b, c, d, e: integer): integer;
var
f, g: integer;
{
begin
f := b + c;
g := d + e;
Result := a + f + g;
end;
}
asm // push ebp; mov ebp, esp; sub esp, 8;
add edx, ecx
mov f, edx // b + c
mov edx, d
add edx, e
mov g, edx // d + e
add eax, f
add eax, g
end; // add esp, 8; pop ebp; ret 8
Nessa função, a pilha teria o seguinte aspecto:
| |
+-----------+
| var. g | <- EBP-8, ESP
+-----------+
| var. f | <- EBP-4
+-----------+
| Orig. EBP | <- EBP
+-----------+
| Ret_Addr |
+-----------+
| Param e | <- EBP+8
+-----------+
| Param d | <- EBP+12
+-----------+
| |
O Que Vem Agora?
================
Na continuação deste artigo, aprenderemos mais instruções e veremos
como passar e retornar outros tipos de parâmetros, como trabalhar com
arrays, como acessar campos de registros e objetos, como chamar métodos
e mais.
Nesse capítulo iremos aprender algumas novas instruções assembler e o
básico da manipulação de strings ANSI, também chamadas de strings longas.
Novos opcodes
=============
Abaixo os opcodes introduzidos neste atrigo:
* JL (Jump if Lower, desvie se menor): A descrição mais adequada levaria
muito tempo para ser explicada, então vamos dizer que JL salta (desvia)
para o label especificado desde que na operação CMP (ou SUB) anterior
o primeiro operando seja menor que o segundo numa comparação com sinal:
// if signed(op1) < signed(op2) then goto @@label;
cmp op1, op2
jl @@label
JG (Jump if Greater, desvie se maior), JLE (Jump if Lower or Equal,
desvie se menor ou igual) e JGE (Jump if Greater or Equal, desvie se
maior ou igual) completa a família de desvios condicionais para
comparações com sinal.
* JA (Jump if Above, desvie se maior): salta (desvia) para o label
especificado desde que na operação CMP (ou SUB) anterior o primeiro
operando seja maior que o segundo numa comparação sem sinal:
// if unsigned(op1) > unsigned(op2) then goto @@label;
cmp op1, op2
ja @@label
JB (Jump if Below, desvie se menor), JBE (Jump if Below or Equal,
desvie se menor ou igual) e JAE (Jump if Above or Equal, desvie se
maior ou igual) completam a família de desvios condicionais para
comparações sem sinais.
* LOOP: Decrementa ECX e, se não for zero, desvia para o label indicado.
LOOP @@label é o equivalente mais curto e rápido de:
dec ecx // ECX := ECX - 1;
jnz @@label // if ECX <> 0 then goto @@label
Trabalhando com strings ANSI
============================
Uma variável string é representada por um ponteiro de 32 bits. Se a
string é vazia (''), então o ponteiro é nil (zero), caso contrário,
esse ponteiro aponta para o primeiro caractere dessa string. O tamanho
da string e a contagem de referência são dois inteiros em deslocamentos
negativos a partir do primeiro byte da string:
+-----------+
| s: string |-------------------+
+-----------+ |
V
--+-----------+-----------+-----------+---+---+---+---+---+---+---+--
| allocSiz | refCnt | length | H | e | l | l | o | ! | #0|
--+-----------+-----------+-----------+---+---+---+---+---+---+---+--
(longint) (longint) (longint)
\-----------------v-----------------/
StrRec record
const skew = sizeof(StrRec); // 12
Quando passamos uma string como um parâmetro para uma função, o que de
fato é passado é o ponteiro de 32 bits. Os valores string são um pouco
mais complicados de explicar. A rotina que chamou a rotina que retorna
a string deve passar- como último e invisível parâmetro da chamada, um
tipo PString-o endereço de uma variável string que receberá o resultado
da função.
d := Uppercase(s); // Internamente convertido para: Uppercase(s, @d);
Se o resultado da função é usado em uma expressão ao invés de ser
atribuído diretamente à variável, a rotina que chama deve utilizar uma
variável temporária incializada com nil (string vazia). O compilador faz
tudo isso automaticamente no nosso código Object Pascal mas, se temos
que fazer isso por conta própria se optarmos por escrever código
assembler que chame rotinas que retornam strings.
Para algumas tarefas, não podemos chamar as clássicas funções de string
diretamente. Por exemplo, a função Length não é o nome de uma função de
verdade,. é uma construção interna do próprio compilador e o compilador
gera o código para a função apropriada, dependendo do parâmetro ser uma
string ou um array dinâmico. Em assembler, ao invés de Lenght, teríamos
que usar a função LStrLen (declarada na unidade System) para obter o
tamanho da string.
Existem mais coisas que deveríamos saber a respeito das strings mas o
que temos já é suficiente para um primeiro exemplo.
Versão Assembler de Uppercase
=============================
Eis a declaração da função:
function AsmUpperCase(const s: string): string;
O parâmetro "s" será passado em EAX e o endereço de "Result" será
passado como o segundo parâmetro, ou seja, em EDX.
Basicamente a função deve fazer:
1) Obter o comprimento da string a converter
2) Alocar memória para a string convertida
3) Copiar os caracteres um a um, convertidos para maiúsculas
1) Obter o comprimento da string a converter
--------------------------------------------
Faremos isso através de uma chamada a System.@LStrLen. A função espera
a string em EAX (ela já está lá) e o resultado será colocado em EAX;
então, temos que salvar o valor de EAX (o parâmetro "s") em algum lugar
antes de chamar a função de modo que "s" não seja perdido. Podemos salvar
numa variável local "src". Já que funções são livres para utilizar os
registradores EAX, ECX e EDX, presumimos que o valor em EDX ("@Result")
poderia também ser destruído após uma chamada a System.@LStrLen, de modo
que é útil salvar esse valor numa variável local, por exemplo, "psrc".
O resultado da chamada a System.@LStrLen, deixado em EAX, servirá como
parâmetro da chamada a System.@LStrSetLength (para alocar memória para
o conteúdo da string de resultado), como contador dos bytes a copiar, de
modo que esse valor também deve ser salvo, por exemplo, na variável "n":
var
pdst: Pointer; // Endereço da string resultado
src: PChar; // String de origem
n: Integer; // Comprimento da string de origem
asm
// O endereço da string de resultado é passado em EDX.
// Salvamos esse valor na variável pdst:
mov pdst, edx // pdst := EDX;
// Salvamos EAX (s) na variável local (src)
mov src, eax // src := EAX;
// n := Length(s);
call System.@LStrLen // EAX := LStrLen(EAX);
mov n, eax // n := EAX;
2) Alocar memória para a string convertida
------------------------------------------
A alocação é realizada através de uma chamada a System.@LStrSetLength.
O procedimento espera dois parâmetros: o endereço da string (que
salvamos em "pdst") e o comprimento da string (que está em EAX).
// SetLength(pdst^, n); // Alocar a string de resultado
mov edx, eax // EDX := n; // Segundo parâmetro p/LStrSetLength
mov eax, pdst // EAX := pdst; // Primeiro parâmetro p/LStrSetLength
call System.@LStrSetLength // LStrSetLength(EAX, EDX);
3) Copiar os caracteres um a um, convertidos para maiúsculas
------------------------------------------------------------
Se o comprimento da string era zero, já terminamos:
// if n = 0 then exit;
mov ecx, n // ECX := n;
test ecx, ecx // Fazer and de ECX com ECX para definir flags
// (ECX inalterado)
jz @@end // Ir para @@end se o flag zero está marcado (ECX=0)
Não sendo esse o caso, devemos copiar os caracteres de uma string para
a outra, convertendo-os para maiúsculas conforme necessário. Nós vamos
utilizar ESI e EDX para apontar para os caracteres da string de origem
e destino respectivamente, AL para carregar os caracteres da string de
origem e realizar a mudança antes de armazená-los na string de destino e
ECX para controlar a instrução de LOOP que contará os caracteres. Já que
ESI é um registro que tem que ser preservado, devemos salvar seu valor
para restaurá-lo mais tarde. Decidi salvar ESI colocando-o na pilha.
push esi // Salve ESI na pilha
// Inicializar ESI e EDX
mov eax, pdst // EAX := pdst; // Endereço da string de resultado
mov esi, src // ESI := src; // String de origem
mov edx, [eax] // EDX := pdst^; // String de resultado
@@cycle:
mov al, [esi] // AL := ESI^;
// if Shortint(AL) < Shortint(Ord('a')) then goto @@nochange
cmp al, 'a'
jl @@nochange
// AL in ['a'..#127]
// if Byte(AL) > Byte(Ord('a')) then goto @@nochange
cmp al, 'z'
ja @@nochange
// AL in ['a'..'z']
sub al, 'a'-'A' // Dec(AL, Ord('a')-Ord('A'));
@@nochange:
mov [edx], al // EDX^ := AL;
inc esi // Inc(ESI);
inc edx // Inc(EDX);
loop @@cycle // Dec(ECX); if ECX <> 0 then goto cycle
Transforme o Windows 7 a HUD-Vermelho Nota: instalador Pacotes de pele tem opção de instalação fácil e segura, por favor, desinstale a versão antiga ou outro de pacotes de pele antes de instalar a nova versão.Antes de instalar fechar todo o programa runnig, depois de terminar reinicie o sistema. Suporte:
Windows 7, Windows 7 SP1 - [X86_X64] - [Language All] - [Versão Tudo]
Baixe o instalador Offline: X64: http://bitshare.com/...amers-.exe.html http://filevice.com/pkxx7bho1b6c
V¡®u§ got a reaction from Vitor Pinho ☮ in Como Fazer Seu Keylogger [100% Fud]- 2013
V¡®u§ got a reaction from Nestle in Mudar O Ip Em 10 Segundos
V¡®u§ got a reaction from iReapZz in Onehitcf 12.0 [13/03/2013]
V¡®u§ got a reaction from ɓʀuɳѳ' ИИ#92 in Onehitcf 13.0 [Cf]
V¡®u§ got a reaction from NewWars in Mr Catra - É Gillette Let Let Let
V¡®u§ got a reaction from Mastema in Hud Red Skin Pack