Mensajes

Mirar esto, entrevista a los creadores.
http://www.youtube.com/watch?v=PsicUT0UydI
¿Cuantos de aquí le decís ei pi ai a la API de cualquier lado? jajaja , en fin...
Campus party:
http://www.youtube.com/watch?feature=player_embedded&v=OpYkL8Zy2XU#!
¿Cuantas veces dice la edad que tenía?
¿Qué están cambiando el mundo?
Pf...

[¿Cuál es la diferencia entre hacker y cracker?, ¿le molesta el uso equivocado que se hace del término hacker?]

¿Cuál es la diferencia entre hacker y cracker?, ¿le molesta el uso equivocado que se hace del término hacker?

Me molesta mucho. Cada vez que lo veo pienso "esto no, por favor". Es como cuando veo algo escrito en Comic Sans. La diferencia fundamental es que un cracker es un pirata informático es alguien que destruye o, más que destruye, ,que se dedica al tema de la seguridad informática. No como un hacker, que se puede dedicar a programar software de seguridad informática también, pero que puede hacer muchas otras cosas, como por ejemplo programar kernels.

Un comentario de uno en la página con mucha razón , el último parrafo está omitido:

- Un verdadero hacker no va por la vida diciendo que lo es. La privacidad y el anonimato son obligatorios.

- Un verdadero hacker no se hace publicidad a sí mismo. Sus logros son su publicidad. Y el boca a boca es su oficina de marketing.

- Un verdadero hacker no participa en un concurso público a cara descubierta. Sólo participa en retos que se plateen dentro de la ELITE.

- Un verdadero hacker jamás confiesa públicamente sus fuentes de información. Aquellos que tienen lo que hay que tener, saben perfectamente dónde encontró dicha información, y los que no lo saben, simplemente no la necesitan.

- Un verdadero hácker sabría que alguien que rompe cuentas de Tuenti para que un tercero invada la privacidad ajena, no es un hácker. Es un simple hijodeputa.

Hola estoy intentado el simple_KGM , pero es muy complicado , tengo la primera parte ya pasada , es así:
1. Abrimos el simple_KGM y buscamos las apis en el olly , umm GetDlgItemInt y dos GetDlgItemText , bueno pongamos los breakpoints.

2. Coge nuestro ID, y mira si eax es 0 (eax en ese momento es el largo del nombre) , si es 0 va al chico malo,si nó, le resta 0D4h y lo guarda en la memoria [404674]

3. Coge nuestro serial y mira si eax es 0(eax en ese momento es el largo del serial),si es 0 va al chico malo, si nó, lo guarda en [404678]
4. Coge nuestro nombre y mira si eax es 4, si es mas bajo , chico malo, si nó, mira si eax es 20, si es más grande chico malo... De aquí deducimos que nuestro nombre debe tener entre 4 y 20 carácteres , ni más ni menos.Una vez hecho esto va cogiendo cada byte de nuestro nombre y le hace estas operaciones:

Código (asm) [Seleccionar] Expandir


MOV EDI,EAX
XOR EDX,EDX
XOR ESI,ESI
MOV ECX,1
LOOP:
      INC EDX
      MOVZX EAX,BYTE PTR DS:[EDX+4042D3]
      CMP EDX,EDI
      XOR EDX,EDX
      ADD EAX,ESI
      SHL EAX,4
      ADD EAX,10001
      PUSH EAX                                ; /Arg1
      CALL 00401283                           ; \Simple_KGM_2.00401283
      ADD ESI,EAX
      INC ECX
      CMP ECX,20
JNE LOOP

El call que hay ahí en medio:

Código (asm) [Seleccionar] Expandir


PUSH EBP                                 ; Simple_KGM_2.00401283(guessed Arg1)
MOV EBP,ESP
PUSH ECX
MOV EAX,DWORD PTR SS:[ARG.1]
MOV ECX,666
CICLO:  
       ADD EAX,68656865
       ROR EAX,8
       SUB EAX,65686568
       ROL EAX,16
       MOV EBX,EAX
       NOT EAX
       SUB EBX,EAX
       ADC EAX,EBX
       ROR EAX,6
LOOP CICLO
ADD EAX,61733376
XOR EAX,76337361
NOP
NOP
NOP
NOP
NOP
NOP
NOP
AND EAX,0000FFFF
SHL EAX,10
MOV AX,0DEAD
SUB EAX,D00EA00D
POP ECX
LEAVE
RETN 4

Después del loop , compara el resultado de todas las operaciones con [404674] , adivinad quien había en la posición de memoria, el valor de nuestro ID -04Dh ,con lo que si hacemos un keygen para eso tendriamos que pedir el nombre , hacer las rutinas de calculo para el ID , y sumarle 04Dh , ya que cuando lo metemos en el programa se lo resta.
Hasta ahí bien , he hecho mitad del keygen para eso, nos pide el nombre y el te calcula el ID:

Código (asm) [Seleccionar] Expandir


.386 ; Hace el código compatible con el procesador 386
.MODEL flat,stdcall

INCLUDE user32.inc
INCLUDE kernel32.inc
INCLUDE msvcrt.inc
INCLUDELIB user32.lib
INCLUDELIB kernel32.lib
INCLUDELIB msvcrt.lib
;PARA TENER LOS BUFFERS
__p__iob    PROTO C

_iobuf STRUCT
   _ptr        DWORD ?
   _cnt        DWORD ?
   _base       DWORD ?
   _flag       DWORD ?
   _file       DWORD ?
   _charbuf    DWORD ?
   _bufsiz     DWORD ?
   _tmpfname   DWORD ?
_iobuf ENDS

FILE TYPEDEF _iobuf

;PROTOTIPOS DE FUNCIONES EN C
EXTRN printf:NEAR
EXTRN fgets:NEAR
EXTRN sscanf:NEAR
EXTRN getchar:NEAR
EXTRN strlen:NEAR
;PROTOTIPOS DE FUNCIONES EN ASM



.data ;Datos del programa
INGRESA_NOMBRE BYTE "Ingresa tu nombre: ",0
TU_ID_ES   BYTE "Tu ID es: %u",0Ah,0Dh,0
PULSE_TECLA BYTE "Pulse intro para terminar . . .",0
;ESPECIFICADORES DE FORMATO
ESPI BYTE "%d",0
ESPS BYTE "%s",0
ESPIU BYTE "%u",0
.data?
NOMBRE BYTE  20 DUP (0)
ID     DWORD ?
BUFFER_FGETS BYTE 20 DUP(0)
stdin  DWORD ?
stdout DWORD ?
stderr DWORD ?
.code
rutinaSerial PROC
PUSH EBP
MOV EBP,ESP
PUSH ECX
MOV EAX,[EBP+8]
MOV ECX,666h
CICLO:
ADD EAX,68656865h
ROR EAX,8h
SUB EAX,65686568h
ROL EAX,16h
MOV EBX,EAX
NOT EAX
SUB EBX,EAX
ADC EAX,EBX
ROR EAX,6h
LOOP CICLO
ADD EAX,61733376h
XOR EAX,76337361h
AND EAX,0000FFFFh
SHL EAX,10h
MOV AX,0DEADh
SUB EAX,0D00EA00Dh
POP ECX
leave
ret

rutinaSerial endp
.code ;Código del programa
main PROC
;Buffers
call    __p__iob
   mov     stdin,eax           ; #define stdin  (&__iob_func()[0])
   add     eax,SIZEOF(FILE)
   mov     stdout,eax          ; #define stdout (&__iob_func()[1])
   add     eax,SIZEOF(FILE)
   mov     stderr,eax          ; #define stderr (&__iob_func()[2])

;Inicio código.
push OFFSET INGRESA_NOMBRE
push OFFSET ESPS
call printf
push stdin
push 20
push OFFSET BUFFER_FGETS
call fgets

push OFFSET NOMBRE
push OFFSET ESPS
push OFFSET BUFFER_FGETS
call sscanf
push OFFSET NOMBRE
   call strlen
MOV EDI,EAX
XOR EDX,EDX
XOR ESI,ESI
MOV ECX,1
L1:
INC EDX
MOVZX EAX,NOMBRE[EDX-1]
CMP EDX,EDI
JNE L2
XOR EDX,EDX
L2:
ADD EAX,ESI
SHL EAX,4h
ADD EAX,10001h
PUSH EAX                              
CALL rutinaSerial
ADD ESI,EAX
INC ECX
CMP ECX,20h
JNE L1
add eax,0D4h

mov ID,EAX
push ID
push OFFSET TU_ID_ES
call printf
push OFFSET PULSE_TECLA
push OFFSET ESPS
call printf
call getchar
invoke ExitProcess,0
ret

main endp
END main
Despues , lo que hace es con wsprintf , pasa lo que hay en eax , o sea nuestro ID , a una cadena en notación hexadecimal, y seguidamente , hay una rutina en la que hacen operaciones con un valor que no es constante !!! , cambia , y ese valor lo cogen con lo que retorna la api , VirtualAlloc pasandole estos parámetros, pero es que siempre da un valor diferente , y para hacer un keygen como sé cual es ese valor?
Pongo las rutinas que decía:

Código (asm) [Seleccionar] Expandir

CPU Disasm
Address   Hex dump          Command                                  Comments
004011AA  |.  50            PUSH EAX                                 ; /<%08X>
004011AB  |.  68 16404000   PUSH OFFSET 00404016                     ; |Format = "%08X"
004011B0  |.  68 F4454000   PUSH OFFSET 004045F4                     ; |Buf
004011B5  |.  E8 1A010000   CALL <JMP.&user32.wsprintfA>             ; \USER32.wsprintfA
004011BA  |.  83C4 0C       ADD ESP,0C
004011BD  |.  FF35 3E404000 PUSH DWORD PTR DS:[40403E]               ; /Arg3 = 290000
004011C3  |.  6A 10         PUSH 10                                  ; |Arg2 = 10
004011C5  |.  68 F4424000   PUSH OFFSET 004042F4                     ; |Arg1 = ASCII "12345"
004011CA  |.  E8 F4020000   CALL 004014C3                            ; \Simple_KGM_2.004014C3

Y los parametros que se le pasan a la api:

Código (asm) [Seleccionar] Expandir

Address   Hex dump          Command                                  Comments
00401326  |.  6A 04         PUSH 4                                   ; /Protect = PAGE_READWRITE
00401328  |.  68 00100000   PUSH 1000                                ; |AllocType = MEM_COMMIT
0040132D  |.  6A 54         PUSH 54                                  ; |Size = 84.
0040132F  |.  6A 00         PUSH 0                                   ; |Address = NULL
00401331  |.  E8 30110000   CALL <JMP.&kernel32.VirtualAlloc>        ; \KERNEL32.VirtualAlloc

Bueno no hay problema , la cogeré con virtualprotect o algo de eso.

Felisidades avesudra me sorprendiastes hasta en masm lo hisistes
yo tambien estoy practicando masm a ratos cuando puedo pero seme hizo mas fasil hacerlo en vb6

saludos flamer y felisitaciones los demas si estan un poco complicados

Si bueno no estoy acostumbrado a hacer crackmes pero los fáciles me mata la curiosidad jajaja , ya que estoy aprendiendo no viene mal , aunque también lo he puesto en C , es normal que para hacer estas cosas recurramos a lenguajes de más alto nivel. Voy a intentar mirar el SerialMe.

¡Un saludo!

Hola Flamer , ya estaba con ese crame   , bueno ya está vencido, un pequeño tute.
1.Abrimos el programa con el Olly , buscamos las APIS a ver que hay de interesante... ummm GetDlgItemInt ... para que será? jeje , ponemos el breakpoint en las dos.
2.Bien , ejecutamos el programa dando F9 , ponemos nuestro ID , y el serial , y presionamos registrar.
3. Aleluya! , caemos en donde coge los seriales... Seguimos mirando , y coge mi ID , y lo mete en ebx, despues coge mi serial y lo mete en ECX...
4. Entramos al call , ese que hay ahí abajo , está muy claro , al serial , le suma 4C , lo incrementa en uno , le añade 38B , se añade a sí mismo , se multiplica por trés y se le resta uno.
5. Salimos del call y vemos una comparación de ebx con eax , ¿con eax? , si.. yo también me extrañé , pero es que al coger el serial en el ultimo GetDlgItemInt, devolvió su valor en eax , lo movió a ecx , pero no borró eax, por lo tanto está comparando nuestro serial original , con las operaciones que le ha hecho a nuestro ID.

Pues listo! Armemos nuestro keygen en ASM que estoy practicando jeje:

Código (asm) [Seleccionar] Expandir

TITLE keygen (keygen.asm)
.386 ; Hace el código compatible con el procesador 386
.MODEL flat,stdcall

INCLUDE user32.inc
INCLUDE kernel32.inc
INCLUDE msvcrt.inc
INCLUDELIB user32.lib
INCLUDELIB kernel32.lib
INCLUDELIB msvcrt.lib
;PARA TENER LOS BUFFERS
__p__iob    PROTO C

_iobuf STRUCT
   _ptr        DWORD ?
   _cnt        DWORD ?
   _base       DWORD ?
   _flag       DWORD ?
   _file       DWORD ?
   _charbuf    DWORD ?
   _bufsiz     DWORD ?
   _tmpfname   DWORD ?
_iobuf ENDS

FILE TYPEDEF _iobuf

;PROTOTIPOS DE FUNCIONES EN C

EXTRN fgets:NEAR
EXTRN sscanf:NEAR
EXTRN getchar:NEAR
EXTRN printf:NEAR
EXTRN strlen:NEAR
;PROTOTIPOS DE FUNCIONES EN ASM



.data ;Datos del programa

MSG_ID BYTE "Ingrese su ID(maximo 4 digitos):",0
MSG_KEY BYTE "Su serial es: %d",0Ah,0Dh,0
PULSE_TECLA BYTE "Pulse intro para salir . . .",0

;ESPECIFICADORES DE FORMATO
ESPI BYTE "%d",0
ESPS BYTE "%s",0
.data?
ID   DWORD ?
SERIAL DWORD ?
BUFFER_FGETS DWORD ?
stdin  DWORD ?
stdout DWORD ?
stderr DWORD ?
.code ;Código del programa
main PROC
;Buffers
call    __p__iob
   mov     stdin,eax           ; #define stdin  (&__iob_func()[0])
   add     eax,SIZEOF(FILE)
   mov     stdout,eax          ; #define stdout (&__iob_func()[1])
   add     eax,SIZEOF(FILE)
   mov     stderr,eax          ; #define stderr (&__iob_func()[2])
;Inicio código.
push OFFSET MSG_ID
push OFFSET ESPS
call printf
;COGEMOS DEL BUFFER DIEZ CARÁCTERES POR SI LAS MOSCAS.
push stdin
push 10
push OFFSET BUFFER_FGETS
call fgets
;COGEMOS EL ID DEL BUFFER DE FGETS CON SSCANF
push OFFSET ID
push OFFSET ESPI
push OFFSET BUFFER_FGETS
call sscanf
;;;;;;;;;;;;;;;;;;;;;;;;
;CREACIÓN DEL SERIAL   ;
;;;;;;;;;;;;;;;;;;;;;;;;
mov ebx ,ID   ;
add ebx,4Ch   ;
inc ebx   ;
add ebx,38Bh   ;
add ebx,ebx   ;
imul ebx,3   ;
dec ebx   ;
;;;;;;;;;;;;;;;;;;;;;;;;
;IMPRIMIMOS SERIAL
push ebx
push OFFSET MSG_KEY
call printf
;IMPRIMIMOS PARA AVISAR
push OFFSET PULSE_TECLA
push OFFSET ESPS
call printf
;CUANDO PULSE INTRO CERRAMOS
call getchar
invoke ExitProcess,0
ret

main endp
END main

Y no podía abandonar a mi querido C , uff , que liviano se me hace al ASM:

Código (c) [Seleccionar] Expandir

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

int main()
{
   char * buffer_fgets = malloc(10);
   int ID;
   int serial;
   printf("Ingresa el ID (4 caracteres maximo):");
   fgets(buffer_fgets,6,stdin);
   sscanf(buffer_fgets,"%d",&ID);
   serial=ID;
   //Rutina de creación.
   serial+=76;//4c en hex
   ++serial;
   serial+=907;//38b en hex
   serial+=serial;
   serial*=3;
   --serial;
   printf("Tu serial es: %d \n",serial);
   printf("Presione intro para terminar . . .");
   getchar();
   return 0;
}


Flamer cyclone vencido, gracias por la colecta de los crackmes , el método antidebug de este no sé ni cual es, porque el olly no se me cierra , he usado el 2.01 , en cuanto a un tute pues pequeño tute:
1.Abrimos el crackme con el Olly , pulsamos F9 y caemos en el entry point del programa.
Estudio del crackme.
-Luego de pedir el serial , saca a este mismo de la memoria y lo rota 11 veces a la derecha.

Código (ASM) [Seleccionar] Expandir


MOV EAX,DWORD PTR DS:[4030BC]
ROR EAX,11
MOV EBX,554F0000
CMP EAX,EBX
-Después lo compara con 554F0000.
Por lo que deducimos que si:

Código [Seleccionar] Expandir

ROR x,11 = 554F0000
Donde x es el serial que metemos ,despejamos, la inversa de ror , es rol por lo que queda esto:

Código [Seleccionar] Expandir

x =  ROL 554F0000,11
x = 0000AA9E que es igual a 43678 en decimal.
¡Un saludo!

Si no tienes las librerías wxWidgets compiladas estáticamente(para que se incluya en el ejecutable) no se pondrá con el ejecutable y este mísmo al ejecutarlo te pedira la libreria (.dll) , por lo tanto si quieres distribuir tu aplicación y no tienes las wxWidgets compiladas estáticamente , tendrás que poner esa dll que está en el directorio que dices junto al ejecutable.En cuanto al aviso ni idea.

Normalmente el ejecutable no se encuentra en la carpeta release, sino en debug.

Saludos.

Eso depende de como tengas configurado Codeblocks , Limated Corch vete a la izquierda , donde se despliega el proyecto con todos los archivos y da clic derecho encima de tu proyecto , después clicas en Properties , seguidamente te vas a build targets , y eliges una de las dos opciones (Debug o Release) y miras a la derecha donde pone output filename para ver donde lo guarda en cada caso. Para cambiar entre compilar en Modo Debug o Release , a la derecha del botón de compilar pone Build Target y eliges Debug o Release , sabiendo ya donde se guarda el ejecutable.

Esto va en el subforo .NET de programación general , de todas maneras  , creo que es así , solo he mirado por google:

Código (cpp) [Seleccionar] Expandir


using system.windows.forms; //Debes poner esto para usar el MessageBox
//El que haya de por medio.
string nombredeltextbox = "El que cojas , yo no sé como cojerlo";
if (String.Compare(nombredeltextbox,"Pepito") == 0)
{
   MessageBox.Show("Hola");
}
//Más código...

PD: Busca en google , como comparar cadenas en C# etc...

["Oye, tu sabes porque esto no va??"]

Yo creo que no. La gran masa sigue creyendo que Apple es lo mejor en todo, cuando la realidad es que cualquier terminal de gama media, supera a un Iphone 4S en hardware.
La exclusividad y perfecto marketing de Apple hace que cada día mas gente se crea todas las tonterías que dicen, eso si, luego cuando no les va el bluetooth, o no es compatible con no se que, etc, ya te vienen... "Oye, tu sabes porque esto no va??".
La respuesta que les doy a mis familiares y amigos es básicamente la misma, ¿¿¿Querias Iphone??? Pues ahora te lo comes con patatinas.

Es verdad que limitan muchísimo , y que el hardware es el que a ellos les da la gana... tengo un Ipod Touch 3G y estoy contento con él(pirateado) , me gusta ver las Keynotes y los nuevos productos de apple , pero los productos no valen lo que cuestan.En cuanto a lo del dinero podeis mirarlo en la página oficial www.apple.com/es/