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 (http://www.4shared.com/file/134460754/d2da06cc/02_-_Criptografia.html)
Mais conteúdo...
29 apostilas falando de criptografia e algoritmos, totalizando 16,1 MB descompactado..
(http://dc178.4shared.com/download/181790973/7f800a69/criptografia.JPG?tsid=20091226-235309-2c2e5812)
Download das apostilas (http://www.4shared.com/file/181777493/cb3c326c/Criptografia.html)
Complementando o topico segue abaixo uma implementação em C do algoritmo de RSA.
--------------------------------------------------
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 */
/******************************************************************************/
O TrueCrypt é bom.