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

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

@ -1,4 +1,6 @@
#pragma once
#ifndef BUFFER_HPP
#define BUFFER_HPP
#include <cstdint>
#include <string>
@ -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();

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

@ -1,11 +1,11 @@
#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
@ -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,7 +49,7 @@ 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;
}
@ -58,18 +59,18 @@ int main(int argc, char** argv)
// 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
@ -79,10 +80,12 @@ int main(int argc, char** argv)
Buffer decrypted_buffer;
// 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)) {
if (decrypted_buffer.taken < sizeof(Index))
{
Index index = {0};
index.offset = sizeof(Index);
decrypted_buffer.add_end((uint8_t *)&index, sizeof(Index));
@ -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

157
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,13 +59,20 @@ 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;
}
@ -68,8 +80,9 @@ Arg get_args(int argc, char** argv, 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);
@ -82,25 +95,26 @@ std::optional<LoginInfoPointer> arg_new_password(Buffer& decrypted_buffer, Buffe
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 {};
}
}
@ -136,7 +151,7 @@ void arg_username(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const char
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);
@ -160,7 +175,7 @@ void arg_label_name(Buffer& decrypted_buffer, Buffer& encrypted_buffer, const ch
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);
@ -185,17 +200,17 @@ void arg_list(Buffer& decrypted_buffer)
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)
{
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,92 +218,93 @@ 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)
{
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));
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)
{
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);
}
}
@ -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);

40
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;
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;
@ -37,9 +41,10 @@ bool Buffer::resize(size_t new_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;
}
@ -47,9 +52,10 @@ int Buffer::add_end(uint8_t* data, size_t 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);
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;
}
@ -59,10 +65,10 @@ 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,10 +76,10 @@ 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;
}
@ -91,7 +97,7 @@ 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,7 +108,7 @@ 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);
@ -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);
@ -143,4 +150,3 @@ bool Buffer::load_from_file(std::string file_path)
this->file_path = file_path;
return load_from_file();
}

66
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)
{
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)
{
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)
{
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)
{
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;
}

9
source/func.cpp
View File

@ -1,7 +1,9 @@
#include <ctime>
#include "func.h"
#include "glob.h"
#include "Buffer.h"
#include <cstring>
#include "func.hpp"
#include "glob.hpp"
#include "buffer.hpp"
int find_logininfo_in_buffer(Buffer &buffer, const char *label)
{
@ -57,7 +59,6 @@ void add_logininfo_to_buffer(Buffer& buffer, const char* label, const char* user
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)

77
source/glob.cpp
View File

@ -1,50 +1,64 @@
#include "glob.h"
#include "glob.hpp"
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;
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;
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;
@ -52,7 +66,8 @@ Glob_Result glob(const char* pattern, const char* text)
}
}
break;
default: {
default:
{
prev = *pattern;
matched |= prev == *text;
pattern += 1;
@ -60,9 +75,12 @@ 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;
@ -71,23 +89,30 @@ Glob_Result glob(const char* pattern, const char* text)
case '\\':
pattern += 1;
if (*pattern == '\0') return Glob_Result::SYNTAX_ERROR; // unfinished escape
if (*pattern == '\0')
return Glob_Result::SYNTAX_ERROR; // unfinished escape
// fallthrough
default: {
if (*pattern == *text) {
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;

60
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) {
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,7 +83,8 @@ 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 {};
}
@ -90,14 +99,15 @@ std::optional<std::string> get_save_path()
// 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);
@ -106,3 +116,25 @@ 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