From a12f7243c9edd9cceaffb38a3d8857973825597a Mon Sep 17 00:00:00 2001
From: redlineo <romanov.pd@gmail.com>
Date: Fri, 24 Jan 2025 09:41:30 +0000
Subject: [PATCH] changed struct of storing, adding proccess of encrypting
 features

---
 README.md    |  4 ++--
 red_crypto.c | 23 +++++++++++++++++++++++
 red_crypto.h | 29 +++++++++++++++++++++++------
 3 files changed, 48 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 431a6d1..6901aad 100644
--- a/README.md
+++ b/README.md
@@ -133,13 +133,13 @@ To represent the resources that will be spent on the password storage. It is jus
 
 If you have 10 different password, set 64 byte size for encrypted password, 16 byte size for ecrypted name for each password, you will store:
 
-$ 10*(64+16) = 800b $
+$10*(64+16)=800b$
 
 i.e. even if you have arduino with 1kb EEPROM, you can store enough passwords.
 
 If you have up to 100.000 rewrite cycles, and if you will change you passwords every month, you will use up the entire resource of memory in:
 
-$ \frac{100.000}{10*(64+16)}=\frac{125}{12}=10.4167 $
+$\frac{100.000}{10*(64+16)}=\frac{125}{12}=10.4167$
 
 i.e. you can rewrite you passwords for 10 years. But in my calculations not consider the probability of forgetting passwords. 
 
diff --git a/red_crypto.c b/red_crypto.c
index 86f9766..6c19ad6 100644
--- a/red_crypto.c
+++ b/red_crypto.c
@@ -31,6 +31,29 @@ uint8_t decrypted_mode = 0;
 
 uint8_t red_menu_mode = 0;
 
+void encrypt_pass_kuzn() {
+    kuz_key_t key;
+    w128_t    x;
+
+    init_dec_pass();
+
+// for hashing key, like a KDF algorithm
+#ifdef USE_SHA256_KEY
+    SHA256_CTX ctx;
+    sha256_init(&ctx);
+    sha256_update(&ctx, readed_key, min_len(u_strlen(readed_key), MAX_KEY_LEN));
+    BYTE result_key[SHA256_BLOCK_SIZE];
+    sha256_final(&ctx, result_key);
+    print_hex(result_key);
+    kuz_set_encrypt_key(&key, result_key);
+#endif
+// if you don't have enough FLASH in MCU
+#ifndef USE_SHA256_KEY
+    kuz_set_encrypt_key(&key, readed_key);
+#endif
+
+}
+
 // decrypting passwords
 void decrypt_pass_kuzn() {
     kuz_key_t key;
diff --git a/red_crypto.h b/red_crypto.h
index d5aadaa..cfd0fb1 100644
--- a/red_crypto.h
+++ b/red_crypto.h
@@ -29,6 +29,19 @@
 #    define MAX_KEY_LEN 128
 #    define BLOCK_SIZE 16
 
+#    ifndef INIT_STORAGE_SIZE
+#        define INIT_STORAGE_SIZE 4
+#    endif
+
+#    ifndef INIT_STORAGE_PASS_LEN
+#        define INIT_STORAGE_PASS_LEN 128
+#    endif
+
+#    ifdef INIT_STORAGE_PASS_LEN
+#        if (INIT_STORAGE_PASS_LEN % 16 != 0)
+#            error "Password length must be multiply of 16 (16,32,64...)"
+#        endif
+#    endif
 
 // example for encrypted 64 byte password
 //  const uint8_t red_enc_pass[STORAGE_SIZE][STORAGE_PASS_LEN] = {
@@ -56,21 +69,25 @@ enum red_crypto_keys {
     RED_PASS10
 };
 
-uint8_t storage_size = 4;
-uint8_t storage_pass_len = 64;
+uint8_t storage_size     = INIT_STORAGE_SIZE;
+uint8_t storage_pass_len = INIT_STORAGE_PASS_LEN;
 
 typedef union {
-    uint8_t raw[1+1+4+(uint32_t)storage_size*(uint32_t)storage_pass_len];
+    uint8_t raw[3 + 3 + 1 + 1 + 4 + 1 + (uint32_t)storage_size * (uint32_t)storage_pass_len];
     struct {
-        uint8_t storage_size;
-        uint8_t storage_pass_len;
+        uint8_t  init_var[3]; // if in eeprom is bytes "RED", then it's not first flash or first power-on, or in eeprom is old red_crypto
+        uint8_t  version[3]; // red_crypto library version
+        uint8_t  storage_size;
+        uint8_t  storage_pass_len;
         uint32_t memory_usage;
-        uint8_t passwords[(uint32_t)storage_size*(uint32_t)storage_pass_len];
+        uint8_t  password_count;
+        uint8_t  passwords[(uint32_t)storage_size * (uint32_t)storage_pass_len];
     };
 } red_crypto_storage;
 
 red_crypto_storage enc_pass;
 
 uint8_t crypto_process_record_user(uint16_t keycode, keyrecord_t *record);
+void    encrypt_pass_kuzn(void);
 
 #endif