commit d67d3461007a725604d21ebcc3e4167039171c6b Author: mht Date: Sun Apr 20 18:32:01 2025 +0330 Initial commit diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..b8a779f --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,21 @@ + +cmake_minimum_required(VERSION 2.6) + +project(KeyASample) + +find_library(KEYAC keyac) +find_library(KEYA keya) + +set(cppdongle_sources Ne-code.cpp) + +set(cppdongle_headers ) + +set(KEYA_LIB_DIR ${CMAKE_SOURCE_DIR}/lib/) + + +link_directories(${KEYA_LIB_DIR}) + +add_executable(run-keya2 ${cppdongle_sources} ${cppdongle_headers}) +target_link_libraries(run-keya2 keya keyac pthread) + + diff --git a/Ne-code.cpp b/Ne-code.cpp new file mode 100644 index 0000000..fbe2485 --- /dev/null +++ b/Ne-code.cpp @@ -0,0 +1,217 @@ +// +// Created by mht on 20.04.25. +// +#include +#include +#include +#include +#include +#include +#include "keya.h" + +using namespace std; + +// Helper to pad data to 16 bytes +void pad_data(vector& data) +{ + size_t pad_len = 16 - (data.size() % 16); + if (pad_len < 16) { + data.insert(data.end(), pad_len, 0); // simple zero padding + } +} + +// Read file into vector +vector read_file(const string& filename) +{ + ifstream file(filename, ios::binary); + return vector((istreambuf_iterator(file)), istreambuf_iterator()); +} + +// Write vector into file +void write_file(const string& filename, const vector& data) +{ + ofstream file(filename, ios::binary); + file.write(reinterpret_cast(data.data()), data.size()); +} + +// Encrypt buffer using KeyA +int encrypt_buffer(vector& data, unsigned char* kp, unsigned char* kr, unsigned char* kw) +{ + KeyA keya; + int result = keya.OpenDevice(0); + if (result != 0) return result; + + result = keya.Init(kp, kr, kw, NULL); + if (result != 0) { + keya.CloseDevice(); + return result; + } + + unsigned char temp[16]; + for (size_t i = 0; i < data.size(); i += 16) { + memcpy(temp, &data[i], 16); + result = keya.EncByKV(0, temp, temp); + if (result != 0) { + keya.CloseDevice(); + return result; + } + memcpy(&data[i], temp, 16); + } + + keya.CloseDevice(); + return 0; +} + +// Decrypt buffer using KeyA +int decrypt_buffer(vector& data, unsigned char* kp, unsigned char* kr, unsigned char* kw) +{ + KeyA keya; + int result = keya.OpenDevice(0); + if (result != 0) return result; + + result = keya.Init(kp, kr, kw, NULL); + if (result != 0) { + keya.CloseDevice(); + return result; + } + + unsigned char temp[16]; + for (size_t i = 0; i < data.size(); i += 16) { + memcpy(temp, &data[i], 16); + result = keya.DecByKV(0, temp, temp); + if (result != 0) { + keya.CloseDevice(); + return result; + } + memcpy(&data[i], temp, 16); + } + + keya.CloseDevice(); + return 0; +} + +// Save size as first 8 bytes (uint64_t) of encrypted file +void prepend_size(vector& data, uint64_t size) +{ + vector result(8); + for (int i = 0; i < 8; ++i) { + result[i] = (size >> (i * 8)) & 0xFF; + } + result.insert(result.end(), data.begin(), data.end()); + data = result; +} + +// Extract original size from first 8 bytes +uint64_t extract_size(vector& data) +{ + uint64_t size = 0; + for (int i = 7; i >= 0; --i) { + size = (size << 8) | data[i]; + } + data.erase(data.begin(), data.begin() + 8); + return size; +} + +// Save list of hashes into a text file +void save_hashes_to_file(const vector& hashes, const string& filename) +{ + ofstream file(filename); + for (const auto& hash : hashes) { + file << hash << "\n"; + } +} + +// Read hashes from decrypted data +vector read_hashes_from_memory(const vector& data) +{ + vector hashes; + istringstream iss(string(data.begin(), data.end())); + string line; + while (getline(iss, line)) { + if (!line.empty()) + hashes.push_back(line); + } + return hashes; +} + +// Check if a hash exists in list +bool hash_exists(const string& input_hash, const vector& hashes) +{ + for (const auto& hash : hashes) { + if (hash == input_hash) { + return true; + } + } + return false; +} + +int main() +{ + // Your keys + unsigned char g_Kp[16] = {0x74,0xD8,0xCD,0x0F,0xC6,0x6A,0x09,0x69,0xB1,0x4A,0xC5,0xD1,0xE9,0x7A,0x9D,0x07}; + unsigned char g_Kr[16] = {0xDA,0x58,0x86,0x3C,0xD6,0x65,0xDF,0xE2,0x84,0x04,0xD3,0x4E,0x74,0xEB,0xBD,0x16}; + unsigned char g_Kw[16] = {0xC8,0xA8,0x16,0x3C,0x59,0xEF,0x9C,0xC4,0xC0,0xEC,0x48,0x41,0x4B,0xE5,0x11,0x37}; + + unsigned char* kp = g_Kp; + unsigned char* kr = g_Kr; + unsigned char* kw = g_Kw; + + // Step 1: Save some hashes to file + vector hashes = { + "8d523c784e2f81de923e2fad5960983b735aca25b2490a1cd50d91dc4b166795b27e59f8dfb76ef5120460224cc9ab5d489dc9ae135a732588dd43f71048771c", + "dd590a463303424547f76562fbaeca485c1b95581b7340ecdd02e308166ddcfcac757ed23b11931d23ca46e1b6498fe3c95bf2fd7f760337b41d9e7f4e396678", + "75863d940c8f298c92ccdcfeca6d809d2e5bf67d23c588d2bd62f4b8f86be8a882e30b9b5e524b79e8cf618290b18eec8b621d9c9d73f5300246bd3e15c99561", + "b6d7ec0a2520e2a2ba8f7bb4807b4f3641b80f1062075028600201b1b01e4ac102e078061cd4618f2e847348b118a11be1341a9d3a41fcfc443f92c69c40ffa1", + "4347b58249eea37f74c8a036ca29d6b2a362b9a8743bbd4f99de75c92b46fd876bf98a65041c28c9f10eb548df7645079fe616b00e42711d52135034fe5dbc55", + "a254cc5e08d0d11da6074fccbbc5fbff7a2ce99e6a36f6294f66e271455d3f0663f70864a74ea7d307c0ad7d76fa30694b52dcd9385a8de21b9a708a791d6a8c", + "f9f0ce3eed54de9e057fd66ae17e4b2dccb5b4b6c17e18a278e6628a8a5ac4e357f06c510370e06da2a62241a3200f3d5334102e045c36b5a74954f2ff070a79", + "a1475fdb4b02de84a57f85babc010e5f12281eedea1c75efeac54af7e40c0dfa1659eaa0b106c6aa3a605c7ec442f477d425db24b75c8a818750d9fe06e3727a", + "183d402bb712787f5aa8bf3f0cbe91d3383fdd460edac3db01ea756ae5afe9ca60d8917d749358a012b2b45eaae04ae5fc10fe17aa42409841dc5b475c2794a1", + "a29fc7db04adb89736832cd94dd1fd3fe405e18db670ef3f055e3310dd2f0fc4dd3c4535adcd1ec3fcd16f45a8b814558586bfc67b1d01d664cd51ee1db05c28", + "0092d1a3a78bab2b85abc55d5a851c3c351d0dacd402d77ad57b6d3f08836262bc7dff8b958368cddedd3aa8246ec4919f77c325210cabeadd2dfde5ce8d0412", + "0485a2fd8aceaddfeb45f4072f64637bec8ab5962e088c4f8f0a46196d6b80c1a2924e1d43fa530b2183e5240507115a3db8d49aae9d100195a6ba1eb8f1adcf", + "ec23e51688c082584821a20038510a818c58a0201dbb7ee133d0b11dfc6456a2ad1de4dd944e8083e378af4e58362b5c3ecf3f242493e0cfc1c1cde58e7fc8f1" + + }; + save_hashes_to_file(hashes, "hashes.txt"); + cout << "Hashes saved to 'hashes.txt'." << endl; + + // Step 2: Encrypt the hashes file + vector hash_data = read_file("hashes.txt"); + + uint64_t original_size = hash_data.size(); // Save original size + pad_data(hash_data); // pad to multiple of 16 + + if (encrypt_buffer(hash_data, kp, kr, kw) == 0) { + prepend_size(hash_data, original_size); // Put size in front + write_file("lic.enc", hash_data); + cout << "Encryption successful. Encrypted file saved as 'lic.enc'." << endl; + } else { + cout << "Encryption failed." << endl; + return 1; + } + + // Step 3: Later... Decrypt and check for input hash + vector enc_data = read_file("hashes.enc"); + uint64_t saved_size = extract_size(enc_data); + + if (decrypt_buffer(enc_data, kp, kr, kw) == 0) { + enc_data.resize(saved_size); // trim padding + vector decrypted_hashes = read_hashes_from_memory(enc_data); + + string input_hash; + cout << "Enter a hash to search for: "; + cin >> input_hash; + + if (hash_exists(input_hash, decrypted_hashes)) { + cout << "Hash FOUND in list." << endl; + } else { + cout << "Hash NOT FOUND." << endl; + } + } else { + cout << "Decryption failed." << endl; + return 1; + } + + return 0; +} diff --git a/keya.h b/keya.h new file mode 100755 index 0000000..2d14050 --- /dev/null +++ b/keya.h @@ -0,0 +1,110 @@ +/* + * KeyA.h + * + * Created on: Aug 19, 2008 + * Author: Hedayat Vatankhah , 2008. + */ + +#ifndef KEYA_H_ +#define KEYA_H_ + +#include "keya_types.h" + +/** This can be sent to OpenDevice function to open the next keya device */ +#define KEYA_NEXT_ID(keya) keya.GetKeyAID() + 1 + +class KeyA +{ + public: + KeyA(uint moduleType = _HID_CLASS); + virtual ~KeyA(); + + static uint GetModuleCount(); + static uint EncBlock(const byte *pKey, const byte *pData, byte *pRes); + static uint DecBlock(const byte *pKey, const byte *pData, byte *pRes); + static char *GetErrorText(int lastError, char *perrText, uint buflen); + + uint OpenDevice(int id); + uint CloseDevice(); + int GetKeyAID(); + + uint SetModuleType(uint moduleType); + uint SetKeyAFunctionality(uint keyaFun); + + uint Init(const byte *pKp, const byte *pKr, const byte *pKw, + const byte *pKw2); + uint NetInit(const byte *pKp, const byte *pKr, const byte *pKw, + const byte *pKw2); + uint SetCallBackProc(CallbackProc pAttachCallBack, void *param); + uint SetAttachCallBackProc(PureAttachCallbackProc pAttachCallBack); + uint SetCallBackWithIDProc(CallbackProcWithID callback, + void *param); + void SetCallbackErrorHandlerProc(CallbackErrorHandler handler); + int GetCallbackThreadErrorNumber(); + + uint SetKAB(const byte *pKA, const byte *pKAB); + uint SetKeyAParameters(const byte *pKA, byte *pData); + + uint ChangeKAB(const byte *pKAB, const byte *pNewKAB); + uint WriteAccessKey(const byte *pKBB); + + uint ReadPayamPardazMemory(int address, int len, byte *pBuf); + uint WritePayamPardazMemory(int address, int len, + const byte *pKA, const byte *pData); + + uint ReadFreeMemory(int address, int len, byte *pBuf); + uint WriteFreeMemory(int address, int len, const byte *pBuf); + + uint ReadUserMemory(int address, int len, const byte *pUserKey, + byte *pBuf); + uint WriteUserMemory(int address, int len, const byte *pUserKey, + const byte *pBuf); + uint ReadUserMemory(int address, int len, byte *pBuf); + uint WriteUserMemory(int address, int len, const byte *pBuf); + + uint ReadDeveloperMemory(int address, int len, byte *pBuf); + uint WriteDeveloperMemory(int address, int len, const byte *pBuf); + + uint SetMasterPin(const char *pPin, byte pinLen); + uint SetUserPin(const char *pPin, byte pinLen); + uint UserLogin(const char *pPin, byte pinLen); + uint MasterLogin(const char *pPin, byte pinLen); + //////////////////// New Functions ////////////////// + uint GetAutoLoginStatus(); + uint ResetAutoLogin(); + uint SetAutoLogin(const char *pUserPin, int PinLen, const byte *pAutoLoginKey ); + uint AutoLogin(const byte *pAutoLoginKey ); + uint SetModuleName(const char *strModuleName ); + uint GetModuleName(char *strModuleName, int nModuleNameSize ); + //////////////////////////////////////////////////////////// + uint SetKV(byte iKVIndex, const byte *pKV); + uint EncByKV(byte iKvIndex, const byte *pData, byte *pRes); + uint DecByKV(byte iKvIndex, const byte *pData, byte *pRes); + + uint SetQuery(byte iQueryIndex, const byte *pQueryKey); + uint GetQuery(byte iQueryIndex, const byte *pQueryData, + byte *pQueryResult); + + uint EncByCustomKey(const byte *pCusKey, const byte *pData, + byte *pRes); + uint DecByCustomKey(const byte *pCusKey, const byte *pData, + byte *pRes); + + uint CheckModuleExistence(); + uint GetSerialNumber(byte *pSerialNum); + uint GetMemoryInfo(int *pDevMemLen, int *pSecMemLen, + int *pFMemLen); + uint GetVersionInfo(byte *pVer, byte *pDevMemSup, + byte *pFmemSup, byte *pLoginSup, byte *pCusKeySup); + uint GetKeyCount(int *pQueryKeyNum, int *pKVKeyNum); + + uint SetMaxClient(byte clientNum); + uint GetMaxClient(byte *pClientNum); + + private: + KeyAHID *keya; + + KeyA(KeyA &); +}; + +#endif /* KEYA_H_ */ diff --git a/keya_types.h b/keya_types.h new file mode 100755 index 0000000..31c0326 --- /dev/null +++ b/keya_types.h @@ -0,0 +1,47 @@ +/* + * types.h + * + * Created on: Aug 14, 2008 + * Author: Hedayat Vatankhah , 2008. + */ + +#ifndef KEYA_TYPES_H_ +#define KEYA_TYPES_H_ + +#define FALSE 0 +#define TRUE 1 + +#ifndef NULL +#define NULL 0 +#endif + +/* + * Defining some basic types. (NOTICE: data type collision is possible. fix this! + * Maybe using unsigned instead of uint is much better?! + */ +typedef unsigned char byte; +#ifndef __KERNEL__ +typedef unsigned int uint; +#ifndef __cplusplus +typedef byte bool; +#endif +#endif + +/** This can be sent to OpenDevice function to open the first available KeyA */ +#define KEYA_FIRST_ID 0 + +typedef int (*PureAttachCallbackProc)(void); +typedef int (*CallbackProc)(bool attached, void *param); +typedef int (*CallbackProcWithID)(bool attached, void *param, int keyaid); +typedef void (*CallbackErrorHandler)(int errnum); + +typedef struct KeyA2HIDProtocol KeyAHID; + +/* Only HID class is acceptable by this driver! */ +enum KeyAModuleClass +{ + _CUSTOME_CLASS, + _HID_CLASS +}; + +#endif /* KEYA_TYPES_H_ */ diff --git a/lib/.idea/.gitignore b/lib/.idea/.gitignore new file mode 100755 index 0000000..13566b8 --- /dev/null +++ b/lib/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/lib/.idea/lib.iml b/lib/.idea/lib.iml new file mode 100755 index 0000000..bc2cd87 --- /dev/null +++ b/lib/.idea/lib.iml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/lib/.idea/modules.xml b/lib/.idea/modules.xml new file mode 100755 index 0000000..b0c4ff6 --- /dev/null +++ b/lib/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/lib/.idea/vcs.xml b/lib/.idea/vcs.xml new file mode 100755 index 0000000..d843f34 --- /dev/null +++ b/lib/.idea/vcs.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/lib/libkeya.a b/lib/libkeya.a new file mode 100755 index 0000000..f5278de Binary files /dev/null and b/lib/libkeya.a differ diff --git a/lib/libkeyac.a b/lib/libkeyac.a new file mode 100755 index 0000000..92771c7 Binary files /dev/null and b/lib/libkeyac.a differ diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..9908814 --- /dev/null +++ b/main.cpp @@ -0,0 +1,148 @@ +#include +#include +#include +#include +#include "keya.h" + +using namespace std; + +// Helper to pad data to 16 bytes +void pad_data(vector& data) +{ + size_t pad_len = 16 - (data.size() % 16); + if (pad_len < 16) { + data.insert(data.end(), pad_len, 0); // simple zero padding + } +} + +// Read file into vector +vector read_file(const string& filename) +{ + ifstream file(filename, ios::binary); + return vector((istreambuf_iterator(file)), istreambuf_iterator()); +} + +// Write vector into file +void write_file(const string& filename, const vector& data) +{ + ofstream file(filename, ios::binary); + file.write(reinterpret_cast(data.data()), data.size()); +} + +// Encrypt buffer using KeyA +int encrypt_buffer(vector& data, unsigned char* kp, unsigned char* kr, unsigned char* kw) +{ + KeyA keya; + int result = keya.OpenDevice(0); + if (result != 0) return result; + + result = keya.Init(kp, kr, kw, NULL); + if (result != 0) { + keya.CloseDevice(); + return result; + } + + unsigned char temp[16]; + for (size_t i = 0; i < data.size(); i += 16) { + memcpy(temp, &data[i], 16); + result = keya.EncByKV(0, temp, temp); + if (result != 0) { + keya.CloseDevice(); + return result; + } + memcpy(&data[i], temp, 16); + } + + keya.CloseDevice(); + return 0; +} + +// Decrypt buffer using KeyA +int decrypt_buffer(vector& data, unsigned char* kp, unsigned char* kr, unsigned char* kw) +{ + KeyA keya; + int result = keya.OpenDevice(0); + if (result != 0) return result; + + result = keya.Init(kp, kr, kw, NULL); + if (result != 0) { + keya.CloseDevice(); + return result; + } + + unsigned char temp[16]; + for (size_t i = 0; i < data.size(); i += 16) { + memcpy(temp, &data[i], 16); + result = keya.DecByKV(0, temp, temp); + if (result != 0) { + keya.CloseDevice(); + return result; + } + memcpy(&data[i], temp, 16); + } + + keya.CloseDevice(); + return 0; +} + +// Save size as first 8 bytes (uint64_t) of encrypted file +void prepend_size(vector& data, uint64_t size) +{ + vector result(8); + for (int i = 0; i < 8; ++i) { + result[i] = (size >> (i * 8)) & 0xFF; + } + result.insert(result.end(), data.begin(), data.end()); + data = result; +} + +// Extract original size from first 8 bytes +uint64_t extract_size(vector& data) +{ + uint64_t size = 0; + for (int i = 7; i >= 0; --i) { + size = (size << 8) | data[i]; + } + data.erase(data.begin(), data.begin() + 8); + return size; +} + +int main() +{ + // Your keys + unsigned char g_Kp[16] = {0x74,0xD8,0xCD,0x0F,0xC6,0x6A,0x09,0x69,0xB1,0x4A,0xC5,0xD1,0xE9,0x7A,0x9D,0x07}; + unsigned char g_Kr[16] = {0xDA,0x58,0x86,0x3C,0xD6,0x65,0xDF,0xE2,0x84,0x04,0xD3,0x4E,0x74,0xEB,0xBD,0x16}; + unsigned char g_Kw[16] = {0xC8,0xA8,0x16,0x3C,0x59,0xEF,0x9C,0xC4,0xC0,0xEC,0x48,0x41,0x4B,0xE5,0x11,0x37}; + + unsigned char* kp = g_Kp; + unsigned char* kr = g_Kr; + unsigned char* kw = g_Kw; + + // Step 1: Encrypt JSON file + vector json_data = read_file("orig.txt"); + + uint64_t original_size = json_data.size(); // Save original size + pad_data(json_data); // pad to multiple of 16 + + if (encrypt_buffer(json_data, kp, kr, kw) == 0) { + prepend_size(json_data, original_size); // Put size in front + write_file("data.enc", json_data); + cout << "Encryption successful. Encrypted file saved as 'data.enc'." << endl; + } else { + cout << "Encryption failed." << endl; + } + + // Step 2: Decrypt encrypted file + vector enc_data = read_file("hashes.enc"); + uint64_t saved_size = extract_size(enc_data); // remove first 8 bytes, get size + + if (decrypt_buffer(enc_data, kp, kr, kw) == 0) { + enc_data.resize(saved_size); // trim padding + write_file("hash.txt", enc_data); + cout << "Decryption successful. Decrypted file saved as 'data_decrypted.txt'." << endl; + } else { + cout << "Decryption failed." << endl; + } + + return 0; +} diff --git a/setKey.cpp b/setKey.cpp new file mode 100755 index 0000000..6590ecd --- /dev/null +++ b/setKey.cpp @@ -0,0 +1,213 @@ +#include +#include +#include +#include "keya.h" + +using namespace std; + +const int kv_idx = 0; // The kv index used for encryption +const int data_address = 0; // The start address of memory location to place encypted data + +int produce_data(unsigned char **data, size_t *len) +{ + *len = 20; + *data = new unsigned char[*len]; // Some foo size + + strcpy((char *) *data, "000000"); + // Place the keya serial number in front of the data. + // The length of the serial number is 6 bytes length, + // so the length of the data buffer must be at least 6 bytes. + KeyA keya; + int result; + + result = keya.OpenDevice(0); + if (result != 0) + return result; + + // The serial number will be placed in first six byte of data + result = keya.GetSerialNumber(*data); + if (result != 0) + { + keya.CloseDevice(); + return result; + } + + keya.CloseDevice(); + // End of placing the keya serial number + + return 0; +} + +int write_data(unsigned char *data, size_t len, unsigned char *kp, unsigned char *kr, unsigned char *kw) +{ + unsigned char buffer[16]; + unsigned char *pointer = data; + + KeyA keya; + int result; + int count = 0; + + result = keya.OpenDevice(0); + if (result != 0) + return result; + + // Kw2 is not needed here. Kw2 is only needed for writing to developer memory. + result = keya.Init(kp, kr, kw, NULL); + if (result != 0) + { + keya.CloseDevice(); + return result; + } + + // Data encryption with EncByKV() function is done in 16 bytes blocks, + // so data must be padded for length that not dividable by 16. + while (len > 0) + { + memset(buffer, 0, 16); + if (len < 16) + { + memcpy(buffer, pointer, len); + len = 0; + pointer += len; + } + else + { + memcpy(buffer, pointer, 16); + len -= 16; + pointer += 16; + } + result = keya.EncByKV(kv_idx, buffer, buffer); + if (result != 0) + { + keya.CloseDevice(); + return result; + } + result = keya.WriteUserMemory(data_address + count, 16, NULL, buffer); + if (result != 0) + { + keya.CloseDevice(); + return result; + } + count += 16; + } + + keya.CloseDevice(); + return 0; +} + +int read_data(unsigned char *data, int len, unsigned char *kp, unsigned char *kr, unsigned char *kw) +{ + unsigned char buffer[16]; + unsigned char *pointer = data; + + KeyA keya; + int result; + int count = 0; + + result = keya.OpenDevice(0); + if (result != 0) + return result; + + // Kw2 is not needed here. Kw2 is only needed for writing to developer memory. + result = keya.Init(kp, kr, kw, NULL); + if (result != 0) + { + keya.CloseDevice(); + return result; + } + + while (len > 0) + { + result = keya.ReadUserMemory(data_address + count, 16, NULL, buffer); + if (result != 0) + { + keya.CloseDevice(); + return result; + } + result = keya.DecByKV(kv_idx, buffer, buffer); + if (result != 0) + { + keya.CloseDevice(); + return result; + } + if (len < 16) + { + memcpy(pointer, buffer, len); + len = 0; + pointer += len; + } + else + { + memcpy(pointer, buffer, 16); + len -= 16; + pointer += 16; + } + count += 16; + } + + keya.CloseDevice(); + return 0; +} + +int main(int argc, char** argv) +{ + unsigned char buffer[16]; + unsigned char *data = new unsigned char[6]; + + KeyA keya; + int result; + int exist = keya.CheckModuleExistence(); + cout<< "moudle exis " << exist << endl ; + char* a = new char[300]; // Allocates memory for 60 characters +// keya.GetErrorText(keya.CheckModuleExistence(), a ,300); +// cout<<'\n'<< a <<'\n'; + cout<< "\n Module count: "<< keya.GetModuleCount() <<"\n"; + result = keya.OpenDevice(0); + if (result != 0) + return result; + + cout << "\nopen successfully.\n" << endl; + // The serial number will be placed in first six byte of data + result = keya.GetSerialNumber(data); + cout << "\nserial:"<< data<<".\n" << endl; + + char* b = new char[300]; + + unsigned char g_Kp[16] = {0x74,0xD8,0xCD,0x0F,0xC6,0x6A,0x09,0x69,0xB1,0x4A,0xC5,0xD1,0xE9,0x7A,0x9D,0x07}; + unsigned char g_Kr[16] = {0xDA,0x58,0x86,0x3C,0xD6,0x65,0xDF,0xE2,0x84,0x04,0xD3,0x4E,0x74,0xEB,0xBD,0x16}; + unsigned char g_Kw[16] = {0xC8,0xA8,0x16,0x3C,0x59,0xEF,0x9C,0xC4,0xC0,0xEC,0x48,0x41,0x4B,0xE5,0x11,0x37}; + unsigned char g_Kw2[16] = {0x53,0x1C,0x74,0x5B,0xEC,0x9B,0x8E,0x76,0xD8,0x8E,0x28,0x79,0xD9,0x19,0x6D,0x0D}; + + unsigned char* kp = g_Kp; + unsigned char* kr = g_Kr; + unsigned char* kw = g_Kw; + unsigned char* kw2 = g_Kw2; + + int err = keya.Init(kp, kr, kw, kw2); + + std::cout << "err : " << err << std::endl; + keya.GetErrorText(err,b,300); + + std::cout << "err : " << b << std::endl; + + unsigned char idx = '0'; + + + unsigned char *stuff = new unsigned char[16]; + stuff = (unsigned char *) "aaaaaaaaaaaaaaaa"; + unsigned char *enc = new unsigned char[16]; + keya.EncByKV(idx,stuff,enc); + cout<<"encoded is:"<< enc << endl; + + unsigned char *dec = new unsigned char[16]; + keya.DecByKV(idx,enc,dec); + + cout<<"decoded is:"<< dec << endl; + + keya.CloseDevice(); + cout << "Finished successfully." << endl; + + delete[] data; + delete[] a; + return 0; +}