![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "ASpQPzMUDUdp"
- },
- "outputs": [],
- "source": [
- "!pip install ipdb"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "colab": {
- "background_save": true
- },
- "id": "hnrdydOcDWLj"
- },
- "outputs": [],
- "source": [
- "# Importa ipdb\n",
- "import ipdb\n",
- "\n",
- "# Definir una función con código para depurar\n",
- "def some_function():\n",
- " a = 5\n",
- " b = 10\n",
- " result = a + b\n",
- "\n",
- " # Colocar un punto de interrupción usando ipdb\n",
- " ipdb.set_trace()\n",
- "\n",
- " c = result * 2\n",
- " return c\n",
- "\n",
- "# Llamar a la función que deseas depurar\n",
- "result = some_function()\n",
- "\n",
- "# Cuando llegues al punto de interrupción, puedes usar comandos como 'n' para avanzar a la siguiente línea, 'c' para continuar la ejecución, 'p variable' para imprimir el valor de una variable, etc.\n"
- ]
- }
- ],
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyMmfQ+77ZubyLMijc3J+Uaj",
- "include_colab_link": true
- },
- "kernelspec": {
- "display_name": "Python 3",
- "name": "python3"
- },
- "language_info": {
- "name": "python"
- }
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "nbformat": 4,
- "nbformat_minor": 0
-}
\ No newline at end of file
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!pip install ipdb"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Importa ipdb\n",
+ "import ipdb\n",
+ "\n",
+ "# Definir una función con código para depurar\n",
+ "def some_function():\n",
+ " a = 5\n",
+ " b = 10\n",
+ " result = a + b\n",
+ "\n",
+ " # Colocar un punto de interrupción usando ipdb\n",
+ " ipdb.set_trace()\n",
+ "\n",
+ " c = result * 2\n",
+ " return c\n",
+ "\n",
+ "# Llamar a la función que deseas depurar\n",
+ "result = some_function()\n",
+ "\n",
+ "# Cuando llegues al punto de interrupción, puedes usar comandos como 'n' para avanzar a la siguiente línea, 'c' para continuar la ejecución, 'p variable' para imprimir el valor de una variable, etc.\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git "a/EjemploMiner\303\255aPython.ipynb" "b/EjemploMiner\303\255aPython.ipynb"
index 5edaa3a..ed920c7 100644
--- "a/EjemploMiner\303\255aPython.ipynb"
+++ "b/EjemploMiner\303\255aPython.ipynb"
@@ -1,111 +1,93 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "gpuType": "T4",
- "authorship_tag": "ABX9TyP/h8RYin0S7z74YdHUIae1",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- },
- "accelerator": "GPU"
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
+ {
+ "cell_type": "code",
+ "source": [
+ "import hashlib\n",
+ "import time\n",
+ "import psutil\n",
+ "\n",
+ "# Simular un bloque de datos\n",
+ "bloque = \"Bloque de ejemplo\"\n",
+ "dificultad = 1 # Número de ceros iniciales en el hash\n",
+ "\n",
+ "def mineria(bloque, dificultad):\n",
+ " nonce = 0\n",
+ " intentos = 0\n",
+ " start_time = time.time() # Iniciar el temporizador\n",
+ "\n",
+ " memoria_inicial = psutil.virtual_memory().used\n",
+ " memoria_total = psutil.virtual_memory().total\n",
+ " memoria_max = memoria_inicial\n",
+ "\n",
+ " while True:\n",
+ " # Concatenar el bloque de datos con el nonce y obtener el hash\n",
+ " texto = bloque + str(nonce)\n",
+ " hash_resultado = hashlib.sha256(texto.encode()).hexdigest()\n",
+ "\n",
+ " # Contar intento y medir recursos\n",
+ " intentos += 1\n",
+ " memoria_actual = psutil.virtual_memory().used\n",
+ "\n",
+ " # Actualizar máximo si es necesario\n",
+ " memoria_max = max(memoria_max, memoria_actual)\n",
+ "\n",
+ " # Verificar si el hash cumple con la dificultad\n",
+ " if hash_resultado.startswith('0' * dificultad):\n",
+ " tiempo_total = time.time() - start_time # Calcular el tiempo total\n",
+ " return nonce, hash_resultado, tiempo_total, intentos, memoria_max, memoria_total\n",
+ "\n",
+ " nonce += 1\n",
+ "\n",
+ "# Llamar a la función de minería\n",
+ "nonce, hash_resultado, tiempo_total, intentos, memoria_max, memoria_total = mineria(bloque, dificultad)\n",
+ "\n",
+ "print(f\"Nonce encontrado: {nonce}\")\n",
+ "print(f\"Hash resultante: {hash_resultado}\")\n",
+ "print(f\"Tiempo total utilizado: {tiempo_total} segundos\")\n",
+ "print(f\"Número total de intentos: {intentos}\")\n",
+ "print(f\"Uso máximo de memoria durante la minería: {memoria_max} bytes de un total de {memoria_total} bytes\")\n"
+ ],
+ "metadata": {
+ "outputId": "2a1de2b3-992d-494d-d5ca-0bbf59408e0e"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "import hashlib\n",
- "import time\n",
- "import psutil\n",
- "\n",
- "# Simular un bloque de datos\n",
- "bloque = \"Bloque de ejemplo\"\n",
- "dificultad = 1 # Número de ceros iniciales en el hash\n",
- "\n",
- "def mineria(bloque, dificultad):\n",
- " nonce = 0\n",
- " intentos = 0\n",
- " start_time = time.time() # Iniciar el temporizador\n",
- "\n",
- " memoria_inicial = psutil.virtual_memory().used\n",
- " memoria_total = psutil.virtual_memory().total\n",
- " memoria_max = memoria_inicial\n",
- "\n",
- " while True:\n",
- " # Concatenar el bloque de datos con el nonce y obtener el hash\n",
- " texto = bloque + str(nonce)\n",
- " hash_resultado = hashlib.sha256(texto.encode()).hexdigest()\n",
- "\n",
- " # Contar intento y medir recursos\n",
- " intentos += 1\n",
- " memoria_actual = psutil.virtual_memory().used\n",
- "\n",
- " # Actualizar máximo si es necesario\n",
- " memoria_max = max(memoria_max, memoria_actual)\n",
- "\n",
- " # Verificar si el hash cumple con la dificultad\n",
- " if hash_resultado.startswith('0' * dificultad):\n",
- " tiempo_total = time.time() - start_time # Calcular el tiempo total\n",
- " return nonce, hash_resultado, tiempo_total, intentos, memoria_max, memoria_total\n",
- "\n",
- " nonce += 1\n",
- "\n",
- "# Llamar a la función de minería\n",
- "nonce, hash_resultado, tiempo_total, intentos, memoria_max, memoria_total = mineria(bloque, dificultad)\n",
- "\n",
- "print(f\"Nonce encontrado: {nonce}\")\n",
- "print(f\"Hash resultante: {hash_resultado}\")\n",
- "print(f\"Tiempo total utilizado: {tiempo_total} segundos\")\n",
- "print(f\"Número total de intentos: {intentos}\")\n",
- "print(f\"Uso máximo de memoria durante la minería: {memoria_max} bytes de un total de {memoria_total} bytes\")\n"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "tmCU1Qph0Z3t",
- "outputId": "2a1de2b3-992d-494d-d5ca-0bbf59408e0e"
- },
- "execution_count": 12,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Nonce encontrado: 2\n",
- "Hash resultante: 0e021e65986ee28306c6edd6045766e66bf7b6d5b13146101ee99f4a130011d2\n",
- "Tiempo total utilizado: 0.0009980201721191406 segundos\n",
- "Número total de intentos: 3\n",
- "Uso máximo de memoria durante la minería: 823279616 bytes de un total de 13613268992 bytes\n"
- ]
- }
- ]
- },
- {
- "cell_type": "code",
- "source": [],
- "metadata": {
- "id": "AFTd45eK8djz"
- },
- "execution_count": null,
- "outputs": []
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Nonce encontrado: 2\n",
+ "Hash resultante: 0e021e65986ee28306c6edd6045766e66bf7b6d5b13146101ee99f4a130011d2\n",
+ "Tiempo total utilizado: 0.0009980201721191406 segundos\n",
+ "Número total de intentos: 3\n",
+ "Uso máximo de memoria durante la minería: 823279616 bytes de un total de 13613268992 bytes\n"
+ ]
}
- ]
-}
\ No newline at end of file
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git a/ErrorPendulo.ipynb b/ErrorPendulo.ipynb
index dd7befd..5b80133 100644
--- a/ErrorPendulo.ipynb
+++ b/ErrorPendulo.ipynb
@@ -1,97 +1,82 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyOE0/4aEznc5Lu79h9wus9T",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "ceaffbbe-d41b-4fe8-8e6a-1f68b9cb0563"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "id": "uLuP0t3cz2JU",
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 565
- },
- "outputId": "ceaffbbe-d41b-4fe8-8e6a-1f68b9cb0563"
- },
- "outputs": [
- {
- "output_type": "display_data",
- "data": {
- "text/plain": [
- ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "823ef12d-1fc7-4010-ec75-e7bc3bf4d2b5"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 18,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "X1fUR6kMl7bz",
- "outputId": "823ef12d-1fc7-4010-ec75-e7bc3bf4d2b5"
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (2.31.0)\n",
- "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests) (3.3.2)\n",
- "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests) (3.4)\n",
- "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests) (2.0.7)\n",
- "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests) (2023.7.22)\n"
- ]
- }
- ],
- "source": [
- "!pip install requests"
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (2.31.0)\n",
+ "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests) (3.3.2)\n",
+ "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests) (3.4)\n",
+ "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests) (2.0.7)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests) (2023.7.22)\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install requests"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "from PIL import Image\n",
+ "import requests\n",
+ "from io import BytesIO\n",
+ "\n",
+ "def mandelbrot(c, max_iter):\n",
+ " z = c\n",
+ " for n in range(max_iter):\n",
+ " if abs(z) > 2:\n",
+ " return n\n",
+ " z = z*z + c\n",
+ " return max_iter\n",
+ "\n",
+ "def mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter):\n",
+ " r1 = np.linspace(xmin, xmax, width)\n",
+ " r2 = np.linspace(ymin, ymax, height)\n",
+ " return (np.array([[mandelbrot(complex(r, i), max_iter) for r in r1] for i in r2]), r1, r2)\n",
+ "\n",
+ "# Configuración del fractal\n",
+ "fractal, xs, ys = mandelbrot_set(-2.0, 0.5, -1.25, 1.25, 1000, 1000, 80)\n",
+ "\n",
+ "# Descargar imagen en línea\n",
+ "# url = 'URL_IMAGEN'\n",
+ "response = requests.get(url)\n",
+ "img = Image.open(BytesIO(response.content))\n",
+ "img = img.resize((len(xs), len(ys))) # Redimensionar para coincidir con el fractal\n",
+ "img_data = np.array(img)\n",
+ "\n",
+ "# Aplicar el fractal a la imagen\n",
+ "modified_img_data = np.mod(img_data * fractal[:, :, np.newaxis], 255).astype(np.uint8)\n",
+ "\n",
+ "# Mostrar la imagen modificada\n",
+ "plt.imshow(modified_img_data)\n",
+ "plt.axis('off')\n",
+ "plt.show()\n"
+ ],
+ "metadata": {
+ "outputId": "744c47a8-9364-4c7a-d543-6f793f728475"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "import numpy as np\n",
- "import matplotlib.pyplot as plt\n",
- "from PIL import Image\n",
- "import requests\n",
- "from io import BytesIO\n",
- "\n",
- "def mandelbrot(c, max_iter):\n",
- " z = c\n",
- " for n in range(max_iter):\n",
- " if abs(z) > 2:\n",
- " return n\n",
- " z = z*z + c\n",
- " return max_iter\n",
- "\n",
- "def mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter):\n",
- " r1 = np.linspace(xmin, xmax, width)\n",
- " r2 = np.linspace(ymin, ymax, height)\n",
- " return (np.array([[mandelbrot(complex(r, i), max_iter) for r in r1] for i in r2]), r1, r2)\n",
- "\n",
- "# Configuración del fractal\n",
- "fractal, xs, ys = mandelbrot_set(-2.0, 0.5, -1.25, 1.25, 1000, 1000, 80)\n",
- "\n",
- "# Descargar imagen en línea\n",
- "# url = 'URL_IMAGEN'\n",
- "response = requests.get(url)\n",
- "img = Image.open(BytesIO(response.content))\n",
- "img = img.resize((len(xs), len(ys))) # Redimensionar para coincidir con el fractal\n",
- "img_data = np.array(img)\n",
- "\n",
- "# Aplicar el fractal a la imagen\n",
- "modified_img_data = np.mod(img_data * fractal[:, :, np.newaxis], 255).astype(np.uint8)\n",
- "\n",
- "# Mostrar la imagen modificada\n",
- "plt.imshow(modified_img_data)\n",
- "plt.axis('off')\n",
- "plt.show()\n"
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "U4OlyVcnFQA1"
- },
- "outputs": [],
- "source": [
- "!pip install simpy\n"
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "import simpy\n",
- "\n",
- "def planta(env, nombre, tiempo_produccion):\n",
- " contador_produccion = 0\n",
- " while True:\n",
- " contador_produccion += 1\n",
- " print(f\"{nombre} inició la producción {contador_produccion} en el tiempo {env.now}\")\n",
- " yield env.timeout(tiempo_produccion)\n",
- " print(f\"{nombre} terminó la producción {contador_produccion} en el tiempo {env.now}\")\n",
- "\n",
- "# Crear un entorno de simulación\n",
- "env = simpy.Environment()\n",
- "\n",
- "# Crear dos líneas de producción con diferentes tiempos de producción\n",
- "env.process(planta(env, 'Línea 1', 5))\n",
- "env.process(planta(env, 'Línea 2', 8))\n",
- "\n",
- "# Ejecutar la simulación por un tiempo determinado\n",
- "env.run(until=30)\n"
- ],
- "metadata": {
- "id": "G3c_a8ceI8iq"
- },
- "execution_count": null,
- "outputs": []
- }
- ]
-}
\ No newline at end of file
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!pip install simpy\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import simpy\n",
+ "\n",
+ "def planta(env, nombre, tiempo_produccion):\n",
+ " contador_produccion = 0\n",
+ " while True:\n",
+ " contador_produccion += 1\n",
+ " print(f\"{nombre} inició la producción {contador_produccion} en el tiempo {env.now}\")\n",
+ " yield env.timeout(tiempo_produccion)\n",
+ " print(f\"{nombre} terminó la producción {contador_produccion} en el tiempo {env.now}\")\n",
+ "\n",
+ "# Crear un entorno de simulación\n",
+ "env = simpy.Environment()\n",
+ "\n",
+ "# Crear dos líneas de producción con diferentes tiempos de producción\n",
+ "env.process(planta(env, 'Línea 1', 5))\n",
+ "env.process(planta(env, 'Línea 2', 8))\n",
+ "\n",
+ "# Ejecutar la simulación por un tiempo determinado\n",
+ "env.run(until=30)\n"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git a/cryptopals_set1.ipynb b/cryptopals_set1.ipynb
index 0f390d4..8dda833 100644
--- a/cryptopals_set1.ipynb
+++ b/cryptopals_set1.ipynb
@@ -1,393 +1,365 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyOgfVgWz+HZI1PZ12ckUqA0",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "o6_4WteVW9ge"
- },
- "outputs": [],
- "source": [
- "import base64\n",
- "\n",
- "# Define el string en hexadecimal\n",
- "hex_string = \"49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d\"\n",
- "\n",
- "# Convierte el string hexadecimal a bytes\n",
- "bytes_data = bytes.fromhex(hex_string)\n",
- "\n",
- "# Codifica los bytes en base64\n",
- "base64_data = base64.b64encode(bytes_data)\n",
- "\n",
- "# Decodifica los bytes base64 a string\n",
- "base64_string = base64_data.decode('utf-8')\n",
- "\n",
- "print(\"Resultado en base64:\", base64_string)"
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "def fixed_xor(buffer1, buffer2):\n",
- " # Convierte los buffers hexadecimales en enteros\n",
- " int_buffer1 = int(buffer1, 16)\n",
- " int_buffer2 = int(buffer2, 16)\n",
- "\n",
- " # Calcula el XOR de los enteros\n",
- " xor_result = int_buffer1 ^ int_buffer2\n",
- "\n",
- " # Convierte el resultado de vuelta a hexadecimal\n",
- " hex_result = hex(xor_result)[2:] # [2:] para eliminar el prefijo '0x'\n",
- "\n",
- " # Asegúrate de que el resultado tenga el mismo número de dígitos hexadecimales que los buffers originales\n",
- " hex_result = hex_result.zfill(len(buffer1))\n",
- "\n",
- " return hex_result\n",
- "\n",
- "# Define los strings hexadecimales\n",
- "buffer1 = \"1c0111001f010100061a024b53535009181c\"\n",
- "buffer2 = \"686974207468652062756c6c277320657965\"\n",
- "\n",
- "# Calcula el XOR fijo entre los buffers\n",
- "result = fixed_xor(buffer1, buffer2)\n",
- "\n",
- "print(\"Resultado del XOR fijo:\", result)"
- ],
- "metadata": {
- "id": "pZwTfMJeXJ8_"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "def xor_single_byte(ciphertext, key):\n",
- " return bytes([byte ^ key for byte in ciphertext])\n",
- "\n",
- "def score_text(text):\n",
- " # Puntuación basada en la frecuencia de las letras en inglés\n",
- " letter_frequency = {'E': 12.02, 'T': 9.10, 'A': 8.12, 'O': 7.68, 'I': 7.31,\n",
- " 'N': 6.95, 'S': 6.28, 'R': 6.02, 'H': 5.92, 'D': 4.32,\n",
- " 'L': 3.98, 'U': 2.88, 'C': 2.71, 'M': 2.61, 'F': 2.30,\n",
- " 'Y': 2.11, 'W': 2.09, 'G': 2.03, 'P': 1.82, 'B': 1.49,\n",
- " 'V': 1.11, 'K': 0.69, 'X': 0.17, 'Q': 0.11, 'J': 0.10,\n",
- " 'Z': 0.07}\n",
- " score = sum(letter_frequency.get(char.upper(), 0) for char in text)\n",
- " return score\n",
- "\n",
- "def decrypt_single_byte_xor_all(ciphertext):\n",
- " decrypted_messages = []\n",
- "\n",
- " for key in range(256):\n",
- " decrypted_message = xor_single_byte(ciphertext, key)\n",
- " try:\n",
- " decrypted_text = decrypted_message.decode('latin1')\n",
- " message_score = score_text(decrypted_text)\n",
- " decrypted_messages.append((decrypted_text, chr(key), message_score))\n",
- " except UnicodeDecodeError:\n",
- " continue\n",
- "\n",
- " return decrypted_messages\n",
- "\n",
- "ciphertext = bytes.fromhex(\"1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736\")\n",
- "decrypted_messages = decrypt_single_byte_xor_all(ciphertext)\n",
- "\n",
- "# Ordenar los mensajes descifrados por puntuación\n",
- "decrypted_messages.sort(key=lambda x: x[2], reverse=True)\n",
- "\n",
- "# Imprimir todos los mensajes descifrados y sus claves\n",
- "for decrypted_message, key, score in decrypted_messages:\n",
- " print(\"Mensaje descifrado:\", decrypted_message)\n",
- " print(\"Clave utilizada:\", key)\n",
- " print(\"Puntuación del mensaje:\", score)\n",
- " print()\n"
- ],
- "metadata": {
- "id": "MmLrAVo3X0aG"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "import requests\n",
- "\n",
- "# Descargar el archivo\n",
- "url = \"https://cryptopals.com/static/challenge-data/4.txt\"\n",
- "response = requests.get(url)\n",
- "if response.status_code == 200:\n",
- " with open(\"4.txt\", \"wb\") as f:\n",
- " f.write(response.content)\n",
- " print(\"Archivo descargado con éxito como 4.txt\")\n",
- "else:\n",
- " print(\"Error al descargar el archivo:\", response.status_code)"
- ],
- "metadata": {
- "id": "JDSmSgimZt73"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "def xor_single_byte(ciphertext, key):\n",
- " return bytes([byte ^ key for byte in ciphertext])\n",
- "\n",
- "def score_text(text):\n",
- " # Puntuación basada en la frecuencia de las letras en inglés\n",
- " letter_frequency = {'E': 12.02, 'T': 9.10, 'A': 8.12, 'O': 7.68, 'I': 7.31,\n",
- " 'N': 6.95, 'S': 6.28, 'R': 6.02, 'H': 5.92, 'D': 4.32,\n",
- " 'L': 3.98, 'U': 2.88, 'C': 2.71, 'M': 2.61, 'F': 2.30,\n",
- " 'Y': 2.11, 'W': 2.09, 'G': 2.03, 'P': 1.82, 'B': 1.49,\n",
- " 'V': 1.11, 'K': 0.69, 'X': 0.17, 'Q': 0.11, 'J': 0.10,\n",
- " 'Z': 0.07}\n",
- " score = sum(letter_frequency.get(char.upper(), 0) for char in text)\n",
- " return score\n",
- "\n",
- "def decrypt_single_byte_xor_all(ciphertext):\n",
- " decrypted_messages = []\n",
- "\n",
- " for key in range(256):\n",
- " decrypted_message = xor_single_byte(ciphertext, key)\n",
- " try:\n",
- " decrypted_text = decrypted_message.decode('latin1')\n",
- " message_score = score_text(decrypted_text)\n",
- " decrypted_messages.append((decrypted_text, chr(key), message_score))\n",
- " except UnicodeDecodeError:\n",
- " continue\n",
- "\n",
- " return decrypted_messages\n",
- "\n",
- "# Leer el archivo 4.txt\n",
- "with open(\"4.txt\", \"r\") as f:\n",
- " lines = f.readlines()\n",
- "\n",
- "# Procesar cada línea del archivo\n",
- "for line_number, line in enumerate(lines):\n",
- " ciphertext = bytes.fromhex(line.strip())\n",
- " decrypted_messages = decrypt_single_byte_xor_all(ciphertext)\n",
- "\n",
- " # Ordenar los mensajes descifrados por puntuación\n",
- " decrypted_messages.sort(key=lambda x: x[2], reverse=True)\n",
- "\n",
- " # Si hay algún mensaje con una puntuación alta, imprimirlo\n",
- " best_decryption = decrypted_messages[0]\n",
- " if best_decryption[2] > 0:\n",
- " print(\"Mensaje descifrado en la línea\", line_number + 1, \":\", best_decryption[0])\n",
- " print(\"Clave utilizada:\", best_decryption[1])\n",
- " print(\"Puntuación del mensaje:\", best_decryption[2])\n",
- " print()"
- ],
- "metadata": {
- "id": "tiUa2xeia2Uu"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "def repeating_key_xor(plaintext, key):\n",
- " encrypted_bytes = bytearray()\n",
- " key_length = len(key)\n",
- " for i, byte in enumerate(plaintext):\n",
- " encrypted_byte = byte ^ key[i % key_length]\n",
- " encrypted_bytes.append(encrypted_byte)\n",
- " return encrypted_bytes.hex()\n",
- "\n",
- "# Texto a cifrar\n",
- "plaintext = \"Burning 'em, if you ain't quick and nimble\\nI go crazy when I hear a cymbal\"\n",
- "\n",
- "# Clave\n",
- "key = \"ICE\"\n",
- "\n",
- "# Cifrar el texto con clave repetida XOR\n",
- "encrypted_text = repeating_key_xor(plaintext.encode(), key.encode())\n",
- "print(\"Texto cifrado:\", encrypted_text)"
- ],
- "metadata": {
- "id": "r2oVutx4bQTg"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "import requests\n",
- "import base64\n",
- "\n",
- "def binary_digits(data):\n",
- " return ''.join(format(byte, '08b') for byte in data)\n",
- "\n",
- "def edit_dist(buf1, buf2):\n",
- " bin1 = binary_digits(buf1)\n",
- " bin2 = binary_digits(buf2)\n",
- "\n",
- " dist = 0\n",
- " for b1, b2 in zip(bin1, bin2):\n",
- " if b1 != b2:\n",
- " dist += 1\n",
- "\n",
- " return dist\n",
- "\n",
- "def keysize_edit_distance(ciphertext, keysize):\n",
- " prev = None\n",
- " diff = 0\n",
- " n = 0\n",
- " for i in range(0, len(ciphertext), keysize):\n",
- " chunk = ciphertext[i:i+keysize]\n",
- " if prev:\n",
- " diff += edit_dist(chunk, prev) / keysize\n",
- " n += 1\n",
- " prev = chunk\n",
- " diff /= n\n",
- " return diff\n",
- "\n",
- "def single_xor(buf, key):\n",
- " return bytes(byte ^ key for byte in buf)\n",
- "\n",
- "def english_score(buf):\n",
- " score = 0\n",
- " for c in buf:\n",
- " if chr(c).isalpha() or chr(c).isspace():\n",
- " score += 1\n",
- " return score\n",
- "\n",
- "def repeating_xor(data, key):\n",
- " encrypted = b''\n",
- " for i, byte in enumerate(data):\n",
- " encrypted += bytes([byte ^ key[i % len(key)]])\n",
- " return encrypted\n",
- "\n",
- "URL = 'https://cryptopals.com/static/challenge-data/6.txt'\n",
- "text = requests.get(URL).text\n",
- "data = base64.b64decode(text)\n",
- "\n",
- "keysize = min(range(2, 40), key=lambda x: keysize_edit_distance(data, x))\n",
- "\n",
- "key = []\n",
- "\n",
- "blocks = [data[i:i+keysize] for i in range(0, len(data), keysize)]\n",
- "\n",
- "for key_i in range(keysize):\n",
- " chunk = b\"\"\n",
- " for bl in blocks:\n",
- " if key_i < len(bl):\n",
- " chunk += bytes([bl[key_i]])\n",
- "\n",
- " k = max(range(255), key=lambda x: english_score(single_xor(chunk, x)))\n",
- " key.append(k)\n",
- "\n",
- "plaintext = repeating_xor(data, bytes(key)).decode('ascii')\n",
- "\n",
- "print(\"Clave utilizada:\", bytes(key).decode('ascii'))\n",
- "print(\"Texto descifrado:\", plaintext[:150])"
- ],
- "metadata": {
- "id": "U07vYk3UbjJg"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "import requests\n",
- "from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes\n",
- "from cryptography.hazmat.backends import default_backend\n",
- "import base64\n",
- "\n",
- "def decrypt_aes_ecb(ciphertext, key):\n",
- " backend = default_backend()\n",
- " cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend)\n",
- " decryptor = cipher.decryptor()\n",
- " plaintext = decryptor.update(ciphertext) + decryptor.finalize()\n",
- " return plaintext\n",
- "\n",
- "# Descargar el archivo cifrado\n",
- "url = 'https://cryptopals.com/static/challenge-data/7.txt'\n",
- "response = requests.get(url)\n",
- "encrypted_text_base64 = response.content\n",
- "\n",
- "# Decodificar el contenido Base64\n",
- "ciphertext = base64.b64decode(encrypted_text_base64)\n",
- "\n",
- "# AES-128 ECB key\n",
- "key = b'YELLOW SUBMARINE'\n",
- "\n",
- "# Descifrar el texto cifrado\n",
- "plaintext = decrypt_aes_ecb(ciphertext, key)\n",
- "\n",
- "print(\"Texto descifrado:\", plaintext.decode('utf-8'))"
- ],
- "metadata": {
- "id": "-zUKVUrKeIao"
- },
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "import requests\n",
- "\n",
- "# Función para convertir una cadena hexadecimal a bytes\n",
- "def hex_to_bytes(hex_string):\n",
- " return bytes.fromhex(hex_string)\n",
- "\n",
- "# Obtener los ciphertexts del archivo en la URL proporcionada\n",
- "URL = 'https://cryptopals.com/static/challenge-data/8.txt'\n",
- "response = requests.get(URL)\n",
- "ciphertexts = response.text.split(\"\\n\")\n",
- "\n",
- "# Función para detectar repeticiones de bloques de 16 bytes en los ciphertexts\n",
- "def detect_aes_ecb(ciphertexts):\n",
- " for num, ciphertext in enumerate(ciphertexts):\n",
- " data = hex_to_bytes(ciphertext)\n",
- " blocks = [data[i:i+16] for i in range(0, len(data), 16)]\n",
- " for i, block in enumerate(blocks):\n",
- " count = blocks.count(block)\n",
- " if count != 1:\n",
- " print(\"Posible uso de AES en modo ECB en el ciphertext {}: bloque {} se repite {} veces\".format(num, i, count))\n",
- "\n",
- "# Detectar AES en ECB\n",
- "detect_aes_ecb(ciphertexts)"
- ],
- "metadata": {
- "id": "KoLVmn_Hea_X"
- },
- "execution_count": null,
- "outputs": []
- }
- ]
-}
\ No newline at end of file
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import base64\n",
+ "\n",
+ "# Define el string en hexadecimal\n",
+ "hex_string = \"49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d\"\n",
+ "\n",
+ "# Convierte el string hexadecimal a bytes\n",
+ "bytes_data = bytes.fromhex(hex_string)\n",
+ "\n",
+ "# Codifica los bytes en base64\n",
+ "base64_data = base64.b64encode(bytes_data)\n",
+ "\n",
+ "# Decodifica los bytes base64 a string\n",
+ "base64_string = base64_data.decode('utf-8')\n",
+ "\n",
+ "print(\"Resultado en base64:\", base64_string)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def fixed_xor(buffer1, buffer2):\n",
+ " # Convierte los buffers hexadecimales en enteros\n",
+ " int_buffer1 = int(buffer1, 16)\n",
+ " int_buffer2 = int(buffer2, 16)\n",
+ "\n",
+ " # Calcula el XOR de los enteros\n",
+ " xor_result = int_buffer1 ^ int_buffer2\n",
+ "\n",
+ " # Convierte el resultado de vuelta a hexadecimal\n",
+ " hex_result = hex(xor_result)[2:] # [2:] para eliminar el prefijo '0x'\n",
+ "\n",
+ " # Asegúrate de que el resultado tenga el mismo número de dígitos hexadecimales que los buffers originales\n",
+ " hex_result = hex_result.zfill(len(buffer1))\n",
+ "\n",
+ " return hex_result\n",
+ "\n",
+ "# Define los strings hexadecimales\n",
+ "buffer1 = \"1c0111001f010100061a024b53535009181c\"\n",
+ "buffer2 = \"686974207468652062756c6c277320657965\"\n",
+ "\n",
+ "# Calcula el XOR fijo entre los buffers\n",
+ "result = fixed_xor(buffer1, buffer2)\n",
+ "\n",
+ "print(\"Resultado del XOR fijo:\", result)"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def xor_single_byte(ciphertext, key):\n",
+ " return bytes([byte ^ key for byte in ciphertext])\n",
+ "\n",
+ "def score_text(text):\n",
+ " # Puntuación basada en la frecuencia de las letras en inglés\n",
+ " letter_frequency = {'E': 12.02, 'T': 9.10, 'A': 8.12, 'O': 7.68, 'I': 7.31,\n",
+ " 'N': 6.95, 'S': 6.28, 'R': 6.02, 'H': 5.92, 'D': 4.32,\n",
+ " 'L': 3.98, 'U': 2.88, 'C': 2.71, 'M': 2.61, 'F': 2.30,\n",
+ " 'Y': 2.11, 'W': 2.09, 'G': 2.03, 'P': 1.82, 'B': 1.49,\n",
+ " 'V': 1.11, 'K': 0.69, 'X': 0.17, 'Q': 0.11, 'J': 0.10,\n",
+ " 'Z': 0.07}\n",
+ " score = sum(letter_frequency.get(char.upper(), 0) for char in text)\n",
+ " return score\n",
+ "\n",
+ "def decrypt_single_byte_xor_all(ciphertext):\n",
+ " decrypted_messages = []\n",
+ "\n",
+ " for key in range(256):\n",
+ " decrypted_message = xor_single_byte(ciphertext, key)\n",
+ " try:\n",
+ " decrypted_text = decrypted_message.decode('latin1')\n",
+ " message_score = score_text(decrypted_text)\n",
+ " decrypted_messages.append((decrypted_text, chr(key), message_score))\n",
+ " except UnicodeDecodeError:\n",
+ " continue\n",
+ "\n",
+ " return decrypted_messages\n",
+ "\n",
+ "ciphertext = bytes.fromhex(\"1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736\")\n",
+ "decrypted_messages = decrypt_single_byte_xor_all(ciphertext)\n",
+ "\n",
+ "# Ordenar los mensajes descifrados por puntuación\n",
+ "decrypted_messages.sort(key=lambda x: x[2], reverse=True)\n",
+ "\n",
+ "# Imprimir todos los mensajes descifrados y sus claves\n",
+ "for decrypted_message, key, score in decrypted_messages:\n",
+ " print(\"Mensaje descifrado:\", decrypted_message)\n",
+ " print(\"Clave utilizada:\", key)\n",
+ " print(\"Puntuación del mensaje:\", score)\n",
+ " print()\n"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import requests\n",
+ "\n",
+ "# Descargar el archivo\n",
+ "url = \"https://cryptopals.com/static/challenge-data/4.txt\"\n",
+ "response = requests.get(url)\n",
+ "if response.status_code == 200:\n",
+ " with open(\"4.txt\", \"wb\") as f:\n",
+ " f.write(response.content)\n",
+ " print(\"Archivo descargado con éxito como 4.txt\")\n",
+ "else:\n",
+ " print(\"Error al descargar el archivo:\", response.status_code)"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def xor_single_byte(ciphertext, key):\n",
+ " return bytes([byte ^ key for byte in ciphertext])\n",
+ "\n",
+ "def score_text(text):\n",
+ " # Puntuación basada en la frecuencia de las letras en inglés\n",
+ " letter_frequency = {'E': 12.02, 'T': 9.10, 'A': 8.12, 'O': 7.68, 'I': 7.31,\n",
+ " 'N': 6.95, 'S': 6.28, 'R': 6.02, 'H': 5.92, 'D': 4.32,\n",
+ " 'L': 3.98, 'U': 2.88, 'C': 2.71, 'M': 2.61, 'F': 2.30,\n",
+ " 'Y': 2.11, 'W': 2.09, 'G': 2.03, 'P': 1.82, 'B': 1.49,\n",
+ " 'V': 1.11, 'K': 0.69, 'X': 0.17, 'Q': 0.11, 'J': 0.10,\n",
+ " 'Z': 0.07}\n",
+ " score = sum(letter_frequency.get(char.upper(), 0) for char in text)\n",
+ " return score\n",
+ "\n",
+ "def decrypt_single_byte_xor_all(ciphertext):\n",
+ " decrypted_messages = []\n",
+ "\n",
+ " for key in range(256):\n",
+ " decrypted_message = xor_single_byte(ciphertext, key)\n",
+ " try:\n",
+ " decrypted_text = decrypted_message.decode('latin1')\n",
+ " message_score = score_text(decrypted_text)\n",
+ " decrypted_messages.append((decrypted_text, chr(key), message_score))\n",
+ " except UnicodeDecodeError:\n",
+ " continue\n",
+ "\n",
+ " return decrypted_messages\n",
+ "\n",
+ "# Leer el archivo 4.txt\n",
+ "with open(\"4.txt\", \"r\") as f:\n",
+ " lines = f.readlines()\n",
+ "\n",
+ "# Procesar cada línea del archivo\n",
+ "for line_number, line in enumerate(lines):\n",
+ " ciphertext = bytes.fromhex(line.strip())\n",
+ " decrypted_messages = decrypt_single_byte_xor_all(ciphertext)\n",
+ "\n",
+ " # Ordenar los mensajes descifrados por puntuación\n",
+ " decrypted_messages.sort(key=lambda x: x[2], reverse=True)\n",
+ "\n",
+ " # Si hay algún mensaje con una puntuación alta, imprimirlo\n",
+ " best_decryption = decrypted_messages[0]\n",
+ " if best_decryption[2] > 0:\n",
+ " print(\"Mensaje descifrado en la línea\", line_number + 1, \":\", best_decryption[0])\n",
+ " print(\"Clave utilizada:\", best_decryption[1])\n",
+ " print(\"Puntuación del mensaje:\", best_decryption[2])\n",
+ " print()"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "def repeating_key_xor(plaintext, key):\n",
+ " encrypted_bytes = bytearray()\n",
+ " key_length = len(key)\n",
+ " for i, byte in enumerate(plaintext):\n",
+ " encrypted_byte = byte ^ key[i % key_length]\n",
+ " encrypted_bytes.append(encrypted_byte)\n",
+ " return encrypted_bytes.hex()\n",
+ "\n",
+ "# Texto a cifrar\n",
+ "plaintext = \"Burning 'em, if you ain't quick and nimble\\nI go crazy when I hear a cymbal\"\n",
+ "\n",
+ "# Clave\n",
+ "key = \"ICE\"\n",
+ "\n",
+ "# Cifrar el texto con clave repetida XOR\n",
+ "encrypted_text = repeating_key_xor(plaintext.encode(), key.encode())\n",
+ "print(\"Texto cifrado:\", encrypted_text)"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import requests\n",
+ "import base64\n",
+ "\n",
+ "def binary_digits(data):\n",
+ " return ''.join(format(byte, '08b') for byte in data)\n",
+ "\n",
+ "def edit_dist(buf1, buf2):\n",
+ " bin1 = binary_digits(buf1)\n",
+ " bin2 = binary_digits(buf2)\n",
+ "\n",
+ " dist = 0\n",
+ " for b1, b2 in zip(bin1, bin2):\n",
+ " if b1 != b2:\n",
+ " dist += 1\n",
+ "\n",
+ " return dist\n",
+ "\n",
+ "def keysize_edit_distance(ciphertext, keysize):\n",
+ " prev = None\n",
+ " diff = 0\n",
+ " n = 0\n",
+ " for i in range(0, len(ciphertext), keysize):\n",
+ " chunk = ciphertext[i:i+keysize]\n",
+ " if prev:\n",
+ " diff += edit_dist(chunk, prev) / keysize\n",
+ " n += 1\n",
+ " prev = chunk\n",
+ " diff /= n\n",
+ " return diff\n",
+ "\n",
+ "def single_xor(buf, key):\n",
+ " return bytes(byte ^ key for byte in buf)\n",
+ "\n",
+ "def english_score(buf):\n",
+ " score = 0\n",
+ " for c in buf:\n",
+ " if chr(c).isalpha() or chr(c).isspace():\n",
+ " score += 1\n",
+ " return score\n",
+ "\n",
+ "def repeating_xor(data, key):\n",
+ " encrypted = b''\n",
+ " for i, byte in enumerate(data):\n",
+ " encrypted += bytes([byte ^ key[i % len(key)]])\n",
+ " return encrypted\n",
+ "\n",
+ "URL = 'https://cryptopals.com/static/challenge-data/6.txt'\n",
+ "text = requests.get(URL).text\n",
+ "data = base64.b64decode(text)\n",
+ "\n",
+ "keysize = min(range(2, 40), key=lambda x: keysize_edit_distance(data, x))\n",
+ "\n",
+ "key = []\n",
+ "\n",
+ "blocks = [data[i:i+keysize] for i in range(0, len(data), keysize)]\n",
+ "\n",
+ "for key_i in range(keysize):\n",
+ " chunk = b\"\"\n",
+ " for bl in blocks:\n",
+ " if key_i < len(bl):\n",
+ " chunk += bytes([bl[key_i]])\n",
+ "\n",
+ " k = max(range(255), key=lambda x: english_score(single_xor(chunk, x)))\n",
+ " key.append(k)\n",
+ "\n",
+ "plaintext = repeating_xor(data, bytes(key)).decode('ascii')\n",
+ "\n",
+ "print(\"Clave utilizada:\", bytes(key).decode('ascii'))\n",
+ "print(\"Texto descifrado:\", plaintext[:150])"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import requests\n",
+ "from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes\n",
+ "from cryptography.hazmat.backends import default_backend\n",
+ "import base64\n",
+ "\n",
+ "def decrypt_aes_ecb(ciphertext, key):\n",
+ " backend = default_backend()\n",
+ " cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=backend)\n",
+ " decryptor = cipher.decryptor()\n",
+ " plaintext = decryptor.update(ciphertext) + decryptor.finalize()\n",
+ " return plaintext\n",
+ "\n",
+ "# Descargar el archivo cifrado\n",
+ "url = 'https://cryptopals.com/static/challenge-data/7.txt'\n",
+ "response = requests.get(url)\n",
+ "encrypted_text_base64 = response.content\n",
+ "\n",
+ "# Decodificar el contenido Base64\n",
+ "ciphertext = base64.b64decode(encrypted_text_base64)\n",
+ "\n",
+ "# AES-128 ECB key\n",
+ "key = b'YELLOW SUBMARINE'\n",
+ "\n",
+ "# Descifrar el texto cifrado\n",
+ "plaintext = decrypt_aes_ecb(ciphertext, key)\n",
+ "\n",
+ "print(\"Texto descifrado:\", plaintext.decode('utf-8'))"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "import requests\n",
+ "\n",
+ "# Función para convertir una cadena hexadecimal a bytes\n",
+ "def hex_to_bytes(hex_string):\n",
+ " return bytes.fromhex(hex_string)\n",
+ "\n",
+ "# Obtener los ciphertexts del archivo en la URL proporcionada\n",
+ "URL = 'https://cryptopals.com/static/challenge-data/8.txt'\n",
+ "response = requests.get(URL)\n",
+ "ciphertexts = response.text.split(\"\\n\")\n",
+ "\n",
+ "# Función para detectar repeticiones de bloques de 16 bytes en los ciphertexts\n",
+ "def detect_aes_ecb(ciphertexts):\n",
+ " for num, ciphertext in enumerate(ciphertexts):\n",
+ " data = hex_to_bytes(ciphertext)\n",
+ " blocks = [data[i:i+16] for i in range(0, len(data), 16)]\n",
+ " for i, block in enumerate(blocks):\n",
+ " count = blocks.count(block)\n",
+ " if count != 1:\n",
+ " print(\"Posible uso de AES en modo ECB en el ciphertext {}: bloque {} se repite {} veces\".format(num, i, count))\n",
+ "\n",
+ "# Detectar AES en ECB\n",
+ "detect_aes_ecb(ciphertexts)"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git a/free_fall.ipynb b/free_fall.ipynb
index 827d013..03bca43 100644
--- a/free_fall.ipynb
+++ b/free_fall.ipynb
@@ -1,174 +1,154 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyO7cuDZydMWsELJ+JqhswK0",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "b814cd86-dd28-4e61-9218-d8cabe5f71fb"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 607
- },
- "id": "cDUX_XpjfjZa",
- "outputId": "b814cd86-dd28-4e61-9218-d8cabe5f71fb"
- },
- "outputs": [
- {
- "output_type": "display_data",
- "data": {
- "text/plain": [
- ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "283c61b2-20bf-48e8-cb50-8f0615724fe4"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 452
- },
- "id": "3sz8gUIDg649",
- "outputId": "283c61b2-20bf-48e8-cb50-8f0615724fe4"
- },
- "outputs": [
- {
- "output_type": "display_data",
- "data": {
- "text/plain": [
- ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "f8346fcd-a2bc-4080-e49c-922c04d5ec9d"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "tmjJV2fdxclV",
- "outputId": "f8346fcd-a2bc-4080-e49c-922c04d5ec9d"
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Root: 2.000000000000002\n"
- ]
- }
- ],
- "source": [
- "def newton_raphson(func, deriv, initial_guess, tolerance=1e-6, max_iterations=100):\n",
- " x = initial_guess\n",
- " for _ in range(max_iterations):\n",
- " x_new = x - func(x) / deriv(x)\n",
- " if abs(x_new - x) < tolerance:\n",
- " return x_new\n",
- " x = x_new\n",
- " return x\n",
- "\n",
- "# Ejemplo de función y su derivada\n",
- "func = lambda x: x**2 - 4\n",
- "deriv = lambda x: 2*x\n",
- "\n",
- "# Encontrar la raíz cerca de 1\n",
- "root = newton_raphson(func, deriv, 1)\n",
- "print(\"Root:\", root)\n"
- ]
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Root: 2.000000000000002\n"
+ ]
}
- ]
-}
\ No newline at end of file
+ ],
+ "source": [
+ "def newton_raphson(func, deriv, initial_guess, tolerance=1e-6, max_iterations=100):\n",
+ " x = initial_guess\n",
+ " for _ in range(max_iterations):\n",
+ " x_new = x - func(x) / deriv(x)\n",
+ " if abs(x_new - x) < tolerance:\n",
+ " return x_new\n",
+ " x = x_new\n",
+ " return x\n",
+ "\n",
+ "# Ejemplo de función y su derivada\n",
+ "func = lambda x: x**2 - 4\n",
+ "deriv = lambda x: 2*x\n",
+ "\n",
+ "# Encontrar la raíz cerca de 1\n",
+ "root = newton_raphson(func, deriv, 1)\n",
+ "print(\"Root:\", root)\n"
+ ]
+ }
+ ]
+}
diff --git a/picoCTF_2019.ipynb b/picoCTF_2019.ipynb
index f5b218b..3bc1adc 100644
--- a/picoCTF_2019.ipynb
+++ b/picoCTF_2019.ipynb
@@ -1,593 +1,531 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyNr4rEJBkjQgTUNCOH5QHwn",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "29106503-6835-48c5-dab0-034a0d07f87d"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 314
- },
- "id": "t1g8x2Uj-cra",
- "outputId": "29106503-6835-48c5-dab0-034a0d07f87d"
- },
- "outputs": [
- {
- "output_type": "display_data",
- "data": {
- "text/plain": [
- ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Mod 26\n",
+ "\n",
+ "# Mensaje cifrado\n",
+ "mensaje_cifrado = \"cvpbPGS{arkg_gvzr_V'yy_gel_2_ebhaqf_bs_ebg13_uJdSftmh}\"\n",
+ "\n",
+ "# Función para descifrar ROT13\n",
+ "def descifrar_rot13(texto):\n",
+ " texto_descifrado = \"\"\n",
+ " for char in texto:\n",
+ " if char.isalpha():\n",
+ " offset = 13 if char.islower() else -13\n",
+ " texto_descifrado += chr((ord(char) - ord('a' if char.islower() else 'A') + offset) % 26 + ord('a' if char.islower() else 'A'))\n",
+ " else:\n",
+ " texto_descifrado += char\n",
+ " return texto_descifrado\n",
+ "\n",
+ "# Descifrar el mensaje cifrado\n",
+ "mensaje_descifrado = descifrar_rot13(mensaje_cifrado)\n",
+ "\n",
+ "# Imprimir el mensaje descifrado\n",
+ "print(\"Mensaje descifrado:\", mensaje_descifrado)"
+ ],
+ "metadata": {
+ "outputId": "a6ca0421-f7a8-4917-d6d1-c7eb6e250097"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# Mod 26\n",
- "\n",
- "# Mensaje cifrado\n",
- "mensaje_cifrado = \"cvpbPGS{arkg_gvzr_V'yy_gel_2_ebhaqf_bs_ebg13_uJdSftmh}\"\n",
- "\n",
- "# Función para descifrar ROT13\n",
- "def descifrar_rot13(texto):\n",
- " texto_descifrado = \"\"\n",
- " for char in texto:\n",
- " if char.isalpha():\n",
- " offset = 13 if char.islower() else -13\n",
- " texto_descifrado += chr((ord(char) - ord('a' if char.islower() else 'A') + offset) % 26 + ord('a' if char.islower() else 'A'))\n",
- " else:\n",
- " texto_descifrado += char\n",
- " return texto_descifrado\n",
- "\n",
- "# Descifrar el mensaje cifrado\n",
- "mensaje_descifrado = descifrar_rot13(mensaje_cifrado)\n",
- "\n",
- "# Imprimir el mensaje descifrado\n",
- "print(\"Mensaje descifrado:\", mensaje_descifrado)"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "xfLaZqAalHbp",
- "outputId": "a6ca0421-f7a8-4917-d6d1-c7eb6e250097"
- },
- "execution_count": 25,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Mensaje descifrado: picoCTF{next_time_I'll_try_2_rounds_of_rot13_hWqFsgzu}\n"
- ]
- }
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Mensaje descifrado: picoCTF{next_time_I'll_try_2_rounds_of_rot13_hWqFsgzu}\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Mind your Ps and Qs\n",
+ "\n",
+ "import requests\n",
+ "\n",
+ "# URL del archivo a descargar\n",
+ "url = \"https://mercury.picoctf.net/static/bf5e2c8811afb4669f4a6850e097e8aa/values\"\n",
+ "\n",
+ "# Nombre de archivo local donde se guardará el archivo descargado\n",
+ "nombre_archivo = \"valores.txt\"\n",
+ "\n",
+ "# Realizar la solicitud GET para descargar el archivo\n",
+ "response = requests.get(url)\n",
+ "\n",
+ "# Verificar si la solicitud fue exitosa\n",
+ "if response.status_code == 200:\n",
+ " # Guardar el contenido del archivo en un archivo local\n",
+ " with open(nombre_archivo, 'wb') as file:\n",
+ " file.write(response.content)\n",
+ " print(\"Descarga exitosa. El archivo se ha guardado como:\", nombre_archivo)\n",
+ "else:\n",
+ " print(\"Error al descargar el archivo. Código de estado:\", response.status_code)"
+ ],
+ "metadata": {
+ "outputId": "aad9e584-2290-4b73-bf9a-5bad54bca9fc"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# Mind your Ps and Qs\n",
- "\n",
- "import requests\n",
- "\n",
- "# URL del archivo a descargar\n",
- "url = \"https://mercury.picoctf.net/static/bf5e2c8811afb4669f4a6850e097e8aa/values\"\n",
- "\n",
- "# Nombre de archivo local donde se guardará el archivo descargado\n",
- "nombre_archivo = \"valores.txt\"\n",
- "\n",
- "# Realizar la solicitud GET para descargar el archivo\n",
- "response = requests.get(url)\n",
- "\n",
- "# Verificar si la solicitud fue exitosa\n",
- "if response.status_code == 200:\n",
- " # Guardar el contenido del archivo en un archivo local\n",
- " with open(nombre_archivo, 'wb') as file:\n",
- " file.write(response.content)\n",
- " print(\"Descarga exitosa. El archivo se ha guardado como:\", nombre_archivo)\n",
- "else:\n",
- " print(\"Error al descargar el archivo. Código de estado:\", response.status_code)"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "7IKuZpdfmMEB",
- "outputId": "aad9e584-2290-4b73-bf9a-5bad54bca9fc"
- },
- "execution_count": 26,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Descarga exitosa. El archivo se ha guardado como: valores.txt\n"
- ]
- }
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Descarga exitosa. El archivo se ha guardado como: valores.txt\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!cat valores.txt"
+ ],
+ "metadata": {
+ "outputId": "9c9a1824-18c1-4e8c-b49e-713ca36b4734"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "!cat valores.txt"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "zJNSsykUmlLZ",
- "outputId": "9c9a1824-18c1-4e8c-b49e-713ca36b4734"
- },
- "execution_count": 28,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Decrypt my super sick RSA:\n",
- "c: 421345306292040663864066688931456845278496274597031632020995583473619804626233684\n",
- "n: 631371953793368771804570727896887140714495090919073481680274581226742748040342637\n",
- "e: 65537"
- ]
- }
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Decrypt my super sick RSA:\n",
+ "c: 421345306292040663864066688931456845278496274597031632020995583473619804626233684\n",
+ "n: 631371953793368771804570727896887140714495090919073481680274581226742748040342637\n",
+ "e: 65537"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "\"\"\"\n",
+ "C = ciphertext\n",
+ "p and q = prime numbers\n",
+ "n = p * q\n",
+ "phi = (p-1) * (q-1)\n",
+ "e = some number that 1 < e < phi and gcd(e,phi) == 1\n",
+ "d = e^(-1) mod phi\n",
+ "\"\"\"\n",
+ "\n",
+ "\"\"\"\n",
+ "Use factordb con n\n",
+ "n = 1461849912200000206276283741896701133693 * 431899300006243611356963607089521499045809\n",
+ "p = 1461849912200000206276283741896701133693\n",
+ "q = 431899300006243611356963607089521499045809\n",
+ "\"\"\"\n",
+ "\n",
+ "\n",
+ "from Crypto.Util.number import inverse, long_to_bytes\n",
+ "\n",
+ "c = 421345306292040663864066688931456845278496274597031632020995583473619804626233684\n",
+ "n = 631371953793368771804570727896887140714495090919073481680274581226742748040342637\n",
+ "e = 65537\n",
+ "p = 1461849912200000206276283741896701133693\n",
+ "q = 431899300006243611356963607089521499045809\n",
+ "\n",
+ "phi = (p-1)*(q-1)\n",
+ "\n",
+ "d = inverse(e, phi)\n",
+ "\n",
+ "m = pow(c,d,n)\n",
+ "\n",
+ "print(long_to_bytes(m))"
+ ],
+ "metadata": {
+ "outputId": "7d7c8038-254c-441f-88ec-1e46e4aac112"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "\"\"\"\n",
- "C = ciphertext\n",
- "p and q = prime numbers\n",
- "n = p * q\n",
- "phi = (p-1) * (q-1)\n",
- "e = some number that 1 < e < phi and gcd(e,phi) == 1\n",
- "d = e^(-1) mod phi\n",
- "\"\"\"\n",
- "\n",
- "\"\"\"\n",
- "Use factordb con n\n",
- "n = 1461849912200000206276283741896701133693 * 431899300006243611356963607089521499045809\n",
- "p = 1461849912200000206276283741896701133693\n",
- "q = 431899300006243611356963607089521499045809\n",
- "\"\"\"\n",
- "\n",
- "\n",
- "from Crypto.Util.number import inverse, long_to_bytes\n",
- "\n",
- "c = 421345306292040663864066688931456845278496274597031632020995583473619804626233684\n",
- "n = 631371953793368771804570727896887140714495090919073481680274581226742748040342637\n",
- "e = 65537\n",
- "p = 1461849912200000206276283741896701133693\n",
- "q = 431899300006243611356963607089521499045809\n",
- "\n",
- "phi = (p-1)*(q-1)\n",
- "\n",
- "d = inverse(e, phi)\n",
- "\n",
- "m = pow(c,d,n)\n",
- "\n",
- "print(long_to_bytes(m))"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "bcdrkbj5nEyZ",
- "outputId": "7d7c8038-254c-441f-88ec-1e46e4aac112"
- },
- "execution_count": 30,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "b'picoCTF{sma11_N_n0_g0od_55304594}'\n"
- ]
- }
- ]
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "b'picoCTF{sma11_N_n0_g0od_55304594}'\n"
+ ]
}
- ]
-}
\ No newline at end of file
+ ]
+ }
+ ]
+}
diff --git a/picoctf_2021_1.ipynb b/picoctf_2021_1.ipynb
index 005a76b..db21df7 100644
--- a/picoctf_2021_1.ipynb
+++ b/picoctf_2021_1.ipynb
@@ -1,237 +1,207 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyNwqvqv7I8rWjyo+hzi46Ia",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "6fb0ec76-563e-4f4c-d1a1-f0702f8414f2"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "ddL0Xsvu1LRs",
- "outputId": "6fb0ec76-563e-4f4c-d1a1-f0702f8414f2"
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "--2024-04-03 12:02:43-- https://mercury.picoctf.net/static/1d8a5a2779c4dc24999f0358d7a1a786/enc\n",
- "Resolving mercury.picoctf.net (mercury.picoctf.net)... 18.189.209.142\n",
- "Connecting to mercury.picoctf.net (mercury.picoctf.net)|18.189.209.142|:443... connected.\n",
- "HTTP request sent, awaiting response... 200 OK\n",
- "Length: 57 [application/octet-stream]\n",
- "Saving to: ‘enc’\n",
- "\n",
- "\renc 0%[ ] 0 --.-KB/s \renc 100%[===================>] 57 --.-KB/s in 0s \n",
- "\n",
- "2024-04-03 12:02:43 (37.5 MB/s) - ‘enc’ saved [57/57]\n",
- "\n",
- "灩捯䍔䙻ㄶ形楴獟楮獴㌴摟潦弸彥㜰㍢㐸㙽\n"
- ]
- }
- ],
- "source": [
- "# Transformation\n",
- "!wget -O enc https://mercury.picoctf.net/static/1d8a5a2779c4dc24999f0358d7a1a786/enc\n",
- "\n",
- "with open('enc', 'r') as file:\n",
- " content = file.read()\n",
- " print(content)"
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "--2024-04-03 12:02:43-- https://mercury.picoctf.net/static/1d8a5a2779c4dc24999f0358d7a1a786/enc\n",
+ "Resolving mercury.picoctf.net (mercury.picoctf.net)... 18.189.209.142\n",
+ "Connecting to mercury.picoctf.net (mercury.picoctf.net)|18.189.209.142|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 57 [application/octet-stream]\n",
+ "Saving to: ‘enc’\n",
+ "\n",
+ "\renc 0%[ ] 0 --.-KB/s \renc 100%[===================>] 57 --.-KB/s in 0s \n",
+ "\n",
+ "2024-04-03 12:02:43 (37.5 MB/s) - ‘enc’ saved [57/57]\n",
+ "\n",
+ "灩捯䍔䙻ㄶ形楴獟楮獴㌴摟潦弸彥㜰㍢㐸㙽\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Transformation\n",
+ "!wget -O enc https://mercury.picoctf.net/static/1d8a5a2779c4dc24999f0358d7a1a786/enc\n",
+ "\n",
+ "with open('enc', 'r') as file:\n",
+ " content = file.read()\n",
+ " print(content)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Cadena codificada\n",
+ "encoded_string = '灩捯䍔䙻ㄶ形楴獟楮獴㌴摟潦弸彥㜰㍢㐸㙽'\n",
+ "\n",
+ "# Decodificación\n",
+ "print(encoded_string.encode('utf-16-be'))"
+ ],
+ "metadata": {
+ "outputId": "c6ad0cc4-2aac-47c1-e02a-012380b5b049"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# Cadena codificada\n",
- "encoded_string = '灩捯䍔䙻ㄶ形楴獟楮獴㌴摟潦弸彥㜰㍢㐸㙽'\n",
- "\n",
- "# Decodificación\n",
- "print(encoded_string.encode('utf-16-be'))"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "RUNK0rul1gl-",
- "outputId": "c6ad0cc4-2aac-47c1-e02a-012380b5b049"
- },
- "execution_count": 6,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "b'picoCTF{16_bits_inst34d_of_8_e703b486}'\n"
- ]
- }
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "b'picoCTF{16_bits_inst34d_of_8_e703b486}'\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Obedient Cat\n",
+ "\n",
+ "!wget -O flag.txt https://mercury.picoctf.net/static/a5683698ac318b47bd060cb786859f23/flag\n",
+ "!cat flag.txt"
+ ],
+ "metadata": {
+ "outputId": "74f73195-72f3-4a71-c122-089f644fc883"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# Obedient Cat\n",
- "\n",
- "!wget -O flag.txt https://mercury.picoctf.net/static/a5683698ac318b47bd060cb786859f23/flag\n",
- "!cat flag.txt"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "C-COBTd25xcW",
- "outputId": "74f73195-72f3-4a71-c122-089f644fc883"
- },
- "execution_count": 19,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "--2024-04-03 12:21:16-- https://mercury.picoctf.net/static/a5683698ac318b47bd060cb786859f23/flag\n",
- "Resolving mercury.picoctf.net (mercury.picoctf.net)... 18.189.209.142\n",
- "Connecting to mercury.picoctf.net (mercury.picoctf.net)|18.189.209.142|:443... connected.\n",
- "HTTP request sent, awaiting response... 200 OK\n",
- "Length: 34 [application/octet-stream]\n",
- "Saving to: ‘flag.txt’\n",
- "\n",
- "\rflag.txt 0%[ ] 0 --.-KB/s \rflag.txt 100%[===================>] 34 --.-KB/s in 0s \n",
- "\n",
- "2024-04-03 12:21:16 (19.6 MB/s) - ‘flag.txt’ saved [34/34]\n",
- "\n",
- "picoCTF{s4n1ty_v3r1f13d_4a2b35fd}\n"
- ]
- }
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "--2024-04-03 12:21:16-- https://mercury.picoctf.net/static/a5683698ac318b47bd060cb786859f23/flag\n",
+ "Resolving mercury.picoctf.net (mercury.picoctf.net)... 18.189.209.142\n",
+ "Connecting to mercury.picoctf.net (mercury.picoctf.net)|18.189.209.142|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 34 [application/octet-stream]\n",
+ "Saving to: ‘flag.txt’\n",
+ "\n",
+ "\rflag.txt 0%[ ] 0 --.-KB/s \rflag.txt 100%[===================>] 34 --.-KB/s in 0s \n",
+ "\n",
+ "2024-04-03 12:21:16 (19.6 MB/s) - ‘flag.txt’ saved [34/34]\n",
+ "\n",
+ "picoCTF{s4n1ty_v3r1f13d_4a2b35fd}\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# GET aHEAD\n",
+ "\n",
+ "import requests\n",
+ "\n",
+ "# URL del servidor\n",
+ "url = \"http://mercury.picoctf.net:28916/\"\n",
+ "\n",
+ "# Enviar una solicitud GET al servidor\n",
+ "response = requests.get(url)\n",
+ "\n",
+ "# Verificar si la solicitud fue exitosa (código de estado 200)\n",
+ "if response.status_code == 200:\n",
+ " # Imprimir el contenido de la respuesta\n",
+ " print(response.text)\n",
+ "else:\n",
+ " print(\"Error al conectarse al servidor:\", response.status_code, response.reason)\n"
+ ],
+ "metadata": {
+ "outputId": "9514a49b-eac9-4c1c-a535-4a506b3a53cf"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# GET aHEAD\n",
- "\n",
- "import requests\n",
- "\n",
- "# URL del servidor\n",
- "url = \"http://mercury.picoctf.net:28916/\"\n",
- "\n",
- "# Enviar una solicitud GET al servidor\n",
- "response = requests.get(url)\n",
- "\n",
- "# Verificar si la solicitud fue exitosa (código de estado 200)\n",
- "if response.status_code == 200:\n",
- " # Imprimir el contenido de la respuesta\n",
- " print(response.text)\n",
- "else:\n",
- " print(\"Error al conectarse al servidor:\", response.status_code, response.reason)\n"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "4AE5_zdW6T9A",
- "outputId": "9514a49b-eac9-4c1c-a535-4a506b3a53cf"
- },
- "execution_count": 21,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "\n",
- "\n",
- "\n",
- "\n",
- " "
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "doKTeX2r_bq9"
- },
- "outputs": [],
- "source": [
- "!wget -O ende.py https://mercury.picoctf.net/static/2ac2139344d2e734d5d638ac928f1a8d/ende.py\n",
- "!wget -O pw.txt https://mercury.picoctf.net/static/2ac2139344d2e734d5d638ac928f1a8d/pw.txt\n",
- "!wget -O flag.txt.en https://mercury.picoctf.net/static/2ac2139344d2e734d5d638ac928f1a8d/flag.txt.en"
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "!ls\n",
- "!cat ende.py"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "_4R3DUBp_-nY",
- "outputId": "981e79e6-37e9-4147-e746-e12e94e4869e"
- },
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "ende.py flag.txt.en pw.txt sample_data\n",
- "\n",
- "import sys\n",
- "import base64\n",
- "from cryptography.fernet import Fernet\n",
- "\n",
- "\n",
- "\n",
- "usage_msg = \"Usage: \"+ sys.argv[0] +\" (-e/-d) [file]\"\n",
- "help_msg = usage_msg + \"\\n\" +\\\n",
- " \"Examples:\\n\" +\\\n",
- " \" To decrypt a file named 'pole.txt', do: \" +\\\n",
- " \"'$ python \"+ sys.argv[0] +\" -d pole.txt'\\n\"\n",
- "\n",
- "\n",
- "\n",
- "if len(sys.argv) < 2 or len(sys.argv) > 4:\n",
- " print(usage_msg)\n",
- " sys.exit(1)\n",
- "\n",
- "\n",
- "\n",
- "if sys.argv[1] == \"-e\":\n",
- " if len(sys.argv) < 4:\n",
- " sim_sala_bim = input(\"Please enter the password:\")\n",
- " else:\n",
- " sim_sala_bim = sys.argv[3]\n",
- "\n",
- " ssb_b64 = base64.b64encode(sim_sala_bim.encode())\n",
- " c = Fernet(ssb_b64)\n",
- "\n",
- " with open(sys.argv[2], \"rb\") as f:\n",
- " data = f.read()\n",
- " data_c = c.encrypt(data)\n",
- " sys.stdout.write(data_c.decode())\n",
- "\n",
- "\n",
- "elif sys.argv[1] == \"-d\":\n",
- " if len(sys.argv) < 4:\n",
- " sim_sala_bim = input(\"Please enter the password:\")\n",
- " else:\n",
- " sim_sala_bim = sys.argv[3]\n",
- "\n",
- " ssb_b64 = base64.b64encode(sim_sala_bim.encode())\n",
- " c = Fernet(ssb_b64)\n",
- "\n",
- " with open(sys.argv[2], \"r\") as f:\n",
- " data = f.read()\n",
- " data_c = c.decrypt(data.encode())\n",
- " sys.stdout.buffer.write(data_c)\n",
- "\n",
- "\n",
- "elif sys.argv[1] == \"-h\" or sys.argv[1] == \"--help\":\n",
- " print(help_msg)\n",
- " sys.exit(1)\n",
- "\n",
- "\n",
- "else:\n",
- " print(\"Unrecognized first argument: \"+ sys.argv[1])\n",
- " print(\"Please use '-e', '-d', or '-h'.\")\n",
- "\n"
- ]
- }
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "!cat flag.txt.en"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "kwpaza8VAPbx",
- "outputId": "7bb21474-cff3-4401-f367-09742a0959fb"
- },
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "gAAAAABgUAIV8D5MJdzgLLTkkMlbU84ARVwfX4brMt2rJQCjkpLItytfWVZe1L2dp4K8VrKgRU3axStKJEAqcM0iDaxiYE54Boh8UfAAo1RNifKnlDrFz0gLaznVSFVj2xAUa4V3518068f88f9368f88f9368f88f9368f88f93\n"
- ]
- }
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "!cat pw.txt"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "KY4FkihlAevu",
- "outputId": "01e6c1ac-aaf8-4cd6-e4d7-df78cc3289b7"
- },
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "68f88f9368f88f9368f88f9368f88f93\n"
- ]
- }
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "!python3 ende.py -d flag.txt.en"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "A1D0kIzWA2RQ",
- "outputId": "68ea74c7-8b96-4e0c-baf2-65a7777f4623"
- },
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "Please enter the password:68f88f9368f88f9368f88f9368f88f93\n",
- "picoCTF{4p0110_1n_7h3_h0us3_68f88f93}\n"
- ]
- }
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!wget -O ende.py https://mercury.picoctf.net/static/2ac2139344d2e734d5d638ac928f1a8d/ende.py\n",
+ "!wget -O pw.txt https://mercury.picoctf.net/static/2ac2139344d2e734d5d638ac928f1a8d/pw.txt\n",
+ "!wget -O flag.txt.en https://mercury.picoctf.net/static/2ac2139344d2e734d5d638ac928f1a8d/flag.txt.en"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!ls\n",
+ "!cat ende.py"
+ ],
+ "metadata": {
+ "outputId": "981e79e6-37e9-4147-e746-e12e94e4869e"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "!wget -O warm https://mercury.picoctf.net/static/fc1d77192c544314efece5dd309092e3/warm"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "qFC0W_h2Bj2h",
- "outputId": "3a033061-02f6-457d-c304-ba35426ceb7c"
- },
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "--2024-04-07 14:46:20-- https://mercury.picoctf.net/static/fc1d77192c544314efece5dd309092e3/warm\n",
- "Resolving mercury.picoctf.net (mercury.picoctf.net)... 18.189.209.142\n",
- "Connecting to mercury.picoctf.net (mercury.picoctf.net)|18.189.209.142|:443... connected.\n",
- "HTTP request sent, awaiting response... 200 OK\n",
- "Length: 10936 (11K) [application/octet-stream]\n",
- "Saving to: ‘warm’\n",
- "\n",
- "\rwarm 0%[ ] 0 --.-KB/s \rwarm 100%[===================>] 10.68K --.-KB/s in 0s \n",
- "\n",
- "2024-04-07 14:46:20 (188 MB/s) - ‘warm’ saved [10936/10936]\n",
- "\n"
- ]
- }
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "ende.py flag.txt.en pw.txt sample_data\n",
+ "\n",
+ "import sys\n",
+ "import base64\n",
+ "from cryptography.fernet import Fernet\n",
+ "\n",
+ "\n",
+ "\n",
+ "usage_msg = \"Usage: \"+ sys.argv[0] +\" (-e/-d) [file]\"\n",
+ "help_msg = usage_msg + \"\\n\" +\\\n",
+ " \"Examples:\\n\" +\\\n",
+ " \" To decrypt a file named 'pole.txt', do: \" +\\\n",
+ " \"'$ python \"+ sys.argv[0] +\" -d pole.txt'\\n\"\n",
+ "\n",
+ "\n",
+ "\n",
+ "if len(sys.argv) < 2 or len(sys.argv) > 4:\n",
+ " print(usage_msg)\n",
+ " sys.exit(1)\n",
+ "\n",
+ "\n",
+ "\n",
+ "if sys.argv[1] == \"-e\":\n",
+ " if len(sys.argv) < 4:\n",
+ " sim_sala_bim = input(\"Please enter the password:\")\n",
+ " else:\n",
+ " sim_sala_bim = sys.argv[3]\n",
+ "\n",
+ " ssb_b64 = base64.b64encode(sim_sala_bim.encode())\n",
+ " c = Fernet(ssb_b64)\n",
+ "\n",
+ " with open(sys.argv[2], \"rb\") as f:\n",
+ " data = f.read()\n",
+ " data_c = c.encrypt(data)\n",
+ " sys.stdout.write(data_c.decode())\n",
+ "\n",
+ "\n",
+ "elif sys.argv[1] == \"-d\":\n",
+ " if len(sys.argv) < 4:\n",
+ " sim_sala_bim = input(\"Please enter the password:\")\n",
+ " else:\n",
+ " sim_sala_bim = sys.argv[3]\n",
+ "\n",
+ " ssb_b64 = base64.b64encode(sim_sala_bim.encode())\n",
+ " c = Fernet(ssb_b64)\n",
+ "\n",
+ " with open(sys.argv[2], \"r\") as f:\n",
+ " data = f.read()\n",
+ " data_c = c.decrypt(data.encode())\n",
+ " sys.stdout.buffer.write(data_c)\n",
+ "\n",
+ "\n",
+ "elif sys.argv[1] == \"-h\" or sys.argv[1] == \"--help\":\n",
+ " print(help_msg)\n",
+ " sys.exit(1)\n",
+ "\n",
+ "\n",
+ "else:\n",
+ " print(\"Unrecognized first argument: \"+ sys.argv[1])\n",
+ " print(\"Please use '-e', '-d', or '-h'.\")\n",
+ "\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!cat flag.txt.en"
+ ],
+ "metadata": {
+ "outputId": "7bb21474-cff3-4401-f367-09742a0959fb"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "!strings warm"
- ],
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "i2h6ooIgBnew",
- "outputId": "4a03b433-c997-469e-fd9b-ef996182c97b"
- },
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "/lib64/ld-linux-x86-64.so.2\n",
- "Ti{l\n",
- "libc.so.6\n",
- "puts\n",
- "printf\n",
- "__cxa_finalize\n",
- "strcmp\n",
- "__libc_start_main\n",
- "GLIBC_2.2.5\n",
- "_ITM_deregisterTMCloneTable\n",
- "__gmon_start__\n",
- "_ITM_registerTMCloneTable\n",
- "=y\t \n",
- "=W\t \n",
- "=Z\t \n",
- "AWAVI\n",
- "AUATL\n",
- "[]A\\A]A^A_\n",
- "Hello user! Pass me a -h to learn what I can do!\n",
- "Oh, help? I actually don't do much, but I do have this flag here: picoCTF{b1scu1ts_4nd_gr4vy_6635aa47}\n",
- "I don't know what '%s' means! I do know what -h means though!\n",
- ";*3$\"\n",
- "GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0\n",
- "/usr/lib/gcc/x86_64-linux-gnu/7/include\n",
- "/usr/include/x86_64-linux-gnu/bits\n",
- "/usr/include\n",
- "warm.c\n",
- "stddef.h\n",
- "types.h\n",
- "libio.h\n",
- "stdio.h\n",
- "sys_errlist.h\n",
- "_IO_buf_end\n",
- "_old_offset\n",
- "sys_nerr\n",
- "_IO_save_end\n",
- "short int\n",
- "size_t\n",
- "_IO_write_ptr\n",
- "_flags\n",
- "_IO_buf_base\n",
- "_markers\n",
- "_IO_read_end\n",
- "/opt/hacksports/shared/staging/Wave a flag_0_9988863924324850/problem_files\n",
- "stderr\n",
- "_lock\n",
- "long int\n",
- "_cur_column\n",
- "_IO_2_1_stderr_\n",
- "_IO_FILE_plus\n",
- "_pos\n",
- "argv\n",
- "_sbuf\n",
- "_IO_FILE\n",
- "unsigned char\n",
- "argc\n",
- "_IO_2_1_stdin_\n",
- "_IO_marker\n",
- "_shortbuf\n",
- "_IO_write_base\n",
- "_unused2\n",
- "_IO_read_ptr\n",
- "short unsigned int\n",
- "warm.c\n",
- "main\n",
- "_next\n",
- "__pad1\n",
- "__pad2\n",
- "__pad3\n",
- "__pad4\n",
- "__pad5\n",
- "long unsigned int\n",
- "_IO_write_end\n",
- "__off64_t\n",
- "__off_t\n",
- "_chain\n",
- "GNU C11 7.5.0 -mtune=generic -march=x86-64 -g -fstack-protector-strong\n",
- "_IO_backup_base\n",
- "stdin\n",
- "_flags2\n",
- "_mode\n",
- "_IO_read_base\n",
- "_vtable_offset\n",
- "_IO_save_base\n",
- "sys_errlist\n",
- "_fileno\n",
- "stdout\n",
- "_IO_2_1_stdout_\n",
- "_IO_lock_t\n",
- "crtstuff.c\n",
- "deregister_tm_clones\n",
- "__do_global_dtors_aux\n",
- "completed.7698\n",
- "__do_global_dtors_aux_fini_array_entry\n",
- "frame_dummy\n",
- "__frame_dummy_init_array_entry\n",
- "warm.c\n",
- "__FRAME_END__\n",
- "__init_array_end\n",
- "_DYNAMIC\n",
- "__init_array_start\n",
- "__GNU_EH_FRAME_HDR\n",
- "_GLOBAL_OFFSET_TABLE_\n",
- "__libc_csu_fini\n",
- "_ITM_deregisterTMCloneTable\n",
- "puts@@GLIBC_2.2.5\n",
- "_edata\n",
- "printf@@GLIBC_2.2.5\n",
- "__libc_start_main@@GLIBC_2.2.5\n",
- "__data_start\n",
- "strcmp@@GLIBC_2.2.5\n",
- "__gmon_start__\n",
- "__dso_handle\n",
- "_IO_stdin_used\n",
- "__libc_csu_init\n",
- "__bss_start\n",
- "main\n",
- "__TMC_END__\n",
- "_ITM_registerTMCloneTable\n",
- "__cxa_finalize@@GLIBC_2.2.5\n",
- ".symtab\n",
- ".strtab\n",
- ".shstrtab\n",
- ".interp\n",
- ".note.ABI-tag\n",
- ".note.gnu.build-id\n",
- ".gnu.hash\n",
- ".dynsym\n",
- ".dynstr\n",
- ".gnu.version\n",
- ".gnu.version_r\n",
- ".rela.dyn\n",
- ".rela.plt\n",
- ".init\n",
- ".plt.got\n",
- ".text\n",
- ".fini\n",
- ".rodata\n",
- ".eh_frame_hdr\n",
- ".eh_frame\n",
- ".init_array\n",
- ".fini_array\n",
- ".dynamic\n",
- ".data\n",
- ".bss\n",
- ".comment\n",
- ".debug_aranges\n",
- ".debug_info\n",
- ".debug_abbrev\n",
- ".debug_line\n",
- ".debug_str\n"
- ]
- }
- ]
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "gAAAAABgUAIV8D5MJdzgLLTkkMlbU84ARVwfX4brMt2rJQCjkpLItytfWVZe1L2dp4K8VrKgRU3axStKJEAqcM0iDaxiYE54Boh8UfAAo1RNifKnlDrFz0gLaznVSFVj2xAUa4V3518068f88f9368f88f9368f88f9368f88f93\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!cat pw.txt"
+ ],
+ "metadata": {
+ "outputId": "01e6c1ac-aaf8-4cd6-e4d7-df78cc3289b7"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# Information\n",
- "\n",
- "# wget -O cat.jpg https://mercury.picoctf.net/static/fc1d77192c544314efece5dd309092e3/cat.jpg\n",
- "\n",
- "# exiftool cat.jpg -> encontramos una cadena base64 en license\n",
- "\n",
- "# echo -e \"string\" | base64 -d"
- ],
- "metadata": {
- "id": "RS7P2bLNCBCZ"
- },
- "execution_count": null,
- "outputs": []
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "68f88f9368f88f9368f88f9368f88f93\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!python3 ende.py -d flag.txt.en"
+ ],
+ "metadata": {
+ "outputId": "68ea74c7-8b96-4e0c-baf2-65a7777f4623"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# Nice netcat...\n",
- "\n",
- "# nc mercury.picoctf.net 49039\n",
- "\n",
- "# cat flag.txt | tr -cd '[:print:]' | tr '[:lower:]' '[:upper:]'\n",
- "\n",
- "# cyberchef"
- ],
- "metadata": {
- "id": "7Sm2LazmE03k"
- },
- "execution_count": null,
- "outputs": []
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Please enter the password:68f88f9368f88f9368f88f9368f88f93\n",
+ "picoCTF{4p0110_1n_7h3_h0us3_68f88f93}\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!wget -O warm https://mercury.picoctf.net/static/fc1d77192c544314efece5dd309092e3/warm"
+ ],
+ "metadata": {
+ "outputId": "3a033061-02f6-457d-c304-ba35426ceb7c"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [
- "# Tab, Tab, Attack\n",
- "\n",
- "# unzip Addadshashanammu.zip\n",
- "\n",
- "# cd\n",
- "\n",
- "# file fang-of-haynekhtnamet\n",
- "\n",
- "# ./fang-of-haynekhtnamet"
- ],
- "metadata": {
- "id": "rzsE6Jc_InAN"
- },
- "execution_count": null,
- "outputs": []
- },
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "--2024-04-07 14:46:20-- https://mercury.picoctf.net/static/fc1d77192c544314efece5dd309092e3/warm\n",
+ "Resolving mercury.picoctf.net (mercury.picoctf.net)... 18.189.209.142\n",
+ "Connecting to mercury.picoctf.net (mercury.picoctf.net)|18.189.209.142|:443... connected.\n",
+ "HTTP request sent, awaiting response... 200 OK\n",
+ "Length: 10936 (11K) [application/octet-stream]\n",
+ "Saving to: ‘warm’\n",
+ "\n",
+ "\rwarm 0%[ ] 0 --.-KB/s \rwarm 100%[===================>] 10.68K --.-KB/s in 0s \n",
+ "\n",
+ "2024-04-07 14:46:20 (188 MB/s) - ‘warm’ saved [10936/10936]\n",
+ "\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "!strings warm"
+ ],
+ "metadata": {
+ "outputId": "4a03b433-c997-469e-fd9b-ef996182c97b"
+ },
+ "execution_count": null,
+ "outputs": [
{
- "cell_type": "code",
- "source": [],
- "metadata": {
- "id": "ZYiwu8llLzd1"
- },
- "execution_count": null,
- "outputs": []
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "/lib64/ld-linux-x86-64.so.2\n",
+ "Ti{l\n",
+ "libc.so.6\n",
+ "puts\n",
+ "printf\n",
+ "__cxa_finalize\n",
+ "strcmp\n",
+ "__libc_start_main\n",
+ "GLIBC_2.2.5\n",
+ "_ITM_deregisterTMCloneTable\n",
+ "__gmon_start__\n",
+ "_ITM_registerTMCloneTable\n",
+ "=y\t \n",
+ "=W\t \n",
+ "=Z\t \n",
+ "AWAVI\n",
+ "AUATL\n",
+ "[]A\\A]A^A_\n",
+ "Hello user! Pass me a -h to learn what I can do!\n",
+ "Oh, help? I actually don't do much, but I do have this flag here: picoCTF{b1scu1ts_4nd_gr4vy_6635aa47}\n",
+ "I don't know what '%s' means! I do know what -h means though!\n",
+ ";*3$\"\n",
+ "GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0\n",
+ "/usr/lib/gcc/x86_64-linux-gnu/7/include\n",
+ "/usr/include/x86_64-linux-gnu/bits\n",
+ "/usr/include\n",
+ "warm.c\n",
+ "stddef.h\n",
+ "types.h\n",
+ "libio.h\n",
+ "stdio.h\n",
+ "sys_errlist.h\n",
+ "_IO_buf_end\n",
+ "_old_offset\n",
+ "sys_nerr\n",
+ "_IO_save_end\n",
+ "short int\n",
+ "size_t\n",
+ "_IO_write_ptr\n",
+ "_flags\n",
+ "_IO_buf_base\n",
+ "_markers\n",
+ "_IO_read_end\n",
+ "/opt/hacksports/shared/staging/Wave a flag_0_9988863924324850/problem_files\n",
+ "stderr\n",
+ "_lock\n",
+ "long int\n",
+ "_cur_column\n",
+ "_IO_2_1_stderr_\n",
+ "_IO_FILE_plus\n",
+ "_pos\n",
+ "argv\n",
+ "_sbuf\n",
+ "_IO_FILE\n",
+ "unsigned char\n",
+ "argc\n",
+ "_IO_2_1_stdin_\n",
+ "_IO_marker\n",
+ "_shortbuf\n",
+ "_IO_write_base\n",
+ "_unused2\n",
+ "_IO_read_ptr\n",
+ "short unsigned int\n",
+ "warm.c\n",
+ "main\n",
+ "_next\n",
+ "__pad1\n",
+ "__pad2\n",
+ "__pad3\n",
+ "__pad4\n",
+ "__pad5\n",
+ "long unsigned int\n",
+ "_IO_write_end\n",
+ "__off64_t\n",
+ "__off_t\n",
+ "_chain\n",
+ "GNU C11 7.5.0 -mtune=generic -march=x86-64 -g -fstack-protector-strong\n",
+ "_IO_backup_base\n",
+ "stdin\n",
+ "_flags2\n",
+ "_mode\n",
+ "_IO_read_base\n",
+ "_vtable_offset\n",
+ "_IO_save_base\n",
+ "sys_errlist\n",
+ "_fileno\n",
+ "stdout\n",
+ "_IO_2_1_stdout_\n",
+ "_IO_lock_t\n",
+ "crtstuff.c\n",
+ "deregister_tm_clones\n",
+ "__do_global_dtors_aux\n",
+ "completed.7698\n",
+ "__do_global_dtors_aux_fini_array_entry\n",
+ "frame_dummy\n",
+ "__frame_dummy_init_array_entry\n",
+ "warm.c\n",
+ "__FRAME_END__\n",
+ "__init_array_end\n",
+ "_DYNAMIC\n",
+ "__init_array_start\n",
+ "__GNU_EH_FRAME_HDR\n",
+ "_GLOBAL_OFFSET_TABLE_\n",
+ "__libc_csu_fini\n",
+ "_ITM_deregisterTMCloneTable\n",
+ "puts@@GLIBC_2.2.5\n",
+ "_edata\n",
+ "printf@@GLIBC_2.2.5\n",
+ "__libc_start_main@@GLIBC_2.2.5\n",
+ "__data_start\n",
+ "strcmp@@GLIBC_2.2.5\n",
+ "__gmon_start__\n",
+ "__dso_handle\n",
+ "_IO_stdin_used\n",
+ "__libc_csu_init\n",
+ "__bss_start\n",
+ "main\n",
+ "__TMC_END__\n",
+ "_ITM_registerTMCloneTable\n",
+ "__cxa_finalize@@GLIBC_2.2.5\n",
+ ".symtab\n",
+ ".strtab\n",
+ ".shstrtab\n",
+ ".interp\n",
+ ".note.ABI-tag\n",
+ ".note.gnu.build-id\n",
+ ".gnu.hash\n",
+ ".dynsym\n",
+ ".dynstr\n",
+ ".gnu.version\n",
+ ".gnu.version_r\n",
+ ".rela.dyn\n",
+ ".rela.plt\n",
+ ".init\n",
+ ".plt.got\n",
+ ".text\n",
+ ".fini\n",
+ ".rodata\n",
+ ".eh_frame_hdr\n",
+ ".eh_frame\n",
+ ".init_array\n",
+ ".fini_array\n",
+ ".dynamic\n",
+ ".data\n",
+ ".bss\n",
+ ".comment\n",
+ ".debug_aranges\n",
+ ".debug_info\n",
+ ".debug_abbrev\n",
+ ".debug_line\n",
+ ".debug_str\n"
+ ]
}
- ]
-}
\ No newline at end of file
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Information\n",
+ "\n",
+ "# wget -O cat.jpg https://mercury.picoctf.net/static/fc1d77192c544314efece5dd309092e3/cat.jpg\n",
+ "\n",
+ "# exiftool cat.jpg -> encontramos una cadena base64 en license\n",
+ "\n",
+ "# echo -e \"string\" | base64 -d"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Nice netcat...\n",
+ "\n",
+ "# nc mercury.picoctf.net 49039\n",
+ "\n",
+ "# cat flag.txt | tr -cd '[:print:]' | tr '[:lower:]' '[:upper:]'\n",
+ "\n",
+ "# cyberchef"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Tab, Tab, Attack\n",
+ "\n",
+ "# unzip Addadshashanammu.zip\n",
+ "\n",
+ "# cd\n",
+ "\n",
+ "# file fang-of-haynekhtnamet\n",
+ "\n",
+ "# ./fang-of-haynekhtnamet"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git "a/presi\303\263n_hidrost\303\241tica.ipynb" "b/presi\303\263n_hidrost\303\241tica.ipynb"
index 10ecf78..be744fd 100644
--- "a/presi\303\263n_hidrost\303\241tica.ipynb"
+++ "b/presi\303\263n_hidrost\303\241tica.ipynb"
@@ -1,62 +1,48 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyOtwYKMawYJAczZDwZrD4q2",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "0f709470-0af4-4edd-a2f4-39605ac9d612"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "mOFWraBY2Oq4",
- "outputId": "0f709470-0af4-4edd-a2f4-39605ac9d612"
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "La presión hidrostática a 5 metros de profundidad es: 49050.0 Pascals\n"
- ]
- }
- ],
- "source": [
- "# Definir la densidad del agua en kg/m^3 y la gravedad en m/s^2\n",
- "densidad_agua = 1000 # densidad del agua\n",
- "gravedad = 9.81 # aceleración debido a la gravedad\n",
- "\n",
- "# Función lambda para calcular la presión hidrostática\n",
- "presion_hidrostatica = lambda h: densidad_agua * gravedad * h\n",
- "\n",
- "# Calcular la presión a 5 metros de profundidad\n",
- "presion_a_5m = presion_hidrostatica(5) # h = 5 metros\n",
- "print(f'La presión hidrostática a 5 metros de profundidad es: {presion_a_5m} Pascals')\n"
- ]
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "La presión hidrostática a 5 metros de profundidad es: 49050.0 Pascals\n"
+ ]
}
- ]
-}
\ No newline at end of file
+ ],
+ "source": [
+ "# Definir la densidad del agua en kg/m^3 y la gravedad en m/s^2\n",
+ "densidad_agua = 1000 # densidad del agua\n",
+ "gravedad = 9.81 # aceleración debido a la gravedad\n",
+ "\n",
+ "# Función lambda para calcular la presión hidrostática\n",
+ "presion_hidrostatica = lambda h: densidad_agua * gravedad * h\n",
+ "\n",
+ "# Calcular la presión a 5 metros de profundidad\n",
+ "presion_a_5m = presion_hidrostatica(5) # h = 5 metros\n",
+ "print(f'La presión hidrostática a 5 metros de profundidad es: {presion_a_5m} Pascals')\n"
+ ]
+ }
+ ]
+}
diff --git a/race_car.ipynb b/race_car.ipynb
index cca6885..faed61a 100644
--- a/race_car.ipynb
+++ b/race_car.ipynb
@@ -1,187 +1,165 @@
{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "provenance": [],
- "authorship_tag": "ABX9TyPOZQ8nht9roJYjNp3VPu1S",
- "include_colab_link": true
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
},
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "view-in-github",
- "colab_type": "text"
- },
- "source": [
- ""
- ]
- },
- {
- "cell_type": "code",
- "source": [
- "import random\n",
- "import time"
- ],
- "metadata": {
- "id": "1udLuDbOWPit"
- },
- "execution_count": 2,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "# Función para crear una pista con árboles colocados aleatoriamente\n",
- "def crear_pista(longitud, num_arboles):\n",
- " # Inicializar la pista con guiones bajos\n",
- " pista = ['_'] * longitud\n",
- " arboles_colocados = 0\n",
- "\n",
- " # Colocar árboles en posiciones aleatorias en la pista\n",
- " while arboles_colocados < num_arboles:\n",
- " arbol_pos = random.randint(0, longitud - 1)\n",
- " # Asegurarse de no colocar dos árboles en la misma posición\n",
- " if pista[arbol_pos] != '🌲':\n",
- " pista[arbol_pos] = '🌲'\n",
- " arboles_colocados += 1\n",
- "\n",
- " return pista"
- ],
- "metadata": {
- "id": "oqhqy4usWS7P"
- },
- "execution_count": 3,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "# Función para imprimir el estado actual de las pistas\n",
- "def imprimir_pistas(pista1, pista2, pos1, pos2):\n",
- " # Crear copias de las pistas para modificarlas temporalmente\n",
- " pista1_actual = pista1.copy()\n",
- " pista2_actual = pista2.copy()\n",
- "\n",
- " # Colocar los coches en las pistas según sus posiciones actuales\n",
- " if pos1 >= 0:\n",
- " pista1_actual[pos1] = '🚙'\n",
- " if pos2 >= 0:\n",
- " pista2_actual[pos2] = '🚗'\n",
- "\n",
- " # Imprimir las pistas con la meta al principio\n",
- " print('🏁' + ''.join(pista1_actual))\n",
- " print('🏁' + ''.join(pista2_actual))"
- ],
- "metadata": {
- "id": "skJdPIVlWV2E"
- },
- "execution_count": 4,
- "outputs": []
- },
- {
- "cell_type": "code",
- "source": [
- "# Función para simular la carrera\n",
- "def simular_carrera(longitud_pista):\n",
- " # Crear dos pistas con árboles\n",
- " pista1 = crear_pista(longitud_pista, random.randint(1, 3))\n",
- " pista2 = crear_pista(longitud_pista, random.randint(1, 3))\n",
- "\n",
- " # Inicializar las posiciones de los coches al final de las pistas\n",
- " pos1, pos2 = longitud_pista - 1, longitud_pista - 1\n",
- " # Variables para controlar si los coches están detenidos por un árbol\n",
- " turno_detenido1, turno_detenido2 = False, False\n",
- " fin_carrera = False\n",
- "\n",
- " # Bucle para simular cada turno de la carrera\n",
- " while not fin_carrera:\n",
- " # Mover el primer coche si no está detenido\n",
- " if not turno_detenido1:\n",
- " avance1 = random.randint(1, 3)\n",
- " pos1 = max(0, pos1 - avance1)\n",
- " # Detener el coche si choca con un árbol\n",
- " if pista1[pos1] == '🌲':\n",
- " turno_detenido1 = True\n",
- " else:\n",
- " turno_detenido1 = False\n",
- "\n",
- " # Mover el segundo coche si no está detenido\n",
- " if not turno_detenido2:\n",
- " avance2 = random.randint(1, 3)\n",
- " pos2 = max(0, pos2 - avance2)\n",
- " # Detener el coche si choca con un árbol\n",
- " if pista2[pos2] == '🌲':\n",
- " turno_detenido2 = True\n",
- " else:\n",
- " turno_detenido2 = False\n",
- "\n",
- " # Imprimir el estado actual de las pistas\n",
- " imprimir_pistas(pista1, pista2, pos1, pos2)\n",
- " # Pausar un segundo para simular el tiempo de turno\n",
- " time.sleep(1)\n",
- "\n",
- " # Verificar si alguno de los coches ha llegado a la meta\n",
- " if pos1 == 0 or pos2 == 0:\n",
- " fin_carrera = True\n",
- "\n",
- " # Determinar el resultado de la carrera\n",
- " if pos1 == 0 and pos2 == 0:\n",
- " print(\"¡Empate!\")\n",
- " elif pos1 == 0:\n",
- " print(\"¡Gana el coche 🚙!\")\n",
- " else:\n",
- " print(\"¡Gana el coche 🚗!\")"
- ],
- "metadata": {
- "id": "0Z-p98spWYlP"
- },
- "execution_count": 5,
- "outputs": []
- },
+ {
+ "cell_type": "code",
+ "source": [
+ "import random\n",
+ "import time"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Función para crear una pista con árboles colocados aleatoriamente\n",
+ "def crear_pista(longitud, num_arboles):\n",
+ " # Inicializar la pista con guiones bajos\n",
+ " pista = ['_'] * longitud\n",
+ " arboles_colocados = 0\n",
+ "\n",
+ " # Colocar árboles en posiciones aleatorias en la pista\n",
+ " while arboles_colocados < num_arboles:\n",
+ " arbol_pos = random.randint(0, longitud - 1)\n",
+ " # Asegurarse de no colocar dos árboles en la misma posición\n",
+ " if pista[arbol_pos] != '🌲':\n",
+ " pista[arbol_pos] = '🌲'\n",
+ " arboles_colocados += 1\n",
+ "\n",
+ " return pista"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Función para imprimir el estado actual de las pistas\n",
+ "def imprimir_pistas(pista1, pista2, pos1, pos2):\n",
+ " # Crear copias de las pistas para modificarlas temporalmente\n",
+ " pista1_actual = pista1.copy()\n",
+ " pista2_actual = pista2.copy()\n",
+ "\n",
+ " # Colocar los coches en las pistas según sus posiciones actuales\n",
+ " if pos1 >= 0:\n",
+ " pista1_actual[pos1] = '🚙'\n",
+ " if pos2 >= 0:\n",
+ " pista2_actual[pos2] = '🚗'\n",
+ "\n",
+ " # Imprimir las pistas con la meta al principio\n",
+ " print('🏁' + ''.join(pista1_actual))\n",
+ " print('🏁' + ''.join(pista2_actual))"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Función para simular la carrera\n",
+ "def simular_carrera(longitud_pista):\n",
+ " # Crear dos pistas con árboles\n",
+ " pista1 = crear_pista(longitud_pista, random.randint(1, 3))\n",
+ " pista2 = crear_pista(longitud_pista, random.randint(1, 3))\n",
+ "\n",
+ " # Inicializar las posiciones de los coches al final de las pistas\n",
+ " pos1, pos2 = longitud_pista - 1, longitud_pista - 1\n",
+ " # Variables para controlar si los coches están detenidos por un árbol\n",
+ " turno_detenido1, turno_detenido2 = False, False\n",
+ " fin_carrera = False\n",
+ "\n",
+ " # Bucle para simular cada turno de la carrera\n",
+ " while not fin_carrera:\n",
+ " # Mover el primer coche si no está detenido\n",
+ " if not turno_detenido1:\n",
+ " avance1 = random.randint(1, 3)\n",
+ " pos1 = max(0, pos1 - avance1)\n",
+ " # Detener el coche si choca con un árbol\n",
+ " if pista1[pos1] == '🌲':\n",
+ " turno_detenido1 = True\n",
+ " else:\n",
+ " turno_detenido1 = False\n",
+ "\n",
+ " # Mover el segundo coche si no está detenido\n",
+ " if not turno_detenido2:\n",
+ " avance2 = random.randint(1, 3)\n",
+ " pos2 = max(0, pos2 - avance2)\n",
+ " # Detener el coche si choca con un árbol\n",
+ " if pista2[pos2] == '🌲':\n",
+ " turno_detenido2 = True\n",
+ " else:\n",
+ " turno_detenido2 = False\n",
+ "\n",
+ " # Imprimir el estado actual de las pistas\n",
+ " imprimir_pistas(pista1, pista2, pos1, pos2)\n",
+ " # Pausar un segundo para simular el tiempo de turno\n",
+ " time.sleep(1)\n",
+ "\n",
+ " # Verificar si alguno de los coches ha llegado a la meta\n",
+ " if pos1 == 0 or pos2 == 0:\n",
+ " fin_carrera = True\n",
+ "\n",
+ " # Determinar el resultado de la carrera\n",
+ " if pos1 == 0 and pos2 == 0:\n",
+ " print(\"¡Empate!\")\n",
+ " elif pos1 == 0:\n",
+ " print(\"¡Gana el coche 🚙!\")\n",
+ " else:\n",
+ " print(\"¡Gana el coche 🚗!\")"
+ ],
+ "metadata": {},
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "outputId": "eae5d355-83cd-4c24-b035-7a075e81fed9"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "TOxzlHfwWHbC",
- "outputId": "eae5d355-83cd-4c24-b035-7a075e81fed9"
- },
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "🏁_🌲___🌲🚙___\n",
- "🏁__🌲_____🚗_\n",
- "🏁_🌲___🚙____\n",
- "🏁__🌲__🚗____\n",
- "🏁_🌲___🚙____\n",
- "🏁__🌲🚗______\n",
- "🏁_🌲_🚙_🌲____\n",
- "🏁_🚗🌲_______\n",
- "🏁🚙🌲___🌲____\n",
- "🏁🚗_🌲_______\n",
- "¡Empate!\n"
- ]
- }
- ],
- "source": [
- "# Ejecutar la carrera con una longitud de pista especificada\n",
- "longitud_pista = 10\n",
- "simular_carrera(longitud_pista)\n"
- ]
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "🏁_🌲___🌲🚙___\n",
+ "🏁__🌲_____🚗_\n",
+ "🏁_🌲___🚙____\n",
+ "🏁__🌲__🚗____\n",
+ "🏁_🌲___🚙____\n",
+ "🏁__🌲🚗______\n",
+ "🏁_🌲_🚙_🌲____\n",
+ "🏁_🚗🌲_______\n",
+ "🏁🚙🌲___🌲____\n",
+ "🏁🚗_🌲_______\n",
+ "¡Empate!\n"
+ ]
}
- ]
-}
\ No newline at end of file
+ ],
+ "source": [
+ "# Ejecutar la carrera con una longitud de pista especificada\n",
+ "longitud_pista = 10\n",
+ "simular_carrera(longitud_pista)\n"
+ ]
+ }
+ ]
+}
diff --git a/test_exercises.py b/test_exercises.py
new file mode 100644
index 0000000..950472b
--- /dev/null
+++ b/test_exercises.py
@@ -0,0 +1,24 @@
+import unittest
+
+from validate_pin import validate_pin
+from valid_parentheses import valid_parentheses
+
+
+class ParenthesesTests(unittest.TestCase):
+ def test_balanced_and_unbalanced_inputs(self) -> None:
+ self.assertTrue(valid_parentheses("(())((()())())"))
+ self.assertTrue(valid_parentheses(""))
+ self.assertFalse(valid_parentheses(")(()))"))
+ self.assertFalse(valid_parentheses("(()"))
+
+
+class PinTests(unittest.TestCase):
+ def test_only_four_or_six_ascii_digits_are_valid(self) -> None:
+ self.assertTrue(validate_pin("1234"))
+ self.assertTrue(validate_pin("123456"))
+ self.assertFalse(validate_pin("12345"))
+ self.assertFalse(validate_pin("a234"))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/valid_parentheses.py b/valid_parentheses.py
index 9f5888a..6b4cc81 100644
--- a/valid_parentheses.py
+++ b/valid_parentheses.py
@@ -1,42 +1,14 @@
-"""
-Write a function that takes a string of parentheses, and determines if the order of the parentheses is valid. The function should return true if the string is valid, and false if it's invalid.
-
-Examples
-"()" => true
-")(()))" => false
-"(" => false
-"(())((()())())" => true
-
-Constraints
-0 <= length of input <= 100
-
-All inputs will be strings, consisting only of characters ( and ).
-Empty strings are considered balanced (and therefore valid), and will be tested.
-For languages with mutable strings, the inputs should not be mutated.
-
-Protip: If you are trying to figure out why a string of parentheses is invalid, paste the parentheses into the code editor, and let the code highlighting show you!
-"""
-
-def valid_parentheses(string):
- stack = [] # Crea una pila vacía para almacenar los paréntesis de apertura
-
- for char in string: # Itera a través de cada carácter en la cadena
- try:
- if char == '(': # Si el carácter es un paréntesis de apertura
- stack.append('(') # Agrega el paréntesis a la pila
- elif char == ')': # Si el carácter es un paréntesis de cierre
- if stack.pop() != '(': # Intenta sacar un paréntesis de apertura de la pila
- return False # Si no coincide, la cadena es inválida
- except IndexError: # Captura una excepción si ocurre un índice inválido en la pila (cierre sin apertura)
- return False # La cadena es inválida
-
- return len(stack) == 0 # Si la pila está vacía al final, la cadena es válida
-
-# Pruebas
-print(valid_parentheses("()")) # Output: True
-print(valid_parentheses(")(()))")) # Output: False
-print(valid_parentheses("(")) # Output: False
-print(valid_parentheses("(())((()())())")) # Output: True
-print(valid_parentheses("(()")) # Output: False
-print(valid_parentheses("())")) # Output: False
-print(valid_parentheses(")(")) # Output: False
+"""Check whether a string of parentheses is balanced."""
+
+
+def valid_parentheses(string: str) -> bool:
+ """Return whether every opening parenthesis has a matching close."""
+ stack: list[str] = []
+ for char in string:
+ if char == '(':
+ stack.append(char)
+ elif char == ')':
+ if not stack:
+ return False
+ stack.pop()
+ return not stack
diff --git a/validate_pin.py b/validate_pin.py
index d222fad..2f27406 100644
--- a/validate_pin.py
+++ b/validate_pin.py
@@ -13,9 +13,4 @@ def validate_pin(pin):
"""
def validate_pin(pin):
- if pin == "-":
- return False
- # isdigit() verifica si es todo la cadena numerica
- return (len(pin) == 4 or len(pin) == 6) and pin.isdigit()
-
-print(validate_pin("-12345"))
\ No newline at end of file
+ return len(pin) in (4, 6) and pin.isdigit()