martes, 20 de noviembre de 2018

Criptografía (CXII): Solución Reto Atenea "Durin's Gates" (II)

Ésta es la segunda parte de este post. En estas entradas voy compartiendo la solución al quinto reto de "Criptografía y Esteganografía" de la plataforma ATENEA del CCN-CERT con desafíos de seguridad.

En esta segunda entrega adelantaré en la solución del reto, pero todavía quedará una tercera entrada en la que desvelaré su solución.

En el citado primer post me quedé en la obtención de un archivo de texto (SgaSizcn.txt), el siguiente:
Y preguntaba: ¿Qué puede significar ésto?. ¿Cómo continuamos para resolver este reto?. Pues bien, el contenido de este archivo de texto parece ser código base64, por lo que podemos utilizar openssl para decodificarlo, mediante el siguiente comando:

openssl base64 -d -in SgaSizcn.txt -out SgaSizcn_decoded.txt

Abrimo el archivo así obtenido (SgaSizcn_decoded.txt) con un editor hexadecimal y vemos lo siguiente:
Pues otra vez creo que son pertinentes las preguntas que hacía al final del post anterior: ¿Qué puede significar ésto?, ¿Cómo continuamos para resolver este reto?.

Se admiten comentarios, sugerencias, soluciones... ;)

lunes, 19 de noviembre de 2018

Criptografía (CXI): Solución Reto Atenea "Durin's Gates" (I)

En este post la primera entrada correspondiente a la solución al quinto reto de "Criptografía y Esteganografía" de la plataforma ATENEA del CCN-CERT con desafíos de seguridad.

Con esta primera entrada pretendo aportar pistas para que participen en su resolución aquellos lectores de este humilde blog que estén interesados en este tipo de retos, pero sin facilitarles la solución completa al mismo.

En concreto, este quinto reto tiene el título de "Durin´s Gates" y tras su resolución se obtienen 300 puntos (Dificultad: ☆☆).

Su enunciado dice lo siguiente:


Informaciones fidedignas han revelado que cierto grupo de atacantes utilizan técnicas de esteganografía y cifrado junto con determinados servicios online para comunicarse entre ellos y compartir información confidencial. Recientemente se ha podido interceptar una de las imágenes empleadas para compartir este tipo de mensajes. Se sospecha que la imagen se ha enviado para remitir una clave compartida con la que es posible acceder a uno de los servicios en la nube utilizados por los atacantes.

Tu objetivo será investigar el fichero adjunto .jpg y averiguar si está relacionado con una clave o mensaje de estas características.


Solución: la imagen asociada al reto es la siguiente.
La Wikipedia nos cuenta que, en la novela "El Señor de los Anillos"las Puertas de Durin eran la entrada occidental al reino de Khazad-Dûm (la Mina del Enano) y que fueron construidas en colaboración por Elfos y Enanos. Desde el exterior, ninguna fuerza enana, élfica o humana podía mover las puertas, excepto la contraseña inscrita en ellas; entonces se abrían solas, hacia los lados, hasta tocar la pared de roca.

Investigando un poco más en Internet encontré que la primera línea de la inscripción decía: "Puertas de Durin, Señor de Moria. Di amigo, y entra", y que la contraseña era "Amigo" en élfico, es decir, "Mellon". Cuando intentaba resolver este reto no tenía ni idea de si esto podía ser útil para solucionarlo, pero me había entretenido buscando la información :).

Vamos a ver qué podemos hacer para resolver el reto. En primer lugar, descargamos la imagen asociada al mismo, la abrimos con el software ExifToolGUI y analizamos los metadatos:
Salvo en la etiqueta "Artist" no veo nada que me llame la atención.

Tras realizar varias pruebas con diverso software de estegoanálisis sin obtener ningún resultado, pruebo con steghide, con el siguiente comando:

steghide extract -sf doors_of_durin-f686f3e1aa18d5e3f4261bea89a24c17.jpg

y nos pide una contraseña. Tras introducir como password "Mellon" obtenemos el archivo url.txt.
Accedemos con el navegador a la dirección indicada y nos encontramos con el siguiente archivo (SgaSizcn.txt):
¿Qué puede significar ésto?, ¿Cómo continuamos para resolver este reto?.

Se admiten comentarios, sugerencias, soluciones... ;)

viernes, 2 de noviembre de 2018

Programación (XI): Solución Reto 2

El  enunciado del reto de programación que puse en este post era el siguiente:

"La policía vigila de cerca a los miembros de una secta satánica, ya que sospecha que están involucrados en la comisión de diversos delitos, y ha interceptado las comunicaciones entre sus líderes. Hasta el momento sabe cuándo se Reunirán la próxima vez, pero no ha podido averiGuar dónde. Entre los ficheros interceptados se encuentra el fichero asociado como recurso a este resto y en el que se cree que puede esconderse algún tipo de mensaje; incluso quizá el lugar en el que se mantendrá dicha reunión. ¿Puedes oBtener el mensaje oculto en la imagen y ayudar a la policía a su detención?".

1.- En la primera pista que puse para resolver este reto decía que no es difícil darse cuenta de que dentro del fichero de imagen asociado al reto (Reto_2.pnghay otros dos archivos (Lugar cita.zip y password.txt), ya que para ello basta abrir ese fichero con un software de compresión de archivos o con un editor hexadecimal.
Lógicamente, lo más probable es que la solución a este reto se encuentre en el archivo comprimido Lugar cita.txt que contiene el fichero Lugar cita.zippero al intentar abrirlo o descomprimirlo nos pide una contraseña que desconocemos.

2.- Por tanto, centramos ahora nuestra atención en el otro archivo, password.txt, que podría contener la contraseña que necesitamos.

También decía en la primera pista que puse para resolver este reto que las letras en mayúsculas del enunciado pueden dar una pista importante para entender el contenido de este segundo archivo. A la vista del contenido del archivo password.txt, las letras 'R', 'G' y 'B' pueden hacer referencia a los canales 'Red' (Rojo), 'Green' (Verde) y 'Blue' (Azul) de una imagen en la que los pixeles de la misma contendrían valores en un rango de entre 0 y 255 para la intensidad correspondiente a cada uno de dichos canales.

Si esto es así podemos intentar construir una imagen a partir de los valores que contiene el archivo password.txt, una lista plana de n elementos; donde n/3 sería el número total de pixeles de la imagen y cada uno de los elementos se correspondería con un elemento de una tupla de tres elementos para los canales 'RGB' (cuatro elementos para 'RGBA', caso de que la imagen cuente con canal alfa).

Para ello utilizo el siguiente script de python:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from PIL import Image

def factorizacion_2(n):
# Descomponer un numero en dos factores no triviales
    factores=[]
    i=2
    while i <= int(n**(1/2)):
        if (n%i==0):
           factores.append(i)
           factores.append(int(n/i))
        i+=1
    return factores

# Abrir y leer fichero
fichero=open('password.txt','r')
valores=fichero.read()

# Contar numero de pixels
numero_pixels=int((valores.count(',')+1)/3)
print('Numero de pixels......................................',numero_pixels)

valores=valores.split(",")

factores=factorizacion_2(numero_pixels)
print('Los pares de posibles valores para alto y ancho son...',factores)
x=0
y=x+1
#Crear imágenes considerando los posibles valores para alto y ancho de la imagen y a partir de los valores de los pixels
imagen_ok='N'

while x < len(factores) and (imagen_ok=='N' or imagen_ok=='n'):
    print('*** Probamos con:*************************************')
    print('Ancho imagen..........................................',factores[y])
    print('Alto imagen...........................................',factores[x])
    imagen=Image.new('RGB',(factores[y],factores[x]))
    pixels=imagen.load()
    k=0
    for i in range(factores[x]):
        for j in range(factores[y]):
            pixels[j,i]=(int(valores[k]),int(valores[k+1]),int(valores[k+2]))
            k+=3
    imagen.show()
    imagen_ok= str(input('La imagen es correcta (S/N)?.......................... '))
    if imagen_ok=='N' or imagen_ok=='n':
       if x%2==0:
          x+=1
          y-=1
       else:
          x+=1
          y+=3
    else:
       if imagen_ok=='S' or imagen_ok=='s':
          imagen.save('password.png','PNG')

# Cerrar fichero e imagen
fichero.close()
imagen.close()

Ejecuto este script:
Inicialmente vemos que la imagen tendría 328.635 pixeles, y el script empieza a probar todos los posibles valores para el ancho y alto de la imagen. Tras cada una de las pruebas que realiza nos muestra la imagen resultado y nos pregunta si es correcta.

Finalmente, para un ancho de 603 pixeles y un alto de 545 pixeles, el script nos muestra la siguiente imagen:
Con lo que muy probablemente "4k3l4rr3" sea la contraseña del archivo Lugar cita.zip. Por cierto, para quienes no sepan lo que significa "Akelarre" en euskera ("Aquelarre" en castellano) aquí les dejo este enlace de la Wikipedia.

Probamos a abrir el archivo Lugar cita.txt con la contraseña "4k3l4rr3", efectivamente es la password correcta, y nos encontramos con la siguiente cadena de caracteres:

"4qCg4qC14qCl4qCb4qCB4qCX4qCX4qCB4qCN4qCl4qCX4qCZ4qCK"

3.- ¿Qué significado puede tener esto?. Pues veamos que ocurre si utilizamos un decodificador de Base64 de los muchos que existen online:
Decía en la tercera pista que puse para ayudar a resolver este reto que "salta a la vista" de qué código se trata. Por tanto, yo diría que lo que obtenemos como salida es código Braille :) y, aunque existen diversas herramientas online para ello, vamos a decodificarlo manualmente, de la siguiente manera:
Con lo que ya tendríamos la solución a este reto. El lugar de la reunión es: "Zugarramurdi"; un precioso pueblo navarro y con una cierta relación con el tema escogido para este reto, pero eso ya lo dejo para que aquellos que no lo conozcan y estén interesados lo investiguen por Internet.

lunes, 29 de octubre de 2018

Programación (X): Reto 2

Continúo con la serie de posts dedicada a retos de programación. En esta ocasión se trata de un reto de dificultad media en el que también se ven involucradas la codificación y la esteganográfia.

Doy prevalencia a la programación sobre las otras categorías en la catalogación de este reto porque ésta puede ayudar bastante en su resolución.

Como siempre, se admiten soluciones en forma de comentarios a esta entrada. Pasado un tiempo iré proporcionando pistas para su resolución, un máximo de tres, y posteriormente actualizaré este post con la solución.

Reto 2: "Reunión secreta".

La policía vigila de cerca a los miembros de una secta satánica, ya que sospecha que están involucrados en la comisión de diversos delitos, y ha interceptado las comunicaciones entre sus líderes. Hasta el momento sabe cuándo se Reunirán la próxima vez, pero no ha podido averiGuar dónde. Entre los ficheros interceptados se encuentra el fichero asociado como recurso a este resto y en el que se cree que puede esconderse algún tipo de mensaje; incluso quizá el lugar en el que se mantendrá dicha reunión. ¿Puedes oBtener el mensaje oculto en la imagen y ayudar a la policía a su detención?. 

Dificultad:
Tipo:          Codificación, Esteganografía y Programación.

Recursos:   Reto_2.png.

******** 30/10/2018
Pista 1:    No es difícil darse cuenta de que dentro del fichero de imagen asociado al reto hay otros dos archivos (Lugar cita.zip y password.txt), ya que para ello basta abrir ese fichero con un software de compresión de archivos o con un editor hexadecimal. Hasta aquí todo muy fácil.

Tampoco hay que ser un genio :) para sospechar que el lugar de la reunión se indica en el archivo comprimido Lugar cita.txt que se encuentra en el fichero Lugar cita.zip, pero si intentamos extraerlo nos pide una contraseña que desconocemos.

Visto lo visto, parece evidente que el otro archivo, password.txt, podría contener la contraseña que necesitamos, pero: ¿entiendes el contenido?. Para ello, las letras en mayúsculas del enunciado del reto pueden darte una pista importante.

******** 01/11/2018
Pista 2:    A la vista del contenido del archivo password.txt, las letras 'R', 'G' y 'B' pueden hacer referencia a los canales 'Red' (Rojo), 'Green' (Verde) y 'Blue' (Azul) de una imagen en la que los pixeles de la misma contendrían valores en un rango de entre 0 y 255 para la intensidad correspondiente a cada uno de dichos canales.

Si esto es así podemos intentar construir una imagen a partir de los valores que contiene el archivo password.txt, una lista plana de n elementos; donde n/3 sería el número total de pixeles de la imagen y cada uno de los elementos se correspondería con un elemento de una tupla de tres elementos para los canales 'RGB' (cuatro elementos para 'RGBA', caso de que la imagen cuente con canal alfa).

******** 02/11/2018

Pista 3:    Si has construido ya la imagen a partir de los valores 'RGB' de los pixeles que contiene el archivo password.txt, ya sabes la contraseña para abrir o descomprimir el archivo Lugar cita.txt contenido en Lugar cita.zip.

Pero todavía hay que dar un pequeño paso más: decodificar dos códigos. En el caso del segundo de ellos "salta a la vista" de qué código se trata, pero en el primero...

******** 02/11/2018
Solución.

******** PRÓXIMO RETO
Reto 3 (Programación): Por publicar.

lunes, 22 de octubre de 2018

Codificación (V): Solución Reto RingZer0 Team "Ask your grandpa again!"

En este post la solución a otro de los retos de codificación de la plataforma RingZer0 Team.

Este reto tiene el título "Ask your grandpa again!" y mi valoración sobre su dificultad es:  .

Se trata de un reto en el que al igual que en éste se ven involucradas tarjetas perforadas, pero en este caso su resolución presenta una mayor dificultad. 


Nos dan seis ficheros jpg (card, grandpa, my, programming, punch y yolo) que contienen sendas imágenes de tarjetas perforadas.

Las imágenes de las tarjetas perforadas son las siguientes (en el orden indicado en el párrafo anterior):
Para leer las seis tarjetas adapto el script de python que utilicé en este post, de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def leer_columna_1(perforacion_1):
    """
    Devuelve la lectura que corresponde a una columna con una perforacion.
    """
    columna=''
    columna=[0,1,2,3,4,5,6,7,8,9,'','-','&']
    if columna=='':
       print('Error lectura columna')
    else:
       return columna[perforacion_1]

def leer_columna_2(perforacion_1,perforacion_2):
    """
    Devuelve la lectura que corresponde a una columna con dos perforaciones.
    """
    columna=''
    if perforacion_1==12:
       columna=['','A','B','C','D','E','F','G','H','I','','','']
    elif perforacion_1==11:
       columna=['','J','K','L','M','N','O','P','Q','R','','','']
    elif perforacion_1==0:
       columna=['','/','S','T','U','V','W','X','Y','Z','','','']
    elif perforacion_1==2:
       columna=['','','','','','','','',':','','','','']
    elif perforacion_1==3:
       columna=['','','','','','','','','#','','','','']
    elif perforacion_1==4:
       columna=['','','','','','','','','@','','','','']
    elif perforacion_1==5:
       columna=['','','','','','','','','','','','','']
    elif perforacion_1==6:
       columna=['','','','','','','','','=','','','','']
    elif perforacion_1==7:
       columna=['','','','','','','','','"','','','','']
    else:
       print('Error lectura columna')
    if columna=='':
       print('Error lectura columna')
    else:
       return columna[perforacion_2]

def leer_columna_3(perforacion_1,perforacion_2,perforacion_3):
    """
    Devuelve la lectura que corresponde a una columna con tres perforaciones.
    """
    columna=''
    if perforacion_1==12:
       if perforacion_2==3:
          columna=['','','','','','','','','.','','','','']
       elif perforacion_2==4:
          columna=['','','','','','','','','<','','','','']
       elif perforacion_2==5:
          columna=['','','','','','','','','(','','','','']
       elif perforacion_2==6:
          columna=['','','','','','','','','+','','','','']
       elif perforacion_2==7:
          columna=['','','','','','','','','|','','','','']
       elif perforacion_2==8:
          columna=['','','','','','','','','','','','','']
       else:
          print('Error lectura columna')
    elif perforacion_1==11:
       if perforacion_2==2:
          columna=['','','','','','','','','!','','','','']
       elif perforacion_2==3:
          columna=['','','','','','','','','$','','','','']
       elif perforacion_2==4:
          columna=['','','','','','','','','*','','','','']
       elif perforacion_2==5:
          columna=['','','','','','','','',')','','','','']
       elif perforacion_2==6:
          columna=['','','','','','','','',';','','','','']
       elif perforacion_2==7:
          columna=['','','','','','','','','','','','','']
       else:
          print('Error lectura columna')
    elif perforacion_1==0:
       if perforacion_2==3:
          columna=['','','','','','','','',',','','','','']
       elif perforacion_2==4:
          columna=['','','','','','','','','%','','','','']
       elif perforacion_2==5:
          columna=['','','','','','','','','_','','','','']
       elif perforacion_2==6:
          columna=['','','','','','','','','>','','','','']
       elif perforacion_2==7:
          columna=['','','','','','','','','?','','','','']
       else:
          print('Error lectura columna')
    else:
       print('Error lectura columna')
    if columna=='':
       print('Error lectura columna')
    else:
       return columna[perforacion_3]

# Tarjetas a leer: para cada columna de cada tarjeta incluir, separados por comas, numero de perforaciones y posiciones de las perforaciones.

tarjetas=[[0,1,1,1,3,1,3,1,7,0,2,12,6,2,11,6,2,11,9,2,11,4,2,12,1,2,0,3,3,12,5,8,1,1,1,1,2,12,8,2,12,6,2,11,3,2,12,1,2,12,7,1,11,2,12,4,2,12,6,2,12,5,2,12,2,1,0,2,12,4,3,0,3,8,2,12,9,1,4,3,0,3,8,1,1,2,12,8,1,11,3,0,3,8,2,12,9,1,3,3,0,3,8,1,1,1,0,2,12,8,2,12,6,2,12,4,2,12,2,2,12,5,2,12,3,2,12,4,2,12,6,1,3,1,9,2,12,4,3,0,3,8,2,12,9,1,3,3,11,5,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3,1,3,1,7,1,0,1,0,1,5,1,0],
[0,0,0,0,0,0,2,12,5,2,11,5,2,12,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3,1,3,1,7,1,0,1,0,1,6,1,0],
[0,0,0,0,0,0,2,0,6,2,11,9,2,12,9,2,0,3,2,12,5,3,12,5,8,1,6,3,0,3,8,1,1,1,3,1,3,1,7,3,11,5,8,2,11,1,3,12,6,8,1,2,1,9,3,0,3,8,3,12,5,8,2,11,1,2,0,1,1,4,3,11,5,8,3,12,6,8,1,2,1,0,3,0,3,8,2,12,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3,1,3,1,7,1,0,1,0,1,4,1,0],
[0,0,0,0,0,0,2,11,7,2,11,9,2,11,6,2,12,7,2,11,9,2,12,1,2,11,4,0,2,0,6,2,12,6,2,11,3,2,12,1,2,12,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3,1,3,1,7,1,0,1,0,1,1,1,0],
[0,0,0,0,0,0,2,12,9,2,6,8,1,9,1,3,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3,1,3,1,7,1,0,1,0,1,2,1,0],
[0,0,0,0,0,0,2,11,1,2,6,8,1,2,1,8,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3,1,3,1,7,1,0,1,0,1,3,1,0]]

i=0
j=0
while i < len(tarjetas):
      lectura_tarjeta=""
      k=0
      while k < len(tarjetas[j]):
            if tarjetas[j][k]==0:
               lectura_tarjeta=lectura_tarjeta+" "
               k+=1
            elif tarjetas[j][k]==1:
               lectura_tarjeta=lectura_tarjeta+str(leer_columna_1(tarjetas[j][k+1]))
               k+=2
            elif tarjetas[j][k]==2:
               lectura_tarjeta=lectura_tarjeta+str(leer_columna_2(tarjetas[j][k+1],tarjetas[j][k+2]))
               k+=3
            else:
               lectura_tarjeta=lectura_tarjeta+str(leer_columna_3(tarjetas[j][k+1],tarjetas[j][k+2],tarjetas[j][k+3]))
               k+=4
      print(lectura_tarjeta)
      j+=1
      i+=1

Ejecuto este script:
El resultado de la lectura de las tarjetas me resulta familiar. Yo diría que es un pequeño programa escrito en Fortran.

Los dos primeros lenguajes de programación que estudié, allá por 1983 (hace ya unos 35 años), fueron Cobol y Fortran. Empiezo a sospechar que el abuelo del título de este reto soy yo :(.

En el enlace referido a tarjetas perforadas que he puesto al inicio de este post se ve un ejemplo de una tarjeta perforada de un programa Fortran (fuente: Wikipedia):
Ordeno las sentencias y utilizo una herramienta online para ejecutar el código obtenido con el script de python y ver el resultado:
Y, por tanto, la solución a este reto es: FLAG-DFEB0D2829-720FDBECDF39D931.

Codificación (IV): Solución Reto RingZer0 Team "Ask your grandpa!" (II)

Decía en el post anterior que en un post siguiente iba a resolver el  reto de codificación de la plataforma RingZer0 Team que en él aparece utilizando un script de python.

Decía también que este reto tiene el título "Ask your grandpa!" y mi valoración sobre su dificultad es: ☆☆.

Recuerdo de qué se trataba el reto: sólo nos dan un archivo jpg que contiene una imagen de una tarjeta perforada.


En concreto, la tarjeta de este reto tiene 80 columnas (en la siguiente imagen se ha recortado para que se aprecien mejor las perforaciones) y es la siguiente:

Pues bien, para leer esta tarjeta utilizo el siguiente script de python (ver explicación dada en el post anterior):

#!/usr/bin/env python
# -*- coding: utf-8 -*-

def leer_columna_1(perforacion_1):
    """
    Devuelve la lectura que corresponde a una columna con una perforacion.
    """
    columna=''
    columna=[0,1,2,3,4,5,6,7,8,9,'','-','&']
    if columna=='':
       print('Error lectura columna')
    else:
       return columna[perforacion_1]

def leer_columna_2(perforacion_1,perforacion_2):
    """
    Devuelve la lectura que corresponde a una columna con dos perforaciones.
    """
    columna=''
    if perforacion_1==12:
       columna=['','A','B','C','D','E','F','G','H','I','','','']
    elif perforacion_1==11:
       columna=['','J','K','L','M','N','O','P','Q','R','','','']
    elif perforacion_1==0:
       columna=['','/','S','T','U','V','W','X','Y','Z','','','']
    elif perforacion_1==2:
       columna=['','','','','','','','',':','','','','']
    elif perforacion_1==3:
       columna=['','','','','','','','','#','','','','']
    elif perforacion_1==4:
       columna=['','','','','','','','','@','','','','']
    elif perforacion_1==5:
       columna=['','','','','','','','','','','','','']
    elif perforacion_1==6:
       columna=['','','','','','','','','=','','','','']
    elif perforacion_1==7:
       columna=['','','','','','','','','"','','','','']
    else:
       print('Error lectura columna')
    if columna=='':
       print('Error lectura columna')
    else:
       return columna[perforacion_2]

def leer_columna_3(perforacion_1,perforacion_2,perforacion_3):
    """
    Devuelve la lectura que corresponde a una columna con tres perforaciones.
    """
    columna=''
    if perforacion_1==12:
       if perforacion_2==3:
          columna=['','','','','','','','','.','','','','']
       elif perforacion_2==4:
          columna=['','','','','','','','','<','','','','']
       elif perforacion_2==5:
          columna=['','','','','','','','','(','','','','']
       elif perforacion_2==6:
          columna=['','','','','','','','','+','','','','']
       elif perforacion_2==7:
          columna=['','','','','','','','','|','','','','']
       elif perforacion_2==8:
          columna=['','','','','','','','','','','','','']
       else:
          print('Error lectura columna')
    elif perforacion_1==11:
       if perforacion_2==2:
          columna=['','','','','','','','','!','','','','']
       elif perforacion_2==3:
          columna=['','','','','','','','','$','','','','']
       elif perforacion_2==4:
          columna=['','','','','','','','','*','','','','']
       elif perforacion_2==5:
          columna=['','','','','','','','',')','','','','']
       elif perforacion_2==6:
          columna=['','','','','','','','',';','','','','']
       elif perforacion_2==7:
          columna=['','','','','','','','','','','','','']
       else:
          print('Error lectura columna')
    elif perforacion_1==0:
       if perforacion_2==3:
          columna=['','','','','','','','',',','','','','']
       elif perforacion_2==4:
          columna=['','','','','','','','','%','','','','']
       elif perforacion_2==5:
          columna=['','','','','','','','','_','','','','']
       elif perforacion_2==6:
          columna=['','','','','','','','','>','','','','']
       elif perforacion_2==7:
          columna=['','','','','','','','','?','','','','']
       else:
          print('Error lectura columna')
    else:
       print('Error lectura columna')
    if columna=='':
       print('Error lectura columna')
    else:
       return columna[perforacion_3]

# Tarjeta a leer: para cada columna de la tarjeta incluir, separados por comas, numero de perforaciones y posiciones de las perforaciones.

tarjeta=[2,12,6,2,11,3,2,12,1,2,12,7,1,11,2,12,4,2,12,2,1,11,2,12,9,2,11,5,2,12,4,2,12,5,2,0,7,2,2,8,1,3,1,8,1,0,1,1,3,0,3,8,2,0,5,2,12,1,2,11,3,2,2,8,2,12,6,2,11,3,2,12,1,2,12,7,1,11,2,12,2,1,4,1,9,1,3,1,8,1,0,1,1,2,12,3,2,12,4,2,12,2,1,11,1,8,1,3,1,1,2,12,1,2,12,2,2,12,4,2,12,4,2,12,6,2,12,1,1,6,1,2,1,8,2,12,1,2,12,3,1,3,1,1]

lectura_tarjeta=""

i=0
while i < len(tarjeta):
    if tarjeta[i]==0:
       lectura_tarjeta=lectura_tarjeta+" "
       i+=1
    elif tarjeta[i]==1:
       lectura_tarjeta=lectura_tarjeta+str(leer_columna_1(tarjeta[i+1]))
       i+=2
    elif tarjeta[i]==2:
       lectura_tarjeta=lectura_tarjeta+str(leer_columna_2(tarjeta[i+1],tarjeta[i+2]))
       i+=3
    else:
       lectura_tarjeta=lectura_tarjeta+str(leer_columna_3(tarjeta[i+1],tarjeta[i+2],tarjeta[i+3]))
       i+=4

print(lectura_tarjeta)

Ejecuto este script:

Y, como se observa en la figura anterior, la solución a este reto es: FLAG-B493801CDB-831ABDDFA628AC31.

sábado, 20 de octubre de 2018

Codificación (III): Solución Reto RingZer0 Team "Ask your grandpa!" (I)

En este post la solución a uno de los retos de codificación de la plataforma RingZer0 Team.

Este reto tiene el título "Ask your grandpa!" y mi valoración sobre su dificultad es: ☆☆.

En este reto sólo nos dan un archivo jpg que contiene una imagen de una tarjeta perforada.


En concreto, la tarjeta de este reto tiene 80 columnas (en las siguientes imágenes se ha recortado para que se aprecien mejor las perforaciones y su significado) y es la siguiente:

Antes de intentar leerla, conviene recordar que tal y como nos cuenta Wikipedia en el enlace anterior: "Las 10 posiciones inferiores representaban (de arriba a abajo) los dígitos del 0 al 9. Las dos posiciones superiores de una columna eran llamadas perforación de zona 12 (superior), y perforación de zona 11".

Una columna con dos perforaciones, una en la zona [12,11,0] + otra en la zona de dígitos [1-9], era una letra; una columna con una perforación en la zona de dígitos [0-9] era un dígito; una columna con otras perforaciones concretas diferentes a las indicadas era un carácter especial (por ejemplo: [2]+[8] = ":"; [0]+[3]+[8] = "," ; etc.).


Es decir, tal y como se puede ver en la siguiente figura, la  primera columna, con una perforación en la zona [12] + una perforación en el dígito [1], sería la letra "A"; la segunda columna, con una perforación en la zona [12] + una perforación en el dígito [2], sería la "B"; etc.
Solución: en primer lugar, a partir de la explicación dada anteriormente, soluciono este reto de forma manual, y en un post siguiente lo haré mediante un script de python.
Por tanto, la solución a este reto es: FLAG-B493801CDB-831ABDDFA628AC31.

domingo, 14 de octubre de 2018

Programación (IX): Solución Reto HackThis "Coding Level 2"

En este post la solución a otro de los retos de programación de la plataforma HackThis.

Este reto tiene el título "Coding Level 2" y mi valoración sobre su dificultad es: .

Su enunciado dice lo siguiente:


A string has been encoded using a very simple custom encryption method, explained here, decrypt the message. You have a 5 second time limit for each attempt.


nos dan una lista de palabras como la siguiente:
La explicación del método de cifrado es:
Soluciónutilizo el siguiente script de Python.

import requests

def Decipher(string_encoded):
    print("")
    print("Cadena cifrada..........................",string_encoded)
    print("Longitud cadena cifrada.................",len(string_encoded))
    i=0
    ascii_str=""
    string_decoded=""
    while i < len(string_encoded):
          if string_encoded[i]!=" ":
             ascii_char=126-(int(string_encoded[i]+string_encoded[i+1])-32)
             ascii_str=ascii_str+str(ascii_char)+","
             string_decoded=string_decoded+chr(ascii_char)
             i+=3
          else:
             ascii_str=ascii_str+" ,"
             string_decoded=string_decoded+" "
             i+=2
    print("Caracteres ASCII decimal................",ascii_str)
    print("Cadena descifrada.......................",string_decoded)
    return string_decoded

url="https://www.hackthis.co.uk/levels/coding/2"
login="https://www.hackthis.co.uk/?login"
payload={"username":"tu usuario","password":"tu contraseña"}

#Empezar una sesion
s=requests.Session()

#Login
s.post(login,data=payload)

#Obtener mensaje cifrado
response=s.get(url).text
cipher_message=response[response.find("< textarea>")+10:response.find("< /textarea")]

#Descifrar mensaje
answer=Decipher(cipher_message)

#Enviar la respuesta
payload={"answer":answer}
s.post(url, data=payload)
response=s.get(url).text
if ("Incomplete" in response):
     print("Incorrect answer")
else:
     print("Correct answer")

Ejecuto este script:

Y, como se observa en la figura anterior, la respuesta es correcta.

sábado, 13 de octubre de 2018

Programación (VIII): Solución Reto HackThis "Coding Level 1"

En este post la solución a uno de los retos de programación de la plataforma HackThis.

Este reto tiene el título "Coding Level 1" y mi valoración sobre su dificultad es: .

Su enunciado dice lo siguiente:


The words have been jumbled up, your task is to write some code to return them to alphabetical order. Then submit your answer in the same format, for example: ant, badger, cattle, zebra. You have 5 seconds to complete the mission.


nos dan una lista de palabras como la siguiente:
Soluciónutilizo el siguiente script de Python.

import requests

def sort(string):
    string=string.split(", ")
    return ", ".join(sorted(string))

url="https://www.hackthis.co.uk/levels/coding/1"
login="https://www.hackthis.co.uk/?login"
payload={"username":"tu usuario","password":"tu contraseña"}

#Empezar una sesion
s=requests.Session()

#Login
s.post(login,data=payload)

#Obtener palabras desordenadas
response=s.get(url).text
words=response[response.find("< textarea>")+10:response.find("< /textarea")]
print("Words:",words)

#Ordenar las palabras alfabeticamente
answer=sort(words)
print("Answer:",answer)

#Enviar la respuesta
payload={"answer":answer}
s.post(url,data=payload)
response=s.get(url).text
if ("Incomplete" in response):
   print("Incorrect answer")
else:
   print("Correct answer")

Ejecuto este script:
Y, como se observa en la figura anterior, la respuesta es correcta.

viernes, 12 de octubre de 2018

Programación (VII): Solución Reto WeChall "Can you read me"

En este post la solución a uno de los retos de programación de la plataforma WeChall.

Este reto tiene el título "Can you read me" y mi valoración sobre su dificultad es: .

Su enunciado dice lo siguiente:


A friend and me have a bet running, that you won't beat his OCR program in scanning text out of images.
His average scan time is 2.5 seconds, can you beat that?.


Y nos dan una imagen como la siguiente:
Soluciónutilizo el siguiente script de Python.

from PIL import Image
from io import BytesIO
from urllib.parse import quote as urlencode
from bs4 import BeautifulSoup
import pytesseract
import requests

s = requests.session()

url = 'https://www.wechall.net/'
image_url = url+'challenge/can_you_readme/gimme.php'
solution_url = url+'challenge/can_you_readme/index.php'

payload = {'username': 'tu usuario', 'password': 'tu contraseña'}

s.post(url,payload)
r2 = s.get(image_url)

#Obtener el texto
captcha = Image.open(BytesIO(r2.content))
captcha.save('read_me.png')
print('Resolviendo Captcha')
captcha_text = pytesseract.image_to_string(captcha)
print('Texto extraido',captcha_text)

#Enviar la solucion
r3 = s.get(solution_url + '?action=Answer&solution=' + urlencode(captcha_text)).text
r3 = BeautifulSoup(r3, 'html.parser')
if r3.select('.gwf_errors'):
   exit(r3.select('.gwf_errors li')[0].text)
print(r3.select('.gwf_messages li')[0].text)

Ejecuto este script:
Y, como se observa en la figura anterior, la respuesta es correcta.