09_ntb_cifraHilll.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNt54JG95NlEzhnzRnf8x1a",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/luasampaio/CienciaDados/blob/main/ntb_cifraHilll.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### A Cifra de Hill\n",
        "- É uma técnica de criptografia simétrica baseada em álgebra linear, que utiliza matrizes para transformar o texto original em texto cifrado. Foi desenvolvida por Lester S. Hill em 1929 e é uma das primeiras cifras poligráficas que opera em blocos de texto.\n",
        "\n",
        "\n",
        "### Pontos de Atenção\n",
        "- Determinante: A matriz 𝐾\n",
        "K deve ter determinante coprimo com 26\n",
        "26 para ser invertível.\n",
        "Segurança: Embora inovadora em seu tempo, a Cifra de Hill não é segura contra ataques modernos e é usada apenas para fins educacionais.\n",
        "- Se precisar de um exemplo completo ou implementação em código, é só avisar!\n",
        "\n"
      ],
      "metadata": {
        "id": "otC9JI_RDByE"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ngEVoU9RDzcd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# importando a biblioteca de funções numpy do Python\n",
        "import numpy as numpy"
      ],
      "metadata": {
        "id": "iY2agjXHCzDw"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "egWAx1MqCs7P"
      },
      "outputs": [],
      "source": [
        "# Função responsável por retornar o equivalente numérico para as letras do alfabeto\n",
        "def equivalenteDecimal(letra):\n",
        "\n",
        "    # definindo uma cadeia de caracteres com todas as letras do alfabeto\n",
        "    alfabeto = \"zabcdefghijklmnopqrstuvwxy\"\n",
        "\n",
        "    # encontra a posição da letra na string e a retorna\n",
        "    return(alfabeto.find(letra))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "equivalenteDecimal('a')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Brymr5SREP3l",
        "outputId": "06962f92-b8e9-4523-e970-bb372322d862"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# função responsável por retornar o equivalente alfabético para um valor numérico\n",
        "def equivalenteAlfabetico(numero):\n",
        "\n",
        "    # definindo uma cadeia de caracteres com todas as letras do alfabeto\n",
        "    alfabeto = \"zabcdefghijklmnopqrstuvwxy\"\n",
        "\n",
        "    # encontra o pedaço da string a qual o número correspondente indica\n",
        "    return(alfabeto[numero])"
      ],
      "metadata": {
        "id": "YM4RNrnMEdYd"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "equivalenteAlfabetico(23)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "eEXqLEJtEfq7",
        "outputId": "a4e2bca3-4f4f-469f-9c89-469d51f62b19"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'w'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def cifraHill(texto,chave):\n",
        "\n",
        "    # inicializa a variável que vai receber a mensagem codificada\n",
        "    codigo = \"\"\n",
        "    # criando uma matriz responsável por receber o valor númerico equivalente ao alfabético\n",
        "    valorNumerico = numpy.empty([2,1], dtype = int)\n",
        "    # as inicializações indicam que ela será um vetor-coluna do tipo inteiro\n",
        "\n",
        "    # criando uma matriz responsável por receber o valor codificado equivalente ao alfabético\n",
        "    valorCodificado = numpy.empty([2,1], dtype = int)\n",
        "    # as inicializações indicam que ela será um vetor-coluna do tipo inteiro\n",
        "\n",
        "    # estrutura de repetição for responsável para codificar cada par do texto formado\n",
        "    for indice in range(0, len(texto)):\n",
        "\n",
        "        # estrutura de seleção if responsável por adicionar o valor numérico para a primeira letra do par\n",
        "        if(indice == 0 or indice % 2 == 0):\n",
        "\n",
        "            # pega exatamente a letra localizada no elemento numerico de 'indice'\n",
        "            valor = equivalenteDecimal(texto[indice])\n",
        "            # adiciona na primeira linha da primeira coluna\n",
        "            valorNumerico[0][0] = valor\n",
        "\n",
        "        # estrutura de seleção responsável por adicionar o valor numérico para a segunda letra do par\n",
        "        if(indice != 0 and indice % 2 != 0):\n",
        "\n",
        "            # pega exatamente a letra localizada no elemento numerico de 'indice'\n",
        "            valor = equivalenteDecimal(texto[indice])\n",
        "            # adiciona na segunda linha da primeira coluna\n",
        "            valorNumerico[1][0] = valor\n",
        "\n",
        "        # estrutura de seleção responsável por calcular a multiplicação da matriz A pelo vetor-coluna\n",
        "        # dos pares numéricos\n",
        "        if(indice != 0 and indice % 2 != 0):\n",
        "            # realiza a multiplicação da matriz A com os pares de números equivalentes a letras\n",
        "            valorCodificado = numpy.dot(chave, valorNumerico)\n",
        "\n",
        "            # caso o valor do resultado codificado no primeiro par da letra seja maior que 25,\n",
        "            # substitui pelo valor\n",
        "            # do seu módulo por 26\n",
        "            if(valorCodificado[0][0] > 25):\n",
        "                valorCodificado[0][0] = (valorCodificado[0][0] % 26)\n",
        "\n",
        "\n",
        "            if(valorCodificado[1][0] > 25):\n",
        "                valorCodificado[1][0] = (valorCodificado[1][0] % 26)\n",
        "\n",
        "            # pega o equivalente alfabético para os novos números codificados, visando\n",
        "            # construir a frase codificada\n",
        "            a = str(equivalenteAlfabetico(valorCodificado[0][0])) # primeira linha do vetor-coluna\n",
        "            b = str(equivalenteAlfabetico(valorCodificado[1][0])) # segunda linha do vetor-coluna\n",
        "\n",
        "            # adiciona letra por letra codificada a uma variável string para montar a frase\n",
        "            codigo += a\n",
        "            codigo += b\n",
        "\n",
        "    # remove os caracteres desnecessários e mostra somente a parte codificada\n",
        "    codigo = codigo[len(codigo) - len(texto): len(codigo)]\n",
        "\n",
        "    # função retorna código\n",
        "    return codigo"
      ],
      "metadata": {
        "id": "J5iGPfmiEpo3"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "source": [
        "# função responsável por pegar o texto a ser encriptado\n",
        "def inserirFrase(texto_entrada=\"\"): # Add a parameter to accept the input text\n",
        "                                      # Provide a default empty string in case no input is provided during the call.\n",
        "\n",
        "    texto = texto_entrada  # Assign the input text to the 'texto' variable\n",
        "    texto = texto.replace(\" \", \"\") # eliminando os espaços em branco do texto\n",
        "    texto = texto.lower() # deixando toda a string com letras minúsculas\n",
        "\n",
        "    # caso o texto tenha uma quantidade ímpar de letras, adiciona mais uma letra arbitrária ao final\n",
        "    if(len(texto) % 2 != 0):\n",
        "        texto += \"g\" # adiciona-se g, por exemplo\n",
        "\n",
        "    print(\"o texto é: {}\".format(texto)) # imprime o texto informado na tela\n",
        "\n",
        "    return texto # retorna a frase pronta para o sistema de criptografia"
      ],
      "cell_type": "code",
      "metadata": {
        "id": "4jK0ILOoFO8q"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "inserirFrase('Hoje o dia esta lindoo')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "p8qMNYtnFQLm",
        "outputId": "053c92e5-4857-4246-ee24-4b5eb8b5ac5b"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "o texto é: hojeodiaestalindoo\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hojeodiaestalindoo'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "texto = inserirFrase()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R_q4oasnFn-N",
        "outputId": "5bf837db-628f-4f4f-d5c1-16d473a17bc2"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "o texto é: \n"
          ]
        }
      ]
    },
    {
      "source": [
        "import numpy as numpy\n",
        "\n",
        "\n",
        "\n",
        "# Define the key matrix A\n",
        "A = numpy.array([[5, 17], [8, 3]])\n",
        "\n",
        "texto = inserirFrase()\n",
        "\n",
        "cifraHill(texto, A) # função responsável por criptografar o texto\n",
        "# entrada do parâmetro da string de texto e da matriz chave"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "zJAosoMAFzik",
        "outputId": "d8c61cff-996f-45d3-9816-2404e9af5347"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "o texto é: \n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "''"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "akighf2OIox1"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}