SISTEMAS DE CRIPTOGRAFIA 6.0 – Criptografia Simétrica e Assimétrica
Passo 4: Processamento da mensagem em blocos de 16 words
6.2.2.4.2 – Descrição do Algoritmo MD5
O MD5 foi desenvolvido por Ron Rivest em 1991. É basicamente o MD4 com um cinto de segurança, no qual os cálculos são um pouco mais lentos, mas, em compensação, o algoritmo é muito mais seguro.265
Da mesma forma que outras funções hash, o MD5 é usado em assinaturas digitais em que um texto longo precisa ser "comprimido" de forma segura antes de ser cifrado com uma chave privada por um criptossistema de chave pública. Foi projetado para máquinas de 32 bits, podendo ser facilmente programado de forma compacta.
A entrada do MD5 é um fluxo de dados (mensagem) que pode ter um número arbitrário de bits, representado por b, um número inteiro positivo que varia de zero até o infinito. Para obter o digesto da mensagem, seus bits, representados por m0, m1, ..., m{b- 1}, onde b = número de bits da mensagem, são submetidos a diversas operações.
Assim como no MD4, este processo é dividido em cinco etapas ou passos. Devido a problemas de segurança,266 o MD5 foi aperfeiçoado, usando-se várias técnicas:
• Adicionando-se uma quarta rodada.
• Usando uma constante aditiva única em cada etapa das rodadas.
• Fazendo a função G menos simétrica, mudando-a de (XY or XZ or YZ) para (XZ or Y not(Z))
• Promovendo um "efeito avalanche" mais rápido, com cada etapa adicionando seu resultado à etapa anterior.
• Mudando a ordem da entrada dos words nas rodadas 2 e 3 para tornar seus padrões menos parecidos.
• Otimizando as rotações de cada rodada para obter um "efeito avalanche" mais rápido.
6.2.2.5 – O Algoritmo SHS (SHA-1)
O algoritmo Secure Hash Standard – SHS é uma função hash proposta pelo NIST e adotada como padrão pelo governo norte-americano. Foi projetada para ser usada junto com o Digital Signature Standard – DSS, e é parte de um projeto governamental chamado Projeto Capstone (Capstone Project).267
O SHS produz um hash-value de 160 bits a partir de uma entrada de tamanho variável. É estruturalmente similar ao MD4 e MD5. Apesar de ser cerca de 25% mais lento do que o MD5, pode ser mais seguro, porque produz digestos que são cerca de 25% maiores do que os produzidos pelas funções MD.
264 O processo completo pode ser visto em: http://www.numaboa.com/criptografia/hashes (para MD4 e
MD5).
265 Ver: http://pajhome.org.uk/crypt/md5/.
266 Em 2005, Xiaoyun Wang, Xuejia Lai, Dengguo Feng, Hui Chen e Xiuyuan Yu apresentaram um
método de criptoanálise das funções hash MD4, MD5, HAVAL-128 e RIPEMD, o qual reduzia drasticamente o tempo para encontrar colisões nas mesmas.
O SHA-1268 foi aprovado em 1995 pelo governo dos EUA para ser usado por todos os departamentos e agências federais na autenticação de documentos digitais. É um padrão usado para calcular a representação condensada de uma mensagem ou arquivo de dados. Partindo de uma mensagem menor do que 264 bits, o SHA-1 produz uma saída de 160 bits (o digesto da mensagem), que pode ser a entrada para o DSA269 (Digital Signature Algorithm - Algoritmo de Assinatura Digital)270, que gera ou faz a
verificação da assinatura da mensagem.271 Antes do cálculo do digesto, o tamanho em bits da mensagem deve ser ajustado, as funções para os cálculos preparadas e algumas constantes, definidas.
O SHA-1 é considerado seguro porque é quase impossível encontrar uma mensagem que corresponda a um determinado digesto, ou encontrar duas mensagens diferentes que produzam o mesmo digesto. Qualquer alteração feita numa mensagem em trânsito, dará quase que certamente como resultado um digesto diferente, e a assinatura não poderá ser confirmada.
Ele pode ser aplicado, juntamente com o DSA, em e-mails, transferências eletrônicas de fundos, distribuição de software, armazenamento de dados ou outras aplicações que requeiram garantia de integridade e autenticação da origem dos dados.
6.2.2.5.1 – SHA-1 em Javascript – 1272
/*
* A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
* in FIPS PUB 180-1
* Version 2.1a Copyright Paul Johnston 2000 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet * Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for details. */
/*
* Configurable variables. You may need to tweak these to be compatible with
* the server-side, but the defaults work in most cases. */
var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */
var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */
268 O SHA-1 é uma revisão técnica do SHA, na qual foi adicionada uma operação de deslocamento
circular (shift) para a esquerda, para aumentar a segurança. Ele baseia-se nos mesmos princípios usados no algoritmo MD4. Além do SHA-1 e do MD5 existe o Whirlpool, adotado como padrão internacional pela norma ISO 10118-3 (o Whirlpool foi criado pelo brasileiro Paulo Barreto, professor da USP). Para download do código do Whirlpool em Java: http://www.koders.com/java/fidD7A13FF01887615B939ECFCDEAA9C4A606C83117.aspx.
269 Ver: http://en.wikipedia.org/wiki/Digital_Signature_Algorithm. Ver também:
http://www.braghetto.eti.br/files/Trabalho%20Oficial%20Final%20RSA.pdf.
270 Ver item 11.3.2.6.2.
271 A eficiência do processo é maior quando se cria uma assinatura para o digesto, ao invés de criar uma
para a mensagem; isso porque o digesto da mensagem é menor do que a mensagem. Tanto o verificador quanto o criador devem usar o mesmo algoritmo hash para gerar e verificar uma assinatura digital.
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64 encoded strings
*/
function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}
/*
* Perform a simple self-test to see if the VM is working */ function sha1_vm_test() { return hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d"; } /*
* Calculate the SHA-1 of an array of big-endian words, and a bit length
*/
function core_sha1(x, len) { /* append padding */ x[len >> 5] |= 0x80 << (24 - len % 32); x[((len + 64 >> 9) << 4) + 15] = len; var w = Array(80); var a = 1732584193; var b = -271733879; var c = -1732584194; var d = 271733878; var e = -1009589776;
for(var i = 0; i < x.length; i += 16) { var olda = a; var oldb = b; var oldc = c; var oldd = d; var olde = e; for(var j = 0; j < 80; j++) { if(j < 16) w[j] = x[i + j]; else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1); var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), safe_add(safe_add(e, w[j]), sha1_kt(j))); e = d;
c = rol(b, 30); b = a; a = t; } a = safe_add(a, olda); b = safe_add(b, oldb); c = safe_add(c, oldc); d = safe_add(d, oldd); e = safe_add(e, olde); }
return Array(a, b, c, d, e);
} /*
* Perform the appropriate triplet combination function for the current
* iteration */
function sha1_ft(t, b, c, d) {
if(t < 20) return (b & c) | ((~b) & d); if(t < 40) return b ^ c ^ d;
if(t < 60) return (b & c) | (b & d) | (c & d); return b ^ c ^ d;
} /*
* Determine the appropriate additive constant for the current iteration */ function sha1_kt(t) { return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : (t < 60) ? -1894007588 : -899497514; } /*
* Calculate the HMAC-SHA1 of a key and some data */
function core_hmac_sha1(key, data) {
var bkey = str2binb(key);
if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz);
var ipad = Array(16), opad = Array(16);
for(var i = 0; i < 16; i++) {
ipad[i] = bkey[i] ^ 0x36363636; opad[i] = bkey[i] ^ 0x5C5C5C5C; }
var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length
* chrsz);
return core_sha1(opad.concat(hash), 512 + 160); }
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters. */
function safe_add(x, y) {
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16); return (msw << 16) | (lsw & 0xFFFF);
} /*
* Bitwise rotate a 32-bit number to the left. */
function rol(num, cnt) {
return (num << cnt) | (num >>> (32 - cnt)); }
/*
* Convert an 8-bit or 16-bit string to an array of big-endian words * In 8-bit function, characters >255 have their hi-byte silently ignored.
*/
function str2binb(str) {
var bin = Array();
var mask = (1 << chrsz) - 1;
for(var i = 0; i < str.length * chrsz; i += chrsz)
bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i%32);
return bin; }
/*
* Convert an array of big-endian words to a string */
function binb2str(bin) {
var str = "";
var mask = (1 << chrsz) - 1;
for(var i = 0; i < bin.length * 32; i += chrsz)
str += String.fromCharCode((bin[i>>5] >>> (32 - chrsz - i%32)) & mask);
return str; }
/*
* Convert an array of big-endian words to a hex string. */
function binb2hex(binarray) {
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef"; var str = "";
for(var i = 0; i < binarray.length * 4; i++) {
str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) + hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8 )) & 0xF); }
return str; }
/*
* Convert an array of big-endian words to a base-64 string */ function binb2b64(binarray) { var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; var str = "";
for(var i = 0; i < binarray.length * 4; i += 3) {
var triplet = (((binarray[i >> 2] >> 8 * (3 - i %4)) & 0xFF) << 16)
| (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
| ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF); for(var j = 0; j < 4; j++)
{
if(i * 8 + j * 6 > binarray.length * 32) str += b64pad; else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F); } } return str; } 6.2.2.5.2 – SHA-1 em Javascript – 2273 /** *
* Secure Hash Algorithm (SHA1) * http://www.webtoolkit.info/ * **/ function SHA1 (msg) { function rotate_left(n,s) { var t4 = ( n<<s ) | (n>>>(32-s)); return t4; }; function lsb_hex(val) { var str=""; var i; var vh; var vl; for( i=0; i<=6; i+=2 ) { vh = (val>>>(i*4+4))&0x0f; vl = (val>>>(i*4))&0x0f; str += vh.toString(16) + vl.toString(16); } return str; }; function cvt_hex(val) { var str=""; var i; var v; 273 Ver: http://www.webtoolkit.info/javascript-sha1.html.
for( i=7; i>=0; i-- ) { v = (val>>>(i*4))&0x0f; str += v.toString(16); } return str; }; function Utf8Encode(string) {
string = string.replace(/\r\n/g,"\n"); var utftext = "";
for (var n = 0; n < string.length; n++) {
var c = string.charCodeAt(n);
if (c < 128) {
utftext += String.fromCharCode(c);
}
else if((c > 127) && (c < 2048)) {
utftext += String.fromCharCode((c >> 6)
| 192);
utftext += String.fromCharCode((c & 63)
| 128);
}
else {
utftext += String.fromCharCode((c >> 12)
| 224);
utftext += String.fromCharCode(((c >> 6)
& 63) | 128);
utftext += String.fromCharCode((c & 63)
| 128); } } return utftext; }; var blockstart; var i, j;
var W = new Array(80); var H0 = 0x67452301; var H1 = 0xEFCDAB89; var H2 = 0x98BADCFE; var H3 = 0x10325476; var H4 = 0xC3D2E1F0; var A, B, C, D, E; var temp; msg = Utf8Encode(msg);
var msg_len = msg.length;
var word_array = new Array();
for( i=0; i<msg_len-3; i+=4 ) {
j = msg.charCodeAt(i)<<24 | msg.charCodeAt(i+1)<<16 |
msg.charCodeAt(i+2)<<8 | msg.charCodeAt(i+3);
word_array.push( j );
}
switch( msg_len % 4 ) { case 0: i = 0x080000000; break; case 1: i = msg.charCodeAt(msg_len-1)<<24 | 0x0800000; break; case 2: i = msg.charCodeAt(msg_len-2)<<24 | msg.charCodeAt(msg_len-1)<<16 | 0x08000; break; case 3: i = msg.charCodeAt(msg_len-3)<<24 |
msg.charCodeAt(msg_len-2)<<16 | msg.charCodeAt(msg_len-1)<<8 | 0x80;
break;
}
word_array.push( i );
while( (word_array.length % 16) != 14 ) word_array.push( 0 );
word_array.push( msg_len>>>29 );
word_array.push( (msg_len<<3)&0x0ffffffff );
for ( blockstart=0; blockstart<word_array.length;
blockstart+=16 ) {
for( i=0; i<16; i++ ) W[i] = word_array[blockstart+i];
for( i=16; i<=79; i++ ) W[i] = rotate_left(W[i-3] ^
W[i-8] ^ W[i-14] ^ W[i-16], 1);
A = H0; B = H1; C = H2; D = H3; E = H4; for( i= 0; i<=19; i++ ) {
temp = (rotate_left(A,5) + ((B&C) | (~B&D)) + E
+ W[i] + 0x5A827999) & 0x0ffffffff;
E = D; D = C; C = rotate_left(B,30); B = A; A = temp; } for( i=20; i<=39; i++ ) { temp = (rotate_left(A,5) + (B ^ C ^ D) + E +
W[i] + 0x6ED9EBA1) & 0x0ffffffff;
E = D; D = C; C = rotate_left(B,30); B = A; A = temp; } for( i=40; i<=59; i++ ) {
temp = (rotate_left(A,5) + ((B&C) | (B&D) |
(C&D)) + E + W[i] + 0x8F1BBCDC) & 0x0ffffffff;
E = D; D = C; C = rotate_left(B,30); B = A; A = temp; } for( i=60; i<=79; i++ ) { temp = (rotate_left(A,5) + (B ^ C ^ D) + E +
W[i] + 0xCA62C1D6) & 0x0ffffffff;
E = D; D = C; C = rotate_left(B,30); B = A; A = temp; } H0 = (H0 + A) & 0x0ffffffff; H1 = (H1 + B) & 0x0ffffffff; H2 = (H2 + C) & 0x0ffffffff; H3 = (H3 + D) & 0x0ffffffff; H4 = (H4 + E) & 0x0ffffffff; }
var temp = cvt_hex(H0) + cvt_hex(H1) + cvt_hex(H2) +
cvt_hex(H3) + cvt_hex(H4);
return temp.toLowerCase();
6.2.2.6 – O Sistema Kerberos274
Este é um sistema de autenticação de rede por chave-secreta desenvolvido pelo MIT, que usa o DES para encriptação e autenticação. Ele não produz assinaturas digitais, mas provê autenticação em tempo real em ambientes distribuídos (distributed environment). Neste sistema há um Servidor Kerberos na rede o qual: centraliza a gerência de chaves; contém as chaves secretas de todos os usuários; gera chaves solicitadas; autentica a identidade de usuários. Se o Servidor for invadido, toda a segurança do sistema ficará comprometida.
6.2.2.7 – Padrões PKCS275
O PKCS (Public-Key Cryptography Standards) é um conjunto de padrões para a implementação de criptografia de chave pública. É compatível com o PEM e com os padrões CCITT X.509. Alguns algoritmos específicos suportam RSA, DES e o algoritmo Diffie-Hellman de troca de chave.276
274 Ver: http://web.mit.edu/Kerberos/. Para download do Free Kerberos Security JavaScript:
http://scripts.top4download.com/free-kerberos-security/javascript/.
275 Ver: http://en.wikipedia.org/wiki/PKCS.
276 RSAREF: O RSA Laboratories fornece sem custo uma coleção de rotinas de criptografia em código C
para RSA, MD2, MD5 e DES, as quais são plenamente compatíveis com PEM e com os padrões PKCS (não podem ser exportadas para fora dos EUA). Ver: http://www.rsa.com/rsalabs/node.asp?id=2124.
6.2.2.8 – Algoritmos de Espalhamento
A chave, na criptografia de chave pública, é baseada em um hash value. Esse valor é calculado a partir de um número de entrada baixo, utilizando um algoritmo de espalhamento. Basicamente, esse valor é um sumário (digesto) dos valores de origem. O importante, sobre esses hash value, é que se torne quase impossível derivar o número original de entrada sem conhecer os dados utilizados para criá-lo. Eis um exemplo:
Número de entrada Algoritmo de espalhamento Hash value
10.667 # input x 143 1.525.381
Observa-se que é difícil determinar quais os fatores cujo produto é o valor 1.525.381 (ele veio da multiplicação de 10.667 por 143). Mas se se soubesse que o fator multiplicador era 143, então seria fácil calcular o valor 10.667.
As chaves públicas geralmente utilizam algoritmos complexos e hash value muito grandes para criptografia, incluindo números de 40 bits ou até mesmo de 128 bits. Um número de 128 bits possui cerca de 2128 combinações, ou (3402823669209384634633746074300000000000000000000000000000000000000) diferentes combinações possíveis.
6.2.3 – O Algoritmo RSA
Este é um algoritmo de encriptação de dados,277 de chave assimétrica, talvez um
dos mais seguros algoritmos de encriptação atuais. Ele originou-se dos estudos dos matemáticos do Ronald Rivest, Adi Shamir e Leonard Adleman (fundadores da empresa RSA Data Security, Inc.). Tem por fundamento a Teoria dos Números. Foi o primeiro algoritmo a possibilitar encriptação e assinatura digital, e uma das grandes inovações em criptografia de chave pública. O RSA não gera chaves criptografadas, apenas utiliza chaves já criadas por meio de tecnologia de chaves públicas.
Definições básicas:
• Chave: é uma informação restrita que controla toda a operação dos algoritmos de criptografia. No processo de codificação, uma chave opera a transformação do texto claro em um texto criptografado.
• Chave Privada: é uma informação pessoal que permanece de posse da pessoa e não é publicável (ou seja, deve ser mantida em sigilo).
• Chave Pública: é uma informação associada a uma pessoa, e que é distribuída a todos (ou seja, a chave pública pode ser conhecida por todos).
Qualquer mensagem cifrada usando a chave pública só poderá ser decifrada usando-se a respectiva chave privada.
O princípio do algoritmo é construir chaves públicas e privadas utilizando números primos. A questão da escolha dos números primos é fundamental para o algoritmo. Por essa razão, são escolhidos números primos gigantescos (de cem dígitos
277 Ele é composto de um sistema de criação de chaves, um algoritmo de encriptação e um algoritmo de
cada um, no mínimo) para garantir que a chave seja inquebrável (sua segurança baseia- se exatamente na atual intratabilidade da fatoração dos produtos de dois números primos gigantes278).
Em traços gerais, são gerados dois pares de números – as chaves – de tal forma que uma mensagem encriptada com o primeiro par possa ser apenas desencriptada com o segundo par; entetanto, o segundo número não pode ser derivado do primeiro. Esta propriedade assegura que o primeiro número possa ser divulgado a alguém que pretenda enviar uma mensagem encriptada ao detentor do segundo número, já que apenas essa pessoa pode desencriptar.279
6.2.3.1 – Geração das Chaves RSA
Um usuário B, para determinar seu par (PB,SB), procede da seguinte maneira: escolhe ao acaso dois primos grandes p e q e computa o seu produto (n=p*q), e o número f(n)=(p-1)*(q-1); B escolhe ao acaso um número c relativamente primo com f(n) (ou seja, c e f(n) não possuem fatores em comum), e determina d tal que c*d (módulo f(n)). Finalmente, o usuário B publica sua chave pública PB(c,n) e mantém secretos p, q, f(n) e d. A chave secreta SB(d,n) deve ser mantida em sigilo completo.
As chaves são geradas da seguinte maneira:
1. Escolher de forma aleatória dois números primos grandes e 2. Computar
3. Computar a função totiente280 em : .
4. Escolher um inteiro tal que 1 < < , de forma que e sejam primos entre si.
5. Computar de forma que , ou seja, seja o inverso multiplicativo de em .
• No passo 1 os números podem ser testados probabilisticamente para
primalidade.
• No passo 5 é usado o algoritmo de Euclides estendido, e o conceito de inverso
multiplicativo da aritmética modular. A chave pública é o par de números e . A chave privada é o par de números e .
278 Este algoritmo mostra-se computacionalmente inquebrável com números de tais dimensões, e a sua
força é geralmente quantificada com o número de bits utilizados para descrever tais números. Para um número de 100 dígitos são necessários cerca de 350 bits, e as implementações atuais superam os 512 e mesmo os 1024 bits.
279 RSA ern Perl: http://www.webreference.com/perl/tutorial/16/2.html. Ver também:
http://everything2.com/title/RSA+in+3+lines+of+perl.
280 A função totiente, ou função phi (fi) – representada por φ(x) – é definida para um número natural x como sendo igual à quantidade de números menores que x co-primos com respeito a ele.
Matematicamente: . Por exemplo, φ(8) = 4, uma
vez que 1, 3, 5 e 7 são co-primos de 8 [números co-primos são os que não têm nenhum fator comum maior do que 1]. Veja-se o artigo Função Totiente de Euler na Wikipédia, em: http://pt.wikipedia.org/wiki/Fun%C3%A7%C3%A3o_totiente_de_Euler.
• Encriptação:
Para transformar uma mensagem em uma mensagem encriptada usando a chave pública do destinatário e , basta fazer uma potenciação modular (há um algoritmo para realizar esta potência rapidamente).
A mensagem então pode então ser transmitida em canal inseguro para o receptor. • Desencriptação:
Para recuperar a mensagem da mensagem encriptada usando a respectiva chave privada do receptor e , basta fazer outra potenciação modular:
Exemplo:
Para entender melhor, serão escolhidos números primos pequenos, para permitir um acompanhamento de todo o processo de cifragem e decifragem.
• P = 17 • Q = 11
A seguir são calculados dois novos números N e Z de acordo com os números P e Q escolhidos:
• N = P * Q = 17 * 11 = 187
• Z = (P - 1) * (Q - 1) = 16 * 10 = 160
Agora define-se um número D que tenha a propriedade de ser primo em relação à Z. No caso, escolheu-se o número 7, ou seja:
• D = 7
De posse desses números, tem início o processo de criação das chaves públicas e privadas. É necessário encontrar um número E que satisfaça a seguinte propriedade:
• (E * D) mod Z = 1
Se forem feitos os testes com 1, 2, 3... encontra-se:
• E = 1 => (1 * 7) mod 160 = 7 • E = 2 => (2 * 7) mod 160 = 14 • E = 3 => (3 * 7) mod 160 = 21 • ... • E = 23 => (23 * 7) mod 160 = 1 • ...
• E = 183 => (183 * 7) mod 160 = 1 281 • ... • E = 343 => (343 * 7) mod 160 = 1 • ... • E = 503 => (503 * 7) mod 160 = 1 • ...
Então, a propriedade indicada é satisfeita pelos números 23, 183, 343 e 503. Para simplificar os cálculos, será tomado como referência:
E = 23.
Com esse processo definem-se as chaves de encriptação e desencriptação. Para encriptar, usar E e N (23 e 187). Esse par de números é utilizado como chave pública.
Para desencriptar, usar D e N (7 e 187). Esse par de números é utilizado como chave privada.
As equações são:
Texto criptografado = (Texto original ^ E) mod N Texto original = (Texto criptografado ^ D) mod N Exemplo prático:
Seja encaminhar uma mensagem curta, a letra D, por exemplo, aqui representada pelo número 4, tendo por base as chaves estabelecidas.
Para encriptar:
Texto original = 4
Texto criptografado = (4 ^ 23) mod 39
Texto criptografado = 70.368.744.177.664 mod 39 Texto criptografado = 64
Para desencriptar:
Texto recebido = 64
Texto original = (64 ^ 7) mod 39
Texto original = 4.398.046.511.104 mod 39
Texto original = 4
6.2.3.2 – Assinatura Digital com RSA
Para implementar um sistema de assinaturas digitais com RSA, o usuário que possua uma chave privada d pode assinar uma dada mensagem (em blocos) m com a seguinte expressão:
Como já se viu, é difícil descobrir s sem o conhecimento de d. Portanto, uma assinatura digital definida conforme esta equação é difícil de forjar; além disso, o emissor de m não pode negar tê-la emitido, pois ninguém mais poderia ter criado a assinatura. O receptor recupera a mensagem utilizando a chave pública e do emissor:
Como tal, o receptor consegue validar a assinatura do emissor calculando se mod n. Como se pode verificar, o algoritmo RSA satisfaz os três requisitos básicos de uma assinatura digital.
A assinatura varia dependente da mensagem em si, assim, operando sobre mensagens longas, o tamanho da assinatura se torna proporcional a ela. Para evitar isso, faz-se operar o algoritmo sobre um resumo (digesto) da mensagem que identifique essa mensagem como única (geralmente, o digesto de uma mensagem varia alterando um único byte). Em consequência, uma assinatura varia de mensagem para mensagem, para um mesmo emissor.282
6.2.3.3 – Funcionamento do RSA
Uma analogia bastante conhecida no meio acadêmico é a transmissão de mensagens entre Alice e Bob.
Alice e Bob são personagens fictícios que precisam trocar mensagens seguras entre si, sem que estas sejam interceptadas. O algoritmo RSA permite essa troca segura de mensagens, pela utilização de chaves públicas e privadas:
• Alice cria seu par de chaves (uma pública e outra privada) e envia sua chave pública para todos, inclusive Bob;
• Bob escreve sua mensagem para Alice. Após escrevê-la, Bob faz a cifragem do texto final com a chave pública de Alice, gerando um texto criptografado;
• Alice recebe o texto criptografado de Bob e a decifra utilizando a sua chave privada.
O procedimento é realizado com sucesso porque somente a chave privada de Alice é capaz de decifrar um texto criptografado com a sua chave pública.
É importante destacar que se for aplicada a chave pública de Alice sobre o texto critografado, não se consegue a mensagem original de Bob. Dessa forma, mesmo que a mensagem seja interceptada, é impossível decifrá-la sem a chave privada de Alice. Quando Alice quer mandar uma mensagem para Bob, ela busca a chave pública dele em um diretório, usa-a para encriptar a mensagem e a envia. Bob usa a sua chave privada para desencriptar a mensagem e lê-la.
Este sistema também permite a autenticação digital de mensagens, ou seja é possível prover certeza ao receptor sobre a identidade do transmissor e sobre a integridade da mensagem. Quando uma mensagem é encriptada com uma chave privada, ao invés da chave pública; o resultado é uma assinatura digital, ou seja, uma mensagem que só uma pessoa poderia produzir, mas que todos possam verificar.
Na implementação de códigos por hardware, a maior desvantagem do RSA é a sua capacidade de canal limitada, ou seja, o número de bits de mensagem que ele pode transmitir por segundo. Enquanto um chip DES pode processar informação na ordem de milhões de bits por segundo, um chip RSA consegue fazê-lo somente na ordem de mil bits por segundo.
6.2.3.4 – Noções Avançadas de RSA283
d = e-1 mod Φ : a segunda chave de um par, inversa da primeira no anel ZΦ(n) é
calculada pelo algoritmo de Euclides extendido:
O algoritmo funciona devido ao Teorema de Fermat:
6.2.3.4.1 – Segurança do Algoritmo
Os parâmetros p, q e Φ(n) permitem calcular dA a partir de eA. Portanto, devem
ser protegidos juntamente com dA.
Por força bruta, pode-se tentar fatorar n para se obter Φ(n) e saber em que anel