Nome: Paulo Eduardo Rodrigues de Oliveira RA:063570Nome: Pedro Thiago Ezequiel de Andrade RA:063696Nome: Rafael Lucas Gregório D'Oliveira RA:063824

Rsa

Introdução:

Criptografia (Do Grego kryptós, "escondido", e gráphein, "escrita") é o estudo dos princípios e técnicas pelas quais a informação pode ser transformada da sua forma original para outra ilegível, de forma que possa ser conhecida apenas por seu destinatário.

A criptografia pré-computacional era formado por um conjunto de métodos de substituição e transposição dos caracteres de uma mensagem que pudessem ser executados manualmente (ou até mesmo mentalmente) pelo emissor e pelo destinatário da mensagem. O surgimento de máquinas especializadas e, posteriormente, dos computadores ocasionou uma significativa evolução das técnicas criptográficas.

A era da criptografia moderna começa realmente com Claud Shannon, possivelmente o pai da criptografia matemática. Em 1949 ele publicou um artigo Communication Theory of Secrecy Systems com Warren Weaver. Este artigo, junto com outros de seus trabalhos que criaram a área de Teoria da Informação estabeleceu uma base teórica sólida para a criptografia e para a criptoanálise. Depois isso, quase todo o trabalho realizado em criptografia se tornou secreto, realizado em organizações governamentais especializadas (como o NSA nos Estados Unidos). Apenas em meados de 1970 as coisas começaram a mudar.

Em 1976 aconteceram dois grandes marcos da criptografia para o público. O primeiro foi a publicação, pelo governo americano, do DES (Data Encryption Standard), um algoritmo aberto de criptografia simétrica, selecionado pela NIST em um concurso onde foi escolhido uma variante do algoritmo Lucifer, proposto pela IBM. O DES foi o primeiro algoritmo de criptografia disponibilizado abertamente ao mercado.

O segundo foi a publicação do artigo New Directions in Cryptography por Whitfield Diffie e Martin Hellman, que iniciou a pesquisa em sistemas de criptografia de chave pública. Este algoritmo ficou conhecido como "algoritmo Diffie-Hellman para troca de chaves" e levou ao imediato surgimento de pesquisas neste campo, que culminou com a criação do algoritmo RSA, por Ronald Rivest, Adi Shamir e Leonard Adleman.

RSA:

Podemos resumir o RSA em três partes: Geração das chaves, Codificação, e Decodificação.

Geração das chaves:

1 -- Escolhe-se dois números primos p e q.2 -- Calculamos n = p.q.3 -- Daí calculamos φ(n) = (p – 1)(q - 1), onde φ é a função totiente de Euler. 4 -- Escolhe-se um e tal que 1 < e < φ(n) e m.d.c.(φ(n), e) = 1. 5 -- Daí calculamos d de tal forma que d.e ≡ 1 (mod φ(n)).A chave pública o par de números n e eA chave privada o par de números n e d

Codificação:

Primeiramente deve-se converter a mensagem em números. Uma forma é associar a cada caractere um numero de dois dígitos. Se forem usar apenas letras, por exemplo, pode-se fazer A=10, B=11, C=12.... Depois, quebramos a mensagem em blocos, que devem ter valor menor que n.Cada bloco é encriptado separadamente da seguinte forma:

Seja m o bloco. O bloco encriptado será c ≡ me (mod n).

Decodificação:

Para recuperar a mensagem m da mensagem encriptada c basta fazer outra potenciação modular: m ≡ c

d (mod n).

Porque funciona? :

Inicialmente supomos que m.d.c.(m,n) = 1. Daí temos que provar que cd ≡ m (mod n) .

Isto é, me.d

≡ m (mod n). Mas e.d ≡ 1 (mod φ(n)) logo e.d = 1 + r.φ(n). E portanto m

e.d ≡ m.m

r.φ(n) ≡ m (mod n).

Se m.d.c.(m,n) > 1 teremos a igualdade de qualquer forma pois daí m sera divisível por p ou q , e portanto m

e.d ≡ m ≡ 0 (mod p) ou m

e.d ≡ m ≡ 0 (mod q).

Logo, em qualquer caso me.d

≡ m (mod n). Alem disso, como fizemos m<n temos realmente a igualdade m

e.d ≡ m.

Assinatura Digital:

Para que o metodo rsa fique ainda mais seguro, a mensagem pode ser assinada. Suponha que uma mensagem codificada será enviada de a para b, e que ambos tenham uma chave publica C e sua respctiva chave privada D.

Quando a for enviar a mensagem então ao invés de enviar Cb(m), ele envia Da(Cb(m)). Logo quando b receber a mensagem codificada, para decodificar-la ele usa a sua chave privada e a chave publica de b, assim Db(Ca(Da(Cb(m)))) ≡ Db(Cb(m)) ≡ m. Se a mensagem final fizer sentido, então b terá certeza que essa mensagem veio de a.

Segurança do RSA:

Como RSA é um método de chave publica, então quanto mais difícil for de calcular d a partir da chave publica, mais seguro será o método.

Para se calcular d, basta aplicar o algoritmo euclidiano estendido para φ(n) e e. Logo para se calcular d a partir da chave publica é preciso achar φ(n), mas isso implica a fatoração de n. Como achar d sem ter φ(n) também implica a fatoração de n e descobrir a mensagem sem ter d, é inviável e ninguém conseguiu se n é grande, então acredita-se que quebrar o RSA é equivalente a fatorar n, logo basta escolher um n apropriado para que o método seja seguro, já que não existe algoritmo rápido de fatoração.

Algoritmo em C:

Programa que codifica:

#include <stdio.h>#include <math.h>#include <stdlib.h>

/*Esse programa codifica em criptografia RSA qualquer mensagem com menos 50 caracteres (letras minusculas e _ que será usado no lugar do espaço). Nesse programa são usadas a chave publica geral (40297,449) e a chave de decodificação para assinar o codigo (29489,20459). Na chave geral n = 683*59 logo a chave de decodificação geral é (40297,4493), na chave da assinatura n = 797*37 e a chave publica da assinatura é (29489,1283). Tanto a chave de decodificação geral quanto a chave publica da assinatura seram usadas no programa que descodifica o codigo aqui gerado. Observe que o n da chave publica é maior que o n da chave da assinatura. Isso não é por acaso e seá¡ explicado mais a frente.*/

long long int potmod (int a,int e,long long int n){ /*função que calcula pontenciação mod n isso é a^e mod n*/long long int t=1;int i;for (i=1;i<=e;i++) t = t*a%n;return t;}

int main (){char mc[50] ;int mi[50],i,j,k=0,e=1,c[20],d[20];FILE *arq;arq = fopen("codigo.txt" , "w") ;/*Nesse arquivo será guardada a mensagem codificada*/printf ("Use somente letra minúcula e _ ao invés de espaço.\n");

while (e==1 || e==0){/*A variavel "e" será usada para identificar se existe caracteres não reconhecidos pelo código, caso exista a mensagem deverá ser reescrita sem estes caracteres*/ e = 1; printf ("Mensagem: "); scanf("%s", mc); for (i=0;mc[i]!=0;i++){ mi[i] = mc[i]; /*Para a pré-codificação, os caracteres são transformados em inteiros segundo a tabela ascii...*/ if (mi[i]==95) mi[i] = 99; else {/*...depois subtrai 87 de todos os inteiros para que tenham 2 algarismos*/ if (mi[i]>=97) mi[i] = mi[i] - 87; else e = 0; } } if (e==0) printf("Sua mensagem tem caracteres indisponíveis, escreva-a denovo.\n"); else e = 2; }j=0;while (j<i-2){/*Para terminar o pré-codificação os inteiros seram reagrupados tentando fazer que os novos inteiros que sejam menores e o mais proximo possivel, com os mesmo algarismo e em mesma ordem, de n da chave da assinatura.*/ c[k] = mi[j]*10000 + mi[j+1]*100 + mi[j+2]; if (c[k]<29489) j = j+3; else { if (c[k]/10<29489 && c[k]%10!=0) { /*Caso o resto seja 0, como esse resto será o primeiro algarismo a esquerda ele seria perdido, para que isso não aconteça...*/ mi[j+2] = c[k]%10; c[k] = c[k]/10; j = j+2; } else {/*...se usa dois inteiros para formar o novo inteiro*/ c[k] = c[k]/100; j = j+2; } } k++; }/*procedimento que evita erros*/if (j==i-2) c[k] = 100*mi[j] + mi[j+1];if (j==i-1) c[k] = mi[j];for (i=0;i<=k;i++){/*Enfim a codificação final. Aqui já da para perceber porque o n da chave publica é maior que o n da chave da assinatura. Como depois da codificação os inteiros não podem ser reagrupados ((a^e)^d=a) senão a mensagem será perdida, para que após a primeira codificação o inteiro não fique maior que o n da segunda codificação, basta tomar o primeiro n menor que o segundo, já que o inteiro codificado será menor que o primeiro n. E não haverá problemas na decodificação ja (a^e)^d=a e a é menor que o n da chave assinatura.*/ d[i] = potmod (c[i],20459,29489); d[i] = potmod (d[i],449,40297); fprintf(arq, "%d ",d[i]); }fclose(arq);}

Programa que decodifica:

#include <stdio.h> #include <math.h> #include <stdlib.h>

/*Na decodificação será usada primeiro a chave de decodificação geral (40297,4493) e depois a chave publica da assinatura (29489,1283).Assim sendo a mensagem "a", será enviada a mensagem "(a^da)^eg" onde da é a chave de decodificação da assinatura e eg é a chave puglica geral, logo a mensagem decodificada será "(((a^da)^eg)^dg)^ea=(a^da)^ea=a"*/

long long int potmod (int a,int e,long long int n){ /*função que calcula pontenciação mod n isso é a^e mod n*/long long int t=1;int i;for (i=1;i<=e;i++) t = t*a%n;return t;}

int main (){char mc[50] ;int mi[50],i,j,k=0,e=1,c[20],d[20],r;FILE *arq;arq = fopen("codigo.txt" , "r") ;for (i=0;!feof(arq);i++){/*primeira parte da decodificação, onde será obtida a mensagem após a pré-codificação*/ fscanf(arq,"%d",&d[i]); c[i] = potmod (d[i],4493,40297); c[i] = potmod (c[i],1283,29489); }for (j=0; j<i-1; j++){/*Segunda parte da decodificação, onde será reagrupado os algarismo em pares*/ if (c[j]>=10000) c[j] = r*100000 + c[j]; else { if (c[j]>=1000) c[j] = r*10000 + c[j]; else { if (c[j]>=100) c[j] = r*1000 + c[j]; else { if (c[j]>=10) c[j] = r*100 + c[j]; else c[j] = 10*r + c[j]; } } } if (c[j]>=100000 || (c[j]<10000 && c[j]>=1000) || c[j]<100) r=0; if (c[j]<100000 && c[j]>=10000){ r = c[j]%10; c[j] = c[j]/10;} if (c[j]<1000 && c[j]>=100){ r = c[j]%10; c[j] = c[j]/10;} mi[k] = c[j]/10000; if (mi[k]!=0) {c[j] = c[j]%10000; k++;} mi[k] = c[j]/100; if (mi[k]!=0) {c[j] = c[j]%100; k++;} mi[k] = c[j]; k++; }for (i=0;i<k;i++) {/*E aqui onde enfim os inteiros são transformados em caracteres, retornando a mensagem original*/if (mi[i]!=99) mc[i] = mi[i]+87;else mc[i] = 95;}printf("%s\n",mc);}