Министерство науки и высшего образования Российской Федерации Федеральное государственное автономное образовательное учреждение высшего образования

ТОМСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ СИСТЕМ УПРАВЛЕНИЯ И РАДИОЭЛЕКТРОНИКИ (ТУСУР)

Кафедра комплексной информационной безопасности электронно-вычислительных систем (КИБЭВС)

ШИФРОВАНИЕ ДАННЫХ С ПОМОЩЬЮ ETOKEN

Отчет по лабораторной работе №6

по дисциплине «Программно-аппаратные средства защиты информации»

		Студент гр. 731-2
		__________
		Руководитель
		Преподаватель каф. КИБЭВС
		__________

Введение

Цель работы: ознакомиться с типами шифрования и механизмами, обеспечивающими генерацию ключей eToken, научиться осуществлять шифрование и расшифровывание данных с помощью eToken.

1 Ход работы

Первоочередно были созданы два файла согласно методическим указаниям: один менее 128 байт, другой более, что представлено на рисунке 1.1.

Рисунок 1.1 – Создание файлов с данными

Далее был добавлен метод, который генерировал сессионный ключ, что представлено на рисунке 1.2.

Рисунок 1.2 – Функция генерации сессионного ключа

Далее была описана часть функции main в которой происходит открытие сессии, логи, чтение файла и создание сессионного ключа, что представлено на рисунке 1.3.

Рисунок 1.3 – Первая часть функции main

Далее была описана часть функции main в которой происходит приведение длины данных к необходимой длине и их шифрование, что представлено на рисунке 1.4.

Рисунок 1.4 – Вторая часть функции main с шифрованием

Далее была описана часть функции main в которой происходит вызов функции расшифрования, вывод расшифрованных данных и выход из сессии, что представлено на рисунке 1.5.

Рисунок 1.5 – Третья часть функции main с расшифрованием

Далее были была проверена работоспособность программы на ранее созданных файлах, что представлено на рисунках 1.6 – 1.7.

Рисунок 1.6 – Проверка на файле размером более 128 байт

Рисунок 1.7 – Проверка на файле размером менее 128 байт

Заключение

В ходе выполнения лабораторной работы было произведено ознакомление с типами шифрования и механизмами, обеспечивающими генерацию ключей eToken, и получены навыки осуществлять шифрование и расшифровывание данных с помощью eToken.

Приложение 1

#include "stdlib.h"

#include "stdio.h"

#include "include\eTPkcs11.h"

#include <windows.h>

#include <iostream>

#include "fstream"

using namespace std;

void init();

void leave(const char*);

CK_FUNCTION_LIST_PTR pFunctionList=NULL;

CK_C_GetFunctionList pGFL = 0;

bool

wasInit = false;

void init()

{

HINSTANCE hLib = LoadLibraryA("etpkcs11.DLL");

if (hLib == NULL)

{

leave ("Cannot load DLL.");

}

(FARPROC&)pGFL= GetProcAddress(hLib, "C_GetFunctionList");

if (pGFL == NULL)

{

leave ("Cannot find GetFunctionList().");

}

if (CKR_OK != pGFL(&pFunctionList))

{

leave ("Can't get function list. \n");

}

if (CKR_OK != pFunctionList->C_Initialize (0))

{

leave ("C_Initialize failed...\n");

}

wasInit = true;

}

static void leave(const char * message)

{

if (message) printf("%s ", message);

if(wasInit)

{

if (CKR_OK != pFunctionList->C_Finalize(0))

{

printf ("C_Finalize failed...\n");

}

wasInit = false;

}

exit(message ? -1 : 0 );

}

static CK_ULONG GetFirstSlotId( )

{

CK_ULONG slotID = -1;

CK_ULONG ulCount = 0;

CK_SLOT_ID_PTR pSlotIDs = NULL_PTR;

CK_ULONG i;

if (pFunctionList->C_GetSlotList(TRUE,NULL_PTR,&ulCount) ==

CKR_OK)

{

if (ulCount > 0)

{

pSlotIDs = new CK_SLOT_ID[ulCount];

if ((pFunctionList->C_GetSlotList(TRUE,pSlotIDs,&ulCount))

== CKR_OK)

{

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

{

CK_SLOT_INFO info;

if ((pFunctionList->C_GetSlotInfo(pSlotIDs[i],&info)) == CKR_OK)

{

if (info.flags & (CKF_HW_SLOT ||CKF_TOKEN_PRESENT))

{

slotID = pSlotIDs[i];

break;

}

}

}

}

}

}

if (pSlotIDs)

{

delete[] pSlotIDs;

pSlotIDs = NULL_PTR;

}

return slotID;

}

static bool ReadDataFromFile(const char* fileName, CK_BYTE_PTR* data, DWORD* dataSize)

{

bool ret = false;

HANDLE file = CreateFileA(fileName, GENERIC_READ, 0, NULL,

OPEN_EXISTING, 0, NULL);

if (file != INVALID_HANDLE_VALUE)

{

DWORD size = GetFileSize(file, NULL);

if (size != INVALID_FILE_SIZE)

{

*data = new BYTE[size];

if (ReadFile(file, *data, size, dataSize, NULL)) {

ret = true;

}

}

CloseHandle(file);

}

return true;

}

static bool SaveDataToFile(const char* fileName, CK_BYTE_PTR* data, DWORD* dataSize)

{

bool ret = true;

HANDLE file = CreateFileA(fileName, GENERIC_WRITE, 0, NULL,

CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

if (file != INVALID_HANDLE_VALUE)

{

DWORD tmp=0;

if (WriteFile(file, *data, *dataSize, &tmp, NULL))

{

ret = false;

}

CloseHandle(file);

}

return ret;

}

CK_OBJECT_CLASS cko_SecretKey = CKO_SECRET_KEY;

CK_KEY_TYPE ckk_DES3 = CKK_DES3;

CK_BYTE ck_False = FALSE;

CK_MECHANISM ckm_DES3_KEY_GEN = {CKM_DES3_KEY_GEN, NULL, 0};

CK_MECHANISM ckm_DES3 = {CKM_DES3_CBC, NULL, 0};

#define sizeofarray(a) (sizeof(a)/sizeof(a[0]))

CK_OBJECT_HANDLE CreateSessionKey(CK_SESSION_HANDLE hSession)

{

CK_ATTRIBUTE SessionKeyTemplate[] =

{

{ CKA_CLASS, &cko_SecretKey, sizeof(cko_SecretKey)},

{ CKA_KEY_TYPE, &ckk_DES3, sizeof(ckk_DES3)},

{ CKA_TOKEN, &ck_False, sizeof(ck_False)}

};

CK_OBJECT_HANDLE hSessionKey = NULL;

int rv = pFunctionList->C_GenerateKey(

hSession,

&ckm_DES3_KEY_GEN,

SessionKeyTemplate,

sizeofarray(SessionKeyTemplate),&hSessionKey);

if (rv!=CKR_OK) leave("Ошибка генерации секртеного ключа");

return hSessionKey;

}

int main()

{

init();

//char path[100];

//char path[100] = "D:\\2.txt";

char path[100] = "D:\\1.txt";

char pass[20];

printf("Path to file: ");

//gets(path);

printf("\nPIN-code: ");

gets(pass);

CK_ULONG slotID = GetFirstSlotId();

if (slotID == -1)

{

leave("Token unconnected");

}

CK_SESSION_HANDLE hSession;

CK_OBJECT_HANDLE hKey;

CK_BYTE_PTR file = NULL;

DWORD fileSize;

if (pFunctionList->C_OpenSession( slotID, CKF_SERIAL_SESSION | CKF_RW_SESSION, NULL, NULL, &hSession) != CKR_OK)

{

leave("Cant run the session");

}

if (pFunctionList->C_Login(hSession, CKU_USER, (LPBYTE)pass, strlen(pass)) != CKR_OK)

{

leave("Error login");

}

if (!ReadDataFromFile(path, &file, &fileSize))

{

leave("Error reading file");

}

hKey = CreateSessionKey(hSession);

printf("Session key: %d \n", hKey);

const size_t blockSize = 128;

DWORD encrSize = (fileSize % 128 != 0) ? ((fileSize / 128) + 1) * 128 : fileSize;

DWORD numberofBlocks = encrSize / blockSize;

CK_BYTE_PTR pEncryptedData = new byte[encrSize]();

CK_BYTE_PTR pDecrData = new byte[encrSize]();

CK_ULONG EncrLen = encrSize, DecrLen = encrSize;

CK_BYTE_PTR buffer = new byte[blockSize]();

CK_BYTE_PTR bufferEncryptedData = new byte[blockSize]();

CK_RV rv = 0;

rv = pFunctionList->C_EncryptInit(hSession, &ckm_DES3, hKey);

for (int i = 0; i < numberofBlocks; i++)

{

int tmpblockSize = (i == numberofBlocks - 1) ? fileSize % blockSize : blockSize;

memcpy(buffer, &file[i * blockSize], tmpblockSize);

pFunctionList->C_EncryptUpdate(hSession, buffer, blockSize, bufferEncryptedData, &EncrLen);

if (i == numberofBlocks - 1)

{

pFunctionList->C_EncryptFinal(hSession, bufferEncryptedData, &EncrLen);

}

memcpy(&pEncryptedData[i * blockSize], bufferEncryptedData, blockSize);

}

printf("\nEncrypted data: \n");

for (int i = 0; i < encrSize; i++) printf("%c", pEncryptedData[i]);

rv = pFunctionList->C_DecryptInit(hSession, &ckm_DES3, hKey);

for (int i = 0; i < numberofBlocks; i++)

{

memcpy(bufferEncryptedData, &pEncryptedData[i * blockSize], blockSize);

rv = pFunctionList->C_DecryptUpdate(hSession, bufferEncryptedData, blockSize, buffer, &DecrLen);

if (i == numberofBlocks - 1)

{

pFunctionList->C_DecryptFinal(hSession, buffer, &DecrLen);

}

memcpy(&pDecrData[i * blockSize], buffer, blockSize);

}

pDecrData[fileSize] = '\0'; // Добавляем терминатор строки

printf("\nDecrypted Data: \n%s\n", pDecrData);

pFunctionList->C_Logout(hSession);

pFunctionList->C_CloseSession(hSession);

delete[] buffer;

delete[] bufferEncryptedData;

delete[] pEncryptedData;

delete[] pDecrData;

leave(NULL);

return 0;

}

Томск 2025