{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Criptografia - Cifra de Hill\n",
    "#### Vamos aprender um método para codificar mensagens utilizando Cifras de Hill, cujo princípio reside em transformações matriciais. Para isso, vamos usar uma matriz chave e sua inversa mod 26."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Referência: Álgebra Linear com aplicações / Anton Howard e Chris Rorres; trad. Claus Ivo Doering. - 8. ed. - Porto Alegre: Bookman, 2001."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O estudo de codificação e decodificação de mensagens secretas é denomidado criptografia. Embora os códigos secretos remotem aos primórdios da comunicação escrita, tem havido um aumento recente de interesse no assunto devido à necessidade de manter a privacidade da informação transmitida ao longo de linhas públicas de comunicação (um exemplo atual é o sistema de criptografia utilizado pela marca WhatsApp, do Facebook). Na linguagem da criptografia, os códigos são denomidados cifras, as mensagens não codificadas são textos comuns e as mensagens codificadas são textos cifrados ou criptogramas. O processo de converter um texto comum em cifrado é chamado cifrar ou criptografar e o processo inverso de converter um texto cifrado em comum é chamado decifrar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As cifras mais simples, denominadas de cifras de substituição, são as que substituem cada letra do alfabeto por uma outra letra. Para o exemplo que vamos mostrar não vamos usar esse sistema trivial. Vamos substituir cada letra por um número, que pode ser tabelada a demanda do cliente. Entretanto, para esse exemplo, vamos usar a numeração sequencial para fins didáticos:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{bmatrix}\n",
    "          a & b & c & d & e & f & g & h & i & j & k & l & m & n & o & p & q & r & s & t & u & v & w & x & y & z \\\\\n",
    "          1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 & 15 & 16 & 17 & 18 & 19 & 20 & 21 & 22 & 23 & 24 & 25 & 0 \\\\\n",
    "          \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importando a biblioteca de funções numpy do Python\n",
    "import numpy as numpy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "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",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "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])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cifras de Hill (Criptografar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma desvantagem das cifras de substituição é que elas preservam as frequências de letras individuais, tornando relativamente fácil quebrar o código por métodos estatísticos. Uma maneira de superar este problema é dividir o texto em grupos de letras e criptografar o texto comum por grupo, em vez de uma letra de cada vez. Um sistema polígrafo é um sistema de criptografia no qual o texto comum é dividido em n letras, cada um dos quais é substituido por um conjunto de n letras cifradas. Vamos estudar as Cifras de Hill que são baseadas em transformações matriciais. Daqui para frente  nos vamos supor que cada letra de texto comum e de texto cifrado, excetuando o z, tem um valor númerico que especifica sua posição no alfabeto padrão. O z receberá 0 por estarmos trabalhando com operações que envolvem o módulo 26, e como z seria a 26º letra do alfabeto, o seu módulo por 26 é 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos casos mais simples de Cifras de Hill, transformaremos pares sucessivos de texto comum  em texto cifrado pelo seguinte procedimento:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - ) Escolha uma matriz 2 x 2 (poderia ser matrizes de ordens maiores, trabalhando assim com 3 letras consecutivas):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$A = \\begin{bmatrix}\n",
    "              a_{11} & a_{12} \\\\\n",
    "              a_{21} & a_{22} \\\\\n",
    "              \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "com entradas inteiras para efetuar a codificação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 - ) Agrupe letras sucessivas de texto em pares, adicionando uma letra fictícia para completar o último par. Se o texto comum tem um número ímpar de letras, substitua cada letra de texto comum por seu valor numérico."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3 - ) Converta cada par sucessivo $p_{1}p_{2}$ de letras de texto em um vetor-coluna:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$p = \\begin{bmatrix}\n",
    "          p_{1} \\\\\n",
    "          p_{2} \\\\\n",
    "          \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e forme o produto A.p. Nós chamamos p de vetor comum e A.p o correspondente vetor cifrado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com o novo vetor coluna cifrado, é possível que ocorra resultados acima de 25. Em casos como esses, vamos fazer o módulo por 26 de cada elemento do vetor-coluna cifrado, justificando o motivo de z receber 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4 - )  Converta cada vetor cifrado em seu equivalente alfabético."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando uma matriz A, responsável pela segurança da criptografia\n",
    "# definindo a matriz A\n",
    "A = numpy.array([[5,6],[2,3]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# função responsável por codificar nossa matriz, dependendo da matriz inserida\n",
    "# veremos mais abaixo que uma entrada específica de outra matriz é suficiente para decodificar nossa matriz\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",
    "            # caso o valor do resultado codificado no segundo par da letra seja maior que 25, \n",
    "            # substitui pelo valor \n",
    "            # do seu módulo por 26\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# função responsável por pegar o texto a ser encriptado\n",
    "def inserirFrase():\n",
    "    \n",
    "    texto = \"\" # inicializando uma variável vazia\n",
    "    texto = str(input(\"Informe um texto sem acentos: \")) # padrão de entrada para receber uma string\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": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora escolher uma frase a ser encriptada:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Professor Edmar Ensina Muito Bem Algebra Linear\" (sem acentos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Informe um texto sem acentos:  ProfessorEdmarEnsinaMuitoBemAlgebraLinear\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o texto é: professoredmarensinamuitobemalgebralinearg\n"
     ]
    }
   ],
   "source": [
    "# chama a função para adicionar um texto a variável\n",
    "texto = inserirFrase() \n",
    "# a opção por criar tal função advém da necessidade da frase ter que atender aos requisitos \n",
    "# informados acima para ser codificada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora codificar a mensagem inserida acima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fhgviocepytuidezsmxeikizijywylmcnfylyhembe'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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": "markdown",
   "metadata": {},
   "source": [
    "### Cifras de Hill (Descriptografia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de entrar na parte de descriptografia, vamos falar um pouco de aritmética modular, requisito necessário para conseguir descriptografar as frases criptografadas através das Cifras de Hill. Contudo, vamos nos fixar apenas em definições, teoremas e colorários para entender o básico de tal requesito, pois o assunto em sua integridade não é algo que se possa entender de forma superficial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definição: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Dados um número inteiro positivo m e dois inteiros a e b quaisquer, dizemos que a é equivalente a b módulo m, e escrevemos a = b (mod m), se a - b é um múltiplo inteiro de m."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemplos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7 = 2 (mod 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "19 = 3 (mod 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-1 = 25 (mod 26)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12 = 0 (mod 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definição: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Dado um número a em $Z_{m}$, dizemos que um número $a^{-1}$ em $Z_{m}$ é um recíproco, ou inverso multiplicativo de a módulo m se $aa^{-1} = a^{-1}a = 1 (mod m)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Embora existam métodos gerais para resolver equações modulares, ensiná-los seria algo que foge do objetivo de tudo em que estamos trabalhando no momento. Então, vamos ver uma tabela que poderá ajudar a definir nossa matriz de descriptografia:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recíprocos Módulo 26:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\begin{bmatrix}\n",
    "          a & 1 & 3 & 5 & 7 & 9 & 11 & 15 & 17 & 19 & 21 & 23 & 25 \\\\\n",
    "          a^{-1} & 1 & 9 & 21 & 15 & 3 & 19 & 7 & 23 & 11 & 5 & 17 & 25 \\\\\n",
    "          \\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada cifra útil deve possuir um procedimento para decifrar. Para fazer isso com as cifras de Hill, usamos a inversa (mod 26) da matriz codificadora. Para ser preciso, se m é um inteiro positivo, dizemos que uma matriz A com entradas em $Z_{m}$ é invertível módulo m se existir uma matriz B com entradas em $Z_{m}$ tal que:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$AB = BA = I(mod m)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "é invertível módulo 26 e que está matriz é usada para uma 2-cifra de Hill (o 2 indica quantas letras são usadas por grupo de criptografia). Se"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$p = \\begin{bmatrix}\n",
    "              p_{1} \\\\\n",
    "              p_{2} \\\\\n",
    "              \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "é um vetor comum, então"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$c = Ap$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$p = A^{-1}c$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, cada vetor comum pode ser recuperado do correspondente vetor cifrado pela multiplicação à esquerda por $A^{-1}$ (mod 26)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Colorário: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Uma matriz quadrada A com entradas em $Z_{m}$ é invertível módulo m se, e somente se, m e o resíduo de det(A) módulo m não têm fatores primos comuns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Colorário:  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Uma matriz quadrada A com entradas em $Z_{26}$ é invertível módulo 26 se, e somente se, o resíduo de det(A) módulo 26 não é divisível por 2 ou 13."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em suma, temos que a partir dessas definições, teremos os seguintes procedimentos:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$A^{-1} = (ad - bc)^{-1}\\begin{bmatrix}\n",
    "                                 d & -b \\\\\n",
    "                                 -c & a \\\\\n",
    "                                 \\end{bmatrix}(mod 26)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Onde $(ad - bc)^{-1}$ é o recíproco do resíduo de $ad - bc(mod 26)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos encontrar a inversa da matriz A módulo 26:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 6]\n",
      " [2 3]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz A\n",
    "print(\"{}\".format(A)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo a matriz A\n",
    "A = numpy.array([[5,6],[2,3]]) \n",
    "# calculando o resíduo (ad - bc)\n",
    "residuo = (A[0][0] * A[1][1] - A[0][1] * A[1][0]) % 26 \n",
    "# temos a.a^{-1} = 1 (mod 26)\n",
    "# residuo.reciproco = x  = 1 (mod 26)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# imprime o residuo \n",
    "print(\"{}\".format(residuo)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por erro e tentativa temos: $3.9 = 27 = 1(mod 26)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logo o recíproco é 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo o reciproco\n",
    "reciproco = 9 \n",
    "# definindo o posicionamento da matriz invertível (mod 26)\n",
    "descriptografia = numpy.array([[A[1][1], -A[0][1]], [-A[1][0], A[0][0]]]) \n",
    "# realizando a multiplicação com o recíproco\n",
    "descriptografia *= reciproco \n",
    "# definindo o módulo 26 de cada elemento\n",
    "descriptografia %= 26 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 24]\n",
      " [ 8 19]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a matriz descriptograda\n",
    "print(\"{}\".format(descriptografia)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos descriptografar a mensagem criptografada anteriormente, usando a $matriz A^{-1} (mod 26)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definindo a cifra criptografada, dada anteriormente pela criptografia com A\n",
    "cifra = \"fhgviocepytuidezsmxeikizijywylmcnfylyhembe\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'professoredmarensinamuitobemalgebralinearg'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# chamando a função responsável por criptografar/descriptografar\n",
    "cifraHill(cifra,descriptografia) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cifras de Hill (N Camadas de Criptografia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos utilizar o processor de criptografia n vezes consecutivas em uma mesma frase utilizando m matrizes, de modo que ao fazer as m inversíveis módulo 26 das matrizes e realizar n vezes o mesmo processo de criptografia com essas novas matrizes, teremos o texto original em nossas mãos. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos aplicar a criptografia duas vezes consecutivas em uma mesma frase, mas para fins didáticos vamos manter a mesma matriz de transformação definida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Informe um texto sem acentos:  QuemEstudaPassa\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o texto é: quemestudapassag\n"
     ]
    }
   ],
   "source": [
    "# chama a função para receber uma frase e configurá-la para a criptografia\n",
    "frase = inserirFrase() \n",
    "# A Frase é: \"Quem Estuda Passa\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'csywioryzkhiaquw'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cifraHill(frase,A) # imprime a frase criptografada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Informe um texto sem acentos:  csywioryzkhiaquw\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o texto é: csywioryzkhiaquw\n"
     ]
    }
   ],
   "source": [
    "# vamos inserir a frase criptografada\n",
    "frase = inserirFrase() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ykcoekfgngpqcaig'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vamos encriptar uma segunda camada\n",
    "cifraHill(frase,A) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Informe um texto sem acentos:  ykcoekfgngpqcaig\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o texto é: ykcoekfgngpqcaig\n"
     ]
    }
   ],
   "source": [
    "# vamos inserir a frase encriptada por duas vezes consecutivas\n",
    "frase = inserirFrase() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'csywioryzkhiaquw'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vamos descriptografar a primeira camada\n",
    "cifraHill(frase,descriptografia) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Informe um texto sem acentos:  csywioryzkhiaquw\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o texto é: csywioryzkhiaquw\n"
     ]
    }
   ],
   "source": [
    "# vamos inserir a frase novamente para quebrar a segunda e última camada\n",
    "frase = inserirFrase() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'quemestudapassag'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# por fim, vamos descriptografar por completo\n",
    "cifraHill(frase,descriptografia) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aprenda Mais Sobre Criptografia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - ) ABRAHAM SINKOV, Elementary Criptanalysis, a Mathematical Approach(Mathematical Association of America, Mathematical Library, 1966)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 - ) ALAN G. KONHEIM, Cryptography, a Primer(Wiley-Interscience, 1981)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alguma Dúvida? Entre em Contato Comigo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Me envie um e-mail](mailto:alysson.barbosa@ee.ufcg.edu.br);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}