cyptography done

Password_manager/Password_manager.vcxproj

@@ -139,6 +139,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="include\buffer.h" />
+    <ClInclude Include="include\func.h" />
     <ClInclude Include="include\win.h" />
     <ClInclude Include="include\cryptography.h" />
   </ItemGroup>

Password_manager/Password_manager.vcxproj.filters

@@ -35,5 +35,8 @@
     <ClInclude Include="include\buffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="include\func.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Password_manager/include/Buffer.h

@@ -5,8 +5,9 @@ class Buffer
 {
 public:
 	unsigned char* buffer = nullptr;
-	size_t size = 0;
+	int taken = 0;
-	Buffer(size_t size)
+	int size = 0;
+	Buffer(int size)
 	{
 		this->size = size;
 		this->buffer = new unsigned char[size];
@@ -22,4 +23,27 @@ public:
 		if (buffer)	delete[] buffer;
 	}
 
+	void resize(int new_size)
+	{
+		unsigned char* new_buffer = (unsigned char*)realloc(buffer, new_size);
+		if (!new_buffer)
+		{
+			printf_s("Error resizing buffer\n");
+			return;
+		}
+
+		buffer = new_buffer;
+		size = new_size;
+	}
+
+	void add(void* data, int data_size)
+	{
+		if (taken + data_size > size)
+		{
+			resize(size + data_size);
+		}
+		memcpy_s(buffer + taken, size - taken, data, data_size);
+		taken += data_size;
+	}
+
 };

Password_manager/include/cryptography.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <cstdint>
+#include "buffer.h"
 
 struct evp_cipher_ctx_st;
 typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
@@ -8,16 +9,16 @@ typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
 class Cryptography
 {
 public:
-	Cryptography(const char* password);
+	Cryptography(const char* password, size_t size);
 	~Cryptography();
-	int encrypt(uint8_t* input_buffer, int32_t input_buffer_size);
+	bool encrypt(Buffer* plain, Buffer* encrypted);
-	int decrypt(uint8_t* input_buffer);
+	bool decrypt(Buffer* encrypted, Buffer* decrypted);
-	
+
 private:
 	uint8_t key[32] = { 0 };
 	uint8_t iv[16] = { 0 };
 	EVP_CIPHER_CTX* ctx = nullptr;
 
-	bool generate_key_and_iv_from_password(const char* password);
+	bool generate_key_and_iv_from_password(const char* password, size_t size);
-	void handleErrors();
+	bool handleErrors();
 };

Password_manager/include/func.h

@@ -0,0 +1,83 @@
+#pragma once
+#include <fstream>
+#include "buffer.h"
+
+
+struct Pass
+{
+	char label[20];
+	char password[20];
+
+	Pass()
+	{
+		memset(label, 0, 20);
+		memset(password, 0, 20);
+	};
+};
+
+bool find_password(Buffer* buff, char* label, char* password)
+{
+	Pass* passwords = (Pass*)buff->buffer;
+
+	for (int i = 0; i < buff->taken / sizeof(Pass); i++)
+	{
+		if (!strcmp(passwords[i].label, label))
+		{
+			strcpy_s(password, 20, passwords[i].password);
+			return true;
+		}
+	}
+	return false;
+}
+
+void generate_password(char* password)
+{
+	srand(time(NULL));
+	char characters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_-+={[}]|:;<,>.?";
+	for (int i = 0; i < 15; i++)
+	{
+		password[i] = characters[rand() % (sizeof(characters) - 1)];
+	}
+	password[15] = '\0';
+}
+
+bool save_buffer_to_file(Buffer* buffer)
+{
+	std::ofstream file("passwords.bin", std::ios::binary);
+	if (!file.is_open())
+	{
+		printf_s("Error saving file\n");
+		return false;
+	}
+	file.write((char*)buffer->buffer, buffer->taken);
+	file.close();
+	return true;
+}
+
+bool load_buffer_from_file(Buffer* buffer)
+{
+
+	std::ifstream file("passwords.bin", std::ios::binary);
+	if (!file.is_open()) return false;
+
+	file.seekg(0, std::ios::end);
+	buffer->resize(file.tellg());
+	file.seekg(0, std::ios::beg);
+	file.read((char*)buffer->buffer, buffer->size);
+
+	if (file)
+		buffer->taken = buffer->size;
+	else
+		buffer->taken = file.gcount();
+
+	file.close();
+	return true;
+}
+
+
+void print_usage()
+{
+	printf_s("Usage:\n");
+	printf_s("password_manager.exe <label>\n");
+	printf_s("password_manager.exe -g <label>\n");
+}

Password_manager/source/cryptography.cpp

@@ -1,20 +1,21 @@
 #include <openssl/evp.h>
 #include <openssl/err.h>
+#include <openssl/aes.h>
 #include <string>
 #include <iostream>
 #include <fstream>
 
 #include "cryptography.h"
-#include "buffer.h"
 
-Cryptography::Cryptography(const char* password)
+
+Cryptography::Cryptography(const char* password, size_t size)
 {
 	OpenSSL_add_all_algorithms();
 	ERR_load_crypto_strings();
 
-	if (!generate_key_and_iv_from_password(password))
+	if (!generate_key_and_iv_from_password(password, size))
 	{
-		std::cout << "Error generating key and IV from password\n";
+		printf_s("Error generating key and IV from password\n");
 		return;
 	}
 }
@@ -25,103 +26,61 @@ Cryptography::~Cryptography()
 	EVP_cleanup();
 }
 
-int Cryptography::encrypt(uint8_t* input_buffer, int32_t input_buffer_size)
+bool Cryptography::encrypt(Buffer* plain, Buffer* encrypted)
 {
-	// Allocate memory for the ciphertext
+	encrypted->resize(plain->taken + AES_BLOCK_SIZE);
-	int ciphertext_len = 0;
-	
-	Buffer encrypted_buffer(input_buffer_size + EVP_CIPHER_block_size(EVP_aes_256_cbc()));
 
-	// Create and initialize the context for encryption
 	ctx = EVP_CIPHER_CTX_new();
-	if (!ctx) handleErrors();
+	if (!ctx) return handleErrors();
-
+	if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) return handleErrors();
-	if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();
-
-	// Perform encryption
-	if (1 != EVP_EncryptUpdate(ctx, encrypted_buffer.buffer, &ciphertext_len, input_buffer, input_buffer_size)) handleErrors();
 
+	if (1 != EVP_EncryptUpdate(ctx, encrypted->buffer, &encrypted->taken, plain->buffer, plain->taken)) return handleErrors();
 	int final_len;
-	if (1 != EVP_EncryptFinal_ex(ctx, encrypted_buffer.buffer + ciphertext_len, &final_len)) handleErrors();
+	if (1 != EVP_EncryptFinal_ex(ctx, encrypted->buffer + encrypted->taken, &final_len)) return handleErrors();
-	ciphertext_len += final_len;
+	encrypted->taken += final_len;
 
-	// Clean up the context 
 	EVP_CIPHER_CTX_free(ctx);
 
 
-	// store the encrypted buffer to file
+	return true;
-
-	std::ofstream file("encrypted_file.bin", std::ios::binary);
-	if (file) 
-	{
-		file.write((char*)encrypted_buffer.buffer, ciphertext_len);
-		file.close();
-	}
-
-
-
-	return ciphertext_len;
 }
 
-int Cryptography::decrypt(uint8_t* out_buffer)
+bool Cryptography::decrypt(Buffer* encrypted, Buffer* decrypted)
 {
-	// read the encrypted buffer from file
+	decrypted->resize(encrypted->taken + AES_BLOCK_SIZE);
-	
-
-
-	std::ifstream file("encrypted_file.bin", std::ios::binary);
-	if (!file) return 0;
-
-	file.seekg(0, std::ios::end);
-	int encrypted_buffer_len = file.tellg();
-	file.seekg(0, std::ios::beg);
-
-	Buffer encrypted_buffer(encrypted_buffer_len);
-
-	file.read((char*)encrypted_buffer.buffer, encrypted_buffer_len);
-	file.close();
-	
-	
-
-
-	
 
 
 	ctx = EVP_CIPHER_CTX_new();
-	if (!ctx) handleErrors();
+	if (!ctx) return handleErrors();
+	if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) return handleErrors();
 
-	if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) handleErrors();
+	if (1 != EVP_DecryptUpdate(ctx, decrypted->buffer, &decrypted->taken, encrypted->buffer, encrypted->taken)) return handleErrors();
-
-	int decrypted_len = 0;
-	if (1 != EVP_DecryptUpdate(ctx, out_buffer, &decrypted_len, encrypted_buffer.buffer, encrypted_buffer_len)) handleErrors();
 	int final_len;
-	if (1 != EVP_DecryptFinal_ex(ctx, out_buffer + decrypted_len, &final_len)) handleErrors();
+	if (1 != EVP_DecryptFinal_ex(ctx, decrypted->buffer + decrypted->taken, &final_len)) return handleErrors();
-	decrypted_len += final_len;
+	decrypted->taken += final_len;
 
-	// Clean up the context
 	EVP_CIPHER_CTX_free(ctx);
-
+	return true;
-	return decrypted_len;
 }
 
-bool Cryptography::generate_key_and_iv_from_password(const char* password)
+bool Cryptography::generate_key_and_iv_from_password(const char* password, size_t size)
 {
 	int iterations = 10000;
 
 	// Derive key and IV using PBKDF2
-	if (1 != PKCS5_PBKDF2_HMAC(password, strlen(password), nullptr, 0, iterations, EVP_sha256(), 32, key)) return false;
+	if (1 != PKCS5_PBKDF2_HMAC(password, size, nullptr, 0, iterations, EVP_sha256(), 32, key)) return false;
-	if (1 != PKCS5_PBKDF2_HMAC(password, strlen(password), nullptr, 0, iterations, EVP_sha256(), 16, iv)) return false;
+	if (1 != PKCS5_PBKDF2_HMAC(password, size, nullptr, 0, iterations, EVP_sha256(), 16, iv)) return false;
 	return true;
 }
 
-void Cryptography::handleErrors()
+bool Cryptography::handleErrors()
 {
 	EVP_CIPHER_CTX_free(ctx);
 
 	while (auto error = ERR_get_error())
 	{
 		char* error_string = ERR_error_string(error, nullptr);
-		std::cout << error_string << "\n";
+		printf_s("%s\n", error_string);
 	}
-	abort();
+	return false;
 }

Password_manager/source/main.cpp

@@ -1,99 +1,73 @@
 #include <iostream>
 #include <fstream>
 #include "win.h"
-
+#include "buffer.h"
-struct Pass
+#include "cryptography.h"
-{
+#include "func.h"
-	char label[20];
-	char password[20];
-
-	Pass()
-	{
-		memset(label, 0, 20);
-		memset(password, 0, 20);
-	};
-};
-
-void load_password(char* label, char* password)
-{
-	std::ifstream file("passwords.bin", std::ios::binary);
-	if (!file.is_open())
-	{
-		std::cout << "Error opening file\n";
-		return;
-	}
-	Pass pass;
-	while (file.read((char*)&pass, sizeof(Pass)))
-	{
-		if (strcmp(pass.label, label) == 0)
-		{
-			strcpy_s(password, 20, pass.password);
-			return;
-		}
-	}
-	std::cout << "Password not found\n";
-	file.close();
-}
-
-void save_password(char* label, char* password)
-{
-	std::ofstream file("passwords.bin", std::ios::binary | std::ios::app);
-	if (!file.is_open())
-	{
-		std::cout << "Error opening file\n";
-		return;
-	}
-	Pass pass;
-	strcpy_s(pass.label, 20, label);
-	strcpy_s(pass.password, 20, password);
-	file.write((char*)&pass, sizeof(Pass));
-	file.close();
-}
-
-void generate_password(char* password)
-{
-	char characters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_-+={[}]|:;<,>.?";
-	for (int i = 0; i < 15; i++)
-	{
-		password[i] = characters[rand() % (sizeof(characters) - 1)];
-	}
-	password[15] = '\0';
-}
-
 
 int main(int argc, char** argv)
 {
+
 	bool generate = false;
 	if (argc < 2)
 	{
-		std::cout << "Usage: \n";
+		print_usage();
-		std::cout << "Password_manager.exe <account>\n";
 		return 1;
 	}
-	
+
 	if (!strcmp("-g", argv[1]))
 	{
 		if (argc < 3)
 		{
-			std::cout << "Usage: \n";
+			print_usage();
-			std::cout << "Password_manager.exe -g <account>\n";
 			return 1;
 		}
-		std::cout << "Generating password for " << argv[2] << "\n";
+		printf_s("Generating password for %s\n", argv[2]);
 		generate = true;
 	}
 
-	char password[20] = { 0 };
+	Buffer encrypted_buffer;
+	if (!load_buffer_from_file(&encrypted_buffer))
+		if (!generate) {
+			printf_s("No passwords, try generating password\n");
+			return 1;
+		}
 
+
+
+	printf_s("Input main password:");
+	std::string user_pass = get_passwd();
+	if (user_pass.empty())
+	{
+		printf_s("Error getting password\n");
+		return 1;
+	}
+
+	Cryptography crypto(user_pass.c_str(), user_pass.size());
+
+	Buffer decrypted_buffer;
+	if (encrypted_buffer.size > 0)
+		if (!crypto.decrypt(&encrypted_buffer, &decrypted_buffer)) return 1;
+
+
+	Pass pass;
 	if (generate)
 	{
-		generate_password(password);
+		generate_password(pass.password);
-		save_password(argv[2], password);
+		strcpy_s(pass.label, 20, argv[2]);
-		put_data_on_clipboard(password);
+		decrypted_buffer.add(&pass, sizeof(Pass));
+		crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
+		save_buffer_to_file(&encrypted_buffer);
 	}
 	else
 	{
-		load_password(argv[1], password);
+		if (!find_password(&decrypted_buffer, argv[1], pass.password))
-		put_data_on_clipboard(password);
+		{
+			printf_s("Password not found\n");
+			return 1;
+		}
 	}
+	printf_s("Password: %s\n", pass.password);
+	printf_s("Password copied to clipboard\n");
+	put_data_on_clipboard(pass.password);
 }

Password_manager/source/win.cpp

@@ -4,65 +4,65 @@
 #include "win.h"
 
 bool put_data_on_clipboard(const char* text) {
-    int len = strlen(text);
+	int len = strlen(text);
-    if (strnlen_s(text, 20) == 0) {
+	if (strnlen_s(text, 20) == 0) {
-		std::cerr << "Text is empty" << std::endl;
+		printf_s("Text is empty\n");
 		return false;
 	}
-    // Open the clipboard
+	// Open the clipboard
-    if (!OpenClipboard(nullptr)) {
+	if (!OpenClipboard(nullptr)) {
-        std::cerr << "Failed to open clipboard" << std::endl;
+		printf_s("Failed to open clipboard");
-        return false;
+		return false;
-    }
+	}
-    // Allocate global memory for the text
+	// Allocate global memory for the text
-    HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, strlen(text) + 1);
+	HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, strlen(text) + 1);
-    if (!hMem) {
+	if (!hMem) {
-        CloseClipboard();
-        std::cerr << "Failed to allocate memory for text" << std::endl;
-        return false;
-    }
-    // Copy the text to the allocated memory
-    char* memData = static_cast<char*>(GlobalLock(hMem));
-    if (!memData) {
 		CloseClipboard();
-		std::cerr << "Failed to lock memory for text" << std::endl;
+		printf_s("Failed to allocate memory for text");
 		return false;
 	}
-    strcpy_s(memData, strlen(text) + 1, text);
+	// Copy the text to the allocated memory
-    GlobalUnlock(hMem);
+	char* memData = static_cast<char*>(GlobalLock(hMem));
-    // Set the data to the clipboard
+	if (!memData) {
-    EmptyClipboard();
+		CloseClipboard();
-    SetClipboardData(CF_TEXT, hMem);
+		printf_s("Failed to lock memory for text");
-    // Clean up and close the clipboard
+		return false;
-    CloseClipboard();
+	}
-    return true;
+	strcpy_s(memData, strlen(text) + 1, text);
+	GlobalUnlock(hMem);
+	// Set the data to the clipboard
+	EmptyClipboard();
+	SetClipboardData(CF_TEXT, hMem);
+	// Clean up and close the clipboard
+	CloseClipboard();
+	return true;
 }
 
 
 std::string get_passwd()
 {
-   
-    HANDLE hStdInput = GetStdHandle(STD_INPUT_HANDLE);
-    DWORD mode = 0;
 
-    // Create a restore point Mode
+	HANDLE hStdInput = GetStdHandle(STD_INPUT_HANDLE);
-    // is know 503
+	DWORD mode = 0;
-    GetConsoleMode(hStdInput, &mode);
 
-    // Enable echo input
+	// Create a restore point Mode
-    // set to 499
+	// is know 503
-    SetConsoleMode( hStdInput, mode & (~ENABLE_ECHO_INPUT));
+	GetConsoleMode(hStdInput, &mode);
 
-    // Take input
+	// Enable echo input
-    std::string ipt;
+	// set to 499
-    std::getline(std::cin, ipt);
+	SetConsoleMode(hStdInput, mode & (~ENABLE_ECHO_INPUT));
 
-    // Otherwise next cout will print
+	// Take input
-    // into the same line
+	std::string ipt;
-    std::cout << std::endl;
+	std::getline(std::cin, ipt);
 
-    // Restore the mode
+	// Otherwise next cout will print
-    SetConsoleMode(hStdInput, mode);
+	// into the same line
+	std::cout << std::endl;
 
-    return ipt;
+	// Restore the mode
+	SetConsoleMode(hStdInput, mode);
+
+	return ipt;
 }