[Material] Criptografia

[sirbagda]

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 (detentor da "chave secreta"), o que a torna difícil de ser lida por alguém não autorizado. Assim sendo, só o receptor da mensagem pode ler a informação com facilidade. É um ramo da Matemática, parte da Criptologia. (fonte: http://pt.wikipedia.org/wiki/Criptografia)

A video aula foi retirada de um curso de delphi. Mas esta video aula, não tem nada a ver com delphi, fala do basico sobre criptografia. É um ótimo conteúdo.

Formato: AVI
Tamanho: 16,062 KB
Duração: 5:34
Idioma: Português brasileiro
Hospedagem: 4shared
Download ou Visualização

Mais conteúdo...

29 apostilas falando de criptografia e algoritmos, totalizando 16,1 MB descompactado..



Download das apostilas

[VonNatur]

Complementando o topico segue abaixo uma implementação em C do algoritmo de RSA.

Código Selecionar Expandir


--------------------------------------------------
6.1 :: Simple RSA in C
--------------------------------------------------


/******************************************************************************/
/* SIMPLE RSA IN C */
/* BY RoOtLiQuId */
/******************************************************************************/
/* */
/* NESTA VERSAO EU IMPLEMENTEI O RSA BEM SIMPLES DE MANEIRA QUE FIQUE FACIL */
/* DE ENTENDER */
/* NAO USEI NENHUMA BIBLIOTECA, E POR ISSO A MAIOR CHAVE RSA QUE PODEMOS TER */
/* VAI SER DE 32 BITS DEVIDO A LIMITACAO DA ARITMETICA PADRAO DA LINGUAGEM C */
/******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>




#define ULONG unsigned long long
#define LONG long long



/* como nao ensinei um jeito de achar numeros primos,
aki vao 2 numeros primos predefinidos*/
#define PRIMO1 17863
#define PRIMO2 17851




typedef struct RSA_PublicKEY {
ULONG N;
ULONG E;
} RSA_PublicKEY;


typedef struct RSA_KEY {

/* Private Key : */ ULONG D;

RSA_PublicKEY publicKey;

} RSA_KEY;





/******************************************************************************/
/* Aqui se faz o calculo do "modular inverse of an integer when that integer */
/* is relatively prime to the modulus" */
/* hehehehe, ou seja: */
/* Devemos achar D tal que : ( E*D ) % PHI == 1 */
/* Portanto usamos o Fuckin Bizzarre "Extended Euclidian Algorithm" */
/*Veja mais em http://www.grc.nasa.gov/WWW/price000/pfc/htc/zz_xeuclidalg.html*/
/******************************************************************************/
ULONG RSA_extend(ULONG E, ULONG PHI) {
LONG q, u2, u3, v2, v3, t2, t3;

u2 = 0;
u3 = (LONG)PHI;
v2 = 1;
v3 = (LONG)E;

while (v3 != 0)
{
q = u3/v3 ;
t2 = u2 - q * v2;
t3 = u3 - q * v3;

u2 = v2;
u3 = v3;

v2 = t2;
v3 = t3;
}
printf("u2 = %d u3 = %d\n", u2, u3);

if (u2 < 0)
return (ULONG)u2 + PHI;
else
return (ULONG)u2;
}




/******************************************************************************/
/* Calculo do GREATEST COMMON DIVISOR */
/* ou seja, Maior Divisor Comum ou MDC */
/******************************************************************************/
ULONG RSA_GCD( ULONG e, ULONG PHI ) {
ULONG a, great;

if (e > PHI) {
while (e%PHI != 0) {
a = e%PHI;
e = PHI;
PHI = a;
}
great = PHI;
} else {
while (PHI%e != 0) {
a = PHI%e;
PHI = e;
e = a;
}
great = e;
}
return great;
}




/******************************************************************************/
/* Calculo necessario para encontrar o E da formula: */
/* E satisfaz a condição: MDC( E, PHI ) == 1 */
/******************************************************************************/
ULONG RSA_tofindE( ULONG PHI, ULONG P, ULONG Q ) {
ULONG great;
ULONG e;

great = 0;
e = 2;

while (great != 1) {
e = e + 1;
great = RSA_GCD(e,PHI);
}
return e;
}




/******************************************************************************/
/* Aqui vamos usar os numeros primos PRIMO1 e PRIMO2 definidos lah em cima */
/* para gerar as chaves publicas e privadas */
/******************************************************************************/
void RSA_generateKey( RSA_KEY * key ){
ULONG P, Q, PHI;

P = PRIMO1 ;

Q = PRIMO2 ;

PHI = (P - 1) * (Q - 1);
key->publicKey.E = RSA_tofindE( PHI, P, Q );
key->publicKey.N = P * Q;
key->D = RSA_extend( key->publicKey.E, PHI );


printf( "PHI %u ", PHI );
printf( " N %u ", key->publicKey.N );
printf( " E %u ",key->publicKey.E );
printf( " D %u ",key->D );
printf( "\n\n" );
}




/******************************************************************************/
/* Funcao usada para encriptar um numero ULONG data */
/* precisamos apenas da chave publica */
/* */
/* Cripted = Message^E mod N; */
/******************************************************************************/
ULONG RSA_PublicEncrypt( ULONG data, RSA_PublicKEY publicKey ){
ULONG C, F, i;


/* Metodo ruin:
C = (ULONG)pow(data, publicKey.E) % publicKey.N;

Este metodo eh ruin pois vc vai elevar um numero grande a outro muito
grande e depois com esse resultado vai fazer um modulo pelo numero N
Ao inves de fazer assim, podemos simplismente fazer um loop onde vamos
multiplicando o numero por ele mesmo e jah vai fazendo modulo por N
Assim economizamos precisao, pois nunca teremos um numero super
gigantesco, ele vai ficar sempre no maximo do tamanho de N
*/

if ( publicKey.E % 2 == 0) {
C = 1;
F = (data*data) % publicKey.N;

for ( i = 1; i <= publicKey.E/2; i++) {
C = (F*C) % publicKey.N;
}

} else {
C = data;
F = (data*data) % publicKey.N;

for ( i = 1; i <= publicKey.E/2; i++) {
C = (F*C) % publicKey.N;
}

}


printf( " %u Encripted is:", data );
printf(" %u \n", C );

return C;
}



/******************************************************************************/
/* funcao usada para desencriptar um numero ULONG C */
/* Precisaremos da chave privada */
/* */
/* Message = Cripted^D mod N */
/******************************************************************************/
ULONG RSA_PrivateDecrypt( ULONG C, RSA_KEY key ){
ULONG G, F;
ULONG i;

/* metodo Ruin:
G = (ULONG)(pow( C, key.D )) % key.publicKey.N;
pelo mesmo motivo anterior
*/

if ( key.D % 2 == 0) {
G = 1;
F = (C*C) % key.publicKey.N;
for ( i = 1; i <= key.D/2; i++) {
G = (F*G) % key.publicKey.N;
}
} else {
G = C;
F = (C*C) % key.publicKey.N;
for ( i = 1; i <= key.D/2; i++) {
G = (F*G) % key.publicKey.N;
}
}




printf( " %u Decripted is:", C );
printf( " %u \n\n", G );

}



/* Fuckin Main Function */
int main(){

RSA_KEY key; /* declaracao da nossa chave */

printf("\n");

RSA_generateKey( &key ); /* Geramos a chave */


/* Encriptamos o numero 123456789 */
ULONG c = RSA_PublicEncrypt( (ULONG)(123456789), key.publicKey );


/* Pegamos o numero encriptado e descriptografamos para ver se fica
igual ao inicial */
RSA_PrivateDecrypt( c, key );

printf("\n");

return 0;
}
/******************************************************************************/
/* END OF SIMPLE RSA IN C */
/******************************************************************************/


[SPYTECH]

O TrueCrypt é bom.