Remove string size limit

Password_manager/include/Buffer.h

@@ -12,7 +12,8 @@ public:
 	Buffer();
 	~Buffer();
 	bool resize(size_t new_size);
-	int add(uint8_t* data, size_t data_size);
+	int add_end(uint8_t* data, size_t data_size);
+	int add_middle(uint8_t* data, size_t data_size, size_t index);
 
 	// Removes data from buffer without checking if it's in the buffer
 	void remove_fast(uint8_t* data, size_t data_size);

Password_manager/include/arg_func.h

@@ -5,9 +5,9 @@ class Buffer;
 class Cryptography;
 #include <string>
 
-Pass* arg_get(Buffer& decrypted_buffer, const char* label);
+const char* arg_get(Buffer& decrypted_buffer, const char* label);
 
-Pass* arg_generate(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto);
+const char* arg_generate(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto);
 
 void arg_list(Buffer& decrypted_buffer);
 
@@ -15,7 +15,7 @@ void arg_delete(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char*
 
 void arg_print_all_p(Buffer& decrypted_buffer, std::string& user_pass);
 
-Pass* arg_input(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto);
+const char* arg_input(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto);
 
 void arg_change(Buffer& decrypted_buffer, Buffer& encrypted_buffer, std::string& user_pass, Cryptography& crypto);
 

Password_manager/include/func.h

@@ -1,16 +1,20 @@
 #pragma once
 #include <fstream>
 
-constexpr auto MAX_STRING_SIZE = 21;
+constexpr auto MAX_STRING_SIZE = 15;
 
 class Buffer;
 
 struct Pass
 {
-	char label[MAX_STRING_SIZE];
+	uint32_t label;
-	char password[MAX_STRING_SIZE];
+	uint32_t password;
+};
 
-	Pass() = default;
+struct Index
+{
+	uint32_t count;
+	uint32_t offset;
 };
 
 enum class Arg
@@ -26,13 +30,19 @@ enum class Arg
 	Error // error
 };
 
-Pass* find_password(Buffer* buff, const char* label);
+int find_password_in_buffer(Buffer& buff, const char* label);
 
-void generate_password(char* password);
+void delete_password_from_buffer(Buffer& in, Buffer& out, int index_of_pass);
 
-bool save_buffer_to_file(Buffer* buffer);
+void add_password_to_buffer(Buffer& in, const char* label, const char* password);
 
-bool load_buffer_from_file(Buffer* buffer);
+const char* get_password_from_buffer(Buffer& decrypted_buffer, int label);
+
+void generate_password(std::string& password);
+
+bool save_buffer_to_file(Buffer& buffer);
+
+bool load_buffer_from_file(Buffer& buffer);
 
 void print_usage();
 

Password_manager/source/arg_func.cpp

@@ -8,67 +8,145 @@
 #include "cryptography.h"
 
 
-Pass* arg_get(Buffer& decrypted_buffer, const char* label)
+const char*arg_get(Buffer& decrypted_buffer, const char* label)
 {
-	Pass* pass = find_password(&decrypted_buffer, label);
+	int pass = find_password_in_buffer(decrypted_buffer, label);
-	if (!pass) printf_s("Password not found\n");
+	if (pass < 0) {
-	return pass;
+		printf_s("Password not found\n");
-}
-
-Pass* arg_generate(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto)
-{
-	printf_s("Generating password for %s\n", label);
-	Pass* pass = find_password(&decrypted_buffer, label);
-	Pass new_pass = { 0 };
-	if (pass != nullptr) generate_password(pass->password);
-	else
-	{
-		generate_password(new_pass.password);
-		strcpy_s(new_pass.label, MAX_STRING_SIZE, label);
-		int position = decrypted_buffer.add((uint8_t*)&new_pass, sizeof(Pass));
-		if (position < 0)
-		{
-			printf_s("Error adding password\n");
 		return nullptr;
 	}
-		pass = (Pass*)(decrypted_buffer.buffer + position);
+	return get_password_from_buffer(decrypted_buffer, pass);
 }
+
+const char* arg_generate(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto)
+{
+	if (decrypted_buffer.taken < 8) {
+		Index index = { 0, 0 };
+		index.offset = sizeof(Index);
+		decrypted_buffer.add_end((uint8_t*)&index, sizeof(Index));
+	}
+
+	printf_s("Generating password for %s\n", label);
+
+	int pass = find_password_in_buffer(decrypted_buffer, label);
+
+	std::string password(MAX_STRING_SIZE, 0);
+
+	generate_password(password);
+
+
+	if (pass < 0)
+	{
+		add_password_to_buffer(decrypted_buffer, label, password.c_str());
 		crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
-	save_buffer_to_file(&encrypted_buffer);
+		save_buffer_to_file(encrypted_buffer);
-	return pass;
+
+		Index* index = (Index*)decrypted_buffer.buffer;
+
+		return get_password_from_buffer(decrypted_buffer, index->count - 1);
+
+	}
+	else
+	{
+
+		delete_password_from_buffer(decrypted_buffer, encrypted_buffer, pass);
+		add_password_to_buffer(encrypted_buffer, label, password.c_str());
+		crypto.encrypt(&encrypted_buffer, &decrypted_buffer);
+		save_buffer_to_file(decrypted_buffer);
+
+		Index* index = (Index*)encrypted_buffer.buffer;
+
+		return get_password_from_buffer(encrypted_buffer, index->count - 1);
+
+	}
+
+	return 0;
+}
+
+const char* arg_input(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto)
+{
+	if (decrypted_buffer.taken < 8) {
+		Index index = { 0, 0 };
+		index.offset = sizeof(Index);
+		decrypted_buffer.add_end((uint8_t*)&index, sizeof(Index));
+	}
+
+	printf_s("Input password for %s:", label);
+
+	std::string new_string = get_user_password();
+
+	if (new_string.empty())
+	{
+		printf_s("error getting password\n");
+		return nullptr;
+	}
+
+	int pass = find_password_in_buffer(decrypted_buffer, label);
+
+	if (pass < 0)
+	{
+		add_password_to_buffer(decrypted_buffer, label, new_string.c_str());
+		crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
+		save_buffer_to_file(encrypted_buffer);
+
+		Index* index = (Index*)encrypted_buffer.buffer;
+
+		return get_password_from_buffer(encrypted_buffer, index->count - 1);
+
+
+	}
+	else
+	{
+		delete_password_from_buffer(decrypted_buffer, encrypted_buffer, pass);
+		add_password_to_buffer(encrypted_buffer, label, new_string.c_str());
+		crypto.encrypt(&encrypted_buffer, &decrypted_buffer);
+		save_buffer_to_file(decrypted_buffer);
+
+		Index* index = (Index*)decrypted_buffer.buffer;
+
+		return get_password_from_buffer(decrypted_buffer, index->count - 1);
+
+	}
+
+	return 0;
 }
 
 void arg_list(Buffer& decrypted_buffer)
 {
-	Pass* passwords = (Pass*)decrypted_buffer.buffer;
+	Index* index = (Index*)decrypted_buffer.buffer;
-	for (int i = 0; i < decrypted_buffer.taken / sizeof(Pass); i++)
+	Pass* pass = (Pass*)(decrypted_buffer.buffer + sizeof(Index));
+
+	for (size_t i = 0; i < index->count; i++)
 	{
-		printf_s("%s\n", passwords[i].label);
+		printf_s("label: %s\n", decrypted_buffer.buffer + pass[i].label + index->offset);
 	}
 }
 
-void arg_delete(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto)
+void arg_delete(Buffer& in_buffer, Buffer& out_buffer, const char* label_to_del, Cryptography& crypto)
 {
-	printf_s("Deleting password for %s\n", label);
+	printf_s("Deleting password for %s\n", label_to_del);
-	Pass* pass = find_password(&decrypted_buffer, label);
+	int pass = find_password_in_buffer(in_buffer, label_to_del);
-	if (!pass)
+	if (pass < 0)
 	{
 		printf_s("Password not found\n");
 		return;
 	}
-	else
+
-	{
+	arg_list(in_buffer);
-		decrypted_buffer.remove_fast((uint8_t*)pass, sizeof(Pass));
+
-	}
+	delete_password_from_buffer(in_buffer, out_buffer, pass);
-	crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
+	
-	save_buffer_to_file(&encrypted_buffer);
+	arg_list(out_buffer);
+
+	crypto.encrypt(&out_buffer, &in_buffer);
+	save_buffer_to_file(in_buffer);
 	printf_s("Password deleted\n");
 }
 
 void arg_print_all_p(Buffer& decrypted_buffer, std::string& user_pass)
 {
-	printf_s("Input main password for confirmation:\n");
+	printf_s("Input main password for confirmation:");
-	std::string new_string = get_passwd();
+	std::string new_string = get_user_password();
 	if (new_string.empty())
 	{
 		printf_s("Error getting password\n");
@@ -79,57 +157,24 @@ void arg_print_all_p(Buffer& decrypted_buffer, std::string& user_pass)
 		printf_s("Wrong password\n");
 		return;
 	}
-	Pass* passwords = (Pass*)decrypted_buffer.buffer;
+
-	for (int i = 0; i < decrypted_buffer.taken / sizeof(Pass); i++)
+	Index* index = (Index*)decrypted_buffer.buffer;
+	Pass* pass = (Pass*)(decrypted_buffer.buffer + sizeof(Index));
+
+	for (size_t i = 0; i < index->count; i++)
 	{
-		printf_s("%s: %s\n", passwords[i].label, passwords[i].password);
+		printf_s("label: %s\t\t\t", decrypted_buffer.buffer + pass[i].label + index->offset);
+		printf_s("password: %s\n", decrypted_buffer.buffer + pass[i].password + index->offset);
 	}
 }
 
-Pass* arg_input(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto)
-{
-	printf_s("Input password for %s:\n", label);
 
-	std::string new_string = get_passwd();
-
-
-	if (new_string.empty())
-	{
-		printf_s("Error getting password\n");
-		return nullptr;
-	}
-
-	Pass* pass = find_password(&decrypted_buffer, label);
-	Pass new_pass = { 0 };
-
-
-	if (pass != nullptr)
-	{
-		strcpy_s(pass->password, MAX_STRING_SIZE, new_string.c_str());
-	}
-	else
-	{
-		strcpy_s(new_pass.password, MAX_STRING_SIZE, new_string.c_str());
-		strcpy_s(new_pass.label, MAX_STRING_SIZE, label);
-		int position = decrypted_buffer.add((uint8_t*)&new_pass, sizeof(Pass));
-		if (position < 0)
-		{
-			printf_s("Error adding password\n");
-			return nullptr;
-		}
-		pass = (Pass*)(decrypted_buffer.buffer + position);
-	}
-
-	crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
-	save_buffer_to_file(&encrypted_buffer);
-	return pass;
-}
 
 void arg_change(Buffer& decrypted_buffer, Buffer& encrypted_buffer, std::string& user_pass, Cryptography& crypto)
 {
 	printf_s("Input main password for confirmation:");
 
-	std::string new_string = get_passwd();
+	std::string new_string = get_user_password();
 	if (new_string.empty())
 	{
 		printf_s("Error getting password\n");
@@ -143,7 +188,7 @@ void arg_change(Buffer& decrypted_buffer, Buffer& encrypted_buffer, std::string&
 	}
 
 	printf_s("Input new password:");
-	new_string = get_passwd();
+	new_string = get_user_password();
 	if (new_string.empty())
 	{
 		printf_s("Error getting password\n");
@@ -151,7 +196,7 @@ void arg_change(Buffer& decrypted_buffer, Buffer& encrypted_buffer, std::string&
 	}
 
 	printf_s("Input new password again:");
-	user_pass = get_passwd();
+	user_pass = get_user_password();
 	if (user_pass.empty())
 	{
 		printf_s("Error getting password\n");
@@ -166,15 +211,16 @@ void arg_change(Buffer& decrypted_buffer, Buffer& encrypted_buffer, std::string&
 
 	crypto.generate_key_and_iv_from_password(new_string.c_str(), new_string.size());
 	crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
-	save_buffer_to_file(&encrypted_buffer);
+	save_buffer_to_file(encrypted_buffer);
 	printf_s("Password changed\n");
 }
 
 void arg_show(Buffer& decrypted_buffer, const char* label) {
 
-	Pass* pass = find_password(&decrypted_buffer, label);
+	int pass = find_password_in_buffer(decrypted_buffer, label);
-	if (!pass)
+
+	if (pass < 0)
 		printf_s("Password not found\n");
 	else
-		printf_s("Password: %s\n", pass->password);
+		printf_s("Password: %s\n", get_password_from_buffer(decrypted_buffer, pass));
 }

Password_manager/source/buffer.cpp

@@ -33,7 +33,7 @@ bool Buffer::resize(size_t new_size)
 	return true;
 }
 
-int Buffer::add(uint8_t* data, size_t data_size)
+int Buffer::add_end(uint8_t* data, size_t data_size)
 {
 	if (taken + data_size > size)
 		if (!resize(size + data_size)) return -1;
@@ -43,6 +43,16 @@ int Buffer::add(uint8_t* data, size_t data_size)
 	return taken - data_size;
 }
 
+int Buffer::add_middle(uint8_t* data, size_t data_size, size_t index)
+{
+	if (taken + data_size > size)
+		if (!resize(size + data_size)) return -1;
+	memmove_s(buffer + index + data_size, size - index - data_size, buffer + index, taken - index);
+	memcpy_s(buffer + index, size - index, data, data_size);
+	taken += data_size;
+	return index;
+}
+
 void Buffer::remove_fast(uint8_t* data, size_t data_size)
 {
 	int64_t index = data - buffer;

Password_manager/source/func.cpp

@@ -2,21 +2,76 @@
 #include "glob.h"
 #include "Buffer.h"
 
-Pass* find_password(Buffer* buff, const char* label)
+int find_password_in_buffer(Buffer& decrypted_buffer, const char* label)
 {
-	Pass* passwords = (Pass*)buff->buffer;
+	Index* index = (Index*)decrypted_buffer.buffer;
+	Pass* pass = (Pass*)(decrypted_buffer.buffer + sizeof(Index));
 
-	for (int i = 0; i < buff->taken / sizeof(Pass); i++)
+	for (size_t i = 0; i < index->count; i++)
 	{
-		if (glob(label, passwords[i].label) == Glob_Result::MATCHED)
+		if (glob(label, (const char*) decrypted_buffer.buffer + pass[i].label + index->offset) == Glob_Result::MATCHED)
-		{
+			return i;
-			return &passwords[i];
-		}
-	}
-	return nullptr;
 	}
 
-void generate_password(char* password)
+	return -1;
+}
+
+void delete_password_from_buffer(Buffer& in, Buffer& out, int index_of_pass) 
+{
+	Index* index = (Index*)in.buffer;
+	Pass* pass = (Pass*)(in.buffer + sizeof(Index));
+
+	int size = sizeof(Index) + sizeof(Pass) * (index->count - 1);
+
+	out.resize(size);
+	out.taken = size;
+
+	((Index*)out.buffer)[0].count = index->count - 1;
+	((Index*)out.buffer)[0].offset = size;
+	int count = 0;
+	for (size_t i = 0; i < index->count; i++)
+	{
+		if (i == index_of_pass) continue;
+
+		uint8_t* label = in.buffer + pass[i].label + index->offset;
+		size_t label_start = out.add_end(label, strlen((const char*)label) + 1);
+
+		uint8_t* password = in.buffer + pass[i].password + index->offset;
+		size_t password_start = out.add_end(password, strlen((const char*)password) + 1);
+
+
+		pass = (Pass*)(out.buffer + sizeof(Index));
+		pass[count].label = label_start - size;
+		pass[count].password = password_start - size;
+		count++;
+	}
+}
+
+void add_password_to_buffer(Buffer& in, const char* label, const char* password)
+{
+	int label_start = in.add_end((uint8_t*)label, strlen(label) + 1);
+	int password_start = in.add_end((uint8_t*)password, strlen(password) + 1);
+
+	Index* index = (Index*)in.buffer;
+
+	label_start = label_start - index->offset;
+	password_start = password_start - index->offset;
+	Pass pass = { label_start, password_start };
+	index->count++;
+	index->offset += sizeof(Pass);
+
+	in.add_middle((uint8_t*)&pass, sizeof(Pass), index->offset - sizeof(Pass));
+	
+}
+
+const char* get_password_from_buffer(Buffer& decrypted_buffer, int label)
+{
+	Index* index = (Index*)decrypted_buffer.buffer;
+	Pass* pass = (Pass*)(decrypted_buffer.buffer + sizeof(Index));
+	return (const char*)decrypted_buffer.buffer + pass[label].password + index->offset;
+}
+
+void generate_password(std::string& password)
 {
 	srand(time(NULL));
 	char characters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_-+={[}]|:;<,>.?";
@@ -27,33 +82,34 @@ void generate_password(char* password)
 	password[MAX_STRING_SIZE - 1] = '\0';
 }
 
-bool save_buffer_to_file(Buffer* buffer)
+bool save_buffer_to_file(Buffer& buffer)
 {
-	std::ofstream file("passwords.bin", std::ios::binary);
+	std::ofstream file("passwords.bin", std::ios::binary | std::ios::out);
 	if (!file.is_open())
 	{
 		printf_s("Error saving file\n");
 		return false;
 	}
-	file.write((char*)buffer->buffer, buffer->taken);
+	file.write((char*)buffer.buffer, buffer.taken);
 	file.close();
 	return true;
 }
 
-bool load_buffer_from_file(Buffer* buffer)
+bool load_buffer_from_file(Buffer& buffer)
 {
-	std::ifstream file("passwords.bin", std::ios::binary);
+	std::ifstream file("passwords.bin", std::ios::binary | std::ios::in);
 	if (!file.is_open()) return false;
 
 	file.seekg(0, std::ios::end);
-	buffer->resize(file.tellg());
+	size_t file_size = file.tellg();
+	buffer.resize(file_size);
 	file.seekg(0, std::ios::beg);
-	file.read((char*)buffer->buffer, buffer->size);
+	file.read((char*)buffer.buffer, buffer.size);
 
 	if (file)
-		buffer->taken = buffer->size;
+		buffer.taken = file_size;
 	else
-		buffer->taken = file.gcount();
+		buffer.taken = file.gcount();
 
 	file.close();
 	return true;
@@ -64,13 +120,12 @@ void print_usage()
 {
 	printf_s(" Usage:\n\n");
 	printf_s(" password_manager.exe [flags]\n\n");
-	printf_s(" Note: <label> max len %d char\n\n", MAX_STRING_SIZE);
 	printf_s(" Flags:\n\n");
 	printf_s(" -h         \t print this message\n");
 	printf_s(" <label>    \t get password of this label can use GLOB\n");
 	printf_s(" -g <label> \t generate or update password of this label\n");
 	printf_s(" -d <label> \t delete password of this label\n");
-	printf_s(" -i <label> \t input password for this label max %d char\n", MAX_STRING_SIZE);
+	printf_s(" -i <label> \t input password for this label\n");
 	printf_s(" -s <label> \t show password for this label\n");
 	printf_s(" -l         \t list all labels\n");
 	printf_s(" -p         \t print all passwords\n");

Password_manager/source/main.cpp

@@ -8,92 +8,24 @@
 
 #ifdef _DEBUG
 
+
+
 int main()
 {
-	Buffer encrypted_buffer;
+	const char* label = "pet";
-	load_buffer_from_file(&encrypted_buffer);
+	Arg args = Arg::List;
-	
-
-	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 = nullptr;
-	std::string label = "test";
-
-
-	printf_s("\n--arg_generate--------------------------------------------\n");
-
-	pass = arg_generate(decrypted_buffer, encrypted_buffer, label.c_str(), crypto);
-	printf_s("Generated Password: %s\n", pass->password);
-	
-	printf_s("\n--arg_get-------------------------------------------------\n");
-
-	pass = arg_get(decrypted_buffer, label.c_str());
-	printf_s("Password: %s\n", pass->password);
-
-	
-	printf_s("\n--arg_list------------------------------------------------\n");
-
-	arg_list(decrypted_buffer);
-
-
-	label = "test2";
-	
-	printf_s("\n--arg_input-----------------------------------------------\n");
-
-	pass = arg_input(decrypted_buffer, encrypted_buffer, label.c_str(), crypto);
-	printf_s("Password: %s\n", pass->password);
-
-	printf_s("\n--arg_show------------------------------------------------\n");
-
-	arg_show(decrypted_buffer, label.c_str());
-
-
-	printf_s("\n--arg_print_all_p-----------------------------------------\n");
-
-	arg_print_all_p(decrypted_buffer, user_pass);
-
-	printf_s("\n--arg_delete----------------------------------------------\n");
-
-	arg_delete(decrypted_buffer, encrypted_buffer, label.c_str(), crypto);
-	label = "test";
-	arg_delete(decrypted_buffer, encrypted_buffer, label.c_str(), crypto);
-
-}
-
-#else
-
-int main(int argc, char** argv)
-{
-	char* label = nullptr;
-	Arg args = get_args(argc, argv, &label);
 	if (args == Arg::Error) return 1;
 
 	Buffer encrypted_buffer;
-	if (!load_buffer_from_file(&encrypted_buffer))
+	if (!load_buffer_from_file(encrypted_buffer))
 		if (!(args == Arg::Generate || args == Arg::Input)) {
 			printf_s("No passwords, try generating password\n");
 			return 1;
 		}
 
-	printf_s("Input main password:");
+	
-	std::string user_pass = get_user_password();
+	std::string user_pass = "123";
-	if (user_pass.empty())
+
-	{
-		printf_s("Error getting password\n");
-		return 1;
-	}
 
 	Cryptography crypto(user_pass.c_str(), user_pass.size());
 
@@ -101,7 +33,7 @@ int main(int argc, char** argv)
 	if (encrypted_buffer.size > 0)
 		if (!crypto.decrypt(&encrypted_buffer, &decrypted_buffer)) return 1;
 
-	Pass* pass = nullptr;
+	const char* pass = nullptr;
 
 	switch (args)
 	{
@@ -141,7 +73,80 @@ int main(int argc, char** argv)
 	if (!pass) return 1;
 
 	printf_s("Password copied to clipboard\n");
-	put_data_on_clipboard(pass->password);
+	put_data_on_clipboard(pass);
+
+}
+
+#else
+
+int main(int argc, char** argv)
+{
+	char* label = nullptr;
+	Arg args = get_args(argc, argv, &label);
+	if (args == Arg::Error) return 1;
+
+	Buffer encrypted_buffer;
+	if (!load_buffer_from_file(&encrypted_buffer))
+		if (!(args == Arg::Generate || args == Arg::Input)) {
+			printf_s("No passwords, try generating password\n");
+			return 1;
+		}
+
+	printf_s("Input main password:");
+	std::string user_pass = get_user_password();
+	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;
+
+	const char* pass = nullptr;
+
+	switch (args)
+	{
+	case Arg::Get:
+		pass = arg_get(decrypted_buffer, label);
+		break;
+
+	case Arg::Generate:
+		pass = arg_generate(decrypted_buffer, encrypted_buffer, label, crypto);
+		break;
+
+	case Arg::List:
+		arg_list(decrypted_buffer);
+		break;
+
+	case Arg::Delete:
+		arg_delete(decrypted_buffer, encrypted_buffer, label, crypto);
+		break;
+
+	case Arg::Print_all_p:
+		arg_print_all_p(decrypted_buffer, user_pass);
+		break;
+
+	case Arg::Input:
+		pass = arg_input(decrypted_buffer, encrypted_buffer, label, crypto);
+		break;
+
+	case Arg::Change:
+		arg_change(decrypted_buffer, encrypted_buffer, user_pass, crypto);
+
+
+	case Arg::Show:
+		arg_show(decrypted_buffer, label);
+		break;
+	}
+
+	if (!pass) return 1;
+
+	printf_s("Password copied to clipboard\n");
+	put_data_on_clipboard(pass);
 
 }