Loguearse a una web con python

Existen diferentes formas de hacer un login a una pagina web, en esta ocasión decidí poner una parte del código utilizado anteriormente para loguearse a una web en Python.

Para este ejemplo el login ha sido realizado mediante una petición POST de la librería requests de Python, los datos enviados mediante esta petición depende de la url en donde realizará el login.

Para el ejemplo se envían los siguientes datos:

payload {
       "Usuario":user,
       "Password":clave,
       "btnEntrar":"Entrar",
}

Para saber que datos son enviados mediante el método POST pueden descargarse la pagina html del login y en la etiqueta form cambiarle el método POST por GET y ademas la dirección url donde se realizará la acción para que no te direccione a la pagina descargada, pueden editar la pagina con cualquier editor de texto. Para el ejemplo descargue el login de esta pagina. Veamos como hacerlo en la imagen:

Datos editados: action="datos.html" method="get" (donde datos.html es una copia de la pagina login.html descargada)

Los datos enviados aparentemente son miusuario y miclave, pero veamos en la siguiente imagen que todos los datos enviados son:

username=miusuario&password=miclave&return=&61523a137fcedfbcb0f2faa936635de7=1

En nuestro payload mencionado anteriormente para este login probablemente seria:

payload = {
       "username":"miusuario",
       "password":"miclave",
       "return":"",
       "61523a137fcedfbcb0f2faa936635de7"="1",
}

Por lo general son los datos que debería tener nuestra variable payload.

Una vez que sabemos los datos que se envían, el siguiente paso es analizar el resultado que retorna. Pues esto depende de cada pagina, es mas fácil cuando tienes una cuenta valida para saber que resultado esperas cuando los datos ingresados son correctos y a la vez saber que datos retorna cuando tu contraseña o usuario son incorrectos. En esta parte depende de la pagina y de uno mismo como analizar el contenido que retorna.

Aquí un ejemplo de como seria analizar el contenido que retorna:

Esto es asumiendo que retorna un id="mensaje-respuesta" con contenido que indica "Cuenta correcta"

Los demás como ya lo he mencionado depende del login y el contenido que retorna la petición, ademas de un poco de ingenio para hacer peticiones seguidas u otra cosa que se te pueda ocurrir. Para ver todo el contenido del código pueden ingresar aqui donde ademas hay una variable proxies por si quieren acceder mediante un proxy, saludos y happy hack.

Enlaces:

https://github.com/phaoliop/Loginwithpy/blob/master/Data/login.py

Lista de claves por defecto - UNMSM

Me tome el tiempo de ver cuantas cuentas aun continúan usando su clave por defecto y los resultados realmente me sorprendieron.  En total son alrededor de 7015 usuarios que sus cuentas han sido validadas, para no afectar a nadie he ocultado los últimos caracteres de los usuarios y de las contraseñas, por mi parte yo solo hice esto con la intención de informar.

Asumo que cada uno debe saber que la clave que esta usando, por si desean verificar si aparecen en la lista, puedes verificar aqui (presionen f3 e ingresen los primeros caracteres de su correo o dni).

Datos encontrados: 

Los datos encontrados user:password (Total: 7015)

Debo agregar que son cuentas de pre-grado que estudiaban hasta el 2015, probablemente si hubiera validado hasta los del estudiantes de pre-grado y demás personal dentro de la universidad en el 2017, los resultados hubieran sido aun mayores.

Entre los datos encontrados, decidí separar para obtener cuantas cuentas son por facultad:

1. MEDICINA = 772
2. DERECHO Y CIENCIA POLÍTICA = 715
3. LETRAS Y CIENCIAS HUMANAS = 416
4. FARMACIA Y BIOQUÍMICA = 146
5. ODONTOLOGÍA = 136
6. EDUCACIÓN = 429
7. QUÍMICA E INGENIERÍA QUÍMICA = 309
8. MEDICINA VETERINARIA = 79
9. CIENCIAS ADMINISTRATIVAS = 427
10. CIENCIAS BIOLÓGICAS = 167
11. CIENCIAS CONTABLES = 500
12. CIENCIAS ECONÓMICAS = 332
13. CIENCIAS FÍSICAS = 202
14. CIENCIAS MATEMÁTICAS = 278
15. CIENCIAS SOCIALES = 550
16. INGENIERÍA GEOLÓGICA = 428
17. INGENIERÍA INDUSTRIAL = 363
18. PSICOLOGÍA = 193
19. INGENIERÍA ELECTRÓNICA = 330
20. INGENIERÍA DE SISTEMAS E INFORMÁTICA = 243
    
    ----------------------------------------------------------------
    TOTAL = 7015

En primero lugar recomendarles que cambien su clave, probablemente muchos ni utilicen su cuenta, pero puede que haya personas que se aprovechen de esto, por mi parte solo ha sido para informarles, avisen y happy hack!.

Enlaces:

https://github.com/phaoliop/Loginwithpy/blob/master/preusers_pwd.txt

https://github.com/phaoliop/Loginwithpy/blob/master/estadisticas_facus.txt

Escala de privilegios - Archivos con el bit SUID activo

El bit suid es un permiso que se puede conceder tanto a directorios como ficheros. El SUID en ficheros es un permiso muy especial, que permite a un usuario con permisos de ejecución para dicho fichero, tomar los permisos del dueño del fichero durante su ejecución.

Para el ejemplo de hoy primero haremos un pequeño programa en C que ejecuta comandos de la terminal (el ejecutable lo generara nuestro usuario root). Luego le daremos el permiso de SUID y veremos como varia al activar el bit.

Aplicación:

Bueno para generar nuestro programa en C es solo esta pequeña porción de código que pueden verlo aqui.

Luego compilamos y ejecutamos el programa:

• $ gcc filesuid.c -o filesuid
• $ ./filesuid

Lo cual luego solo debes ingresar el comando que realizamos ejecutar y listo. En este caso ejecutaremos primero el comando ls -l para ver la informacion de los archivos y luego el comando whoami que lo que hace es mostrar el nombre del usuario en el que estamos.

• my_shell > ls -l
• my_shell > whoami

-rwxr-xr-x : el primero hace referencia al tipo de archivo, los 3 siguientes rwx al usuario,
3 siguientes grupo, 3 siguientes al resto de usuarios. Un guion (-) indica que no esta activo el bit en esa posición.

Como resultado nos muestra los permisos que tiene el archivo "filesuid" que es nuestro ejecutable y aqui debemos ver el simbolo X resaltado, que hace referencia a que el archivo puede ser ejecutado por el usuario, ademas seguido del siguiente comando nos indica que somos el usuario root, pues en realidad es así.

Continuando con el ejemplo ahora desde otra terminal veamos lo mismo pero con otro usuario, en este caso mi usuario se llama paolo, ejecutamos:

• $ ls -l
• $ ./filesuid
• my_shell > whoami

En este caso al ejecutar whoami nos indica que somos el usuario paolo. Para salir del programa escriban salir.

Ahora asignemos el bit SUID a nuestro ejecutable, desde la terminal del usuario root, ejecutamos los siguientes comandos:

• $ chmod 4755 filesuid
  4: activa el bit suid; 7: activa los bits rwx para el usuario; 5: activa los bits r-x para el grupo; 5 activa los bits r-x para los demas miembros;
• $ ls -l
  vemos los permisos del ejecutable y notaremos que en vez de un x, aparece una s ( esto indica que el bit suid esta activo)

El bit suid es el que esta resaltado, donde la s minúscula indica que esta activo.

Por ultimo en nuestra terminal de otro usuario (no root) ejecutamos nuestro archivo que ya esta activado el bit suid:

• $ ls -l
• $ ./filesuid
• my_shell > whoami

En el cual nos muestra que somos root cuando estamos como usuario paolo. Pues una vez aqui y con los permisos de root existen las vulnerabilidades por tener archivos -como en el ejemplo- con el bit SUID activo.

Enlaces:

https://github.com/phaoliop/Programming_C-Cplus/blob/master/C/SO/filesuid.c

Referencias:

https://hvivani.com.ar/2013/09/06/permisos-especiales-sticky-bit-suid-sgid/

Logran vulnerar el protocolo WPA2 - Key Reinstallation Attack

Es probable que tu Wi-Fi en tu casa no sea tan seguro como crees, recientemente ha salido la noticia de una severas vulnerabilidades en el protocolo Wi-Fi Protected Access II que permiten a los atacantes escuchar a escondidas el tráfico de Wi-Fi que pasa entre las computadoras y los puntos de acceso.

El exploit de prueba de concepto se llama KRACK (Key Reinstallation AtaCK), abreviatura de Ataques de re-instalación de claves. La investigación ha sido un secreto muy vigilado durante semanas antes de una divulgación coordinada programada para hoy Lunes 16-08-2017.

Una advertencia que el US-CERT distribuyó recientemente, describió la investigación de esta manera (traducción al español) :

" US-CERT se ha dado cuenta de varias vulnerabilidades de administración clave en el protocolo de seguridad Wi-Fi Protected Access II (WPA2) de 4 vías. El impacto de la explotación de estas vulnerabilidades incluye descifrado, repetición de paquetes, secuestro de conexión TCP, inyección de contenido HTTP y otros. Tenga en cuenta que, como problemas de nivel de protocolo, la mayoría o todas las implementaciones correctas del estándar se verán afectadas. El CERT / CC y el investigador informante KU Leuven publicarán públicamente estas vulnerabilidades el 16 de octubre de 2017. "

En una pagina Github perteneciente a uno de los investigadores, se utilizaron las siguientes etiquetas:

• WPA2
• KRACK
• key reinstallation
• security protocols
• network security, attacks
• nonce reuse
• handshake
• packet number
• initialization vector

Es probable que la gran mayoría de los puntos de acceso existentes no se parcheen rápidamente, y algunos no se paren en absoluto. Si los informes iniciales son precisos de que los ataques de derivación de cifrado son fáciles y confiables en el protocolo WPA2, es probable que los atacantes puedan espiar el tráfico de Wi-Fi cercano a medida que pasa entre las computadoras y los puntos de acceso.


Hasta el momento no hay información de la gravedad que ocasionaría. Recordar que el  Wi-Fi ofrece una cantidad limitada de seguridad física: un ataque debe estar cerca. Entonces, de repente no eres vulnerable a todos en Internet. Es una protección muy débil, pero esto es importante cuando se revisa su nivel de amenaza.

Además, es probable que no tenga demasiados protocolos que confíen en la seguridad de WPA2. Cada vez que accede a un sitio https, como este, el navegador está negociando una capa separada de cifrado.

Comprometer servidor FTP - HackLab #1 de gf0s

 En mi búsqueda de algún reto de Hacking básico, he encontrado los HackLabs de GF0S que decía que eran para los que recién iniciamos en Seguridad Informática y pues soy uno de ellos así que decidí probar a ver que tal me iba.

En este caso, se trata del HackLab #1 - Comprometer un servidor FTP, pueden encontrar los demás retos aqui.

http://labs.gf0s.com/

 

 

Objetivo: 

 

- Intentar obtener el diseño del prototipo del dron.
- Dejar una evidencia (subir un archivo .txt)

Reglas:

 

- Esta prohibido todo ataque DoS / DDoS. En caso de identificar este comportamiento, el servidor será dado de baja.
- Cuando logres acceder al sistema, deberás dejar una evidencia. Dicha evidencia deberá ser exclusivamente un archivo .txt con el nick del usuario.
- El contenido del archivo puede ser lo que tú quieras. Recomiendan poner un ascii art.
- El servidor estará activo durante 1 semana. Por favor, no publicar durante este tiempo la manera en la que accediste. ( El reto es del 2015, así que ya paso tiempo).

Recolectando información

La información que nos brindan es: 

-Nombre del administrador: Alejandro Quero 
-Facebook del administrador: https://www.facebook.com/profile.php?id=100010301916909

Revisando el perfil del administrador, logre encontrar la siguiente información:

- Fecha de nacimiento del administrador: 11/08/1980
- Falta limpiar los metadatos a sus archivos
- El servidor ftp al que se conecta: 52.10.103.130
- El usuario que utiliza para acceder al servidor ftp: aquero
- Otro posible usuario: Pedro
- 2 archivos .pdf 'Diagrama de red WAN'  y 'Diagrama de red LAN' (enlace aqui)


Ademas información muy importante sobre las contraseñas:

- Para contraseñas que se utilizan para acceder vía red ( telnet, ftp o red de windows) , se utilizan contraseñas de solo dígitos y son solamente de 7 dígitos.
- Para contraseñas locales ( como documentos .pdf .doc o .zip ), se utilizan contraseñas con unicamente letras minúsculas y números, ademas deberán ser de 6 dígitos.

Accediendo al servidor ftp

 

Según la información que hemos obtenido, ya tenemos el nombre del usuario, que es aquero, luego probé algunas claves utilizadas frecuentemente y al no dar resultado, pues cree un diccionario para luego acceder con fuerza bruta.

Generando diccionario:

La opción menos viable pero que resultaría era generar un diccionario un diccionario con todas las posibles opciones que podía haber, para ello utilice la herramienta Crunch, que tiene el siguiente formato:

• $  crunch <min> <max> <texto> -o <archivo_de_salida>Donde:
  min: mínimo de caracteres
  max: máximo de caracteres
  texto: contiene los caracteres posibles
  archivo_de_salida: nombre del archivo de salida
  

Ahora ejecutamos el siguiente comando:

• $  crunch 7 7 0123456789 -o pwd.txt

Pero esto me iba a demorar mucho, así que antes de ir por todo a lo bruto, decidí hacer un diccionario algo mas especial, ya que tenemos su fecha de nacimiento, pues utilicemos eso:

•   $  crunch 7 7 1980 -o pwd.txt

*Nota: ponemos minimo(7) y maximo(7) por la informacion que obtuvimos previamente.
*Nota 2: nuestro texto es 1980, pues de la cadena 11/08/1980, sin repetir digitos es 1,0,8,9.

 

 Utilizando fuerza bruta para obtener la contraseña:

Ahora para acceder al servidor ftp, utilizaremos la herramienta Hydra:

• $  hydra -l aquero -P pwd.txt ftp://52.10.103.130Donde los siguientes parametros son para:
  -l: usuario para acceder al servidor ftp
  -P: archivo que contiene el diccionario

*Nota: Con este diccionario que creamos anteriormente, demore menos tiempo en encontrar la clave.

Después de unos minutos, he logrado conseguir la clave con el diccionario anteriormente generado. La clave es: 0019808

Entonces ahora ya podemos acceder al servidor ftp:

Usuario: aquero
Contraseña: 0019808

Conectándonos al servidor ftp:

Ahora para conectarnos al servidor ftp, utilizamos lo siguiente:

•  $  ftp 52.10.103.130

Donde luego nos pedirá el usuario, luego la contraseña:

Uno de los objetivos es subir una evidencia, en mi caso es un archivo .txt (paoloprogrammer.txt). Ejecutamos lo siguiente ahí mismo:

•  ftp> send paoloprogrammer.txt paoloprogrammer.txt  

Si todo ha salido correcto, visualizamos nuestro archivo subido y los de otros que ya han dejado su evidencia tambien:

•  ftp>  ls -a

En donde podemos visualizar nuestro archivo subido (paoloprogrammer.txt) y ademas un directo llamado privado. Para la siguiente parte accederemos desde la web.

Obteniendo el diseño del prototipo del dron

Bueno aun nos falta encontrar el diseño del drone, así que accediendo desde web podemos ver también la carpeta privado y en donde encontramos un archivo .zip (PrototipoPrivado6.zip) .

Una vez descargado el archivo, vemos que contiene una imagen, pero esta protegido por contraseña. Para esto utilicé una herramienta para obtener la clave, pues de la información obtenida anteriormente nos dice que los archivos .pdf .doc o .zip sus claves son caracteres y números, ademas tiene una longitud de 6 dígitos, veamos.

Obteniendo clave para el archivo .zip :

Utilice la herramienta fcrackzip, la cual tambien esta en Kali, ejecutamos lo siguiente:

•  $  fcrackzip -b -c a1 -l 6-6 -v -u PrototipoPrivado6.zip
  
  Donde:
  -b: utiliza el algoritmo para fuerza bruta
  -c: indicamos caracteres alfanuméricos (a1)
  -l: longitud mínima - longitud máxima (6-6)
  
  

Después de unos minutos, ha encontrado la clave:

Y pues ahora solo nos queda, descomprimir y obtener la imagen del prototipo:

Y listo, hemos completado el reto, es un reto ya de mas de 2 años, pero fue entretenido, la imagen obtenida es la siguiente:

Bueno eso ha sido todo, si desean ver el archivo .txt que deje como muestra, pueden verlo aquí:
http://labs.gf0s.com/website/paoloprogrammer.txt

Enlaces:

http://labs.gf0s.com/

http://labs.gf0s.com/R1cde3/r1-index.html

En Instagram tu foto de perfil tambien se muestra y a su tamaño real

Cuando uno tiene tiempo libre, aveces encuentra estas cosas, lo cual no quiere decir que otras personas ya lo sepan.  Hace un tiempo atrás, mientras visualizaba el contenido de las paginas html, me di cuenta de algo que tiene que ver con las fotos que tenemos en Instagram, esto incluye la de perfil.

Instagram te permite modificar los "parámetros" que se envía a través de la URL que contiene la imagen, en este caso de tu perfil. ¿Como? pues muy fácil, solo ingresas a la foto del perfil que deseas ver, abres en una pestaña, modificas el contenido que esta en /s150x150/ de la URL por un tamaño mas grande, de preferencia /s1080x1080/ y observa como la imagen se muestra en general en su tamaño real o máximo.

Bueno para visualizar la foto,  el ejemplo que les mostraré sera la foto de perfil de la cuenta del mismo Instagram.

1. Ingresar al perfil del usuario en Instagram:

-En este caso, yo he abierto la cuenta de Instagram:

2. Ingresar a la foto de perfil:

-Podemos arrastrar la imagen como en la flecha superior o hacer click derecho sobre la imagen y seleccionar "Abrir imagen en una pestaña nueva" :

3. Ubicarse en esta parte de la url que nos aparece:

-En esta parte es donde cambiaremos los valores, por defecto la imagen que nos muestran es del tamaño 150x150 px, en donde se le antepone un s ( asumo que quizás sea por size):

4. Cambiamos el tamaño de la imagen:

-Jugando con los valores, me di cuenta que no muestra cualquiera, por lo general es 1080x1080, 720x720, etc. Entonces para este caso hemos cambiado de /s150x150/ a /s1080x1080/ :

-Como notaras el tamaño de la imagen se ve mas grande de lo que era antes, para algunos casos no se expande mucho, yo asumo que es por la calidad o la foto real subida por el usuario.


Bueno, existe algunas otras cosas que puedes cambiar en la url, pero a mi parecer solo cambia un poco la tonalidad de la imagen. Después de esto desarrolle un analizador de codigo html en Java en donde el programa obtiene la foto de perfil en los diferente tamaños que descubrí que me permitía cambiar. Les dejo el programa aqui.

Aplicación

Una aplicacion simple, en la cual puedes obtener la imagen de 2 formas:

-Ingresando el nombre del usuario ( en la imagen es "miusuario").
-Ingresando la direccion url del usuario ( en la imagen es "https://www.instagram.com/miusuario").

*Nota: La opción de guardar por defecto es en el escritorio C:/Users/%username%/Desktop

Enlaces:

https://github.com/phaoliop/InstaPerfil

Una debilidad del cifrado RC4 - Reutilizacion del KeyStream

RC4 es un cifrado de flujo. Los cifrados de flujo funcionan expandiendo una clave secreta en una clave larga de bits pseudo-aleatorios (KeyStream).  Una debilidad bien conocida de los algoritmos de cifrado de flujo es que cifrando dos mensajes (P1, P2) con la misma clave (K) y vector S[] se puede revelar información sobre ambos mensajes, en esta ocasión esto es lo que vamos a realizar.


Si          C1 = P1 (+) RC4(S, K)
y           C2 = P2 (+) RC4(S, K)

entonces:

     C1 (+) C2 = (P1 (+) RC4(S, K)) (+) (P2 (+) RC4(S, K)) = P1 (+) P2


Es decir, si aplicamos un XOR a los dos texto cifrados (C1 y C2) el keystream se cancela, y el resultado que obtenemos de eso es el XOR de los textos iniciales (P1 XOR P2).

Si disponemos de uno de los textos iniciales (P1) o (P2), esto nos permitiria obtener el otro texto inicial (P1) o (P2), con tan solo aplicar un XOR entre el texto inicial que tenemos (P) y el resultado de aplicar XOR entre los dos textos cifrados (C1 XOR C2).

RC4

Como anteriormente vimos, en este caso utilizaremos de nuevo el programa anterior RC4.c para obtener 2 textos cifrados que nosotros mismos ingresemos y la misma clave de cifrado para ambos. Debo agregar que para facilidad del ejemplo ingresemos 2 textos del mismo tamaño:

*Nota: Los textos ingresados del primer parámetro son del mismo tamaño y las claves son las mismas.

Implementación

Para realizar la implementación, como casi siempre utilizando el lenguaje de programación C. El programa anteriormente implementado del cifrado RC4 lo he pasado como libreria y he agregado un archivo "Make" para la compilación de los archivos del programa.

*Nota: Al ejecutar make en la ubicacion donde se encuentra nuestro archivo make, compilara lo indicado en el archivo, generala los objetos y luego el ejecutable.

Continuando, ejecutamos el ejecutable que tiene 4 parametros (./attrc4 texto1 clave1 texto2 clave2) , para nuestro ejemplo las cadenas tienen que ser de la misma longitud y las claves las mismas para ambos:

*Nota: El programa attrc4 cifra los textos 1 y 2 con las claves 1 y 2 ingresadas por parametro. Luego a partir del texto 1 ingresado y al aplicar XOR entre los textos cifrados, obtiene el segundo texto ingresado (texto 2).

Como podemos visualizar, el programa cifra el primer parámetro (P1) con la clave ingresada en el segundo parámetro y nos muestra en pantalla el texto cifrado 1 (C1), luego cifra el tercer parametro (P2) con la clave ingresada en el cuarto parámetro y nos muestra en pantalla el texto cifrado 2 (C2).

A partir de aplicar el XOR entre C1 y C2, obtenemos el texto 2 (P2) al de nuevo aplicar XOR entre el resultado de (C1 XOR C2) y el texto 1 (P1).

Código

En la parte del código, es lo ya explicado anteriormente y bueno, adicional mente existe una función para obtener el máximo de 2 números, que utilicé para obtener el tamaño de la cadena de mayor caracteres, en caso de que ingreses cadenas iniciales de diferente longitud, veras que retorna una cadena de N caracteres, donde N es el máximo(longitud(P1), longitud(P2)), pero solo los caracteres correctos serán el mínimo(longitud(P1), longitud(P2)) los caracteres restantes corresponden a la parte sin descifrar.
Pueden ver el codigo fuente aqui.

El código de la función principal:

/**
    Autor: PaoloRamirez
    Tema: Debilidad cifrado RC4 - Reutilizacion del KeyStream
    Link: https://www.facebook.com/PaoloProgrammer/
**/

#include <stdio.h>
#include <string.h>
#include <stdlib.h> 
#include "rc4.h"

int maximo(int a, int b)
{
    if (a>b)
    {
        return a;
    }
    else
    {
        return b;
    }
}

int main(int argc, char **argv) 
{
    int i=1;
    int indice=0; //Indica el texto que utilizamos (texto 1, texto2)

    int len;
    len=maximo(strlen(argv[1]), strlen(argv[3])); //Tamaño maximo de los 2 textos del parametro
    unsigned char text_cifrado[2][len+1];
    memset(text_cifrado[0],0,sizeof(text_cifrado[0]));
    memset(text_cifrado[1],0,sizeof(text_cifrado[1]));

    for (i = 1; i < 5; i+=2)
    {

        int len_texto,len_clave;
        len_texto=strlen(argv[i]);
        len_clave=strlen(argv[i+1]);

        /**
            Texto inicial
            Clave de cifrado
        **/
        //Tamaño de cadena = len+fincadena \0
        char texto[len_texto+1];
        char clave[len_clave+1];

        //Format
        memset(texto,0,sizeof(texto));
        memset(clave,0,sizeof(clave));

        //Copiar a variables
        strcpy(texto,argv[i]);
        strcpy(clave,argv[i+1]);
     
        
        int x;
        rc4_generar_vector(clave, strlen(clave));
        printf("Texto cifrado(%i):\n",indice+1);
        for (x = 0; x < strlen(texto); x++)
        {
            //Cifrado por flujo
            text_cifrado[indice][x] = texto[x] ^ rc4_salida();
            printf("%02X", text_cifrado[indice][x]);
        }

        indice++;
        printf("\n\n");
    }

    /**
        Suponiendo que sabemos el texto 1
        Y tenemos el texto cifrado de 1 (C1) y el texto cifrado de 2 (C2)
        Obtendremos el texto 2
    **/
    int x;

    /*Texto 1*/
    int len_texto_1;
    len_texto_1 = strlen(argv[1]);
    char texto_1[len_texto_1+1];
    
    //Format
    memset(texto_1,0,sizeof(texto_1));
    
    //Agregando contenido del texto 1 a nuestra cadena
    strcpy(texto_1, argv[1]);

    printf("Texto 1:\n%s\n\n",texto_1);

    /**
        1. Obtener el resultado de aplicar XOR entre textos cifrados-> C1 XOR C2
    **/

    /*Resultado del XOR entre C1 y C2*/
    unsigned char c1_xor_c2[len+1];
    memset(c1_xor_c2, 0, sizeof(c1_xor_c2));

    
    printf("XOR entre textos cifrados:\n");
    for (x = 0; x < len; x++)
    {
        c1_xor_c2[x] = text_cifrado[0][x] ^ text_cifrado[1][x]; //Obteniendo C1 XOR C2
        printf("%02X", c1_xor_c2[x]);
    }
    printf("\n\n");

    
    /**
        2. Obtener el texto 2 al aplicar XOR entre texto 1 XOR c1_xor_c2
    **/

    /*Texto 2*/
    int len_texto_2;
    len_texto_2 = len;
    char texto_2[len_texto_2+1];
    //Format
    memset(texto_2,0,sizeof(texto_2));

    printf("Texto 2 obtenido:\n");
    for (x = 0; x < len; x++)
    {
        texto_2[x] = c1_xor_c2[x] ^ texto_1[x]; //Obteniendo texto 2
        printf("%c", texto_2[x]);
    }
    printf("\n");    

}

Enlaces

https://github.com/phaoliop/Programming_C-Cplus/tree/master/C/Cifrado/RC4-KeyStream

https://github.com/phaoliop/Programming_C-Cplus/tree/master/C/Cifrado/RC4-KeyStream

Referencias

http://wiki.elhacker.net/seguridad-wireless/introduccion/vulnerabilidades-del-cifrado-wep

https://paoloprogrammer.blogspot.pe/2017/09/cifrado-rc4.html

https://paoloprogrammer.blogspot.pe/2017/09/cifrado-xor.html