Лабораторная работа №2 Изучение алгоритма асимметричного шифрования

Цель работы: изучить один из алгоритмов асимметричного шифрования.

Задание: разработать и отладить приложение, реализующее алгоритм асимметричного шифрования RSA.

Ход работы Описание алгоритма

RSA(аббревиатура от фамилий Rivest, Shamir и Adleman) — криптографический алгоритм с открытым ключом, основывающийся на вычислительной сложности задачи факторизации больших целых чисел.

RSA-ключи генерируются следующим образом:

1. Выбираются два различных случайных простых числа pиqзаданного размера (например, 1024 бита каждое).

2. Вычисляется их произведение n=pq, которое называетсямодулем.

3. Вычисляется значение функции Эйлера от числа n:

4. Выбирается целое число  -открытая экспонента, взаимно простое со значением функции. Обычно в качествеeберут простые числа, содержащие небольшое количество единичных бит в двоичной записи, например, простые числа Ферма 17, 257 или 65537.

5. Вычисляется число d – секретная экспонента,  мультипликативно обратное к числуeпо модулю, то есть число, удовлетворяющее условию:

6. Пара {e,n} публикуется в качествеоткрытого ключа RSA(англ.RSA public key).

7. Пара {d,n} играет рользакрытого ключа RSA(англ.RSA private key) и держится в секрете.

Шифрование: .

Дешифрование:

Листинг:

#include <stdio.h>

#include <conio.h>

int phi,M,n,e,d,C,FLAG;

void check()

{

int i;

for(i=3;e%i==0 && phi%i==0;i+2)

{

FLAG = 1;

return;

}

FLAG = 0;

}

void encrypt()

{

int i;

C = 1;

for(i=0;i< e;i++)

C=C*M%n;

C = C%n;

printf("\n\tEncrypted keyword : %d",C);

}

void decrypt()

{

int i;

M = 1;

for(i=0;i< d;i++)

M=M*C%n;

M = M%n;

printf("\n\tDecrypted keyword : %d",M);

}

void main()

{

int p,q,s;

printf("Enter Two Relatively Prime Numbers\t: ");

scanf("%d%d",&p,&q);

n = p*q;

phi=(p-1)*(q-1);

printf("\n\tF(n)\t= %d",phi);

do

{

printf("\n\nEnter e\t: ");

scanf("%d",&e);

check();

}while(FLAG==1);

d = 1;

do{

s = (d*e)%phi;

d++;

}while(s!=1);

d = d-1;

printf("\n\tPublic Key\t: {%d,%d}",e,n);

printf("\n\tPrivate Key\t: {%d,%d}",d,n);

printf("\n\nEnter The Plain Text\t: ");

scanf("%d",&M);

encrypt();

printf("\n\nEnter the Cipher text\t: ");

scanf("%d",&C);

decrypt();

getch();

}

Вывод: я изучил алгоритм RSA.

Лабораторная работа №3 Изучение алгоритма электронной цифровой подписи (эцп)

Цель работы: изучить алгоритм электронной цифровой подписи

Задание: написать программу, реализующую алгоритм DSA.

Ход работы

DSA(Digital Signature Algorithm) — алгоритм с использованием открытого ключа для создания электронной подписи, но не для шифрования. Поскольку подписываемые документы — переменного (и как правило достаточно большого) объёма, в схемах ЭП зачастую подпись ставится не на сам документ, а на его хеш. Для вычисления хэша используются криптографические хеш-функции, что гарантирует выявление изменений документа при проверке подписи. Вместе сDSA часто используется хеш-функцияSHA-1.

Пусть H(x) – хеш-функция,q– большое простое число, размерность которогоNв битах совпадает с размерностью в битах значений хэш-функции H, р – простое число такое, что (р-1) делится наq(битовая длинаpобозначаетсяL),g– число, мультипликативный порядок которого по модулюpравенq. Для его вычисления можно воспользоваться формулой. Тогда:

Листинг:

#include <CkCrypt2.h>

#include <CkDsa.h>

void ChilkatSample(void)

{

bool success;

// Use Chilkat Crypt to hash the contents of a file.

CkCrypt2 crypt;

success = crypt.UnlockComponent("Anything for 30-day trial.");

if (success != true) {

printf("%s\n",crypt.lastErrorText());

return;

}

crypt.put_EncodingMode("hex");

crypt.put_HashAlgorithm("sha-1");

const char * hashStr;

// Return the SHA-1 hash of a file. The file may be any size.

// The Chilkat Crypt component will stream the file when

// computing the hash, keeping the memory usage constant

// and reasonable.

// The 20-byte SHA-1 hash is returned as a hex-encoded string.

hashStr = crypt.hashFileENC("hamlet.xml");

CkDsa dsa;

// The Chilkat Crypt and Chilkat DSA components are separate

// products. To license both, it's least expensive to purchase

// the "Chilkat Bundle" which provides licenses to all the

// Chilkat components.

success = dsa.UnlockComponent("Anything for 30-day trial");

if (success != true) {

printf("%s\n",dsa.lastErrorText());

return;

}

// Load a DSA private key from a PEM file. Chilkat DSA

// provides the ability to load and save DSA public and private

// keys from encrypted or non-encrypted PEM or DER.

// The LoadText method is for convenience only. You may

// use any means to load the contents of a PEM file into

// a string.

const char * pemPrivateKey;

pemPrivateKey = dsa.loadText("dsa_priv.pem");

success = dsa.FromPem(pemPrivateKey);

if (success != true) {

printf("%s\n",dsa.lastErrorText());

return;

}

// You may optionally verify the key to ensure that it is a valid

// DSA key.

success = dsa.VerifyKey();

if (success != true) {

printf("%s\n",dsa.lastErrorText());

return;

}

// Load the hash to be signed into the DSA object:

success = dsa.SetEncodedHash("hex",hashStr);

if (success != true) {

printf("%s\n",dsa.lastErrorText());

return;

}

// Now that the DSA object contains both the private key and hash,

// it is ready to create the signature:

success = dsa.SignHash();

if (success != true) {

printf("%s\n",dsa.lastErrorText());

return;

}

// If SignHash is successful, the DSA object contains the

// signature. It may be accessed as a hex or base64 encoded

// string. (It is also possible to access directly in byte array form via

// the "Signature" property.)

const char * hexSig;

hexSig = dsa.getEncodedSignature("hex");

printf("Signature:\n");

printf("%s\n",hexSig);

// -----------------------------------------------------------

// Step 2: Verify the DSA Signature

// -----------------------------------------------------------

CkDsa dsa2;

// Load the DSA public key to be used for verification:

const char * pemPublicKey;

pemPublicKey = dsa2.loadText("dsa_pub.pem");

success = dsa2.FromPublicPem(pemPublicKey);

if (success != true) {

printf("%s\n",dsa2.lastErrorText());

return;

}

// Load the hash to be verified against the signature.

success = dsa2.SetEncodedHash("hex",hashStr);

if (success != true) {

printf("%s\n",dsa2.lastErrorText());

return;

}

// Load the signature:

success = dsa2.SetEncodedSignature("hex",hexSig);

if (success != true) {

printf("%s\n",dsa2.lastErrorText());

return;

}

// Verify:

success = dsa2.Verify();

if (success != true) {

printf("%s\n",dsa2.lastErrorText());

}

else {

printf("DSA Signature Verified!\n");

}

}

Вывод: я изучил алгоритм DSA.