Irish Flan

Yum, time for dessert.

Challenge contributed by CryptoHack

Challenge files:

• output.txt
• irish_flan.py

Se nos proporciona un script en Python que usa cuaterniones para ocultar una clave AES utilizada para cifrar la flag. La implementación de los cuaterniones se basa en clases de Python. Podemos suponer que la implementación es correcta (aunque hay un error en la potencia de un cuaternión, pero no es intencionado).

Análisis del código fuente

La parte relevante del script es:

class Dessert:
    def __init__(self):
        self.n = getPrime(1024) * getPrime(1024)
        self.R = Z(self.n)
        r = secrets.randbelow(self.n**8)
        self.χ = Q(*[self.R(secrets.randbelow(self.n)) for _ in "abcd"])
        self.α = Q(*[self.R(secrets.randbelow(self.n)) for _ in "abcd"])
        self.β = self.χ**-1 * self.α**-1 * self.χ
        self.γ = self.χ**r

    @property
    def pub(self):
        return (self.n,
                self.α,
                self.β,
                self.γ)

    def encrypt(self, m):
        k = Q(*[self.R(secrets.randbelow(self.n)) for _ in "abcd"])
        K = hashlib.sha256(str(k).encode()).digest()
        c = AES.new(K, AES.MODE_CBC, iv=b"\0" * 16).encrypt(pad(m, 16))
        s = secrets.randbelow(self.n**8)
        δ = self.γ**s
        ε = δ**-1 * self.α * δ
        κ = δ**-1 * self.β * δ
        μ = κ * k * κ
        return (c, μ, ε)


if __name__ == "__main__":
    flan = Dessert()
    print("Public key:", ",".join(map(str, flan.pub)))
    with open("flag.txt") as f:
        print("Encryption:", ",".join(
              map(str, flan.encrypt(f.read().strip().encode()))))

La clase Dessert define un módulo público (un producto de dos números primos desconocidos), un entero aleatorio , un cuaternión secreto (aleatorio) y tres cuaterniones públicos (aleatorio), , y . Además, , y satisfacen estas relaciones:

Para cifrar, el script toma un cuaternión aleatorio y lo usa para derivar una clave de AES. Entonces, ese valor de está oculto en las siguientes operaciones entre cuaterniones:

Solución

De los valores anteriores, se nos proporcionan y .

• Nuestro objetivo es encontrar , que solo aparece en . Entonces necesitamos hallar .
• Y para hallar , tenemos que tener , porque .
• Y probablemente podremos encontrar a partir de y , aunque no sabemos el exponente .

Podemos pensar que se puede encontrar fácilmente de , porque sabemos tanto como . Podemos expresar la relación como

Un enfoque es usar un cuaternión simbólico:

E intentar resolver para . En SageMath, el enfoque anterior puede dar errores (o simplemente devolver ).

Un enfoque alternativo es utilizar la forma matricial de los cuateriones (digamos que las letras griegas en minúsculas denotan cuaterniones y las letras griegas mayúsculas denotan formas matriciales), que es un procedimiento equivalente:

Y es una matriz simbólica de :

Ahora, la ecuación nos da condiciones que deben cumplir , , y . Como todas las condiciones son lineales, podemos expresarlas como:

Si intentamos resolver esto con SageMath, obtendremos la solución trivial . Sin embargo, hay más soluciones (sabemos que porque es invertible). Por lo tanto, debe haber condiciones linealmente dependientes en .

Por alguna razón, SageMath no permite calcular el rango de (que es menor que , seguro). Sabemos esto porque debe haber una solución no trivial. Como resultado, sabemos que esta solución está dentro . Este es un subespacio de vectores que se mapean al vector nulo cuando se multiplican por por la derecha.

Si usamos C.right_kernel_matrix() en SageMath, veremos que la base del contiene dos vectores (digamos y ), que implica que

para ciertos enteros y . De manera equivalente, es una combinación lineal de los vectores de , ya que los coeficientes de (como vector) pertenecen a .

En este punto, si establecemos cualquier valor en y en (excepto ), la relación se cumple.

Sin embargo, no se sostiene. Me di cuenta de esto al hacer algunas pruebas y comparar el valor que obtuve de y el esperado. Parece que tener dos grados de libertad para los coeficientes de ’s no es bueno.

En este punto, podemos usar la otra relación: . Aquí recordé del reto RSA 4.0 de SECCON Quals CTF 2023 que la potencia de un cuaternión tiene una cierta estructura (más información aquí). Entonces, dado un cuaternión , para calcular , Necesitamos algunos valores:

Y luego,

Así, .

Algo notable es que las coordenadas del cuaternión se escalan por un cierto número al elevarse a un exponente.

Usando el hecho de que y , podemos definir otra variable y usar tres ecuaciones (una para cada ). Como resultado, terminamos con otro conjunto de ecuaciones lineales en , , , que se puede expresar como:

Esta vez, , lo cual significa que hay un solo vector en la base del , llamémoslo . Por consiguiente, todos los valores que satisfacen las ecuaciones anteriores (y, por lo tanto, las condiciones) son proporcionales a .

Pero aún más, no nos importa el valor de , por lo que tenemos algunos valores , tales que

Y el real es para un cierto entero .

Pero es suficiente para resolver el reto, porque ahora es el esperado. Esto sucede porque solo tenemos un grado de libertad, así que

Finalmente, solo necesitamos hallar y habremos terminado.

Flag

Después de implementar todas las operaciones requeridas, terminamos encontrando la flag:

$ python3 solve.py
ECSC{3qu1v4l3nt_k3y_rec0very_988b09742b}

El script completo se puede encontrar aquí: solve.py.