Mensajes

http://es.wikipedia.org/wiki/Puerto_paralelo

En ese link te dice la verdadera info del puerto paralelo... Y es asi en serio, he trabajado muchisimo con puerto paralelo y serial...

Alli vez una imagen de un conector paralelo macho (el hembra es un espejo de este ok)... Bueno alli veras que el bit menos significativo del puerto de estado es el E3 y el mas significativo es el E7 que ademas es inverso o negado pues...

Con eso ya deberias entender como te llegan los datos... De todas maneras cuando te llega un dato usando la impout32.dll no te importa saber eso, pues el dato lo guardas en una variable...

Mas o menos asi:

Código (c) [Seleccionar] Expandir

HINSTANCE hLib;
inpfuncPtr inp32;
oupfuncPtr out32;

hLib = LoadLibrary("inpout32.dll");
inp32 = (inpfuncPtr) GetProcAddress(hLib, "Inp32");
out32 = (oupfuncPtr) GetProcAddress(hLib, "Out32");

Asi defino las funciones de la DLL...

Código (c) [Seleccionar] Expandir

(out32)(DATOS, Valor_a_Enviar);
 Valor_Recibido = (inp32)(ESTADO);

Y asi envio y recibo... Espero te sirva...

EDITO: Por si no sabes porque llamo estados y tal...

Código (c) [Seleccionar] Expandir

#define DATOS 0x378
#define ESTADO 0x379
#define CONTROL 0x37A

short Valor_a_Enviar;
short Valor_Recibido;

Alli estan las definiciones y variables...

Por favor rebisa antes de postear , este tutorial ya lo publique unos post mas abajo

http://foro.elhacker.net/asm-b84.0/

Si bueno ya que, solamente no crei que otra persona de este foro lo tuviese, pues el libro es de un profesor de la Universidad donde estoy finalizando carrera y ademas es muy amigo mio... Pero ok, si les sale borren el tema y ya...

No lo veo muy avanzado y si esta por demas anticuado (1992).

Si es cierto no es muy avanzado ya que no trata cosas como inclusion de librerias, trabajos con dll's, etc... Pero ese es el nombre y solo lo coloque por eso, vale??

Code 1: Especie de Paint (MUYYYYY BASICO ok), me base en el manejo del modo grafico de DOS y el manejo del mouse.

Código (asm) [Seleccionar] Expandir

MODEL SMALL
STACK 256

MOSTRAR MACRO M
mov dx,OFFSET &M
call Imprimir
ENDM

TERMINAR MACRO
mov ax,4C00h
int 21h
ENDM

DETENER MACRO
mov ah,01h
int 21h
ENDM

LINEA MACRO
mov dl,0Ah
mov ah,02h
int 21h
ENDM

minX EQU 20
minY EQU 40
maxX EQU 500
maxY EQU 280
DATASEG

;--------------------------------------------------------------
Color DB 1 DUP(0)
B_Enc DB '   Especie de Paint v.1.0asm$'
B_Pos DB 'Comenzar$'
B_Com DB 'Limpiar Tabla$'
B_Col DB '   Color del Trazado:$'
B_Sal DB 'Salir$'
;--------------------------------------------------------------
CODESEG
Inicio: mov ax,@data
mov ds,ax
mov es,ax

mov ah,0Fh
int 10h
push ax
call MGrafico
call Encabezado
call Boton_Pos
call Boton_Com
call Boton_Sal
call MMouse
call Lee_Mouse
call OMouse
pop ax
mov ah,00h
int 10h
TERMINAR

MGrafico PROC NEAR
mov ax,0012h
int 10h
mov ah,0Bh
mov bx,0000h
int 10h
ret
MGrafico ENDP

Imprimir PROC NEAR
push ax
mov ah,09h
int 21h
pop ax
ret
Imprimir ENDP

Cursor PROC NEAR
mov ah,02h
mov bh,00h
int 10h
ret
Cursor ENDP

Limpiar PROC NEAR
    mov ax,0600h
  mov bx,7100h
    mov cx,00h
    mov dx,174fh
    int 10h
    ret
Limpiar ENDP

MMouse PROC NEAR
mov ax,0001h
int 33h
ret
MMouse ENDP

OMouse PROC NEAR
mov ax,0002h
int 33h
ret
OMouse ENDP

Boton_Pos PROC NEAR
mov dx,82
mov cx,520

Inicio_Aqui: mov ah,0Ch
mov al,0Eh
mov bh,00h
int 10h
cmp cx,530
je inc_dx
inc cx
jmp Inicio_Aqui

inc_dx: mov cx,520
cmp dx,91
je Continua_Aqui
inc dx
jmp Inicio_Aqui

Continua_Aqui: mov cx,000Ah

Escribe: mov dx,0543h

call Cursor
MOSTRAR B_Pos
ret
Boton_Pos ENDP

Boton_Com PROC NEAR
mov dx,130
mov cx,520

Inicio_Aqui1: mov ah,0Ch
mov al,0Ah
mov bh,00h
int 10h
cmp cx,530
je inc_dx1
inc cx
jmp Inicio_Aqui1

inc_dx1: mov cx,520
cmp dx,139
je Continua_Aqui1
inc dx
jmp Inicio_Aqui1

Continua_Aqui1: mov cx,000Ah

Escribe1: mov dx,0843h

call Cursor
MOSTRAR B_Com
ret
Boton_Com ENDP

Boton_Sal PROC NEAR
mov dx,178
mov cx,520

Inicio_Aqui3: mov ah,0Ch
mov al,06h
mov bh,00h
int 10h
cmp cx,530
je inc_dx3
inc cx
jmp Inicio_Aqui3

inc_dx3: mov cx,520
cmp dx,187
je Continua_Aqui3
inc dx
jmp Inicio_Aqui3

Continua_Aqui3: mov cx,000Ah

Escribe3: mov dx,0B43h

call Cursor
MOSTRAR B_Sal
ret
Boton_Sal ENDP

Encabezado PROC NEAR
mov dx,0000h
call Cursor
MOSTRAR B_Enc
ret
Encabezado ENDP

Colorcitos PROC NEAR
mov dx,1500h
call Cursor
MOSTRAR B_Col
ret
Colorcitos ENDP


Terreno PROC NEAR
mov cx,minX
mov dx,minY

Inicio_Aqui4: mov ah,0Ch
mov al,0Fh
mov bh,00h
int 10h
cmp cx,maxX
je inc_dx4
inc cx
jmp Inicio_Aqui4

inc_dx4: mov cx,minX
cmp dx,maxY
je Continua_Aqui4
inc dx
jmp Inicio_Aqui4

Continua_Aqui4: ret
Terreno ENDP

Lee_Mouse PROC NEAR
Clic_Izq: mov ax,0003h
int 33h
and bx,0001h
cmp bx,0001h
je Verificar1
jmp Clic_Izq

Verificar1: cmp cx,520
jae La_Otra1
jmp Clic_Izq

La_Otra1: cmp cx,530
jbe Ahora_dx1
jmp Clic_Izq

Ahora_dx1: cmp dx,82
jae Otro_Punto1
jmp Ahora_dx2

Otro_Punto1: cmp dx,91
jbe Colocar
jmp Ahora_dx2

Ahora_dx2: cmp dx,178
jae Otro_Punto2
jmp Clic_Izq

Otro_Punto2: cmp dx,187
jbe Sales
jmp Clic_Izq

Colocar: call Terreno
call Colorcitos
call Dib_Cuadros
call Dibujar
jmp Sales

Sales: ret
Lee_Mouse ENDP

Dibujar PROC NEAR
Clicito: mov ax,0003h
int 33h
and bx,0001h
cmp bx,0001h
je Verificar2
jmp Clicito

Verificar2: cmp cx,20
jae Otra2
jmp Verificar3

Otra2: cmp cx,500
jbe Now_dx1
jmp Verificar3

Now_dx1: cmp dx,40
jae Punto1
jmp Verificar3

Punto1: cmp dx,280
jbe Dibujito
jmp Verificar3

Dibujito: sub dx,01h
mov ah,0Ch
mov al,Color[0]
mov bh,00h
int 10h
jmp Clicito

Verificar3: cmp cx,520
jae Otra3
jmp Verificar4

Otra3: cmp cx,530
jbe Ah_dx2
jmp Verificar4

Ah_dx2: cmp dx,130
jae Punto2
jmp Ah_dx3

Punto2: cmp dx,139
jbe Otro_Terreno
jmp Ah_dx3

Otro_Terreno: call Terreno
jmp Clicito

Ah_dx3: cmp dx,178
jae Punto3
jmp Verificar4

Punto3: cmp dx,187
jbe Sales1
jmp Verificar4

Sales1: jmp Sales11

Verificar4: cmp dx,338
jae Otra4
jmp Clicito

Otra4: cmp dx,347
jbe Ah_cx1
jmp Clicito

Ah_cx1: cmp cx,180
jae Puntocx1
jmp Ah_cx2

Puntocx1: cmp cx,189
jbe Cambia_Color1
jmp Ah_cx2

Cambia_Color1: mov Color[0],01h
jmp Clicito

Ah_cx2: cmp cx,200
jae Puntocx2
jmp Ah_cx3

Puntocx2: cmp cx,209
jbe Cambia_Color2
jmp Ah_cx3

Cambia_Color2: mov Color[0],02h
jmp Clicito

Ah_cx3: cmp cx,220
jae Puntocx3
jmp Ah_cx4

Puntocx3: cmp cx,229
jbe Cambia_Color3
jmp Ah_cx4

Cambia_Color3: mov Color[0],03h
jmp Clicito

Ah_cx4: cmp cx,240
jae Puntocx4
jmp Ah_cx5

Puntocx4: cmp cx,249
jbe Cambia_Color4
jmp Ah_cx5

Cambia_Color4: mov Color[0],04h
jmp Clicito

Ah_cx5: cmp cx,260
jae Puntocx5
jmp Ah_cx6

Puntocx5: cmp cx,269
jbe Cambia_Color5
jmp Ah_cx6

Cambia_Color5: mov Color[0],05h
jmp Clicito

Ah_cx6: cmp cx,280
jae Puntocx6
jmp Ah_cx7

Puntocx6: cmp cx,289
jbe Cambia_Color6
jmp Ah_cx7

Cambia_Color6: mov Color[0],06h
jmp Clicito

Ah_cx7: cmp cx,300
jae Puntocx7
jmp Ah_cx8

Puntocx7: cmp cx,309
jbe Cambia_Color7
jmp Ah_cx8

Cambia_Color7: mov Color[0],07h
jmp Clicito

Ah_cx8: cmp cx,320
jae Puntocx8
jmp Ah_cx9

Puntocx8: cmp cx,329
jbe Cambia_Color8
jmp Ah_cx9

Cambia_Color8: mov Color[0],08h
jmp Clicito

Ah_cx9: cmp cx,340
jae Puntocx9
jmp Ah_cx10

Puntocx9: cmp cx,349
jbe Cambia_Color9
jmp Ah_cx10

Cambia_Color9: mov Color[0],09h
jmp Clicito

Ah_cx10: cmp cx,360
jae Puntocx10
jmp Ah_cx11

Puntocx10: cmp cx,369
jbe Cambia_Color10
jmp Ah_cx11

Cambia_Color10: mov Color[0],0Ah
jmp Clicito

Ah_cx11: cmp cx,380
jae Puntocx11
jmp Ah_cx12

Puntocx11: cmp cx,389
jbe Cambia_Color11
jmp Ah_cx12

Cambia_Color11: mov Color[0],0Bh
jmp Clicito

Ah_cx12: cmp cx,400
jae Puntocx12
jmp Clicito

Puntocx12: cmp cx,409
jbe Cambia_Color12
jmp Clicito

Cambia_Color12: mov Color[0],0Ch
jmp Clicito

Sales11: ret
Dibujar ENDP

Dib_Cuadros PROC NEAR

mov dx,338
mov cx,180

@Aqui1: mov ah,0Ch
mov al,01h
mov bh,00h
int 10h
cmp cx,189
je @dx1
inc cx
jmp @Aqui1

@dx1: mov cx,180
cmp dx,347
je Color2
inc dx
jmp @Aqui1

Color2: mov dx,338
mov cx,200

@Aqui2: mov ah,0Ch
mov al,02h
mov bh,00h
int 10h
cmp cx,209
je @dx2
inc cx
jmp @Aqui2

@dx2: mov cx,200
cmp dx,347
je Color3
inc dx
jmp @Aqui2

Color3: mov dx,338
mov cx,220

@Aqui3: mov ah,0Ch
mov al,03h
mov bh,00h
int 10h
cmp cx,229
je @dx3
inc cx
jmp @Aqui3

@dx3: mov cx,220
cmp dx,347
je Color4
inc dx
jmp @Aqui3

Color4: mov dx,338
mov cx,240

@Aqui4: mov ah,0Ch
mov al,04h
mov bh,00h
int 10h
cmp cx,249
je @dx4
inc cx
jmp @Aqui4

@dx4: mov cx,240
cmp dx,347
je Color5
inc dx
jmp @Aqui4

Color5: mov dx,338
mov cx,260

@Aqui5: mov ah,0Ch
mov al,05h
mov bh,00h
int 10h
cmp cx,269
je @dx5
inc cx
jmp @Aqui5

@dx5: mov cx,260
cmp dx,347
je Color6
inc dx
jmp @Aqui5

Color6: mov dx,338
mov cx,280

@Aqui6: mov ah,0Ch
mov al,06h
mov bh,00h
int 10h
cmp cx,289
je @dx6
inc cx
jmp @Aqui6

@dx6: mov cx,280
cmp dx,347
je Color7
inc dx
jmp @Aqui6

Color7: mov dx,338
mov cx,300

@Aqui7: mov ah,0Ch
mov al,07h
mov bh,00h
int 10h
cmp cx,309
je @dx7
inc cx
jmp @Aqui7

@dx7: mov cx,300
cmp dx,347
je Color8
inc dx
jmp @Aqui7

Color8: mov dx,338
mov cx,320

@Aqui8: mov ah,0Ch
mov al,08h
mov bh,00h
int 10h
cmp cx,329
je @dx8
inc cx
jmp @Aqui8

@dx8: mov cx,320
cmp dx,347
je Color9
inc dx
jmp @Aqui8

Color9: mov dx,338
mov cx,340

@Aqui9: mov ah,0Ch
mov al,09h
mov bh,00h
int 10h
cmp cx,349
je @dx9
inc cx
jmp @Aqui9

@dx9: mov cx,340
cmp dx,347
je Color10
inc dx
jmp @Aqui9

Color10: mov dx,338
mov cx,360

@Aqui10: mov ah,0Ch
mov al,0Ah
mov bh,00h
int 10h
cmp cx,369
je @dx10
inc cx
jmp @Aqui10

@dx10: mov cx,360
cmp dx,347
je Color11
inc dx
jmp @Aqui10

Color11: mov dx,338
mov cx,380

@Aqui11: mov ah,0Ch
mov al,0Bh
mov bh,00h
int 10h
cmp cx,389
je @dx11
inc cx
jmp @Aqui11

@dx11: mov cx,380
cmp dx,347
je Color12
inc dx
jmp @Aqui11

Color12: mov dx,338
mov cx,400

@Aqui12: mov ah,0Ch
mov al,0Ch
mov bh,00h
int 10h
cmp cx,409
je @dx12
inc cx
jmp @Aqui12

@dx12: mov cx,400
cmp dx,347
je Salll
inc dx
jmp @Aqui12

Salll: ret
Dib_Cuadros ENDP

END Inicio

Aqui les dejo el ejecutable para que vean el resultado: http://www.megaupload.com/?d=L1KFHMYD


Code 2: Conversor de Decimal a Hexadecimal (Medio Arcaico la manera en que lo trabaje), pero lo hice sin usar variables, a punta de registros.

Código (asm) [Seleccionar] Expandir

MODEL SMALL
STACK 256

MOSTRAR MACRO M
mov dx,OFFSET &M
call Imprimir
ENDM

TERMINAR MACRO
mov ax,4C00h
int 21h
ENDM

DETENER MACRO
mov ah,01h
int 21h
ENDM

LINEA MACRO
mov dl,0Ah
mov ah,02h
int 21h
ENDM

PRINTLETTER MACRO
mov bx,OFFSET VALORES
xlat
mov dx,ax
mov ah,02h
int 21h
ENDM

PRINTBYTE MACRO
mov bx,OFFSET VALORES
xlat
mov dx,ax
mov ah,02h
int 21h
mov ax,di
xlat
mov dx,ax
mov ah,02h
int 21h
ENDM

PRINT3DIGIT MACRO
mov bx,OFFSET VALORES
xlat
mov dx,ax
mov ah,02h
int 21h
mov ax,si
xlat
mov dx,ax
mov ah,02h
int 21h
mov ax,di
xlat
mov dx,ax
mov ah,02h
int 21h
ENDM

PRINTWORD MACRO
mov bx,OFFSET VALORES
xlat
mov dx,ax
mov ah,02h
int 21h
mov ax,cx
xlat
mov dx,ax
mov ah,02h
int 21h
mov ax,si
xlat
mov dx,ax
mov ah,02h
int 21h
mov ax,di
xlat
mov dx,ax
mov ah,02h
int 21h
ENDM

Tamaño EQU 4
DATASEG
Mensaje DB 'Ingrese un Numero de Maximo 4 Digitos y Presione [Enter]: $'
Msm_Salir DB 'A ingresado un Caracter no Valido. Presione cualquier tecla para Salir del Programa$'
Msm_Exc DB 'Solo se Permite un Maximo de 4 Digitos. Intentelo de Nuevo$'
Msm_Result DB 'El codigo Hexadecimal del Numero introducido es: $'
VALORES DB '0123456789ABCDEF$'

CODESEG
Inicio: mov ax,@data
mov ds,ax
MOSTRAR Mensaje
call Ascii_Hex
DETENER
Terminado: TERMINAR

Ascii_Hex PROC NEAR
jmp Comenzar

Arriba: LINEA
MOSTRAR Msm_Result
jmp Multi

Numero_DeMas: cmp al,0Dh
je Arriba
LINEA
MOSTRAR Msm_Exc
LINEA
LINEA
jmp Inicio

Comenzar: xor al,al
mov si,5
mov bx,0
mov cx,0

Escribir: dec si
mov ah,01h
int 21h
cmp si,0
je Numero_DeMas
cmp al,0Dh
je Arriba
cmp al,1Bh
je Salir2
cmp al,30h
jb Salir
cmp al,39h
ja Salir
and al,0Fh
cmp si,4
je @@3
cmp si,3
je @@2
cmp si,2
je @@1
cmp si,1
je @@0

@@3: mov bl,al
jmp Escribir

@@2: mov cl,bl
mov bl,al
jmp Escribir

@@1: mov ch,cl
mov cl,bl
mov bl,al
jmp Escribir

@@0: mov bh,ch
mov ch,cl
mov cl,bl
mov bl,al
jmp Escribir

Salir: mov dl,0Ah
mov ah,02h
int 21h
MOSTRAR Msm_Salir
jmp Terminado1

Salir2: jmp Terminado

Multi: mov al,bh
mov dx,1000
mov ah,0
mul dx
mov si,ax
mov al,bl
mov dx,1
mov ah,0
mul dx
mov di,ax
add si,di
mov al,ch
mov dx,100
mov ah,0
mul dx
mov di,ax
mov al,cl
mov dx,10
mov ah,0
mul dx
mov bx,ax
add bx,di
add bx,si
mov ax,bx
mov dx,0
mov bx,16

Dividir: cmp ax,bx
jb Otro_Lugar0
div bx
mov di,dx
mov dx,0
cmp ax,bx
jb Otro_Lugar1
div bx
mov si,dx
mov dx,0
cmp ax,bx
jb Otro_Lugar2
div bx
mov cx,dx
cmp ax,bx
jb Otro_Lugar3

Otro_Lugar0: PRINTLETTER
jmp Terminado1
Otro_Lugar1: PRINTBYTE
jmp Terminado1
Otro_Lugar2: PRINT3DIGIT
jmp Terminado1
Otro_Lugar3: PRINTWORD
jmp Terminado1
ret
Ascii_Hex ENDP

Imprimir PROC NEAR
push ax
mov ah,09h
int 21h
pop ax
Terminado1: ret
Imprimir ENDP

END Inicio

Aqui dejo el ejecutable para que lo prueben: http://www.megaupload.com/?d=1273QRVX

[Visual.SaC]

Sensacional curso, un libro en formato pdf con una completisima informacion para comenzar a programar virus en ASM. Me eh quedado maravillado cuando lo vi, aunque aun me queda mucho por leer me di cuenta que su contenido es muy llevadero, interesante, y ademas contempla la programacion de virus para Windows y para Linux; juntados con metodos de "infeccion" (por llamarlo de alguna manera) para cada OS nombrado anteriormente.

Índice

Introducción:
Objetivos del curso y algunos consejos antes de empezar

Capítulo 1. Estructura de computadores:
Funcionamiento de un microprocesador standard, memoria, buses, E/S,
microprogramación

Capítulo 2. Fundamentos de SSOO:
Funcionamiento básico de un sistema operativo; shell, API y kernel

Capítulo 3. Sistemas de numeración:
Tocando el binario, hexadecimal y aritméticas binarias

Capítulo 4. Ensamblador I: Conceptos básicos:
Aprendizaje del lenguaje ASM, principales conceptos

Capítulo 5. Ensamblador II: Conceptos avanzados:
Instrucciones avanzadas, API del sistema, coprocesador

Capítulo 6. Utilidades para la programación:
Visores hexadecimales, ensambladores, desensambladores y debuggers

Capítulo 7. Infección bajo Windows:
Técnicas para la programación de virus en Windows

Capítulo 8. Infección bajo Linux:
Programación de autorreplicantes en sistemas Linux

Capítulo 9. Técnicas avanzadas:
Algunos conceptos algo más complejos para la programación de virus (cifrado y
polimorfismo)

Apéndices:
Bibliografía y referencias

El libro esta compuesto por 103 paginas, su formato de descarga es pdf y el link esta para rapidshare (el fichero fue obtenido del blog "visualinformatica"):

http://rapidshare.com/files/113804825/ProVirus.rar.html

La password del fichero es: Visual.SaC

Aqui les dejo unos:

http://www.abcdatos.com/tutoriales/tutorial/l8701.html

http://homepage.mac.com/eravila/asmix86.html

http://fermat.homelinux.net/docs/ensamblador

Este es sobre lenguaje maquina (muy bueno):

http://www.speccy.org/curso-cm/contenido/cap1.html

Win32Asm

Art of Assembly

Interrupt List

Assembly Language Tutor

Assembly Language Programming

Programming from the Ground Up

Aqui Este enlace tiene un recopilado de Muchos tutos y Manuales...

win16

Programación en ensamblador de la arquitectura IA-32

Me gusta este por como tiene organizado los capitulos.

SiliconVilley

La página del autor con más tutoriales:

Me tope con este link que tiene muchas cosas de assembly de distintas plataformas.

http://dmoz.org/Computers/Programming/Languages/Assembly/

Libro de Programacion Avanzada en Ensablador, hecho por el Ing. Electronico Ramon Medina profesor de mi UNIVERSIDAD...

Libro Programacion Avanzada en Ensamblador

Espero les sea util...

De hecho lo que hacen es usar visores que transforman la radiación infrarroja (longitud de onda inferior a la de la luz visible) en radiación de luz visible.

Se trataría de conseguir un sensor infrarrojo de gran alcance y modular la frecuencia de salida a un monitor LCD.

Te puede costar un ojo de la cara.

Tal vez los 2... Eso es extremadamente caro y sino se le dara un uso significativo es como perder los ojos por no dejar...

Imaginandome que el cable ira desde la webcam a la PC...

Lo que debes hacer a mi parecer es un relevador de voltaje, cada 5 metros...

Este circuito lo que hara es recibir la señal del USB y aumentarla de nuevo a su rango estandar de +12 y - 12

Esto se hace con un sencillo circuito comparador, averigua un poco que es y despues te ayudo a construir uno (el diagrama claro esta)...

Saludos...

Hola, estoy haciendo un programa para interactuar con el puerto paralelo en windows, entiendo como debo enviar la información y todo, pero, en el status port, al leer datos, me devuelve números que no sé como interpretar.

Se que el status port tiene 8 señales, pero, por ejemplo si el status por me duvuelve un 79 o algo así, no tengo idea de que significa y quisiera saber si alguien tiene un documento o algo donde se explique detalladamente los datos que se pueden recibir del status port.

Si falta alguna info haganmelo saber.

Saludos y gracias.

Preimero el puerto de estados es de 5 bits, no de 8 bits como dices, el unico de 8 bits es el puerto de datos, ya que el de control es de 4 bits...

Ahora me gustaria saber exactamente como estas usando el puerto paralelo, es decir, con que te comunicas?? Que controlas?? Que haces con el pues??

Espero tu respuesta para explicarte mejor...

Vaya, jamas habia visto un informe con tal cantidad de detalles y tampoco tenia idea de que eran tantos ataques en solo 1 mes, es impresionante... Pero lo mas impresionante es como hacen para detener semejante cantidad...