nikola/password_manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

It compiles no encript

Browse Source
This commit is contained in:
Nikola Petrov 2024-01-14 21:43:49 +01:00
parent 3935c3f34e
commit 36de6ec412
19 changed files with 500 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
include/arg_func.h
View File

@ -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);

48
include/arg_func.hpp Normal file
View File

@ -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

19
include/Buffer.h → include/buffer.hpp
View File

@ -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);
};
};
#endif

23
include/cryptography.h
View File

@ -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();
};

27
include/cryptography.hpp Normal file
View File

@ -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

35
include/func.h
View File

@ -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);

38
include/func.hpp Normal file
View File

@ -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

13
include/glob.h
View File

@ -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);

16
include/glob.hpp Normal file
View File

@ -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

11
include/sys.hpp Normal file
View File

@ -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

6
include/win.h
View File

@ -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();

60
source/main.cpp → main.cpp
View File

@ -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

30
makefile Normal file
View File

@ -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

185
source/arg_func.cpp
View File

@ -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);

56
source/buffer.cpp
View File

@ -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();
}

74
source/cryptography.cpp
View File

@ -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;
}

61
source/func.cpp
View File

@ -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~!@#$%^&*()_-+={[}]|:;<,>.?";

89
source/glob.cpp
View File

@ -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;

70
source/win.cpp → source/sys.cpp
View File

@ -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 {};
}
}
#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