Test Foro de elhacker.net SMF 2.1

Hola! Como va todo? Miren, estoy teniendo un problema, estoy programando con winpcap un sniffer, pero el tema es que quiero reconstruir los paquetes tcp, había econtrado una manera que funciona aparentemente solo con adaptadores ethernet, pero cuando utilizo wi fi, no funciona.

Se que debe existir alguna manera, pero realmente ya no se me ocurre como hacer.
Alguien me podría hechar un poco de claridad??

Gracias!
Un abrazo
APOKLIPTICO

Cita de: madpitbull_99
Este tema tiene como objetivo recopilar términos de uso frecuente en este apartado del foro y definirlos de forma informal teniendo en cuenta el contexto en el que se encuentran. Es decir, no se trata de una definición de diccionario ni de un articulo de la wikipedia entero, se trata de una breve definición añadiendo datos interesantes relacionándolos con el subforo.

Aportad los términos que queráis con o sin su definición correspondiente, los iremos poniendo en este post y creando el glosario. Los términos pueden estar compuestos por varias palabras y las definiciones se modificaran para crear un conjunto mas o menos uniforme (extensión, registro del leguaje utilizado...).

Esperamos hacer entre todos un recopilatorio de términos que sea útil y sobre todo ameno a la lectura.

Gracias por vuestra participación.

---

- A.K.A.: "Also Known As" = "También conocido como".

- Brute Force: Metodo de crackeo de claves que consiste en probar secuencialmente claves hasta dar con la correcta, suele ser lento, consumidor de recursos y generalmente infeasible. Castellano: "Fuerza bruta"

- Cifrar: Aplicar un algoritmo matemático que tiene como fin hacer teóricamente imposible la lectura de un mensaje. Inglés Encrypt. Nota: "Encriptar" y "Desencriptar" son anglicismos que no deben ser utilizados.

- Charset: Conjunto de caracteres que pueden llegar a componer a una clave (Ej: Minúsculas, Mayúsculas, espacios, números, caracteres especiales, todo el espectro ASCII). Castellano: Conjunto de caracteres.

- Ciphertext: Mensaje después de ser cifrado. Castellano: Texto cifrado.

- Cracking: En la criptografía, crackear un ciphertext, implica encontrar su plaintext sin poseer la clave de descifrado. Si se habla de un Hash, implica encontrar un valor de entrada de la función de Hash que de como resultado el hash que se está tratando de crackear. Castellano: Romper.

- Criptografía: Ciencia que estudia las diferentes maneras de ocultar la información o hacerla ilegible para todos aquellos que no deban leerla. Ingles: Cryptography.

- Criptografía simétrica: es un método criptográfico en el cual se usa una misma clave para cifrar y descifrar mensajes. Inglés Symmetric Cryptography

- Criptografía asimétrica: es un método criptográfico en el cual se usa una clave para cifrar (conocida como clave pública) y una para descifrar (conocida como clave privada). También se la llama "criptografía de clave pública". Inglés: Assymmetric cryptography or Public Key Cryptography

- Descifrar: Aplicar un algoritmo matemático que tiene como fin volver a hacer legible un mensaje cifrado. Inglés Decrypt. Nota: "Encriptar" y "Desencriptar" son anglicismos que no deben ser utilizados.

- Esteganografía: Es la disciplina en la que se estudian y aplican técnicas que permiten el ocultamiento de mensajes u objetos, dentro de otros, llamados portadores, de modo que no se perciba su existencia. Inglés: Steganography.

- Hash: Función matemática bien definida que tiene como valor de entrada cualquier tamaño y tipo de datos y como valor de salida un string de tamaño definido. Para que pueda ser considerado un algoritmo de hash debe cumplir los siguientes requisitos:
     - Bajo costo computacional: Debe ser fácilmente calculable.
     - Deterministico: Para un mismo valor de entrada, debe haber un mismo valor de salida.
     - Uniforme: Los valores de salida deben estar distribuidos uniformemente.
     - No reversible: No debe de ser posible revertir el algoritmo de hash.

- Infeasible: Anglicismo que se utiliza para denominar hechos que en teoría son posibles, pero la cantidad de tiempo o recursos necesarios para lograr dichos hechos, excede en tal manera que los hace extremadamente impracticos.

- Plaintext: Mensaje antes de ser cifrado. Castellano: Texto plano.

- Rainbow table: Son tablas precalculadas que permiten hacer un intercambio memoria-espacio en el cracking de Hashs. Es decir, se precalculan los hashes y se introducen en una tabla, estas tablas, generalmente de gran tamaño, se comparan con el hash que se está tratando de crackear.

Buenos días (para mi) gente, como va todo?
Bueno, mientras desayunaba y leía las preguntas de la gente, viendo si podía ayudar en algo, se me ocurrió lo siguiente:

Algunos de ustedes sabrán que desde hace un par de meses estoy a cargo de la sección de criptografía y estuve tratando de poner mi granito de arena creando un taller de criptografía asimétrica y diversos manuales.
Lamentablemente, perdió actividad por ahora, es muy posible que sea porque muchos de los integrantes están rindiendo exámenes, como yo, pero aún así pensé que sería una buena manera de promocionar la criptografía, que como todos sabemos, es un área muy importante en la seguridad informática, poniéndola como subforo aparte, es decir, que no esté adentro de Seguridad.

Yo creo que de esta manera se va a promocionar el interés de los usuarios en la criptografía, que muchos no deben ni saber que el subforo está ahi.

Bueno, piénsenlo y díganme que les parece.
Un abrazo
APOKLIPTICO.

Hola gente!
Bueno primero, me presento siendo que es el primer post que hago en este subforo, soy APOKLIPTICO un nulo en diseño gráfico jajajaja, tanto en computadora como en papel y lápiz.
Pero bueno, nadie nace sabiendo y estoy aki para aprender.

Hoy les vengo con una cuestión, quiero crear un juego, más específicamente un simulador de hacking, ya lo tengo bastante planteado en la parte de papel y lápiz, pero el tema es que realmente me cuesta mucho la parte del diseño, es decir, quiero que se vea bien que no tenga nada que envidiarle a Uplink, Street Hacker o BS Hacker...
Es por eso que mientras en el subforo de C++ me ayudan con las librerías a utilizar, necesito si pueden orientarme sobre como hacer los botones, menúes, fondos y diseño general del juego, desde la pantalla de presentación hasta la de créditos.

Mis preguntas más concretamente son las siguientes:
1) Software??
2) Como hago fondos? Me puedo basar en un diseño preexistente? de donde saco ese diseño?.
3) Como hago botones y menúes??
4) Se que esto es diseño gráfico, pero los sonidos de donde los puedo sacar???

Un abrazo
APOKLIPTICO

Hola gente, como va todo?
Miren, estoy pensando en hacer un juego, un simulador de hacking, no requiere nada 3d, se un poco de OpenGL pero realmente se complica si quiero hacer una consola y menús simples.
Que me recomiendan utilizar para los menues y las consolas, también me gustaría que se pudiesen crear ventanas movibles y cerrables (consolas externas digamos). Sería como crear un SO simple virtual, pero que los menúes no sean los estandar de windows, sino que se les pueda agregar estilos.

Muchas gracias.
Un abrazo
APOKLIPTICO

PD: Estoy bajo windows (Code::Blocks + Mingw).

Hola gente, como va todo, hoy necesito que me den una mano para saber si es conveniente pasarme a 64 bits.
Estas son las cosas que hago en win32:

1) Gaming. Desde juegos muy viejos (que los juego en dosbox), juegos intermedios (windows 95/98/me) y juegos nuevos (que asumo que no habrá problemas).
2) Programar. C++ y VB, utilizando mingw como compilador y code:blocks como IDE.
3) Debugging/Ingeniería inversa/análisis de Bofs y Hofs. Ollydbg (Shadow).
4) Escucho música (winamp).
5) Msn.
6) Internet varios (Firefox, Filezilla, freesshd, utorrent, etc.)

Los que más me preocupa son los tres primeros, existe la posibilidad de que no pueda seguir haciéndo esas cosas de la misma manera que antes?.

Otra pregunta, ya se que no están a favor de los windows modificados, pero que tal es el BigMouse (windows modificado 64 bits), o me conviene poner una version retail u OEM?

Muchas gracias.
Un abrazo
APOKLIPTICO

El tema ha sido movido a Dudas Generales.

https://foro.elhacker.net/index.php?topic=310926.0

Este es un PM que quería mandarle a Artik, pero excedió sus mensajes personales XD, sin embargo lo comparto con todos:

Hola! Te acordás cuando te pregunté si era posible que se me quemara la fuente por sobrecarga?? y si era posible que se llevase algún componente consigo??

Bueno, ayer se me quemó la fuente mal (con humo y todo), pero por suerte no parece haber habido ningun problema, todavía me queda testear la placa de video y las memorias, pero ahora estoy usándola y funca todo bien, lo único que me extraña es que se ve de un tono distinto las letras de los links, pero bueno, puede ser por otra cosa eso jejeje.

Bueno, era eso nomas.
Un abrazo
APOKLIPTICO

Capítulo I.
Bueno, como prometí, hoy comenzamos con el taller de criptografía asimétrica.
Vamos a empezar con las bases y despues iremos ampliando la información. La idea es que yo voy a explicar lo mejor posible todos los conceptos y luego voy a dar links (Algunos ya existentes en el foro) para ampliar la información ya dada.
Estas son interpretaciones con el fin de hacer más legible y accesible la información que puede resultar compleja, vale aclarar que todo lo expuesto, va a ser basado de otras fuentes, que van a ser aclaradas al final.

Quiero poner unas reglas básicas para como vamos a manejarnos en el taller:
- Todas las preguntas sobre lo expuesto en este thread, deben seguir las siguientes indicaciones:
1) Aclarar a qué parte del taller está referida la pregunta.
2) Ser clara y lo más explícita posible.
3) No utilizar "escritura sms", utilizar signos de puntuación, mayúsculas y espacios y tratar de mantener las faltas de ortografía a un mínimo.
4) No preguntar cosas que ya se han preguntado.
5) Las palabras "encriptar" y "desencriptar" son anglicismos que no deben ser utilizadas. Las palabras correctas son "Cifrar" y "Descifrar". cifrar viene del inglés "Encrypt" y descifrar de "Decrypt".

Voy a comenzar un pequeño glosario de términos que a medida que avanzemos se irá llenando, si se hace muy grande, lo pasaré a un post aparte:
- Plaintext: Mensaje antes de ser cifrado.
- Ciphertext: Mensaje después de ser cifrado.
- Cifrar: Aplicar un algoritmo matemático que tiene como fin hacer teóricamente imposible la lectura de un mensaje.
- Descifrar: Aplicar un algoritmo matemático que tiene como fin volver a hacer legible un mensaje cifrado.
- Charset: Conjunto de caracteres que pueden llegar a componer a una clave (Ej: Minúsculas, Mayúsculas, espacios, números, caracteres especiales, todo el espectro ASCII).
- Brute Force: Metodo de crackeo de claves que consiste en probar secuencialmente claves hasta dar con la correcta, suele ser lento, consumidor de recursos y generalmente infeasible.
- Infeasible: Anglicismo que se utiliza para denominar hechos que en teoría son posibles, pero la cantidad de tiempo o recursos necesarios para lograr dichos hechos, excede en tal manera que los hace extremadamente impracticos.
- A.K.A.: "Also Known As" = "También conocido como".
Comenzemos entonces:
Capítulo I. Este capítulo fue escrito mientras se escuchaba: Die Toten Hosen (Opium Fürs Volk).
Qué es la criptografía asimétrica?

Cita de: WikipediaLa criptografía (Del griego, literalmente «escritura oculta») asimétrica es el método criptográfico  que usa un par de claves para el envío de mensajes. Las dos claves pertenecen a la misma persona a la que se ha enviado el mensaje. Una clave es pública y se puede entregar a cualquier persona, la otra clave es privada y el propietario debe guardarla de modo que nadie tenga acceso a ella.

Entonces: El algoritmo de cifrado asimétrico, crea dos claves, una pública con la que solo se debe cifrar los datos, y una privada, que permite descifrar los datos.

Cuál es la diferencia entre un algoritmo asimétrico y uno simétrico?
Un algoritmo simétrico permite que la misma clave se pueda utilizar para cifrar y para descifrar.
La ventaja del algoritmo simétrico sobre el asimétrico, es que los simétricos suelen ser mucho más seguros con claves más pequeñas, esto significa, utilizando un ejemplo, que para obtener la seguridad que tiene un AES 128 bits (Simétrico) se debe utilizar al menos una clave de RSA 1024 bits. Otra de las ventajas de los algoritmos simétricos es que suelen ser decena de veces más rápidos para computar las claves y para cifrar los datos.

Para qué entonces utilizar criptografía asimétrica?
Sin embargo, una de las grandes fallas que tienen los algoritmos simétricos sobre los asimétricos, es el intercambio de claves, esto se explica a continuación con un ejemplo práctico.
Agustin y Bernardo quieren comunicarse por un canal, Eva, sin embargo, puede ver los paquetes que se transportan por dicho canal.

Agustin y Bernardo entonces, deciden utilizar la criptografía para evitar que Eva pueda ver su comunicación.
Comienzan utilizando criptografía simétrica.
Agustín, le envía a Bernardo la clave que van a utilizar para establecer el canal seguro. Pero Eva también puede ver esta clave.
Agustín cifra los datos que quiere enviar y Bernardo los recibe, sin embargo, Eva tiene la clave simétrica y los datos, entonces puede ver la comunicación entre Agustín y Bernardo.

Canal seguro: FAIL!

Entonces, Agustín y Bernardo, deciden utilizar criptografía asimétrica.
Agustín y Bernardo crean cada uno un par de claves Pública y Privada. Vamos a llamarlas E(A), E(B), D(A) y D(B), siendo E(A) la clave pública de Agustín, E(B) la clave pública de Bernardo, D(A) la clave privada de Agustín y D(B) la clave privada de Bernardo.
1) Agustín le envía a Bernardo E(A) y Bernardo le envía a Agustín E(B).
2) Agustín cifra con E(B) los datos que le quiere mandar a Bernardo y Bernardo cifra con E(A) los datos que le quiere mandar a Agustín.
3) Agustín descifra con D(A) los datos que recibió de Bernardo y Bernardo descifra con D(B) los datos que recibió de Agustín.
4) Eva, lo único que puede ver en el canal, son las dos claves públicas y los datos cifrados, entonces, esta no va a poder ver los datos que Agustín y Bernardo comparten.

Canal seguro: OK!!

Para los que entienden mejor con interpretaciones gráficas, aqui les presento un par:




Bases de la criptografía asimétrica.

Cita de: WikipediaLos sistemas de cifrado de clave pública se basan en funciones-trampa de un solo sentido que aprovechan propiedades particulares, por ejemplo de los números primos. Una función de un solo sentido es aquella cuya computación es fácil, mientras que su inversión resulta extremadamente difícil. Por ejemplo, es fácil multiplicar dos números primos juntos para obtener uno compuesto, pero es difícil factorizar  uno compuesto en sus componentes primos. Una función-trampa de un sentido es algo parecido, pero tiene una "trampa". Esto quiere decir que si se conociera alguna pieza de la información, sería fácil computar el inverso. Por ejemplo, si tenemos un número compuesto por dos factores primos y conocemos uno de los factores, es fácil computar el segundo.

Dado un cifrado de clave pública basado en factorización de números primos, la clave pública contiene un número compuesto de dos factores primos grandes, y el algoritmo de cifrado usa ese compuesto para cifrar el mensaje. El algoritmo para descifrar el mensaje requiere el conocimiento de los factores primos, para que el descifrado sea fácil si poseemos la clave privada que contiene uno de los factores, pero extremadamente difícil en caso contrario.

Fuentes:
- http://es.wikipedia.org/wiki/Criptograf%C3%ADa_asim%C3%A9trica
- http://es.wikipedia.org/wiki/Criptograf%C3%ADa_sim%C3%A9trica
- https://zonatic.usatudni.es/es/aprendizaje/aprende-sobre-el-dnie/57-aspectos-tecnicos/196-criptografia-y-esquemas-de-clave-publica.html

Cualquier duda que tengan, posteenla en ESTE thread, cuando vea que no hay más preguntas, pongo el siguiente tema.

Un abrazo
APOKLIPTICO.

Toda la información expuesta en este taller, está protegida bajo licencia Creative Commons Attribution-NonCommercial-ShareAlike 2.5.

Hola gente, como va todo?
Miren, estaba buscando un programa que me tome la entrada de audio, la amplifique en tiempo real y la saque por la salida de audio.
Si es posible que también se pueda ecualizar, eliminar ruido, etc.
Existe esto???

Muchas gracias!

Hola gente, como va todo?
Estoy tratando de linkear un programa con un DLL utilizando llamadas GetProcAddress y todo eso. Podría linkearlo con el "lib" pero pensé que sería mas divertido de esta manera...

Bueno, mi problema, es el tema de los parámetros, tengo todos los exports de la DLL, y se que pasa un solo parámetro, hay alguna manera de saber el tipo de datos y si es un puntero (o un puntero de un puntero) de dicho parámetro??
Otra cosa, importa si el valor devuelto se ignora? Es decir, tampoco se el valor devuelto, sospecho que es int, pero para este caso no me interesa, el tema es que quería saber si me equivoco en el tipo de datos del valor devuelto, me puede causar un error en la llamada a la función. Por ejemplo si cuando la declaro, pongo void como valor devuelto.

Bueno, muchas gracias!
Un abrazo
APOKLIPTICO

PD: También tengo un programa que utiliza esta DLL, se puede leer los parámetros que le pasa?.
PD2: Que programas me convendría utilizar?? Tengo shadow Ollydbg y PE Explorer.

Hola gente, como va todo?
Miren, mi pregunta es la siguiente, estoy haciendo un programa y necesito utilizar una función (que no se como es) que está definida en un exe. Yo podría llamar al exe directamente y pasarle los parámetros, pero me parece una solución "Poco elegante". Mi pregunta es si es posible llamar desde mi programa a una función de un ejecutable como si fuese una dll.

Estoy trabajando en Code::Blocks + Mingw.

Un abrazo
APOKLIPTICO

NOTA: Para ver todos los capítulos sin las preguntas, referirse a este thread: Manual: Criptografía asimétrica desde cero.

Capítulo I.
Bueno, como prometí, hoy comenzamos con el taller de criptografía asimétrica.
Vamos a empezar con las bases y despues iremos ampliando la información. La idea es que yo voy a explicar lo mejor posible todos los conceptos y luego voy a dar links (Algunos ya existentes en el foro) para ampliar la información ya dada.
Estas son interpretaciones con el fin de hacer más legible y accesible la información que puede resultar compleja, vale aclarar que todo lo expuesto, va a ser basado de otras fuentes, que van a ser aclaradas al final.

Quiero poner unas reglas básicas para como vamos a manejarnos en el taller:
- Todas las preguntas sobre lo expuesto en este thread, deben seguir las siguientes indicaciones:
1) Aclarar a qué parte del taller está referida la pregunta.
2) Ser clara y lo más explícita posible.
3) No utilizar "escritura sms", utilizar signos de puntuación, mayúsculas y espacios y tratar de mantener las faltas de ortografía a un mínimo.
4) No preguntar cosas que ya se han preguntado.
5) Las palabras "encriptar" y "desencriptar" son anglicismos que no deben ser utilizadas. Las palabras correctas son "Cifrar" y "Descifrar". cifrar viene del inglés "Encrypt" y descifrar de "Decrypt".

Voy a comenzar un pequeño glosario de términos que a medida que avanzemos se irá llenando, si se hace muy grande, lo pasaré a un post aparte:
- Plaintext: Mensaje antes de ser cifrado.
- Ciphertext: Mensaje después de ser cifrado.
- Cifrar: Aplicar un algoritmo matemático que tiene como fin hacer teóricamente imposible la lectura de un mensaje.
- Descifrar: Aplicar un algoritmo matemático que tiene como fin volver a hacer legible un mensaje cifrado.
- Charset: Conjunto de caracteres que pueden llegar a componer a una clave (Ej: Minúsculas, Mayúsculas, espacios, números, caracteres especiales, todo el espectro ASCII).
- Brute Force: Metodo de crackeo de claves que consiste en probar secuencialmente claves hasta dar con la correcta, suele ser lento, consumidor de recursos y generalmente infeasible.
- Infeasible: Anglicismo que se utiliza para denominar hechos que en teoría son posibles, pero la cantidad de tiempo o recursos necesarios para lograr dichos hechos, excede en tal manera que los hace extremadamente impracticos.
- A.K.A.: "Also Known As" = "También conocido como".
Comenzemos entonces:
Capítulo I. Este capítulo fue escrito mientras se escuchaba: Die Toten Hosen (Opium Fürs Volk).
Qué es la criptografía asimétrica?

Cita de: WikipediaLa criptografía (Del griego, literalmente «escritura oculta») asimétrica es el método criptográfico  que usa un par de claves para el envío de mensajes. Las dos claves pertenecen a la misma persona a la que se ha enviado el mensaje. Una clave es pública y se puede entregar a cualquier persona, la otra clave es privada y el propietario debe guardarla de modo que nadie tenga acceso a ella.

Entonces: El algoritmo de cifrado asimétrico, crea dos claves, una pública con la que solo se debe cifrar los datos, y una privada, que permite descifrar los datos.

Cuál es la diferencia entre un algoritmo asimétrico y uno simétrico?
Un algoritmo simétrico permite que la misma clave se pueda utilizar para cifrar y para descifrar.
La ventaja del algoritmo simétrico sobre el asimétrico, es que los simétricos suelen ser mucho más seguros con claves más pequeñas, esto significa, utilizando un ejemplo, que para obtener la seguridad que tiene un AES 128 bits (Simétrico) se debe utilizar al menos una clave de RSA 1024 bits. Otra de las ventajas de los algoritmos simétricos es que suelen ser decena de veces más rápidos para computar las claves y para cifrar los datos.

Para qué entonces utilizar criptografía asimétrica?
Sin embargo, una de las grandes fallas que tienen los algoritmos simétricos sobre los asimétricos, es el intercambio de claves, esto se explica a continuación con un ejemplo práctico.
Agustin y Bernardo quieren comunicarse por un canal, Eva, sin embargo, puede ver los paquetes que se transportan por dicho canal.

Agustin y Bernardo entonces, deciden utilizar la criptografía para evitar que Eva pueda ver su comunicación.
Comienzan utilizando criptografía simétrica.
Agustín, le envía a Bernardo la clave que van a utilizar para establecer el canal seguro. Pero Eva también puede ver esta clave.
Agustín cifra los datos que quiere enviar y Bernardo los recibe, sin embargo, Eva tiene la clave simétrica y los datos, entonces puede ver la comunicación entre Agustín y Bernardo.

Canal seguro: FAIL!

Entonces, Agustín y Bernardo, deciden utilizar criptografía asimétrica.
Agustín y Bernardo crean cada uno un par de claves Pública y Privada. Vamos a llamarlas E(A), E(B), D(A) y D(B), siendo E(A) la clave pública de Agustín, E(B) la clave pública de Bernardo, D(A) la clave privada de Agustín y D(B) la clave privada de Bernardo.
1) Agustín le envía a Bernardo E(A) y Bernardo le envía a Agustín E(B).
2) Agustín cifra con E(B) los datos que le quiere mandar a Bernardo y Bernardo cifra con E(A) los datos que le quiere mandar a Agustín.
3) Agustín descifra con D(A) los datos que recibió de Bernardo y Bernardo descifra con D(B) los datos que recibió de Agustín.
4) Eva, lo único que puede ver en el canal, son las dos claves públicas y los datos cifrados, entonces, esta no va a poder ver los datos que Agustín y Bernardo comparten.

Canal seguro: OK!!

Para los que entienden mejor con interpretaciones gráficas, aqui les presento un par:




Bases de la criptografía asimétrica.

Cita de: WikipediaLos sistemas de cifrado de clave pública se basan en funciones-trampa de un solo sentido que aprovechan propiedades particulares, por ejemplo de los números primos. Una función de un solo sentido es aquella cuya computación es fácil, mientras que su inversión resulta extremadamente difícil. Por ejemplo, es fácil multiplicar dos números primos juntos para obtener uno compuesto, pero es difícil factorizar  uno compuesto en sus componentes primos. Una función-trampa de un sentido es algo parecido, pero tiene una "trampa". Esto quiere decir que si se conociera alguna pieza de la información, sería fácil computar el inverso. Por ejemplo, si tenemos un número compuesto por dos factores primos y conocemos uno de los factores, es fácil computar el segundo.

Dado un cifrado de clave pública basado en factorización de números primos, la clave pública contiene un número compuesto de dos factores primos grandes, y el algoritmo de cifrado usa ese compuesto para cifrar el mensaje. El algoritmo para descifrar el mensaje requiere el conocimiento de los factores primos, para que el descifrado sea fácil si poseemos la clave privada que contiene uno de los factores, pero extremadamente difícil en caso contrario.

Fuentes:
- http://es.wikipedia.org/wiki/Criptograf%C3%ADa_asim%C3%A9trica
- http://es.wikipedia.org/wiki/Criptograf%C3%ADa_sim%C3%A9trica
- https://zonatic.usatudni.es/es/aprendizaje/aprende-sobre-el-dnie/57-aspectos-tecnicos/196-criptografia-y-esquemas-de-clave-publica.html

Cualquier duda que tengan, posteenla acá, cuando vea que no hay más preguntas, pongo el siguiente tema.

Un abrazo
APOKLIPTICO.

Toda la información expuesta en este taller, está protegida bajo licencia Creative Commons Attribution-NonCommercial-ShareAlike 2.5.

Hola gente, como va todo?
Miren, estoy teniendo un problema con un programita que estoy haciendo.
Estoy usando winpcap para sniffar un flujo de datos, filtralos y convertirlos, el tema es que por alguna razon, el parser me parsea bien un paquete y me parsea mal otro paquete que es estructuralmente igual, con el contenido cambiado.
Esto me lleva a pensar que puedo llegar a tener algun buffer/heap overflow que me puede estar causando problemas con la memoria.
Hay algun programa para detectar facilmente estas fallas?
Estoy bajo windows XP SP3 x86 + Code::Blocks + Gcc.
Muchas gracias!
Un abrazo
APOKLIPTICO

Hola! Como va todo?
Bueno, siendo que ya he visto suficientes usuarios que ni siquiera se les ocurrió pensar que hay un reglamento que hay que seguir y deciden por hacer lo que se les da la gana, ensuciando el foro con los clásicos "Quiero juanquear una cuenta de hotmail", "No tengo internet y quiero robarselo al vecino", y un laaargo etcétera, se me ocurrió implementar algo que vi hace mucho tiempo en un foro.
En este foro, cuando uno se loguea por primera vez, se le pone al usuario una notificación cada vez que va a crear un nuevo tema que debe leer las reglas antes de hacerlo. Esto continúa hasta que el usuario postea sus primeros 20 mensajes.

Yo no digo que esto eliminará definitivamente todos los posts basura, pero seguro que ayudará a reducir la incidencia de los mismos.

Bueno, que les parece la idea?

Un abrazo
APOKLIPTICO

Hola gente!!
Como va todo?
Bueno, me propuse como fin levantar la actividad de este subforo que realmente tiene muchísimo potencial y trata de un tema súmamente interesante y de gran importancia en la actualidad.

Para esto, necesito a todos ustedes, los que cada vez que ven un texto cifrado, un hash o una imagen sospechosa, les pica el bicho de la curiosidad y quieren saber que hay detrás de esa maraña de caracteres sin orden aparente.

Entonces, se me ocurrió comenzar un taller para que todos los que estén interesados, se apunten, aporten sus conocimientos y aprendan nuevas cosas, el fin de este taller sería crear un algoritmo nuevo, optimizarlo y hacerle criptoanálisis para probar su seguridad.
Lo único que hace falta definir, es sobre que campo de la criptografía nos vamos a desarrollar:
Criptografía asimétrica?
Criptografía simétrica?
Hashes?
Esteganografía?

Es importante que digan que algoritmo les interesa, aparte de ponerlo en la encuesta y aclarar si pueden leer textos en inglés.

Bueno, escucho sus opiniones y sus aportes.

Muchas gracias a todos!
Un abrazo
APOKLIPTICO

Quiénes se han anotado:
- APOKLIPTICO (Simétrico) Inglés: Si.
- Debci (????) Inglés: ????.
- Freeze. (Simétrico) Inglés: Si.
- 16BITBoy. (Hash) Inglés: ???
- MasterPunk (Asimétrico) Inglés: Si.
- Liena. (Asimétrico) Inglés: ???
- Bomba1990. (Asimétrico) Inglés: ???
- Raul338 (Asimétrico) Inglés: Si.
- [D4N93R] (Esteganografía) Inglés:Si.
- WestOn (Asimétrico) Inglés: Si.
- Braulio-- (Hash) Inglés: Si.

Perdón Vertex, pero no sabía si ponerlo ak o en Progamacion C/C++.

El problema es el siguiente: Estoy compilando ettercap-ng bajo mingw32, compiló perfecto con un par de warnings que si el programa despues no funciona bien, las resolveré pero por ahora compila bien, el problema es cuando quiero linkearlo.
Me pide un "libnet.dll.a" yo tengo uno llamado "libnet.a" lo copié y le puse "libnet.dll.a", pero obviamente eso no resolvió el problema.
Me tira un montón de Undefined references, específicamente a estas funciones:

../libnet/lib/libnet.dll.a(libnet_resolve.o):libnet_resolve.c:(.text+0x5da): undefined reference to `PacketGetNetInfoEx'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0xdf): undefined reference to `PacketSetBuff'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0xf4): undefined reference to `PacketGetNetType'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x262): undefined reference to `PacketSetHwFilter'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x289): undefined reference to `PacketAllocatePacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x2dc): undefined reference to `PacketInitPacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x2f9): undefined reference to `PacketSendPacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x30e): undefined reference to `PacketFreePacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x56d): undefined reference to `SendARP@16'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x597): undefined reference to `GetAdaptersInfo@8'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x5c5): undefined reference to `GetAdaptersInfo@8'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x627): undefined reference to `SendARP@16'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x6d6): undefined reference to `GetIpNetTable@12'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x72b): undefined reference to `GetIpNetTable@12'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x521): undefined reference to `PacketGetNetType'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x60d): undefined reference to `PacketAllocatePacket'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x660): undefined reference to `PacketInitPacket'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x67d): undefined reference to `PacketSendPacket'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x692): undefined reference to `PacketFreePacket'


Alguien me podría aclarar un poco esto?
Gracias!

Hola gente, como va todo, hoy les traigo algo que realmente a muchos les va a interesar.

Muchos ya han escuchado la nueva tecnología que permite utilizar la capacidad de procesamiento de la GPU, para hacer cálculos matemáticos de alta complejidad esto tiene el nombre de GPGPU (General Purpose Graphic Processing Unit). Para esto existen varias tecnologías, Nvidia sacó su CUDA (Compute Unified Device Architecture) y Ati sacó su FireStream. También existen diversos lenguajes que se han creado ad-hoc para optimizar el acceso a esta capacidad como Brook+, CAL y algunas librerías para gráficos de juegos como PhysX y Bullet.

Pero sin embargo, hay una tecnología que a mi opinion va a ser el futuro del GPGPU, estoy hablando claramente del OpenCL una api que cross-platform que permite utilizar tanto Stream como Cuda y en caso de que ninguna de las dos esté disponible, utilizar la CPU.

Es por esto que me puse a analizar la capacidad de cálculo de las últimas placas de Nvidia y de Ati.
Para esto, utilizo el FLOPS (Operación de coma flotante por segundo) como unidad de medida.

Para hacer el cálculo de la capacidad de cálculo utilizo esta fórmula:
[Stream/CUDA cores] * 2 * [GPU clock] = Capacidad de cálculo en MFLOPS.

Tomo entonces distintas placas y las comparo:
Nvidia Geforce GTX 480 (La última de Nvidia) = 672 GFLOPS.
Nvidia Geforce GTX 295 (La última del ensamblador XFX) = 553 GFLOPS.
Ati HD4850 (La que tengo yo XD) = 1040 GFLOPS.
Ati HD5970 (La última de ATI) = 4640 GFLOPS (!).
Ati HD5970 Black Edition Limited (La última del ensamblador XFX = 5440 GFLOPS (!!!)

Ahora, claramente podemos ver que las Ati tienen una capacidad de procesamiento mucho mayor a las Nvidia en cuanto a GPGPU.

Ustedes que piensan?
Un abrazo
APOKLIPTICO

Hola gente, como va todo, hoy estaba mirando el certificado de una página y me di cuenta que utiliza como algoritmo de cifrado RC4, osea que debe de ser una combinación RSA-RC4, se envía mediante criptografía asimétrica la clave simétrica y esa es la que sutiliza para cifrar los mensajes que van y vienen.
Ahora, siendo que el algoritmo efectivo con el cual se cifran los datos es RC4 y todos sabemos que si se tienen suficientes IVs de dicho algoritmo, se puede llegar a conseguir la clave y efectivamente descifrar los datos como vimos en el algoritmo WEP.
Esto no se podría utilizar para crackear la clave RC4 de un canal seguro TLS?

Un abrazo
APOKLIPTICO

Hola gente, como va todo? Hoy les traigo dos pedazos de software que realmente les van a sacar las papas del fuego en más de una ocasión.
El primero es cryptool 1.4.3, trae numerosas opciones, ya sea de cifrar/descifrar en varios algoritmos nuevos y antiguos, varios criptoanálisis distintos como análisis de frecuencias, entropía, etc. y por último varios tutoriales educativos sobre distintos algoritmos famosos como RSA.



Por otro lado, tenemos a la nueva version de Cryptool 2.0, aún en Beta.


Esta versión introduce unos nuevos cambios, primero la capacidad de incorporar algoritmos como plugins y por otro lado, una visión más gráfica de cada algoritmo, pudiendo incorporar compuertas lógicas, contadores, e incluso crackeadores.

En mi opinión, a la versión 2.0 todavía le falta trabajo y yo la verdad no soy muy fanático de los programas con GUIs demasiado pesados, pero aún asi, permite ver de manera muy clara todos los algoritmos.

Bueno, espero que les guste, les dejo la página para que los puedan descargar.
http://www.cryptool.org/

Un abrazo
APOKLIPTICO

Hola gente del foro.
Bueno, como veo que mi post anterior no tuvo respuestas, quizas debería hacer un approach mas focalizado en cuanto a mis preguntas.
Estuve leyendo sobre los últimos avances a los ataques sobre WPA+TKIP (Beck-Tews, Ohigashi-Morii attack) y sobre los ya existentes ataques sobre WEP y el algoritmo RC4 (FMS, KOREK, PTW, Vaudenay-Vuagnoux).
Tengo este diagrama:


El tema es que este diagrama da cierta ambigüedad a partes del algoritmo.
1) La "Master key" es la clave WPA (la de 8-63 bytes que se escribe en el setup del router) o la pairwise master key (PMK) que es la clave WPA pasada por el PBKDF2???

2) De donde se sacan la MIC key y la encryption key??? del PBKDF2??? donde están los 64 bits restantes (PBKDF2 = 256 bits: encryption key 128 bits + MIC key 64 bits = 192 bits)???

3) El algoritmo de "hash()" que se da con el IV del RC4 y la encryption key, se hace con cada paquete?? Cual es este algoritmo? MD5? alguno creado ad-hoc?.

Por favor, si alguien puede responder aunque sea una de estas preguntas o mostrarme algún lugar explicativo del algoritmo TKIP, estaría muy agradecido.

Hola gente, estoy pensando en una posible implementación que podría reducir el tiempo y los IVs necesarios para crackear un clave WEP y potencialmente dar un paso más hacia el crackeo del WPA+TKIP.
Pero tengo un par de preguntas al respecto sobre el algoritmo.
1) Que algoritmo (Hash supongo) se utiliza para obtener de la clave WPA la key para luego generar el keystream del RC4?
2.a) Si yo tuviese hipotéticamente suficientes keystreams descifrados con el nuevo método derivado del chop-chop (.xor), podría llegar a conseguir el key del RC4?
2.b) Si pudiese conseguir este key, podría entonces utilizarlo para inyectar paquetes indefinidamente? o ahí entra en juego el key renewal del WPA?.
3) Hay algún lugar donde esté bien explicado el algoritmo WPA+TKIP, como existe para el NTFS la página NTFS.org?
Muchas gracias.
Un abrazo
APOKLIPTICO

Hola gente, como va todo? Acabo de compilar un programa de prueba que utiliza OpenCL. OpenCL es una plataforma que unifica el GPGPU, realmente me pareció muy buena, el tema es que yo solo tengo una Ati HD4850, no tengo ninguna Nvidia para probar, alguien podría hacerme el favor?? Osea, en definitiva lo que necesitaría es el vendor ID de nvidia para agregarlo al programa, una vez que haga esto, se puede adaptar para que funcione con ambas plataformas! No es genial?.

Bueno este es el código en cuestion, se basa en un template de el SDK de Ati Stream modificado, este es el código en cuestión:

main.cpp:


#include "main.hpp"
std::string
convertToString(const char *filename)
{
    size_t size;
    char*  str;
    std::string s;

    std::fstream f(filename, (std::fstream::in | std::fstream::binary));

    if(f.is_open())
    {
        size_t fileSize;
        f.seekg(0, std::fstream::end);
        size = fileSize = f.tellg();
        f.seekg(0, std::fstream::beg);

        str = new char[size+1];
        if(!str)
        {
            f.close();
            return NULL;
        }

        f.read(str, fileSize);
        f.close();
        str[size] = '\0';

        s = str;
        delete[] str;
        return s;
    }
    else
    {
        std::cout << "\nFile containg the kernel code(\".cl\") not found. Please copy the required file in the folder containg the executable.\n";
        exit(1);
    }
    return NULL;
}
int
initializeHost(void)
{
    width               = 102400;
    output                = NULL;

    /////////////////////////////////////////////////////////////////
    // Allocate and initialize memory used by host
    /////////////////////////////////////////////////////////////////
    cl_uint sizeInBytes = width * sizeof(cl_uint);

    output = (cl_uint *) malloc(sizeInBytes);
    if(output == NULL)
    {
        std::cout<<"Error: Failed to allocate output memory on host\n";
        return 1;
    }

    return 0;
}
int
initializeCL(bool UseGPU)
{
    cl_int status = 0;
    size_t deviceListSize;

    /*
     * Have a look at the available platforms and pick either
     * the AMD one if available or a reasonable default.
     */

    cl_uint numPlatforms;
    cl_platform_id platform = NULL;
    status = clGetPlatformIDs(0, NULL, &numPlatforms);
    if(status != CL_SUCCESS)
    {
        std::cout << "Error: Getting Platforms. (clGetPlatformsIDs)\n";
        return 1;
    }

    if(numPlatforms > 0)
    {
        cl_platform_id* platforms = new cl_platform_id[numPlatforms];
        status = clGetPlatformIDs(numPlatforms, platforms, NULL);
        if(status != CL_SUCCESS)
        {
            std::cout << "Error: Getting Platform Ids. (clGetPlatformsIDs)\n";
            return 1;
        }
        for(unsigned int i=0; i < numPlatforms; ++i)
        {
            char pbuff[100];
            status = clGetPlatformInfo(
                        platforms[i],
                        CL_PLATFORM_VENDOR,
                        sizeof(pbuff),
                        pbuff,
                        NULL);
            if(status != CL_SUCCESS)
            {
                std::cout << "Error: Getting Platform Info.(clGetPlatformInfo)\n";
                return 1;
            }
            platform = platforms[i];
            if(!strcmp(pbuff, "Advanced Micro Devices, Inc."))
            {
                break;
            }
        }
        delete platforms;
    }

    if(NULL == platform)
    {
        std::cout << "NULL platform found so Exiting Application." << std::endl;
        return 1;
    }

    /*
     * If we could find our platform, use it. Otherwise use just available platform.
     */
    cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0 };

    /////////////////////////////////////////////////////////////////
    // Create an OpenCL context
    /////////////////////////////////////////////////////////////////
    if(UseGPU) context = clCreateContextFromType(cps, CL_DEVICE_TYPE_GPU, NULL, NULL, &status);
    else context = clCreateContextFromType(cps, CL_DEVICE_TYPE_CPU, NULL, NULL, &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Creating Context. (clCreateContextFromType)\n";
        return 1;
    }

    /* First, get the size of device list data */
    status = clGetContextInfo(context,
                              CL_CONTEXT_DEVICES,
                              0,
                              NULL,
                              &deviceListSize);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Getting Context Info \
            (device list size, clGetContextInfo)\n";
        return 1;
    }

    /////////////////////////////////////////////////////////////////
    // Detect OpenCL devices
    /////////////////////////////////////////////////////////////////
    devices = (cl_device_id *)malloc(deviceListSize);
    if(devices == 0)
    {
        std::cout<<"Error: No devices found.\n";
        return 1;
    }

    /* Now, get the device list data */
    status = clGetContextInfo(
                 context,
                 CL_CONTEXT_DEVICES,
                 deviceListSize,
                 devices,
                 NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Getting Context Info \
            (device list, clGetContextInfo)\n";
        return 1;
    }

    /////////////////////////////////////////////////////////////////
    // Create an OpenCL command queue
    /////////////////////////////////////////////////////////////////
    commandQueue = clCreateCommandQueue(
                       context,
                       devices[0],
                       0,
                       &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Creating Command Queue. (clCreateCommandQueue)\n";
        return 1;
    }

    /////////////////////////////////////////////////////////////////
    // Create OpenCL memory buffers
    /////////////////////////////////////////////////////////////////

    outputBuffer = clCreateBuffer(
                       context,
                       CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
                       sizeof(cl_uint) * width,
                       output,
                       &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: clCreateBuffer (outputBuffer)\n";
        return 1;
    }


    /////////////////////////////////////////////////////////////////
    // Load CL file, build CL program object, create CL kernel object
    /////////////////////////////////////////////////////////////////
    const char * filename  = "kernel.cl";
    std::string  sourceStr = convertToString(filename);
    const char * source    = sourceStr.c_str();
    size_t sourceSize[]    = { strlen(source) };

    program = clCreateProgramWithSource(
                  context,
                  1,
                  &source,
                  sourceSize,
                  &status);
    if(status != CL_SUCCESS)
    {
      std::cout<<
               "Error: Loading Binary into cl_program \
               (clCreateProgramWithBinary)\n";
      return 1;
    }

    /* create a cl program executable for all the devices specified */
    status = clBuildProgram(program, 1, devices, NULL, NULL, NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Building Program (clBuildProgram)\n";
        return 1;
    }

    /* get a kernel object handle for a kernel with the given name */
    kernel = clCreateKernel(program, "Prime", &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Creating Kernel from program. (clCreateKernel)\n";
        return 1;
    }

    return 0;
}


/*
* \brief Run OpenCL program
*
*        Bind host variables to kernel arguments
*          Run the CL kernel
*/
int
runCLKernels(void)
{
    cl_int   status;
    cl_uint maxDims;
    cl_event events[2];
     size_t maxWorkGroupSize;
    size_t maxWorkItemSizes[3];

    /**
    * Query device capabilities. Maximum
    * work item dimensions and the maximmum
    * work item sizes
    */
    status = clGetDeviceInfo(
        devices[0],
        CL_DEVICE_MAX_WORK_GROUP_SIZE,
        sizeof(size_t),
        (void*)&maxWorkGroupSize,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Getting Device Info. (clGetDeviceInfo)\n";
        return 1;
    }

    status = clGetDeviceInfo(
        devices[0],
        CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
        sizeof(cl_uint),
        (void*)&maxDims,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Getting Device Info. (clGetDeviceInfo)\n";
        return 1;
    }

    status = clGetDeviceInfo(
        devices[0],
        CL_DEVICE_MAX_WORK_ITEM_SIZES,
        sizeof(size_t)*maxDims,
        (void*)maxWorkItemSizes,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Getting Device Info. (clGetDeviceInfo)\n";
        return 1;
    }

    /*** Set appropriate arguments to the kernel ***/
    /* the output array to the kernel */
    status = clSetKernelArg(
                    kernel,
                    0,
                    sizeof(cl_mem),
                    (void *)&outputBuffer);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Setting kernel argument. (output)\n";
        return 1;
    }
    status = clGetKernelWorkGroupInfo(kernel,
        devices[0],
        CL_KERNEL_LOCAL_MEM_SIZE,
        sizeof(cl_ulong),
        &usedLocalMemory,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"clGetKernelWorkGroupInfo CL_KERNEL_LOCAL_MEM_SIZE failed." << std::endl;
        return 1;
    }

    if(usedLocalMemory > totalLocalMemory)
    {
        std::cout << "Unsupported: Insufficient local memory on device" << std::endl;
        return 1;
    }

    /* Check group size against group size returned by kernel */
    status = clGetKernelWorkGroupInfo(kernel,
        devices[0],
        CL_KERNEL_WORK_GROUP_SIZE,
        sizeof(size_t),
        &kernelWorkGroupSize,
        0);
    if(status != CL_SUCCESS)
    {
        std::cout<<"clGetKernelWorkGroupInfo CL_KERNEL_COMPILE_WORK_GROUP_SIZE failed." << std::endl;
        return 1;
    }

    if(groupSize > kernelWorkGroupSize)
    {
        std::cout << "Out of Resources!" << std::endl;
        std::cout << "Group Size specified : " << groupSize << std::endl;
        std::cout << "Max Group Size supported on the kernel : " << kernelWorkGroupSize << std::endl;
        std::cout << "Falling back to " << kernelWorkGroupSize << std::endl;
        groupSize = kernelWorkGroupSize;
    }
    /*
     * Enqueue a kernel run call.
     */
    size_t globalThreads[] = {width};
    size_t localThreads[] = {1};
    if(localThreads[0] > maxWorkItemSizes[0] ||
       localThreads[0] > maxWorkGroupSize)
    {
        std::cout << "Unsupported: Device" "does not support requested number of work items.";
        return 1;
    }
    status = clEnqueueNDRangeKernel(
                 commandQueue,
                 kernel,
                 1,
                 NULL,
                 globalThreads,
                 localThreads,
                 0,
                 NULL,
                 &events[0]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Enqueueing kernel onto command queue. \
            (clEnqueueNDRangeKernel)\n";
        return 1;
    }


    /* wait for the kernel call to finish execution */
    status = clWaitForEvents(1, &events[0]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Waiting for kernel run to finish. \
            (clWaitForEvents)\n";
        return 1;
    }

    status = clReleaseEvent(events[0]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Release event object. \
            (clReleaseEvent)\n";
        return 1;
    }

    /* Enqueue readBuffer*/
    status = clEnqueueReadBuffer(
                commandQueue,
                outputBuffer,
                CL_TRUE,
                0,
                width * sizeof(cl_uint),
                output,
                0,
                NULL,
                &events[1]);

    if(status != CL_SUCCESS)
    {
        std::cout <<
            "Error: clEnqueueReadBuffer failed. \
             (clEnqueueReadBuffer)\n";

        return 1;
    }

    /* Wait for the read buffer to finish execution */
    status = clWaitForEvents(1, &events[1]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Waiting for read buffer call to finish. \
            (clWaitForEvents)\n";
        return 1;
    }

    status = clReleaseEvent(events[1]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Release event object. \
            (clReleaseEvent)\n";
        return 1;
    }

    return 0;
}


/*
* \brief Release OpenCL resources (Context, Memory etc.)
*/
int
cleanupCL(void)
{
    cl_int status;

    status = clReleaseKernel(kernel);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseKernel \n";
        return 1;
    }
    status = clReleaseProgram(program);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseProgram\n";
        return 1;
    }
    status = clReleaseMemObject(outputBuffer);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseMemObject (outputBuffer)\n";
        return 1;
    }
    status = clReleaseCommandQueue(commandQueue);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseCommandQueue\n";
        return 1;
    }
    status = clReleaseContext(context);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseContext\n";
        return 1;
    }

    return 0;
}


/*
* \brief Releases program's resources
*/
void
cleanupHost(void)
{
    if(output != NULL)
    {
        free(output);
        output = NULL;
    }
    if(devices != NULL)
    {
        free(devices);
        devices = NULL;
    }
}



int
main(int argc, char * argv[])
{
    bool GPU = true;
    for(int i = 0; i < 2; i++)
    {
    // Initialize Host application
    if(initializeHost()==1)
        return 1;

    // Initialize OpenCL resources
    if(initializeCL(GPU)==1)
    return 1;
/*  char C;
    do
    {
        std::cout << "Use GPU?(Y/N)" << std::endl;
        C = getch();
    }while(!((C == 'Y') || (C == 'y') || (C == 'n') || (C == 'N')));
    if(C == 'Y' || C == 'y')
    {
        if(initializeCL(true)==1)
            return 1;
    }
    else
    {
        if(initializeCL(false)==1)
            return 1;
    }*/

    // Run the CL program
    float Clocklast = clock();
    if(runCLKernels()==1)
        return 1;
    float Benchtime = (clock() - Clocklast) / CLOCKS_PER_SEC;
    // Print output array
    //for(int i = 0; i < width; i++) std::cout << output[i] << " ";
    if(GPU) std::cout << "With GPU: "; else std::cout << "With CPU: ";
    std::cout << Benchtime << " Seconds" << std::endl;
        // Releases OpenCL resources
    if(cleanupCL()==1)
        return 1;

    // Release host resources
    cleanupHost();
    GPU = false;
    }
    return 0;
}



Main.hpp:

#include <CL/cl.h>
#include <string.h>
#include <cstdlib>
#include <iostream>
#include <time.h>
#include <fstream>
#include <conio.h>
/*** GLOBALS ***/

cl_uint *output;
cl_ulong totalLocalMemory;
cl_ulong usedLocalMemory;
size_t kernelWorkGroupSize;
size_t groupSize;
cl_uint width;

/* The memory buffer that is used as input/output for OpenCL kernel */
cl_mem     outputBuffer;

cl_context          context;
cl_device_id        *devices;
cl_command_queue    commandQueue;

cl_program program;

/* This program uses only one kernel and this serves as a handle to it */
cl_kernel  kernel;


/*** FUNCTION DECLARATIONS ***/
/*
* OpenCL related initialisations are done here.
* Context, Device list, Command Queue are set up.
* Calls are made to set up OpenCL memory buffers that this program uses
* and to load the programs into memory and get kernel handles.
*/
int initializeCL(bool UseGPU);

/*
*
*/
std::string convertToString(const char * filename);

/*
* This is called once the OpenCL context, memory etc. are set up,
* the program is loaded into memory and the kernel handles are ready.
*
* It sets the values for kernels' arguments and enqueues calls to the kernels
* on to the command queue and waits till the calls have finished execution.
*
* It also gets kernel start and end time if profiling is enabled.
*/
int runCLKernels(void);

/* Releases OpenCL resources (Context, Memory etc.) */
int cleanupCL(void);

/* Releases program's resources */
void cleanupHost(void);
/*
* Prints no more than 256 elements of the given array.
* Prints full array if length is less than 256.
*
* Prints Array name followed by elements.
*/
void print1DArray(
         const std::string arrayName,
         const unsigned long * arrayData,
         const unsigned int length);


Kernel.cl

__kernel
void Prime(
    __global unsigned int * output)
{
uint tid = get_global_id(0);
output[tid] = 2 * tid;
}


El kernel es muy simple, iba a calcular primos, por eso se llama "prime" pero bueno, todavía no me puse a hacerlo.

Un abrazo
APOKLIPTICO

Hola gente, como va todo?
Estoy jugando un poco con la tecnología opencl y atistream, y entonces, me puse a tratar de adaptar un sample de Nbody, muy interesante que viene con el SDK a mi IDE code::blocks + Mingw. Pero me encontré con algunos problemas, cuando pude resolver todos los problemas del linker, me encontré con estos pedazos de código:
#if defined (_WIN32)
    pos = (cl_float*)malloc_align(numBodies * sizeof(cl_float4),16);
#else
    pos = (cl_float*)memalign(16, numBodies * sizeof(cl_float4));
#endif

y
#if defined (_WIN32)
       free_align (pos);
#else
        free(pos);
#endif

No pude encontrar los includes que funcionan con codeblocks + mingw, entonces pensé si era posible usar los operadores "new" y "delete" para allocar la memoria. Pero despues de probar varias formas, decidí pedir ayuda.
Alguien sabe cual es el include que funciona con esto, o como adaptarlo para que funcione con "new" y "delete"??
Muchas gracias!

Hola gente, como va todo? Bueno hoy traigo dos preguntas:
1) Hay algún buen programa que tenga la opción de "scan for artifacts" como hacía el ATI TOOL, pero que ande? (aclaro: el ati tool no me anda). Es que quiero overclockear mi ATI HD 4850 pero no quiero tener que ponerme a jugar cada vez que hago un cambio para ver si salen artifacts.

2) Hay alguna manera de overclockear mi micro Sempron 2500+ con un chipset nforce 410/430mcp. Aclaro:
- No me anda Ntune/Nvidia system settings. Dejó de funcionar hace un tiempo y no se como puedo llegar a hacerlo funcionar (ni siquiera los de nvidia saben aparentemente). El problema en cuestión es que el slider para modificar el bus, me aparece con rangos ridículos (de 0 Mhz a 20 Mhz), al poner "apply" me tira un error "FSB Bus modification: error. Se han restablecido los valores". Tampoco funciona ejecutando los archivitos .nsu.
- No me anda el clockgen, cuando hago click en apply, me hace toda la pantomima como si los hubiese aplicado, pero no lo hace.
- Ni el SetFSB, aparentemente no tiene soporte para nforce 410.
- Tampoco el CPUCOOL/CPUFSB.
- Lo único que puedo modificar por bios es el Vdimm y los timings (el primero no me sirve demasiado y el segundo lo puedo modificar con memset).

Alguien sabe algo?
Gracias!
Un abrazo
APOKLIPTICO

Hola gente, como va todo? miren, tengo un problema que me está volviendo loco, me venía funcionando perfecto el ntune, hasta que un día dejo de funcionar, me crasheaba todo el tiempo cada vez que lo arrancaba. Reinstalé drivers del nforce y el ntune, no funcionó. Reinstalé los drivers del nforce y el ntune haciendo un driver cleaner pro entre la desinstalación y la instalación. Funcionó no crasheaba más, pero parece que eliminé el "baseline.npe" que es un archivo que aparentemente (digo aparentemente porque esto lo deduzco) establece los valores base para overclockear. Sin este archivo, el rango del slider para overclockear el bus, va de 8 Mhz a 20 Mhz, que a menos que tenga un 486, no tiene mucho sentido. Y aparte no puedo cambiar los timings de las memorias.

Alguien tiene idea como puedo hacer para hacerlo funcionar? A pesar de q sea una porquería, es el único que me permite hacer perfiles para overclockear mi pc y cambiar los timings todo sin tener que reiniciar mi pc.
Un abrazo
APOKLIPTICO

PD: SPECS:

- MSI K8NGM-VL. Nforce 410 - Geforce 6100 (Deshabilitada x BIOS).
- 1 GB DDR 400.
- ATI Radeon HD4850.

Hola! Como va todo?
Estuve googleando un rato para ver si existe algún descompresor RAR/ZIP/7z/Tarball que pueda ser acelerado por GPU.
Como imaginarán, no encontré nada...
Alguien sabe si existe alguno, y en caso de que no existiese, cabe la posibilidad de crear uno?

Un abrazo
APOKLIPTICO

Hola gente, como va todo?
Miren, tengo este problema, estoy tratando de hacer un puente de red con una conexión inalámbrica y una conexion cableada.
Selecciono las dos, click derecho, conexiones de puente.
Me crea el puente y une al puente las dos redes.
Para testeos, dejé desconectado el cable de red (probé tambien conectándolo y obtuve los mismos resultados).
El problema es que cuando quiero pingear la puerta de enlace (192.168.1.1), no me responde los pings.
Tampoco tengo conexión a internet.
Conectando el cable de red, me permite acceder a la otra pc que estoy puenteando, pero no a la puerta de enlace.

Alguien tiene idea cual puede ser el problema??.
Dejo aki mi tabla de rutas:
===========================================================================
ILista de interfaces
0x1 ........................... MS TCP Loopback interface
0xb0005 ...02 13 d3 ef 53 46 ...... Puente minipuerto MAC - Minipuerto del administrador de paquetes
===========================================================================
===========================================================================
Rutas activas:
Destino de red        Máscara de red   Puerta de acceso   Interfaz  Métrica
          0.0.0.0          0.0.0.0      192.168.1.1   192.168.1.109       40
        127.0.0.0        255.0.0.0        127.0.0.1       127.0.0.1       1
      192.168.1.0    255.255.255.0    192.168.1.109   192.168.1.109       40
    192.168.1.109  255.255.255.255        127.0.0.1       127.0.0.1       40
    192.168.1.255  255.255.255.255    192.168.1.109   192.168.1.109       40
        224.0.0.0        240.0.0.0    192.168.1.109   192.168.1.109       40
  255.255.255.255  255.255.255.255    192.168.1.109   192.168.1.109       1
Puerta de enlace predeterminada:       192.168.1.1
===========================================================================
Rutas persistentes:
  ninguno

Y esta es la tabla ARP:
Interfaz: 192.168.1.109 --- 0xb0005
  Dirección IP          Dirección física      Tipo
  192.168.1.1           00-XX-XX-XX-XX-XX     dinámico (Es correcta la MAC).

Bueno, espero que me puedan ayudar.
Un abrazo
APOKLIPTICO

Hola gente, como va?
Tengo en mi pc dos discos, uno de 500 y uno de 80.
El de 80 está dividido en dos particiones, 12 gb - 68 gb.
La primera es la de sistema (12 gb), por otro lado, la de 68 hasta ahora la tenía sin asignar.
El otro día extendí el disco de 500 gb con la partición de 68 quedándome un "disco" virtual de 568 gb.
El problema es que me di cuenta que quizas en algún momento tenga usar el otro disco de 80 gb en otra pc.
Mi pregunta es: se puede des-extender la partición sin tener que formatear?.

Muchas gracias!
Un abrazo
APOKLIPTICO

Hola gente, como va todo?
Miren, tengo que convertir una partición de sistema (osea con el sistema operativo cargado ahí), de FAT32 a NTFS.
Esto es en un Windows XP SP3, estas son las specs de la pc:
Mother ASUS M2N68-AM SE2.
Micro AMD Sempron le1640 2.7 Ghz
Disco MAXTOR STM3802110A 80 GB
2 GB DDR2.

El tema es que esta PC es un servidor, osea que estaría bueno saber el riesgo de que explote todo, y que precauciones se pueden tomar.
Cuanto tarda el proceso?
Se podría hacer de forma remota x un VNC? (más alla de la parte en la cual se tiene que reiniciar obviamente).
Gracias!
Un abrazo
APOKLIPTICO

Hola gente, tengo una Pentium 3 con un problema, cada vez que se le conecta un adaptador Wi Fi USB con chipset RTL8187l, se lentifica terriblemente la pc. Este adaptador Wi-Fi no produce este problema en otras pcs y aparte, en la misma pc con otra mother, funciona bien. Lo que me lleva a pensar que es un tema de la mother. Está conectado a una placa PCI-USB (cabe mencionar que con los USB de la mother ocurre lo mismo). A alguien se le ocurre que podría estar ocasionando esto y como solucionarlo?.

Un abrazo
APOKLIPTICO

Hola gente, necesito una función que me vaya explorando una unidad archivo x archivo, y que cada vez q la llame, me devuelva el siguiente archivo en la unidad. Se que estaría bueno que lo haga yo, pero es un algoritmo largo y medio complejo y se que ya existe, asi q en vez de ir a inventar la rueda, pensé q alguien me podría proporcionar la clase o el conjunto de funciones para este cometido.

La idea es que cada vez q llame a la función, me devuelva el siguiente archivo en la unidad, osea q vaya explorando los subdirectorios.

Gracias!
Un abrazo
APOKLIPTICO

Hola gente, me agarró ayer mientras estaba tratando de dormir una curiosidad (que no ayudó). Yo en varias ocasiones he usado un borrador seguro, sobre todo cuando iba a vender una PC.
Para este fin usaba el eraser, excelente programa, aunque en las últimas versiones cambiaron el GUI a una más intuitiva y simpática y todos sabemos cuales son las consecuencias de esto (WINDOWS VISTAAAA), sin embargo, el core del programa sigue siendo muy bueno.

Mi pregunta es la siguiente: Por que hace falta borrados de hasta 35 veces (el gutmann) para asegurar que sea perfectamente borrado. No se supone que si yo agarro y cambio a "0" todos los sectores en la superficie del disco, eso sería suficiente? Para que uno de los borrados utiliza un generador pseudoaleatorio para sobreescribirlo antes de borrarlo? No sería más facil sobreescribirlo todo con "0" antes de borrar el registro en la MFT?

Un abrazo
APOKLIPTICO

Hola gente, como va?
Mi pregunta hoy es la siguiente: Cual es la mejor manera de hacer un filtro de tráfico en una red chica (20-30 pcs) para filtrar tanto tráfico http/https como otros protocolos (msn, p2p, etc) usando una pc (osea no un hardware) ya sea con windows o con linux/coyote.?

Un abrazo
APOKLIPTICO

Hola gente, bueno no soy el primero que pregunta esto, pero tengo varios problemas con el EFS.
Lo que pasó es que cambié la contraseña de la cuenta administrador, y ahora no puedo acceder a mis archivos...
Probé con ERD commander y advanced password recovery. El tema es que había cambiado tambien el algoritmo de cifrado q se usa de DES a AES, no estoy seguro si mis archivos están cifrados con el primero o con el segundo. Tengo las claves privadas y las públicas, cuando digo que las tengo, digo q tengo todo lo que hay en %APPDATA%\protect, %APPDATA%\crypto y %APPDATA%\systemcertificates.

Hay alguna manera de hacer brute force sobre las claves para sacar la contraseña?? Tengo una ATI HD4850 osea q si tiene soporte GPU, mejor.

Un abrazo
APOKLIPTICO

PD: Bueno, estuve investigando más y ya se cual es la clave privada y el certificado .cer que necesito. El tema es que aparentemente la clave privada está protegida por contraseña. Utiliza Crypto API. Hay alguna manera de hacer brute force sobre la clave privada?

Hola gente, estoy teniendo un problema, quiero unpackear un exe que fue packeado con Xprotector. El problema es que encontré lo siguiente:
- XprotStripper que no funciona en winxp, solo en win2k. Y lamentablemente no puedo instalar en una VM un win2k xq el exe q quiero unpackear no funciona en VM. Aún así queda como opción para probarlo.
- Un tutorial de Ricardo Narvaja, que realmente es muy extenso y avanzado, y en este momento no me puedo poner.

Se les ocurre alguna alternativa? Algun método? algo?
Un abrazo
APOKLIPTICO

Hola gente... Miren, estoy teniendo un problema y quería ver si me podían ayudar...
Estoy tratando de crackear un crackme, el objetivo es parchearlo para que te salte la pantalla que pide una contraseña. El programa no está protegido con nada según el RDG Packet detector, y el ollydbg lo puede analizar bien y no me tira el clásico error que dice que está probablemente compactado. El problema es que cuando uso "Search for all referenced strings" para buscar alguno de los strings que aparecen en la pantalla que pide la contraseña, no me encuentra nada. Lo que me lleva a pensar que no está en el ejecutable principal ese pedazo de código, sino en alguno de los módulos. El problema es que son un montón y estuve buscando en algunos pero no encontré nada.. Hay alguna manera más facil??
Lamentablemente no puedo postear el crackme o distribuirlo de ninguna manera porque me pidieron que no lo haga...

Muchas gracias a todos....
Un abrazo
APOKLIPTICO

Hola gente, bueno, tengo ganas de hacer un poco de DNS poisoning, el problema es que dsniff no me anda muy bien xq ya está super obsoleto, se les ocurre alguna utilidad para hacer dns poisoning que no sea Cain y que permita usar un archivo como el dsniff??
El problema de Cain es que no acepta wildcards, osea si yo le pongo:
0.0.0.0 www.google.com

Entonces va a funcar bien.
Pero yo quiero que no solo www.google.com sea envenenado. Quizas quiero que *.gooogle.com.* sea envenenado, o en una de esas quiero que *.*.* sea envenenado, y no puedo estar poniendo todos los dominios uno por uno..
Hay alguna utilidad que cumpla estas características? En lo posible que sea para windows, pero si es para linux no hay problema...

Un abrazo
APOKLIPTICO

Hola gente, hoy les traigo un chiste que es lo suficientemente complejo como para ser un acertijo jajaja.

Hay dos osos, uno blanco y otro marron en una isla. Quieren pasar a la otra isla, que es más grande y tiene más alimentos. Para esto tienen que nadar, se ponen a nadar, pero a la otra isla solo llega el oso marron.

Por que?
Para los neófitos: Uds hacen preguntas, yo respondo si/no/irrelevante.

Un abrazo
APOKLIPTICO

PD: Las respuestas en el mismo thread.

Hola! Como va todo?
Bueno, miren tengo un tema...
Como hago para que un programa que tiene el RtlProcessIsCrital token activado no me haga un BSOD si lo quiero apagar sino q me diga como muchos de los critical processes de windows "Este proceso es critico para el sistema y no se puede terminar".
Hay alguna manera? (Sin usar drivers para hookear el exitprocess).

Un abrazo
APOKLIPTICO

PD: Es peligroso q ande haciendo guru meditation todo el tiempo, se te caga el kernel de nada (Comprobado en una VM).

Hola gente, miren, tengo este problema...
Tengo una computadora con un UltraVNC troyanizado y quiero instalar un ssh troyanizado que tengo, para poder tener una shell. Mi pregunta es esta: Como hago?
Probé reemplazando el taskmgr.exe y mandando un "ctrl+alt+del" pero no me deja reemplazar el taskmgr.exe x alguna razon, hay alguna manera de hacerlo???
Puedo bajar y subir archivos del server, asi como eliminar.
El ssh troyanizado ya está subido, le puse un acceso directo en la carpeta inicio para que se ejecute en el siguiente reinicio, pero me gustaría que se inicie ahora.
A alguien se le ocurre como puedo hacerlo???

Un abrazo
APOKLIPTICO

PD: El SO del Host es Windows XP SP3.

Hola gente, tengo un problemon, estoy haciendo un pequeño programita q cada tanto crashea un programa editando partes aleatorias de la memoria con datos aleatorios tengo dos preguntas:

1) Que parte de la memoria me conviene editar para tener mayor probabilidad de crashear el proceso? Cual es la direccion de esa memoria?

2) Por qué este codigo no anda?:
Private Sub Timer2_Timer()
'appcrash
Dim i As Integer
For i = 0 To 1
DoEvents
Call WriteAInt(APP_MEM_START, Rnd * 255, 796)
Next i
Timer2.Enabled = False
If DEBUGON = False Then
Timer1.Enabled = True
End If
End Sub

Function WriteAInt(ByVal Address As Long, ByVal Value As Long, ByVal PID As Long)
Dim Handle As Long
Handle = OpenProcess(PROCESS_ALL_ACCESS, False, PID)
Dim ret As Variant
ret = WriteProcessMemory(Handle, Address, Value, 4, 0&)
Call CloseHandle(Handle)
End Function

Me abre el proceso, xq el handle me devuelve un valor non-zero, pero el writeprocessmemory me devuelve "0" siempre, sin importar que valor en la memoria le ponga...
Y si uso el getlasterror, esta tambien me devuelve "0", osea q no se cual es el error q estoy teniendo, tengo privilegios de admin.

Cual puede ser el problema???

Hola gente! Bueno, hoy les presento este programita muy bueno q encontre googleando, rompe hashes y passwords de RARs usando la GPU, q como muchos saben, tiene una capacidad de procesamiento mucho mayor a la de cualquier CPU.
http://www.golubev.com/
Esta es la página principal y estos son los tipos de hashes q permite romper:

    *  md4 (Single byte/Unicode)
    * sha1 (Single byte/Unicode)
    * md5
    * md5x2 md5(md5($pass).ascii) No idea how to call it, some forum's type
    * md5x2s md5(md5($pass).$salt) Same as above except salt added after first md5 (without salt md5x2 and md5x2s are the same).
      Can be used for vBulletin hashes especially with asalt switch
    * mysql5 sha1(sha1($password))
    * ipb md5(md5($salt).$md5($pass))
    * dcc md4(md4($password).lowercase($username))

La verdad q está muy bueno y lo recomiendo...

Un abrazo
APOKLIPTICO

Hola! como va?
Quería saber que tipos de sesiones puede haber en una página hecha en asp con  ‫ ‫javascript.
Xq estaba buscando la manera de autenticacion en una página, y me di cuenta que no es una cookie, y no puede ser x IP xq tengo dos pcs detras de un router con la misma IP publica y no hay problema en abrirla en dos pcs distintas...
Entonces? como puede ser que esté autenticando a los usuarios y manteniendo sus sesiones abiertas si no usa cookies???
Un abrazo
APOKLIPTICO

PD: No puedo poner la página que estoy analizando ya q es algo privado.

PD2: Me parece que si usa cookies, pero lo raro es que cuando borro las cookies, sigo logueado, pero cuando las bloqueo directamente,,no funciona...

PD3: Ahora aparentemente encontre el string cifrado lo pongo aki a ver si a alguien se le ocurre como puede estar cifrado:
1536
823940352
30016938
268616848
30016737
*

Bueno, a los grandes matemáticos les tiro una pregunta:
Hay alguna manera de disminuir la entropía de un archivo de manera reversible y sin modificar el tamaño o modificandolo muy poco??
Ya se que la segunda ley de la termodinámica dice q es imposible reducir la entropía de un sistema, pero eso se aplica a casos físicos, quizas cuando lo transportamos a 1s y 0s no se aplica tanto.
Un abrazo
APOKLIPTICO