Text Widget

Total de visualizações

Blogger templates

Unordered List

Richardson facundes thomaz. Tecnologia do Blogger.

Popular Post

Arquivo do blog

Seguidores

Quem sou eu

Minha foto
são paulo, são paulo, Brazil

Blogroll

Recent Videos

TEST




Muitas pessoas estavam pedindo um tutorial aobscan então aqui eu faço uma breve descrição para usar aobscan.

Por que estamos usando aobscan com freqüência?
Em muitos casos, o endereço do código que queremos mudar não é estática. Isso pode acontecer em muitos jogos
onde os códigos são carregados somente quando eles são usados ​​e também acontece se você não está usando o mesmo
versão do jogo. Código Ifthe si não mudou, apenas o endereço do código, você pode usar aobscan para encontrar o endereço do código.


Primeiro vou começar com um exemplo onde eu mostro como você pode mudar um simples script em um script aobscan,
então eu vou explicar em mais detalhes para aqueles que querem saber como ele está trabalhando. No final eu vou escrever
algumas dicas mais avançadas para os problemas específicos que podem ocorrer quando você estiver usando aobscan.


O processo de destino é o programa Tutorial para CE 6.2. Aqui está um script normal que vai resolver Passo 2
do tutorial (neste ponto eu suponho que você pode fazer truques com endereços de código estático).


Code:
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)

newmem: //this is allocated memory, you have read,write,execute access
mov [ebx+00000464],(int)1000

originalcode:
mov eax,[ebx+00000464]

exit:
jmp returnhere

"Tutorial-i386.exe"+22988:
jmp newmem
nop
returnhere:

[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
"Tutorial-i386.exe"+22988:
mov eax,[ebx+00000464]
//Alt: db 8B 83 64 04 00 00

Para mudar isso em um script com aobscan, você tem que fazer apenas algumas modificações (olhar para os comentários):


Code:
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)
label(whatever)                      //make a label that you can use for your aobscan
registersymbol(whatever)             //also register it as a symbol
aobscan(aob1,8B 83 64 04 00 00 3D)   //use aobscan to search for the code, more explanation later


newmem: //this is allocated memory, you have read,write,execute access
mov [ebx+00000464],(int)1000

originalcode:
mov eax,[ebx+00000464]

exit:
jmp returnhere

aob1:             //replace the static address with your aobscan, which is called aob1 in my case
whatever:         //store aob1 on the whatever label
jmp newmem
nop
returnhere:

[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
whatever:                    //replace the static address with the whatever label
db 8B 83 64 04 00 00         //restore the original byte pattern
unregistersymbol(whatever)   //we don't need this symbol anymore so unregister it

Se você copiar e colar este script em CE, ele procurará o código que eu mudei no roteiro original
e fazer o mesmo a injeção de código. Agora devo explicar algumas coisas em mais detalhes, embora não seja realmente
neccessary para entender tudo em ordem para usar aobscan.
Code:
Tutorial-i386.exe+22988 - 8B 83 64040000        - mov eax,[ebx+00000464]
Tutorial-i386.exe+2298E - 3D E8030000           - cmp eax,000003E8

Se você olhar para ele no disassembler, você pode ver como é esta instrução armazenada na memória.

Code:
8B 83 64 04 00 00
3D E8 03 00 00

Você tem que chegar a um padrão que irá identificar este código. Vamos fazer isso:
Tipo de valor Mudar para 'Array of byte', certifique-se de que a caixa 'gravável' é apenas 'opcional' e que não tem
uma marca de verificação, como o código que está procurando não é gravável, só executável. Agora, digitalize para este padrão de byte

Code:
8B 83 64 04 00 00

Você provavelmente terá 8 resultados, que não é um bom começo e se você verificar o primeiro resultado, não é o
código correto que estamos procurando. Assim, podemos ver que não podemos usar esse padrão de byte. Agora, temos de chegar a um novo padrão que vai filtrar os sete resultados errados. Como podemos ver, o primeiro byte da próxima instrução
inicia com o 3D. Tente procurar por esse padrão de bytes:



Code:
8B 83 64 04 00 00 3D

Agora você terá um resultado, ou pelo menos o primeiro será o código que você está procurando. Este byte
padrão pode ser usado para encontrar o endereço do nosso código. A sintaxe é muito simples


Code:
aobscan(name,byte pattern)
aobscan(aob1,8B 83 64 04 00 00 3D)

O nome dos aobscans e símbolos podem ser qualquer coisa, cabe a você. Após essa instrução é executada,
aob1 é igual a 'Tutorial-i386.exe' 22988 endereço. Você pode usar aob1 para se referir a este endereço.

NOTA: O caractere * é um personagem Coringa. Se você colocar * em seu padrão de byte, que pode ser qualquer coisa.
Eg
'* 83 64 04 00 00 3D' pode ser qualquer coisa de '00 83 64 04 00 00 3D' para '83 64 FF 04 00 00 3D'
Quando você não tem certeza de que um byte será o mesmo em outras versões do jogo, use *.

Fazendo o script:

Como você vê que era necessário marcar para fazer algumas modificações no roteiro original de usar aobscan. Você pode apenas
copiar e colar essas mudanças em seu roteiro, sem jamais perguntar por que eles são necessários, mas se você está curioso, aqui
são as razões.


Code:
label(whatever)
registersymbol(whatever)

Você não é capaz de usar seu resultado aobscan na seção disable e você não pode fazer a varredura do código de qualquer um, porque você mudou com sua injeção de código. É por isso que o endereço tem que ser salvo em algum lugar para uso posterior.


Code:
aob1:             //replace the static address with your aobscan, which is called aob1 in my case
whatever:         //store aob1 on the whatever label

Esta é a parte onde armazenamos aob1 no 'qualquer' símbolo para que possamos usá-lo na seção desativar também.


Disable section


Code:
whatever:                    //replace the static address with the whatever label

É por isso que salvou o endereço em 'o que', precisamos restaurar o código original na seção desativar.


Code:
db 8B 83 64 04 00 00         //restore the original byte pattern


Sim. Tenho substituído

Code:
mov eax,[ebx+00000464]
//Alt: db 8B 83 64 04 00 00

com o padrão de byte inicial. A razão é que a instrução pode ser compilado de forma diferente por CE e temos que estar 100% certo para restaurar as instruções exatamente como era.
Example:
Code:
mov eax,[ebx+ecx++00000464]
and
mov eax,[ecx+ebx++00000464]
tem os mesmos resultados, mas não são a mesma instrução. Temos a certeza de que poderemos restaurar a mesma instrução que tem exatamente o mesmo padrão de byte como o original. Se não conseguirmos fazer isso, o padrão de byte original será perdido e sua aobscan não vai encontrá-lo se você tentar ativar o cheat novamente. Sempre estar 100% certo de que você restaurou o padrão de byte original ou os usuários não serão capazes de transformar o roteiro on / off.

unregistersymbol (whatever) // não precisamos de mais este símbolo tão anular o seu registo
Simples limpeza. Remova o símbolo de que não estamos usando mais.
Dicas avançadas e soluções para os vários problemas que podem ocorrer quando você estiver usando aobscan:

Os erros mais comuns com aobscan estão usando os mesmos nomes de símbolos quando você tem mais do que um script e não restaurar o código original corretamente. Você deve sempre usar símbolos / etiqueta / nomes aobscan separadas em diferentes roteiros e como eu disse acima, ter 100% de certeza de que você haverestored o padrão de byte original. Se seus scripts estão funcionando corretamente, eles podem ser ligado / desligado a qualquer momento de forma independente, sem interferir com o outro. É fácil cometer erros e os usuários muitas vezes culpam CE por algum bug, mas se você seguiu as instruções corretamente, ele deve funcionar. O erro está no seu script, em algum lugar algo é asneira. Confira tudo, olhar para as mudanças no disassembler quando você virar as fraudes on / off, verifique o código original eo código restaurado que eles realmente estão combinando etc

Certifique-se de que o seu padrão de byte não está contendo endereços estáticos ou outros códigos que vai mudar mais provável
em outras versões do jogo. Por exemplo, um código como

Code:
call 00908070

será diferente em outra versão do jogo, porque é 00908070 um endereço estático. Substituir endereços estáticos com * personagem. Cada * é um byte. Assim substituir o endereço com * * * * no padrão.

Como fazer uma injeção de código em um endereço, se você não encontrar um padrão de byte para esse endereço particular?

Vamos supor que queremos mudar este código

Code:
Tutorial-i386.exe+22988 - 8B 83 64040000        - mov eax,[ebx+00000464]
Tutorial-i386.exe+2298E - 3D E8030000           - cmp eax,000003E8
Tutorial-i386.exe+22993 - 75 2C                 - jne Tutorial-i386.exe+229C1

e nós temos um padrão de bytes que nos dá '22988 Tutorial-i386.exe' mas queremos fazer a injeção de código neste endereço:

Code:
Tutorial-i386.exe+2298E - 3D E8030000           - cmp eax,000003E8

Se não encontrar qualquer padrão de byte de trabalho que vai encontrar Tutorial-i386.exe 2298E, podemos usar o padrão de byte anteriormente descobriu que nos dá Tutorial-i386.exe 22988 como o resultado. O código original ficaria assim:

Code:
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)

newmem: //this is allocated memory, you have read,write,execute access
mov [ebx+00000464],(int)1000

originalcode:
cmp eax,000003E8

exit:
jmp returnhere

"Tutorial-i386.exe"+2298E:
jmp newmem
returnhere:

[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
"Tutorial-i386.exe"+2298E:
cmp eax,000003E8
//Alt: db 3D E8 03 00 00

A versão aobscan será este:
Code:
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)
label(whatever)                    
registersymbol(whatever)            
aobscan(aob1,8B 83 64 04 00 00 3D)  

newmem: //this is allocated memory, you have read,write,execute access
mov [ebx+00000464],(int)1000

originalcode:
cmp eax,000003E8

exit:
jmp returnhere

aob1+6:             //22988+6 = 2298E so we are making our code injection on 2298E address instead of 22988
whatever:        
jmp newmem
returnhere:

[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
whatever:
db 3D E8 03 00 00
unregistersymbol(whatever)

Como você pode ver, temos utilizado o padrão de byte que nos dá Tutorial-i386.exe 22988 como resultado, mas desde que nós queremos fazer a injeção de código em 2298E, nós simplesmente usado aob1 6 em vez de aob1. 22988 6 = 2298E e desde aob1 = 22988, aob1 6 também é igual a 2298E.

Saltos em seu script:

Instruções de salto no código original vai causar problemas para você, se você não tratá-los adequadamente. A fonte do problema é a seguinte:
Code:
Tutorial-i386.exe+22988 - 8B 83 64040000        - mov eax,[ebx+00000464]
Tutorial-i386.exe+2298E - 3D E8030000           - cmp eax,000003E8
Tutorial-i386.exe+22993 - 75 2C                 - jne Tutorial-i386.exe+229C1
Tutorial-i386.exe+22995 - 8B 83 4C040000        - mov eax,[ebx+0000044C]

CE vai mostrar que salto condicional como JNE Tutorial-i386.exe 229C1 para facilitar as coisas, mas, na realidade, que a instrução é 2C JNE. Ele vai saltar para a frente 2C bytes.

O que acontece se você usar esse código?

Code:
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)

newmem: //this is allocated memory, you have read,write,execute access
//place your code here

originalcode:
jne Tutorial-i386.exe+229C1
mov eax,[ebx+0000044C]

exit:
jmp returnhere

"Tutorial-i386.exe"+22993:
jmp newmem
nop
nop
nop
returnhere:

[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
"Tutorial-i386.exe"+22993:
jne Tutorial-i386.exe+229C1
mov eax,[ebx+0000044C]
//Alt: db 75 2C 8B 83 4C 04 00 00

Será que vai funcionar? Absolutamente. O problema é que Tutorial-i386.exe 229C1 é um endereço estático e você não pode saltar para um endereço estático, porque vai ser diferente em outras versões do jogo. Este salto vai funcionar quando você está fazendo um script normal, mas você não pode usá-lo com aobscan.

Então, vamos substituí-lo com a instrução original JNE +2C.

Code:
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)

newmem: //this is allocated memory, you have read,write,execute access
//place your code here

originalcode:
jne +2C
mov eax,[ebx+0000044C]

exit:
jmp returnhere

"Tutorial-i386.exe"+22993:
jmp newmem
nop
nop
nop
returnhere:

[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
"Tutorial-i386.exe"+22993:
jne +2C
mov eax,[ebx+0000044C]
//Alt: db 75 2C 8B 83 4C 04 00 00

O que vai acontecer se você permitir isso? Se você tiver sorte, seu programa não irá falhar. Mas isso não vai funcionar. Porque se você saltar para a frente 2C bytes na memória alocada que você criou, você acaba no meio do nada. Não se esqueça que este salto está calculando o destino da atual endereço por isso, quando você faz uma injeção de código, ele está calculando o salto da memória alocada.

Ok como consertar isso? Em primeiro lugar, precisamos de um padrão de byte para este código.
Código:
75 2C 8B 83 4C 04 00 00

Agora calcule a diferença entre o 'Tutorial-i386.exe' 22993 eo destino do salto, 229C1 Tutorial-i386.exe. A diferença é 2E bytes, o que significa que aob1 2E = Tutorial-i386.exe 229C1.

Por que não 2C? Temos JNE 2C e agora temos 2E. A resposta é que o salto relativo irá calcular o destino a partir do final da instrução e que são o seu cálculo a partir do primeiro byte de instrução. Nossa instrução ocupa 2 bytes, por isso, a diferença é de 2 bytes superior.
Agora que sabemos como devemos mudar o salto, podemos fazer um script que irá saltar para aob1 2E, onde quer que seja encontrado pelo aobscan.

Code:
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048) //2kb should be enough
label(returnhere)
label(originalcode)
label(exit)
label(whatever)
registersymbol(whatever)
aobscan(aob1,75 2C 8B 83 4C 04 00 00)

newmem: //this is allocated memory, you have read,write,execute access
//place your code here

originalcode:
jne aob1+2E
mov eax,[ebx+0000044C]

exit:
jmp returnhere

aob1:
whatever:
jmp newmem
nop
nop
nop
returnhere:

[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
whatever:
db 75 2C 8B 83 4C 04 00 00
unregistersymbol(whatever)

Tada, fizemos um magnífico roteiro que absolutamente não está fazendo nada de útil, mas pelo menos ele está saltando no local certo, apesar do fato de que a própria instrução de salto é muito longe do destino. Agora vamos fazer algo útil e substituir JNE com je. Isto irá resolver o passo 2 do tutorial e você pode avançar para o passo 3.

Neste momento, nada mais me vem à mente sobre o assunto. Isso deve ser o suficiente para lidar com a maior parte dos problemas que irá enfrentar quando você estiver usando aobscan.

Gesso projetado Saiba quais os procedimentos para fazer o acabamento de paredes com gesso aplicado com bomba de projeção

O gesso projetado é usado para revestimento de paredes, ­lajes, pilares ou vigas. Ele é aplicado somente em ambien­tes ­internos com uma bomba de ­pro­jeção, forma alternativa ao pro­cesso manual.
A superfície que vai receber o gesso não precisa de nenhum preparo prévio. A espessura da camada de gesso projetado vai depender, principalmente, da regularidade dessa superfície. A camada de gesso não costuma ultrapassar 20 mm.
Para um bom desempenho na projeção, o produto contém aditivos que aumentam sua aderência ao suporte e controlam seu ponto de secagem - se comparado com o gesso tradicional. Em relação ao revestimento feito com argamassa, eliminam-se as etapas de chapisco, emboço e reboco.
Segundo o fabricante do gesso utilizado nesse passo a passo, o produto tem em média 60 minutos de tempo de trabalho. Calcula-se que a produção média diária é de 200 m² - levando em consideração a utilização de uma máquina de projeção e quatro profissionais.

Materiais e EPIs
Fotos: Marcelo Scandaroli
Balde (se possível de plástico, para facilitar o manuseio do gesso), espátula, raspador, desempenadeira de alumínio, réguas H (com 2 m de comprimento), trena, luvas, capacete, óculos e protetor auricular.

IMPORTANTE
Não se esqueça de medir com a trena e aplicar todas as taliscas, constituindo um plano que disfarce as irregularidades da parede. Elas devem marcar o início e o fim da guia mestra a ser executada.

Passo 1
Fotos: Marcelo Scandaroli
1 Aplique a talisca, feita com um recorte de cerâmica, com o próprio gesso na parede. Ela serve para a moldagem da guia mestra, que vai indicar a espessura desejada da camada de gesso.

Passo 2
Fotos: Marcelo Scandaroli
2 Carregue a régua H com o gesso para fazer a guia mestra. Utilize uma espátula para isso. 

Passo 3
Fotos: Marcelo Scandaroli
3 Posicione a régua H carregada ao pé da parede, alinhada às taliscas aplicadas anteriormente. 

Passo 4
Fotos: Marcelo Scandaroli
4 Assente a régua na parede e pressione até que a camada de gesso ganhe a espessura da talisca.  

Passo 5
Fotos: Marcelo Scandaroli
5 Retire o excesso de gesso com a espátula.  

IMPORTANTE
Fotos: Marcelo Scandaroli
As guias mestras devem ser executadas a menos de 2 m entre si (o comprimento da régua H). Isso garante que será possível usar o instrumento para sarrafear o gesso projetado na parede.

Passo 6
Fotos: Marcelo Scandaroli
6 Depois que o gesso secar, retire a régua H.

Passo 7
Fotos: Marcelo Scandaroli
7 Alimente a máquina, desligada, com o gesso em pó. Durante o procedimento, o gesso pode ser colocado com a máquina em funcionamento.

IMPORTANTE
A máquina é abastecida com água e faz a mistura com o gesso automaticamente. A proporção da mistura é ajustada em mecanismos da máquina. Antes de instalar a mangueira e o bico de projeção, deve-se observar a densidade desejada do gesso produzido.

Passo 8
Fotos: Marcelo Scandaroli
Fotos: Marcelo Scandaroli
A aplicação deve ser feita em jatos horizontais, levemente sobrepostos, de cima para baixo. A aplicação deve ser feita com o bico de projeção a cerca de 20 cm ou 30 cm de distância da parede.

DICAS
» O bico deve ficar na horizontal, não se deve inclinar a projeção em nenhum dos pontos.
» Não é preciso aplicar em excesso. O sarrafeamento vai distribuir e nivelar a projeção na espessura determinada pela guia mestra.
» O excesso de gesso, retido na régua H pode ser retirado com uma espátula e espalhado em outra parte da parede ou, então, descartado em um.
Fotos: Marcelo Scandaroli


Passo 9
Fotos: Marcelo Scandaroli
9 Sarrafeie, com a régua H, imediatamente após a aplicação em cada trecho. O procedimento pode ser repetido algumas vezes se necessário.

Passo 10
Fotos: Marcelo Scandaroli
10 Após a secagem, aplique a desempenadeira lisa carregada com a mistura de gesso para corrigir eventuais imperfeições. A mistura para o acabamento final deve ser menos densa (um pouco mais líquida) do que o gesso usado na projeção.

Passo 11
Fotos: Marcelo Scandaroli
Fotos: Marcelo Scandaroli
11 Elimine o gesso da máquina e faça a sua limpeza até que a água saia visivelmente limpa.

Bomba de projeção
Fotos: Marcelo Scandaroli
Fotos: Marcelo Scandaroli
A máquina usada para mistura e aplicação de gesso projetado nesse passo a passo também é usada para aplicação de argamassa. Ela suporta projeção de produtos com até 6 mm de granulometria.

Serviço orçado
Saiba quanto custa para aplicar o gesso com projeção mecânica em 1 m² de superfície
Não incluída taxa de Leis Sociais de 129,34%. Os valores apresentados referem-se apenas ao custo do serviço, não sendo considerada a taxa de BDI.
Data-base: novembro de 2011/São Paulo.


 
Copyright © 2013. TÉCNICO EM EDIFICAÇÕES - All Rights Reserved
Template Created by ThemeXpose | Published By Gooyaabi Templates