From 36de6ec412011208b99740b0ffa759ac5d4ce97b Mon Sep 17 00:00:00 2001
From: Nikola Petrov <nikolape7@gmail.com>
Date: Sun, 14 Jan 2024 21:43:49 +0100
Subject: [PATCH] It compiles no encript

---
 include/arg_func.h               |  45 --------
 include/arg_func.hpp             |  48 ++++++++
 include/{Buffer.h => buffer.hpp} |  19 ++--
 include/cryptography.h           |  23 ----
 include/cryptography.hpp         |  27 +++++
 include/func.h                   |  35 ------
 include/func.hpp                 |  38 +++++++
 include/glob.h                   |  13 ---
 include/glob.hpp                 |  16 +++
 include/sys.hpp                  |  11 ++
 include/win.h                    |   6 -
 source/main.cpp => main.cpp      |  60 +++++-----
 makefile                         |  30 +++++
 source/arg_func.cpp              | 185 +++++++++++++++++--------------
 source/buffer.cpp                |  56 +++++-----
 source/cryptography.cpp          |  74 +++----------
 source/func.cpp                  |  61 +++++-----
 source/glob.cpp                  |  89 +++++++++------
 source/{win.cpp => sys.cpp}      |  70 ++++++++----
 19 files changed, 500 insertions(+), 406 deletions(-)
 delete mode 100644 include/arg_func.h
 create mode 100644 include/arg_func.hpp
 rename include/{Buffer.h => buffer.hpp} (59%)
 delete mode 100644 include/cryptography.h
 create mode 100644 include/cryptography.hpp
 delete mode 100644 include/func.h
 create mode 100644 include/func.hpp
 delete mode 100644 include/glob.h
 create mode 100644 include/glob.hpp
 create mode 100644 include/sys.hpp
 delete mode 100644 include/win.h
 rename source/main.cpp => main.cpp (68%)
 create mode 100644 makefile
 rename source/{win.cpp => sys.cpp} (73%)

diff --git a/include/arg_func.h b/include/arg_func.h
deleted file mode 100644
index 9a6fd26..0000000
--- a/include/arg_func.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-struct LoginInfoPointer;
-class Buffer;
-class Cryptography;
-#include <string>
-#include <optional>
-
-enum class Arg
-{
-	Get, // get password for label
-	Generate, // generate password for label
-	List, // list all labels
-	Delete, // delete password for label
-	Print_all_p, // print all passwords
-	Input, // input password for label
-	Change, // change main password
-	Show, // show password for label
-	Error, // error
-	Username, // update username
-	Name, // update label name
-	File, // select save file
-};
-
-Arg get_args(int argc, char** argv, char** label);
-
-std::optional<LoginInfoPointer> arg_get(Buffer& decrypted_buffer, const char* label);
-
-std::optional<LoginInfoPointer> arg_new_password(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto, bool generate);
-
-void arg_username(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto);
-
-void arg_label_name(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto);
-
-void arg_list(Buffer& decrypted_buffer);
-
-void arg_delete(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto);
-
-void arg_print_all_p(Buffer& decrypted_buffer, std::string& user_pass);
-
-void arg_change(Buffer& decrypted_buffer, Buffer& encrypted_buffer, std::string& user_pass, Cryptography& crypto);
-
-void arg_show(Buffer& decrypted_buffer, const char* label);
-
-void arg_file(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto, std::string& save_location_path);
\ No newline at end of file
diff --git a/include/arg_func.hpp b/include/arg_func.hpp
new file mode 100644
index 0000000..c038c55
--- /dev/null
+++ b/include/arg_func.hpp
@@ -0,0 +1,48 @@
+#ifndef ARG_FUNC_HPP
+#define ARG_FUNC_HPP
+
+struct LoginInfoPointer;
+class Buffer;
+class Cryptography;
+#include <string>
+#include <optional>
+
+enum class Arg
+{
+	Get,				 // get password for label
+	Generate,		 // generate password for label
+	List,				 // list all labels
+	Delete,			 // delete password for label
+	Print_all_p, // print all passwords
+	Input,			 // input password for label
+	Change,			 // change main password
+	Show,				 // show password for label
+	Error,			 // error
+	Username,		 // update username
+	Name,				 // update label name
+	File,				 // select save file
+};
+
+Arg get_args(int argc, char **argv, char **label);
+
+std::optional<LoginInfoPointer> arg_get(Buffer &decrypted_buffer, const char *label);
+
+std::optional<LoginInfoPointer> arg_new_password(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto, bool generate);
+
+void arg_username(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto);
+
+void arg_label_name(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto);
+
+void arg_list(Buffer &decrypted_buffer);
+
+void arg_delete(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto);
+
+void arg_print_all_p(Buffer &decrypted_buffer, std::string &user_pass);
+
+void arg_change(Buffer &decrypted_buffer, Buffer &encrypted_buffer, std::string &user_pass, Cryptography &crypto);
+
+void arg_show(Buffer &decrypted_buffer, const char *label);
+
+void arg_file(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto, std::string &save_location_path);
+
+#endif
\ No newline at end of file
diff --git a/include/Buffer.h b/include/buffer.hpp
similarity index 59%
rename from include/Buffer.h
rename to include/buffer.hpp
index 5cf4403..a16c249 100644
--- a/include/Buffer.h
+++ b/include/buffer.hpp
@@ -1,11 +1,13 @@
-#pragma once
+#ifndef BUFFER_HPP
+#define BUFFER_HPP
+
 #include <cstdint>
 #include <string>
 
 class Buffer
 {
 public:
-	uint8_t* buffer = nullptr;
+	uint8_t *buffer = nullptr;
 	size_t taken = 0;
 	size_t size = 0;
 	std::string file_path;
@@ -14,17 +16,17 @@ public:
 	Buffer();
 	~Buffer();
 	bool resize(size_t new_size);
-	int add_end(uint8_t* data, size_t data_size);
-	int add_middle(uint8_t* data, size_t data_size, size_t index);
+	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);
+	void remove_fast(uint8_t *data, size_t data_size);
 
 	void remove(size_t index, size_t data_size);
 
-	size_t find(uint8_t* data, size_t data_size);
+	size_t find(uint8_t *data, size_t data_size);
 
-	void remove(uint8_t* data, size_t data_size);
+	void remove(uint8_t *data, size_t data_size);
 
 	void clear() { taken = 0; }
 
@@ -33,5 +35,6 @@ public:
 
 	bool load_from_file();
 	bool load_from_file(std::string file_path);
+};
 
-};
\ No newline at end of file
+#endif
\ No newline at end of file
diff --git a/include/cryptography.h b/include/cryptography.h
deleted file mode 100644
index ec425f6..0000000
--- a/include/cryptography.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-#include <cstdint>
-
-struct evp_cipher_ctx_st;
-typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
-
-class Buffer;
-
-class Cryptography
-{
-public:
-	Cryptography(const char* password, size_t size);
-	~Cryptography();
-	bool encrypt(Buffer* plain, Buffer* encrypted);
-	bool decrypt(Buffer* encrypted, Buffer* decrypted);
-	bool generate_key_and_iv_from_password(const char* password, size_t size);
-
-private:
-	uint8_t key[32] = { 0 };
-	uint8_t iv[16] = { 0 };
-	EVP_CIPHER_CTX* ctx = nullptr;
-	bool handleErrors();
-};
diff --git a/include/cryptography.hpp b/include/cryptography.hpp
new file mode 100644
index 0000000..4c56d19
--- /dev/null
+++ b/include/cryptography.hpp
@@ -0,0 +1,27 @@
+#ifndef CRYPTOGRAPHY_HPP
+#define CRYPTOGRAPHY_HPP
+
+#include <cstdint>
+
+struct evp_cipher_ctx_st;
+typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
+
+class Buffer;
+
+class Cryptography
+{
+public:
+	Cryptography(const char *password, size_t size);
+	~Cryptography();
+	bool encrypt(Buffer *plain, Buffer *encrypted);
+	bool decrypt(Buffer *encrypted, Buffer *decrypted);
+	bool generate_key_and_iv_from_password(const char *password, size_t size);
+
+private:
+	uint8_t key[32] = {0};
+	uint8_t iv[16] = {0};
+	EVP_CIPHER_CTX *ctx = nullptr;
+	bool handleErrors();
+};
+
+#endif
\ No newline at end of file
diff --git a/include/func.h b/include/func.h
deleted file mode 100644
index d3c172c..0000000
--- a/include/func.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-#include <string>
-
-class Buffer;
-
-struct LoginInfo
-{
-	uint32_t label;
-	uint32_t username;
-	uint32_t password; 
-};
-
-struct LoginInfoPointer
-{
-	const char* label;
-	const char* username;
-	const char* password;
-};
-
-struct Index
-{
-	uint32_t count;
-	uint32_t offset;
-};
-
-int find_logininfo_in_buffer(Buffer& buffer, const char* label);
-
-void delete_logininfo_from_buffer(Buffer& buffer, int index_of_pass);
-
-void add_logininfo_to_buffer(Buffer& buffer, const char* label, const char* username, const char* password);
-
-LoginInfoPointer get_logininfo_pointer_from_buffer(Buffer& buffer, int index_of_pass);
-
-void generate_password(std::string& password, int len);
-
diff --git a/include/func.hpp b/include/func.hpp
new file mode 100644
index 0000000..e4cef6f
--- /dev/null
+++ b/include/func.hpp
@@ -0,0 +1,38 @@
+#ifndef FUNC_HPP
+#define FUNC_HPP
+
+#include <string>
+
+class Buffer;
+
+struct LoginInfo
+{
+	uint32_t label;
+	uint32_t username;
+	uint32_t password;
+};
+
+struct LoginInfoPointer
+{
+	const char *label;
+	const char *username;
+	const char *password;
+};
+
+struct Index
+{
+	uint32_t count;
+	uint32_t offset;
+};
+
+int find_logininfo_in_buffer(Buffer &buffer, const char *label);
+
+void delete_logininfo_from_buffer(Buffer &buffer, int index_of_pass);
+
+void add_logininfo_to_buffer(Buffer &buffer, const char *label, const char *username, const char *password);
+
+LoginInfoPointer get_logininfo_pointer_from_buffer(Buffer &buffer, int index_of_pass);
+
+void generate_password(std::string &password, int len);
+
+#endif
\ No newline at end of file
diff --git a/include/glob.h b/include/glob.h
deleted file mode 100644
index 0e4e821..0000000
--- a/include/glob.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-
-enum class Glob_Result {
-	OOM_ERROR,
-	ENCODING_ERROR,
-	SYNTAX_ERROR,
-	UNMATCHED,
-	MATCHED,
-};
-
-// https://github.com/tsoding/glob.h
-Glob_Result glob(const char* pattern, const char* text);
\ No newline at end of file
diff --git a/include/glob.hpp b/include/glob.hpp
new file mode 100644
index 0000000..d234961
--- /dev/null
+++ b/include/glob.hpp
@@ -0,0 +1,16 @@
+#ifndef GLOB_HPP
+#define GLOB_HPP
+
+enum class Glob_Result
+{
+	OOM_ERROR,
+	ENCODING_ERROR,
+	SYNTAX_ERROR,
+	UNMATCHED,
+	MATCHED,
+};
+
+// https://github.com/tsoding/glob.h
+Glob_Result glob(const char *pattern, const char *text);
+
+#endif
\ No newline at end of file
diff --git a/include/sys.hpp b/include/sys.hpp
new file mode 100644
index 0000000..2acf6cc
--- /dev/null
+++ b/include/sys.hpp
@@ -0,0 +1,11 @@
+#ifndef WIN_HPP
+#define WIN_HPP
+
+#include <optional>
+#include <string>
+
+bool put_data_on_clipboard(const char *text);
+std::string get_user_password();
+std::optional<std::string> get_save_path();
+
+#endif
\ No newline at end of file
diff --git a/include/win.h b/include/win.h
deleted file mode 100644
index 9b3c5f9..0000000
--- a/include/win.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-#include <optional>
-
-bool put_data_on_clipboard(const char* text);
-std::string get_user_password();
-std::optional<std::string> get_save_path();
diff --git a/source/main.cpp b/main.cpp
similarity index 68%
rename from source/main.cpp
rename to main.cpp
index 6402c51..d7b0c6e 100644
--- a/source/main.cpp
+++ b/main.cpp
@@ -1,20 +1,20 @@
 #include <iostream>
 #include <fstream>
 
-#include "win.h"
-#include "buffer.h"
-#include "cryptography.h"
-#include "func.h"
-#include "arg_func.h"
+#include "sys.hpp"
+#include "buffer.hpp"
+#include "cryptography.hpp"
+#include "func.hpp"
+#include "arg_func.hpp"
 
 #ifdef _DEBUG
 #define DEBUG 0
 #endif // DEBUG
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
 	std::string user_pass = "";
-	char* label = nullptr;
+	char *label = nullptr;
 	Arg args = Arg::Error;
 	std::optional<std::string> save_location_path = std::nullopt;
 	std::string save_location = "";
@@ -30,16 +30,17 @@ int main(int argc, char** argv)
 #else
 
 	args = get_args(argc, argv, &label);
-	if (args == Arg::Error) return 1;
+	if (args == Arg::Error)
+		return 1;
 
 	save_location_path = get_save_path();
 	if (!save_location_path.has_value())
 	{
-		printf_s("Error geting file for save path\n");
+		printf("Error geting file for save path\n");
 		return 1;
 	}
 
-	std::fstream ifile(save_location_path.value(), std::ios::binary || std::ios::in);
+	std::ifstream ifile(save_location_path.value(), std::ios::binary);
 	if (ifile.is_open())
 	{
 		std::getline(ifile, save_location);
@@ -48,28 +49,28 @@ int main(int argc, char** argv)
 
 	if (save_location.empty() && args != Arg::File)
 	{
-		printf_s("No save location, try selecting folder (-f)\n");
+		printf("No save location, try selecting folder (-f)\n");
 		return 1;
 	}
 
 #endif // DEBUG
 
 	Buffer encrypted_buffer;
-	//load file
+	// load file
 	if (!encrypted_buffer.load_from_file(save_location))
 		// if file doesn't exist, check if it's a new password is being generated if not, exit
-		if (!(args == Arg::Generate || args == Arg::Input || args == Arg::File)) {
-			printf_s("No passwords, try generating password (-g or -i)\n");
+		if (!(args == Arg::Generate || args == Arg::Input || args == Arg::File))
+		{
+			printf("No passwords, try generating password (-g or -i)\n");
 			return 1;
 		}
 
-
 #if !DEBUG
-	printf_s("Input main password:");
+	printf("Input main password:");
 	user_pass = get_user_password();
 	if (user_pass.empty())
 	{
-		printf_s("Error getting password\n");
+		printf("Error getting password\n");
 		return 1;
 	}
 #endif // !1
@@ -77,15 +78,17 @@ int main(int argc, char** argv)
 	Cryptography crypto(user_pass.c_str(), user_pass.size());
 
 	Buffer decrypted_buffer;
-	//check if encrypted buffer is empty if not, decrypt it
+	// check if encrypted buffer is empty if not, decrypt it
 	if (encrypted_buffer.size > 0)
-		if (!crypto.decrypt(&encrypted_buffer, &decrypted_buffer)) return 1;
+		if (!crypto.decrypt(&encrypted_buffer, &decrypted_buffer))
+			return 1;
 
-	//if decrypted buffer is empty, add index
-	if (decrypted_buffer.taken < sizeof(Index)) {
-		Index index = { 0 };
+	// if decrypted buffer is empty, add index
+	if (decrypted_buffer.taken < sizeof(Index))
+	{
+		Index index = {0};
 		index.offset = sizeof(Index);
-		decrypted_buffer.add_end((uint8_t*)&index, sizeof(Index));
+		decrypted_buffer.add_end((uint8_t *)&index, sizeof(Index));
 	}
 
 	std::optional<LoginInfoPointer> login_info;
@@ -137,18 +140,19 @@ int main(int argc, char** argv)
 		break;
 	}
 
-	if (!login_info.has_value()) return 0;
+	if (!login_info.has_value())
+		return 0;
 
 #if DEBUG
 
-	printf_s("Username: %s\n", login_info.value().username);
-	printf_s("Password: %s\n", login_info.value().password);
+	printf("Username: %s\n", login_info.value().username);
+	printf("Password: %s\n", login_info.value().password);
 
 #else
 
-	printf_s("Username: %s\n", login_info.value().username);
+	printf("Username: %s\n", login_info.value().username);
 	put_data_on_clipboard(login_info.value().password);
-	printf_s("Password copied to clipboard\n");
+	printf("Password copied to clipboard\n");
 
 #endif // _DEBUG
 
diff --git a/makefile b/makefile
new file mode 100644
index 0000000..3a939d3
--- /dev/null
+++ b/makefile
@@ -0,0 +1,30 @@
+CC=g++
+
+CFLAGS= -std=c++23
+
+INCLUDE_DIR= include
+
+SRC_DIR= source
+
+# Get all cpp files from src directory
+SRCS := $(wildcard $(SRC_DIR)/*.cpp)
+
+# Get all header files from include directory
+HDRS := $(wildcard $(INCLUDE_DIR)/*.h)
+
+all: main run
+
+main:  main.cpp $(SRCS) $(HDRS)
+	$(CC) $(CFLAGS) -O3 -I$(INCLUDE_DIR) $(SRCS) main.cpp -o main
+
+debug:  main.cpp $(SRCS) $(HDRS)
+	$(CC) $(CFLAGS) -I$(INCLUDE_DIR) $(SRCS) -g main.cpp -o main
+
+run: main
+	./main
+
+zip:
+	zip -r main.zip main.cpp $(INCLUDE_DIR) $(SRC_DIR) makefile
+
+clean:
+	rm main
diff --git a/source/arg_func.cpp b/source/arg_func.cpp
index 064eb64..c531b10 100644
--- a/source/arg_func.cpp
+++ b/source/arg_func.cpp
@@ -2,34 +2,36 @@
 #include <iostream>
 #include <sstream>
 #include <fstream>
+#include <cstring>
 
-#include "arg_func.h"
-#include "func.h"
-#include "win.h"
-#include "func.h"
-#include "buffer.h"
-#include "cryptography.h"
+#include "arg_func.hpp"
+#include "func.hpp"
+#include "sys.hpp"
+#include "func.hpp"
+#include "buffer.hpp"
+#include "cryptography.hpp"
 
 void print_args()
 {
-	printf_s(" Usage:\n\n");
-	printf_s(" password_manager.exe [flags]\n\n");
-	printf_s(" Flags:\n\n");
-	printf_s(" -h                   print this message\n");
-	printf_s(" <label>              get password of this label can use GLOB\n");
-	printf_s(" -g <label>           generate password of this label (or update if exists)\n");
-	printf_s(" -i <label>           input new password for this label (or update if exists)\n");
-	printf_s(" -d <label>           delete password of this label\n");
-	printf_s(" -s <label>           show password for this label\n");
-	printf_s(" -u <label>           update username for this label\n");
-	printf_s(" -n <label>           update label name\n");
-	printf_s(" -l                   list all labels\n");
-	printf_s(" -p                   print all passwords\n");
-	printf_s(" -c                   change master password\n");
-	printf_s(" -f <folder path>     select save folder\n");
+	printf(" Usage:\n\n");
+	printf(" password_manager.exe [flags]\n\n");
+	printf(" Flags:\n\n");
+	printf(" -h                   print this message\n");
+	printf(" <label>              get password of this label can use GLOB\n");
+	printf(" -g <label>           generate password of this label (or update if exists)\n");
+	printf(" -i <label>           input new password for this label (or update if exists)\n");
+	printf(" -d <label>           delete password of this label\n");
+	printf(" -s <label>           show password for this label\n");
+	printf(" -u <label>           update username for this label\n");
+	printf(" -n <label>           update label name\n");
+	printf(" -l                   list all labels\n");
+	printf(" -p                   print all passwords\n");
+	printf(" -c                   change master password\n");
+	printf(" -f <folder path>     select save folder\n");
 }
 
-Arg get_args(int argc, char** argv, char** label) {
+Arg get_args(int argc, char **argv, char **label)
+{
 	if (argc < 2)
 	{
 		print_args();
@@ -42,9 +44,12 @@ Arg get_args(int argc, char** argv, char** label) {
 		return Arg::Error;
 	}
 
-	if (!strcmp("-l", argv[1])) return Arg::List;
-	if (!strcmp("-p", argv[1])) return Arg::Print_all_p;
-	if (!strcmp("-c", argv[1])) return Arg::Change;
+	if (!strcmp("-l", argv[1]))
+		return Arg::List;
+	if (!strcmp("-p", argv[1]))
+		return Arg::Print_all_p;
+	if (!strcmp("-c", argv[1]))
+		return Arg::Change;
 
 	if (argc < 3)
 	{
@@ -54,53 +59,62 @@ Arg get_args(int argc, char** argv, char** label) {
 
 	*label = argv[2];
 
-	if (!strcmp("-g", argv[1])) return Arg::Generate;
-	if (!strcmp("-d", argv[1])) return Arg::Delete;
-	if (!strcmp("-i", argv[1]))	return Arg::Input;
-	if (!strcmp("-s", argv[1])) return Arg::Show;
-	if (!strcmp("-u", argv[1])) return Arg::Username;
-	if (!strcmp("-n", argv[1])) return Arg::Name;
-	if (!strcmp("-f", argv[1])) return Arg::File;
+	if (!strcmp("-g", argv[1]))
+		return Arg::Generate;
+	if (!strcmp("-d", argv[1]))
+		return Arg::Delete;
+	if (!strcmp("-i", argv[1]))
+		return Arg::Input;
+	if (!strcmp("-s", argv[1]))
+		return Arg::Show;
+	if (!strcmp("-u", argv[1]))
+		return Arg::Username;
+	if (!strcmp("-n", argv[1]))
+		return Arg::Name;
+	if (!strcmp("-f", argv[1]))
+		return Arg::File;
 
 	return Arg::Error;
 }
 
-std::optional<LoginInfoPointer> arg_get(Buffer& decrypted_buffer, const char* label)
+std::optional<LoginInfoPointer> arg_get(Buffer &decrypted_buffer, const char *label)
 {
 	int pass = find_logininfo_in_buffer(decrypted_buffer, label);
-	if (pass < 0) {
-		printf_s("Password not found\n");
+	if (pass < 0)
+	{
+		printf("Password not found\n");
 		return {};
 	}
 	return get_logininfo_pointer_from_buffer(decrypted_buffer, pass);
 }
 
-std::optional<LoginInfoPointer> arg_new_password(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto, bool generate)
+std::optional<LoginInfoPointer> arg_new_password(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto, bool generate)
 {
 	int pass = find_logininfo_in_buffer(decrypted_buffer, label);
 	std::string username = "";
 	std::string name = label;
 	std::string password = "";
 
-	if (pass >= 0) {
+	if (pass >= 0)
+	{
 		LoginInfoPointer lip = get_logininfo_pointer_from_buffer(decrypted_buffer, pass);
 		username = lip.username;
 		name = lip.label;
 		delete_logininfo_from_buffer(decrypted_buffer, pass);
 	}
 
-	printf_s("New password for %s: \n", name.c_str());
+	printf("New password for %s: \n", name.c_str());
 
 	if (pass < 0)
 	{
-		printf_s("Input username: ");
+		printf("Input username: ");
 		std::getline(std::cin, username);
 	}
 
 	if (generate)
 	{
 		int default_length = 15;
-		printf_s("Input password length [%d]: ", default_length);
+		printf("Input password length [%d]: ", default_length);
 		std::string input;
 		int length = default_length;
 
@@ -108,18 +122,19 @@ std::optional<LoginInfoPointer> arg_new_password(Buffer& decrypted_buffer, Buffe
 		if (!input.empty())
 		{
 			std::istringstream iss(input);
-			if (!(iss >> length)) length = default_length;
+			if (!(iss >> length))
+				length = default_length;
 		}
 
 		generate_password(password, length);
 	}
 	else
 	{
-		printf_s("Input new password: \n");
+		printf("Input new password: \n");
 		password = get_user_password();
 		if (password.empty())
 		{
-			printf_s("error getting password\n");
+			printf("error getting password\n");
 			return {};
 		}
 	}
@@ -127,16 +142,16 @@ std::optional<LoginInfoPointer> arg_new_password(Buffer& decrypted_buffer, Buffe
 	add_logininfo_to_buffer(decrypted_buffer, name.c_str(), username.c_str(), password.c_str());
 	crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
 	encrypted_buffer.save_to_file();
-	Index* index = (Index*)decrypted_buffer.buffer;
+	Index *index = (Index *)decrypted_buffer.buffer;
 	return get_logininfo_pointer_from_buffer(decrypted_buffer, index->count - 1);
 }
 
-void arg_username(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto)
+void arg_username(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto)
 {
 	int pass = find_logininfo_in_buffer(decrypted_buffer, label);
 	if (pass < 0)
 	{
-		printf_s("LoginInfo not found\n");
+		printf("LoginInfo not found\n");
 		return;
 	}
 
@@ -144,7 +159,7 @@ void arg_username(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char
 	std::string password = lip.password;
 	std::string name = lip.label;
 
-	printf_s("Input username for %s: ", name.c_str());
+	printf("Input username for %s: ", name.c_str());
 	std::string username;
 	std::getline(std::cin, username);
 
@@ -154,13 +169,13 @@ void arg_username(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char
 	encrypted_buffer.save_to_file();
 }
 
-void arg_label_name(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto)
+void arg_label_name(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto)
 {
 	int pass = find_logininfo_in_buffer(decrypted_buffer, label);
 
 	if (pass < 0)
 	{
-		printf_s("LoginInfo not found\n");
+		printf("LoginInfo not found\n");
 		return;
 	}
 
@@ -168,7 +183,7 @@ void arg_label_name(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const ch
 	std::string password = lip.password;
 	std::string username = lip.username;
 
-	printf_s("Input new label name for %s:", lip.label);
+	printf("Input new label name for %s:", lip.label);
 	std::string name;
 	std::getline(std::cin, name);
 
@@ -178,24 +193,24 @@ void arg_label_name(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const ch
 	encrypted_buffer.save_to_file();
 }
 
-void arg_list(Buffer& decrypted_buffer)
+void arg_list(Buffer &decrypted_buffer)
 {
-	Index* index = (Index*)decrypted_buffer.buffer;
-	LoginInfo* pass = (LoginInfo*)(decrypted_buffer.buffer + sizeof(Index));
+	Index *index = (Index *)decrypted_buffer.buffer;
+	LoginInfo *pass = (LoginInfo *)(decrypted_buffer.buffer + sizeof(Index));
 
 	for (size_t i = 0; i < index->count; i++)
 	{
-		printf_s("label: %s\n", decrypted_buffer.buffer + pass[i].label + index->offset);
+		printf("label: %s\n", decrypted_buffer.buffer + pass[i].label + index->offset);
 	}
 }
 
-void arg_delete(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label_to_del, Cryptography& crypto)
+void arg_delete(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label_to_del, Cryptography &crypto)
 {
-	printf_s("Deleting password for %s\n", label_to_del);
+	printf("Deleting password for %s\n", label_to_del);
 	int pass = find_logininfo_in_buffer(decrypted_buffer, label_to_del);
 	if (pass < 0)
 	{
-		printf_s("Password not found\n");
+		printf("Password not found\n");
 		return;
 	}
 
@@ -203,96 +218,97 @@ void arg_delete(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char*
 
 	crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
 	encrypted_buffer.save_to_file();
-	printf_s("Password deleted\n");
+	printf("Password deleted\n");
 }
 
-void arg_print_all_p(Buffer& decrypted_buffer, std::string& user_pass)
+void arg_print_all_p(Buffer &decrypted_buffer, std::string &user_pass)
 {
-	printf_s("Input main password for confirmation:");
+	printf("Input main password for confirmation:");
 	std::string new_string = get_user_password();
 	if (new_string.empty())
 	{
-		printf_s("Error getting password\n");
+		printf("Error getting password\n");
 		return;
 	}
 	if (new_string != user_pass)
 	{
-		printf_s("Wrong password\n");
+		printf("Wrong password\n");
 		return;
 	}
 
-	Index* index = (Index*)decrypted_buffer.buffer;
-	LoginInfo* pass = (LoginInfo*)(decrypted_buffer.buffer + sizeof(Index));
+	Index *index = (Index *)decrypted_buffer.buffer;
+	LoginInfo *pass = (LoginInfo *)(decrypted_buffer.buffer + sizeof(Index));
 
-	printf_s("\n");
+	printf("\n");
 	for (size_t i = 0; i < index->count; i++)
 	{
-		printf_s("label: %-10s\t\t", decrypted_buffer.buffer + pass[i].label + index->offset);
-		printf_s("username: %-10s\t\t", decrypted_buffer.buffer + pass[i].username + index->offset);
-		printf_s("password: %s\n", decrypted_buffer.buffer + pass[i].password + index->offset);
+		printf("label: %-10s\t\t", decrypted_buffer.buffer + pass[i].label + index->offset);
+		printf("username: %-10s\t\t", decrypted_buffer.buffer + pass[i].username + index->offset);
+		printf("password: %s\n", decrypted_buffer.buffer + pass[i].password + index->offset);
 	}
 }
 
-void arg_change(Buffer& decrypted_buffer, Buffer& encrypted_buffer, std::string& user_pass, Cryptography& crypto)
+void arg_change(Buffer &decrypted_buffer, Buffer &encrypted_buffer, std::string &user_pass, Cryptography &crypto)
 {
-	printf_s("Input main password for confirmation:");
+	printf("Input main password for confirmation:");
 
 	std::string new_string = get_user_password();
 	if (new_string.empty())
 	{
-		printf_s("Error getting password\n");
+		printf("Error getting password\n");
 		return;
 	}
 
 	if (new_string != user_pass)
 	{
-		printf_s("Passwords don't match\n");
+		printf("Passwords don't match\n");
 		return;
 	}
 
-	printf_s("Input new password:");
+	printf("Input new password:");
 	new_string = get_user_password();
 	if (new_string.empty())
 	{
-		printf_s("Error getting password\n");
+		printf("Error getting password\n");
 		return;
 	}
 
-	printf_s("Input new password again:");
+	printf("Input new password again:");
 	user_pass = get_user_password();
 	if (user_pass.empty())
 	{
-		printf_s("Error getting password\n");
+		printf("Error getting password\n");
 		return;
 	}
 
 	if (new_string != user_pass)
 	{
-		printf_s("Passwords don't match\n");
+		printf("Passwords don't match\n");
 		return;
 	}
 
 	crypto.generate_key_and_iv_from_password(new_string.c_str(), new_string.size());
 	crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
 	encrypted_buffer.save_to_file();
-	printf_s("Password changed\n");
+	printf("Password changed\n");
 }
 
-void arg_show(Buffer& decrypted_buffer, const char* label) {
+void arg_show(Buffer &decrypted_buffer, const char *label)
+{
 
 	int pass = find_logininfo_in_buffer(decrypted_buffer, label);
 
 	if (pass < 0)
-		printf_s("Password not found\n");
+		printf("Password not found\n");
 	else
 	{
 		LoginInfoPointer lip = get_logininfo_pointer_from_buffer(decrypted_buffer, pass);
-		printf_s("Username: %s\n", lip.username);
-		printf_s("Password: %s\n", lip.password);
+		printf("Username: %s\n", lip.username);
+		printf("Password: %s\n", lip.password);
 	}
 }
 
-void arg_file(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* label, Cryptography& crypto, std::string& save_location_path) 
+void arg_file(Buffer &decrypted_buffer, Buffer &encrypted_buffer, const char *label, Cryptography &crypto, std::string &save_location_path)
 {
 	std::string save(label);
 	save.append("\\passwords.bin");
@@ -301,7 +317,8 @@ void arg_file(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char* la
 	file << save << std::endl;
 	file.close();
 
-	if (decrypted_buffer.taken <= sizeof(Index)) return;
+	if (decrypted_buffer.taken <= sizeof(Index))
+		return;
 
 	crypto.encrypt(&decrypted_buffer, &encrypted_buffer);
 	encrypted_buffer.save_to_file(save);
diff --git a/source/buffer.cpp b/source/buffer.cpp
index a8904f3..299b144 100644
--- a/source/buffer.cpp
+++ b/source/buffer.cpp
@@ -1,6 +1,8 @@
-#include "buffer.h"
 #include <iostream>
 #include <fstream>
+#include <cstring>
+
+#include "buffer.hpp"
 
 Buffer::Buffer()
 {
@@ -17,16 +19,18 @@ Buffer::Buffer(size_t size)
 
 Buffer::~Buffer()
 {
-	if (buffer)	delete[] buffer;
+	if (buffer)
+		delete[] buffer;
 }
 
 bool Buffer::resize(size_t new_size)
 {
-	if (size >= new_size) return true;
-	uint8_t* new_buffer = (uint8_t*)realloc(buffer, new_size);
+	if (size >= new_size)
+		return true;
+	uint8_t *new_buffer = (uint8_t *)realloc(buffer, new_size);
 	if (!new_buffer)
 	{
-		printf_s("Error resizing buffer\n");
+		printf("Error resizing buffer\n");
 		return false;
 	}
 	buffer = new_buffer;
@@ -34,35 +38,37 @@ bool Buffer::resize(size_t new_size)
 	return true;
 }
 
-int Buffer::add_end(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;
+		if (!resize(size + data_size))
+			return -1;
 
-	memcpy_s(buffer + taken, size - taken, data, data_size);
+	memcpy(buffer + taken, data, data_size);
 	taken += data_size;
 	return taken - data_size;
 }
 
-int Buffer::add_middle(uint8_t* data, size_t data_size, size_t index)
+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);
+		if (!resize(size + data_size))
+			return -1;
+	memmove(buffer + index + data_size, buffer + index, taken - index);
+	memcpy(buffer + index, data, data_size);
 	taken += data_size;
 	return index;
 }
 
-void Buffer::remove_fast(uint8_t* data, size_t data_size)
+void Buffer::remove_fast(uint8_t *data, size_t data_size)
 {
 	int64_t index = data - buffer;
 	if (index < 0 || index > taken || index + data_size > taken)
 	{
-		printf_s("Error removing from buffer\n");
+		printf("Error removing from buffer\n");
 		return;
 	}
-	memmove_s(buffer + index, size - index, buffer + index + data_size, taken - index - data_size);
+	memmove(buffer + index, buffer + index + data_size, taken - index - data_size);
 	taken -= data_size;
 }
 
@@ -70,14 +76,14 @@ void Buffer::remove(size_t index, size_t data_size)
 {
 	if (index + data_size > taken)
 	{
-		printf_s("Error removing from buffer\n");
+		printf("Error removing from buffer\n");
 		return;
 	}
-	memmove_s(buffer + index, size - index, buffer + index + data_size, taken - index - data_size);
+	memmove(buffer + index, buffer + index + data_size, taken - index - data_size);
 	taken -= data_size;
 }
 
-size_t Buffer::find(uint8_t* data, size_t data_size)
+size_t Buffer::find(uint8_t *data, size_t data_size)
 {
 	for (size_t i = 0; i < taken; i++)
 		if (memcmp(buffer + i, data, data_size) == 0)
@@ -86,12 +92,12 @@ size_t Buffer::find(uint8_t* data, size_t data_size)
 	return -1;
 }
 
-void Buffer::remove(uint8_t* data, size_t data_size)
+void Buffer::remove(uint8_t *data, size_t data_size)
 {
 	size_t index = find(data, data_size);
 	if (index == -1)
 	{
-		printf_s("Error removing from buffer\n");
+		printf("Error removing from buffer\n");
 		return;
 	}
 	remove(index, data_size);
@@ -102,10 +108,10 @@ bool Buffer::save_to_file()
 	std::ofstream file(this->file_path, std::ios::binary | std::ios::out);
 	if (!file.is_open())
 	{
-		printf_s("Error saving file\n");
+		printf("Error saving file\n");
 		return false;
 	}
-	file.write((char*)this->buffer, this->taken);
+	file.write((char *)this->buffer, this->taken);
 	file.close();
 	return true;
 }
@@ -119,7 +125,8 @@ bool Buffer::save_to_file(std::string file_path)
 bool Buffer::load_from_file()
 {
 	std::ifstream file(this->file_path, std::ios::binary | std::ios::in);
-	if (!file.is_open()) return false;
+	if (!file.is_open())
+		return false;
 
 	file.seekg(0, std::ios::end);
 
@@ -127,7 +134,7 @@ bool Buffer::load_from_file()
 	resize(file_size);
 
 	file.seekg(0, std::ios::beg);
-	file.read((char*)buffer, size);
+	file.read((char *)buffer, size);
 
 	if (file)
 		taken = file_size;
@@ -143,4 +150,3 @@ bool Buffer::load_from_file(std::string file_path)
 	this->file_path = file_path;
 	return load_from_file();
 }
-
diff --git a/source/cryptography.cpp b/source/cryptography.cpp
index dee738f..469e78c 100644
--- a/source/cryptography.cpp
+++ b/source/cryptography.cpp
@@ -1,87 +1,45 @@
-#include <openssl/evp.h>
-#include <openssl/err.h>
-#include <openssl/aes.h>
 #include <string>
 #include <iostream>
 #include <fstream>
+#include <cstring>
 
-#include "cryptography.h"
-#include "Buffer.h"
+#include "cryptography.hpp"
+#include "buffer.hpp"
 
-
-Cryptography::Cryptography(const char* password, size_t size)
+Cryptography::Cryptography(const char *password, size_t size)
 {
-	OpenSSL_add_all_algorithms();
-	ERR_load_crypto_strings();
-
-	if (!generate_key_and_iv_from_password(password, size))
-	{
-		printf_s("Error generating key and IV from password\n");
-		return;
-	}
+	// TODO
 }
 
 Cryptography::~Cryptography()
 {
-	ERR_free_strings();
-	EVP_cleanup();
 }
 
-bool Cryptography::encrypt(Buffer* plain, Buffer* encrypted)
+bool Cryptography::encrypt(Buffer *plain, Buffer *encrypted)
 {
-	encrypted->resize(plain->taken + AES_BLOCK_SIZE);
-
-	ctx = EVP_CIPHER_CTX_new();
-	if (!ctx) return handleErrors();
-	if (1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) return handleErrors();
-
-	if (1 != EVP_EncryptUpdate(ctx, encrypted->buffer, (int*)&encrypted->taken, plain->buffer, plain->taken)) return handleErrors();
-	int final_len;
-	if (1 != EVP_EncryptFinal_ex(ctx, encrypted->buffer + encrypted->taken, &final_len)) return handleErrors();
-	encrypted->taken += final_len;
-
-	EVP_CIPHER_CTX_free(ctx);
-
+	// TODO
+	encrypted->resize(plain->size);
+	memcpy(encrypted->buffer, plain->buffer, plain->taken);
 
 	return true;
 }
 
-bool Cryptography::decrypt(Buffer* encrypted, Buffer* decrypted)
+bool Cryptography::decrypt(Buffer *encrypted, Buffer *decrypted)
 {
-	decrypted->resize(encrypted->taken + AES_BLOCK_SIZE);
-
-
-	ctx = EVP_CIPHER_CTX_new();
-	if (!ctx) return handleErrors();
-	if (1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv)) return handleErrors();
-
-	if (1 != EVP_DecryptUpdate(ctx, decrypted->buffer, (int*)&decrypted->taken, encrypted->buffer, encrypted->taken)) return handleErrors();
-	int final_len;
-	if (1 != EVP_DecryptFinal_ex(ctx, decrypted->buffer + decrypted->taken, &final_len)) return handleErrors();
-	decrypted->taken += final_len;
-
-	EVP_CIPHER_CTX_free(ctx);
+	// TODO
+	decrypted->resize(encrypted->size);
+	memcpy(encrypted->buffer, decrypted->buffer, decrypted->taken);
 	return true;
 }
 
-bool Cryptography::generate_key_and_iv_from_password(const char* password, size_t size)
+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, size, nullptr, 0, iterations, EVP_sha256(), 32, key)) return false;
-	if (1 != PKCS5_PBKDF2_HMAC(password, size, nullptr, 0, iterations, EVP_sha256(), 16, iv)) return false;
+	// TODO
 	return true;
 }
 
 bool Cryptography::handleErrors()
 {
-	EVP_CIPHER_CTX_free(ctx);
-
-	while (auto error = ERR_get_error())
-	{
-		char* error_string = ERR_error_string(error, nullptr);
-		printf_s("%s\n", error_string);
-	}
+	// TODO
 	return false;
 }
\ No newline at end of file
diff --git a/source/func.cpp b/source/func.cpp
index 11f4fa5..120dfc5 100644
--- a/source/func.cpp
+++ b/source/func.cpp
@@ -1,33 +1,35 @@
 #include <ctime>
-#include "func.h"
-#include "glob.h"
-#include "Buffer.h"
+#include <cstring>
 
-int find_logininfo_in_buffer(Buffer& buffer, const char* label)
+#include "func.hpp"
+#include "glob.hpp"
+#include "buffer.hpp"
+
+int find_logininfo_in_buffer(Buffer &buffer, const char *label)
 {
-	Index* index = (Index*)buffer.buffer;
-	LoginInfo* pass = (LoginInfo*)(buffer.buffer + sizeof(Index));
+	Index *index = (Index *)buffer.buffer;
+	LoginInfo *pass = (LoginInfo *)(buffer.buffer + sizeof(Index));
 
 	for (size_t i = 0; i < index->count; i++)
 	{
-		if (glob(label, (const char*)buffer.buffer + pass[i].label + index->offset) == Glob_Result::MATCHED)
+		if (glob(label, (const char *)buffer.buffer + pass[i].label + index->offset) == Glob_Result::MATCHED)
 			return i;
 	}
 
 	return -1;
 }
 
-void delete_logininfo_from_buffer(Buffer& buffer, int index_of_pass)
+void delete_logininfo_from_buffer(Buffer &buffer, int index_of_pass)
 {
-	Index* in_index = (Index*)buffer.buffer;
-	LoginInfo* in_pass = (LoginInfo*)(buffer.buffer + sizeof(Index));
+	Index *in_index = (Index *)buffer.buffer;
+	LoginInfo *in_pass = (LoginInfo *)(buffer.buffer + sizeof(Index));
 
-	int size_of_label = strlen((char*)buffer.buffer + in_pass[index_of_pass].label + in_index->offset) + 1;
-	int size_of_username = strlen((char*)buffer.buffer + in_pass[index_of_pass].username + in_index->offset) + 1;
-	int size_of_password = strlen((char*)buffer.buffer + in_pass[index_of_pass].password + in_index->offset) + 1;
+	int size_of_label = strlen((char *)buffer.buffer + in_pass[index_of_pass].label + in_index->offset) + 1;
+	int size_of_username = strlen((char *)buffer.buffer + in_pass[index_of_pass].username + in_index->offset) + 1;
+	int size_of_password = strlen((char *)buffer.buffer + in_pass[index_of_pass].password + in_index->offset) + 1;
 	int size_pass = size_of_label + size_of_username + size_of_password;
 
-	uint8_t* start_of_pass = buffer.buffer + in_pass[index_of_pass].label + in_index->offset;
+	uint8_t *start_of_pass = buffer.buffer + in_pass[index_of_pass].label + in_index->offset;
 	buffer.remove_fast(start_of_pass, size_pass);
 
 	for (size_t i = index_of_pass; i < in_index->count; i++)
@@ -36,42 +38,41 @@ void delete_logininfo_from_buffer(Buffer& buffer, int index_of_pass)
 		in_pass[i].password -= size_pass;
 	}
 
-	buffer.remove_fast((uint8_t*)&in_pass[index_of_pass], sizeof(LoginInfo));
+	buffer.remove_fast((uint8_t *)&in_pass[index_of_pass], sizeof(LoginInfo));
 	in_index->count -= 1;
 	in_index->offset -= sizeof(LoginInfo);
 }
 
-void add_logininfo_to_buffer(Buffer& buffer, const char* label, const char* username, const char* password)
+void add_logininfo_to_buffer(Buffer &buffer, const char *label, const char *username, const char *password)
 {
-	int label_start = buffer.add_end((uint8_t*)label, strlen(label) + 1);
-	int username_start = buffer.add_end((uint8_t*)username, strlen(username) + 1);
-	int password_start = buffer.add_end((uint8_t*)password, strlen(password) + 1);
+	int label_start = buffer.add_end((uint8_t *)label, strlen(label) + 1);
+	int username_start = buffer.add_end((uint8_t *)username, strlen(username) + 1);
+	int password_start = buffer.add_end((uint8_t *)password, strlen(password) + 1);
 
-	Index* index = (Index*)buffer.buffer;
+	Index *index = (Index *)buffer.buffer;
 
 	label_start = label_start - index->offset;
 	username_start = username_start - index->offset;
 	password_start = password_start - index->offset;
-	LoginInfo pass = { label_start, username_start, password_start };
+	LoginInfo pass = {label_start, username_start, password_start};
 	index->count++;
 	index->offset += sizeof(LoginInfo);
 
-	buffer.add_middle((uint8_t*)&pass, sizeof(LoginInfo), index->offset - sizeof(LoginInfo));
-
+	buffer.add_middle((uint8_t *)&pass, sizeof(LoginInfo), index->offset - sizeof(LoginInfo));
 }
 
-LoginInfoPointer get_logininfo_pointer_from_buffer(Buffer& buffer, int index_of_pass)
+LoginInfoPointer get_logininfo_pointer_from_buffer(Buffer &buffer, int index_of_pass)
 {
-	Index* index = (Index*)buffer.buffer;
-	LoginInfo* pass = (LoginInfo*)(buffer.buffer + sizeof(Index));
+	Index *index = (Index *)buffer.buffer;
+	LoginInfo *pass = (LoginInfo *)(buffer.buffer + sizeof(Index));
 	LoginInfoPointer ret;
-	ret.label = (const char*)buffer.buffer + pass[index_of_pass].label + index->offset;
-	ret.username = (const char*)buffer.buffer + pass[index_of_pass].username + index->offset;
-	ret.password = (const char*)buffer.buffer + pass[index_of_pass].password + index->offset;
+	ret.label = (const char *)buffer.buffer + pass[index_of_pass].label + index->offset;
+	ret.username = (const char *)buffer.buffer + pass[index_of_pass].username + index->offset;
+	ret.password = (const char *)buffer.buffer + pass[index_of_pass].password + index->offset;
 	return ret;
 }
 
-void generate_password(std::string& password, int len)
+void generate_password(std::string &password, int len)
 {
 	srand(time(NULL));
 	char characters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_-+={[}]|:;<,>.?";
diff --git a/source/glob.cpp b/source/glob.cpp
index 25952b0..cdb3ad5 100644
--- a/source/glob.cpp
+++ b/source/glob.cpp
@@ -1,58 +1,73 @@
-#include "glob.h"
+#include "glob.hpp"
 
-Glob_Result glob(const char* pattern, const char* text)
+Glob_Result glob(const char *pattern, const char *text)
 {
-	while (*pattern != '\0' && *text != '\0') {
-		switch (*pattern) {
-		case '?': {
+	while (*pattern != '\0' && *text != '\0')
+	{
+		switch (*pattern)
+		{
+		case '?':
+		{
 			pattern += 1;
 			text += 1;
 		}
-				break;
+		break;
 
-		case '*': {
+		case '*':
+		{
 			Glob_Result result = glob(pattern + 1, text);
-			if (result != Glob_Result::UNMATCHED) return result;
+			if (result != Glob_Result::UNMATCHED)
+				return result;
 			text += 1;
 		}
-				break;
+		break;
 
-		case '[': {
+		case '[':
+		{
 			bool matched = false;
 			bool negate = false;
 
 			pattern += 1; // skipping [
-			if (*pattern == '\0') return Glob_Result::SYNTAX_ERROR; // unclosed [
+			if (*pattern == '\0')
+				return Glob_Result::SYNTAX_ERROR; // unclosed [
 
-			if (*pattern == '!') {
+			if (*pattern == '!')
+			{
 				negate = true;
 				pattern += 1;
-				if (*pattern == '\0') return Glob_Result::SYNTAX_ERROR; // unclosed [
+				if (*pattern == '\0')
+					return Glob_Result::SYNTAX_ERROR; // unclosed [
 			}
 
 			char prev = *pattern;
 			matched |= prev == *text;
 			pattern += 1;
 
-			while (*pattern != ']' && *pattern != '\0') {
-				switch (*pattern) {
-				case '-': {
+			while (*pattern != ']' && *pattern != '\0')
+			{
+				switch (*pattern)
+				{
+				case '-':
+				{
 					pattern += 1;
-					switch (*pattern) {
+					switch (*pattern)
+					{
 					case ']':
 						matched |= '-' == *text;
 						break;
 					case '\0':
 						return Glob_Result::SYNTAX_ERROR; // unclosed [
-					default: {
+					default:
+					{
 						matched |= prev <= *text && *text <= *pattern;
 						prev = *pattern;
 						pattern += 1;
 					}
 					}
 				}
-						break;
-				default: {
+				break;
+				default:
+				{
 					prev = *pattern;
 					matched |= prev == *text;
 					pattern += 1;
@@ -60,34 +75,44 @@ Glob_Result glob(const char* pattern, const char* text)
 				}
 			}
 
-			if (*pattern != ']') return Glob_Result::SYNTAX_ERROR; // unclosed [
-			if (negate) matched = !matched;
-			if (!matched) return Glob_Result::UNMATCHED;
+			if (*pattern != ']')
+				return Glob_Result::SYNTAX_ERROR; // unclosed [
+			if (negate)
+				matched = !matched;
+			if (!matched)
+				return Glob_Result::UNMATCHED;
 
 			pattern += 1;
 			text += 1;
 		}
-				break;
+		break;
 
 		case '\\':
 			pattern += 1;
-			if (*pattern == '\0') return Glob_Result::SYNTAX_ERROR; // unfinished escape
-			// fallthrough
-		default: {
-			if (*pattern == *text) {
+			if (*pattern == '\0')
+				return Glob_Result::SYNTAX_ERROR; // unfinished escape
+																					// fallthrough
+		default:
+		{
+			if (*pattern == *text)
+			{
 				pattern += 1;
 				text += 1;
 			}
-			else {
+			else
+			{
 				return Glob_Result::UNMATCHED;
 			}
 		}
 		}
 	}
 
-	if (*text == '\0') {
-		while (*pattern == '*') pattern += 1;
-		if (*pattern == '\0') return Glob_Result::MATCHED;
+	if (*text == '\0')
+	{
+		while (*pattern == '*')
+			pattern += 1;
+		if (*pattern == '\0')
+			return Glob_Result::MATCHED;
 	}
 
 	return Glob_Result::UNMATCHED;
diff --git a/source/win.cpp b/source/sys.cpp
similarity index 73%
rename from source/win.cpp
rename to source/sys.cpp
index d3a9432..0aac7f4 100644
--- a/source/win.cpp
+++ b/source/sys.cpp
@@ -1,31 +1,40 @@
-#include <Windows.h>
 #include <iostream>
 #include <string>
-#include <shlobj.h>
-#include "win.h"
-#include "func.h"
 
-bool put_data_on_clipboard(const char* text) {
+#include "sys.hpp"
+#include "func.hpp"
+
+#ifdef _WIN32
+
+#include <shlobj.h>
+#include <Windows.h>
+
+bool put_data_on_clipboard(const char *text)
+{
 	size_t len = strlen(text);
-	if (len == 0) {
+	if (len == 0)
+	{
 		printf_s("Text is empty\n");
 		return false;
 	}
 	// Open the clipboard
-	if (!OpenClipboard(nullptr)) {
+	if (!OpenClipboard(nullptr))
+	{
 		printf_s("Failed to open clipboard");
 		return false;
 	}
 	// Allocate global memory for the text
 	HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, strlen(text) + 1);
-	if (!hMem) {
+	if (!hMem)
+	{
 		CloseClipboard();
 		printf_s("Failed to allocate memory for text");
 		return false;
 	}
 	// Copy the text to the allocated memory
-	char* memData = static_cast<char*>(GlobalLock(hMem));
-	if (!memData) {
+	char *memData = static_cast<char *>(GlobalLock(hMem));
+	if (!memData)
+	{
 		CloseClipboard();
 		printf_s("Failed to lock memory for text");
 		return false;
@@ -40,7 +49,6 @@ bool put_data_on_clipboard(const char* text) {
 	return true;
 }
 
-
 std::string get_user_password()
 {
 
@@ -75,9 +83,10 @@ std::optional<std::string> get_save_path()
 
 	HRESULT result = SHGetKnownFolderPath(FOLDERID_ProgramData, 0, nullptr, &path);
 
-	if (!SUCCEEDED(result)) {
+	if (!SUCCEEDED(result))
+	{
 		CoTaskMemFree(path); // Free the allocated memory
-		return{};
+		return {};
 	}
 
 	std::wstring userDirectory(path);
@@ -87,17 +96,18 @@ std::optional<std::string> get_save_path()
 
 	DWORD attrib = GetFileAttributes(userDirectory.c_str());
 
-	//check if it exists
-	if(!(attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY)))
+	// check if it exists
+	if (!(attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY)))
 	{
-		if (!CreateDirectory(userDirectory.c_str(), nullptr)) return {};
+		if (!CreateDirectory(userDirectory.c_str(), nullptr))
+			return {};
 	}
-	
 
 	userDirectory.append(L"\\save.txt");
 
 	int size = WideCharToMultiByte(CP_UTF8, 0, userDirectory.c_str(), -1, nullptr, 0, nullptr, nullptr);
-	if (size > 0) {
+	if (size > 0)
+	{
 		std::string str(size, 0);
 		WideCharToMultiByte(CP_UTF8, 0, userDirectory.c_str(), -1, &str[0], size, nullptr, nullptr);
 
@@ -105,4 +115,26 @@ std::optional<std::string> get_save_path()
 	}
 
 	return {};
-}
\ No newline at end of file
+}
+
+#else
+
+bool put_data_on_clipboard(const char *text)
+{
+	// TODO
+	return true;
+}
+
+std::string get_user_password()
+{
+	// TODO
+	return "123";
+}
+
+std::optional<std::string> get_save_path()
+{
+	// TODO
+	return "save.bin";
+}
+
+#endif
\ No newline at end of file