Add refrerence symbolic strings

base62/src/aes.rs

@@ -1,7 +1,57 @@
-use aes::cipher::{BlockDecryptMut, KeyIvInit, block_padding::Pkcs7};
+use crate::{base62::Base62, hash};
+use aes::cipher::{BlockDecryptMut, BlockEncryptMut, KeyIvInit};
+use cbc::cipher::block_padding::Pkcs7;
 use regex::Regex;
 
-use crate::{Base62, hash};
+fn pkcs7_padded_length(input_len: usize) -> usize {
+    let block_size = 16;
+    ((input_len / block_size) + 1) * block_size
+}
+
+pub fn encrypt_aes(plaintext: &str, key_str: &str, iv: [u8; 16]) -> String {
+    let plaintext = plaintext.as_bytes();
+
+    // Hash the env key to get a 32-byte (256-bit) AES key
+    let key = hash(key_str.as_bytes());
+
+    // Generate a pseudo-random salt byte based on the plaintext
+    // I hope this does not break the encryption.
+    let mut salt = 0;
+
+    for byte in plaintext {
+        salt ^= byte;
+    }
+
+    let mut key_salted = key.clone();
+
+    // Salt the key by XORing the salt byte with all the key bytes.
+    // This ensures that the "hash" generated from the plaintext will
+    // make the encrypted result extremely different.
+    for i in 0..32 {
+        key_salted[i] ^= salt;
+    }
+
+    let buf_len = pkcs7_padded_length(plaintext.len());
+
+    let mut buf = vec![0u8; buf_len];
+    let pt_len = plaintext.len();
+    buf[..pt_len].copy_from_slice(&plaintext);
+
+    let mut ct = cbc::Encryptor::<aes::Aes256>::new(&key_salted.into(), &iv.into())
+        .encrypt_padded_mut::<Pkcs7>(&mut buf, pt_len)
+        .unwrap()
+        .to_vec();
+
+    // Add the salt byte to the key byte,
+    ct.insert(0, salt);
+
+    // Encode result in base62
+    Base62::encode_full(&ct, &key)
+}
+
+pub fn encrypt_aes_lines(plaintext: &str, key_str: &str, iv: [u8; 16]) -> String {
+    format!("_{}_", encrypt_aes(plaintext, key_str, iv))
+}
 
 pub fn decrypt_aes(input: &str, key_str: &str, iv: [u8; 16]) -> Result<String, String> {
     // Hash the env key to get a 32-byte (256-bit) AES key

base62/src/aes_encrypt.rs

@@ -1,53 +0,0 @@
-use crate::{base62::Base62, hash};
-use aes::cipher::{BlockEncryptMut, KeyIvInit};
-use cbc::cipher::block_padding::Pkcs7;
-
-fn pkcs7_padded_length(input_len: usize) -> usize {
-    let block_size = 16;
-    ((input_len / block_size) + 1) * block_size
-}
-
-pub fn encrypt_aes(plaintext: &str, key_str: &str, iv: [u8; 16]) -> String {
-    let plaintext = plaintext.as_bytes();
-
-    // Hash the env key to get a 32-byte (256-bit) AES key
-    let key = hash(key_str.as_bytes());
-
-    // Generate a psudo-random salt byte based on the plaintext
-    // I hope this does not break the encryption.
-    let mut salt = 0;
-
-    for byte in plaintext {
-        salt ^= byte;
-    }
-
-    let mut key_salted = key.clone();
-
-    // Salt the key by XORing the salt byte with all the key bytes.
-    // This ensures that the "hash" generated from the plaintext will
-    // make the encrypted result extremely different.
-    for i in 0..32 {
-        key_salted[i] ^= salt;
-    }
-
-    let buf_len = pkcs7_padded_length(plaintext.len());
-
-    let mut buf = vec![0u8; buf_len];
-    let pt_len = plaintext.len();
-    buf[..pt_len].copy_from_slice(&plaintext);
-
-    let mut ct = cbc::Encryptor::<aes::Aes256>::new(&key_salted.into(), &iv.into())
-        .encrypt_padded_mut::<Pkcs7>(&mut buf, pt_len)
-        .unwrap()
-        .to_vec();
-
-    // Add the salt byte to the key byte,
-    ct.insert(0, salt);
-
-    // Encode result in base62
-    Base62::encode_full(&ct, &key)
-}
-
-pub fn encrypt_aes_lines(plaintext: &str, key_str: &str, iv: [u8; 16]) -> String {
-    format!("_{}_", encrypt_aes(plaintext, key_str, iv))
-}

base62/src/base62.rs

@@ -18,19 +18,20 @@ const ENCODING_RATIO: f64 = 8.0 / 5.954196310386875; // 8.0 / log2(62.0)
 impl Base62 {
     pub fn new(key: &[u8], nonce: usize) -> Self {
         // Hash key again, for the chance that this random function can be used to derive the key
+        // My solution to not being good at cryptography lol
         let key = hash(key);
 
         let mut charset: [char; 62] = [0 as char; 62];
 
         // Create a vector of indices from 0 to 61
-        let mut current_indicies = (0..62).map(|i| i as usize).collect::<Vec<usize>>();
+        let mut current_indices = (0..62).map(|i| i as usize).collect::<Vec<usize>>();
 
         // Loop through each byte in the key until all chars are filled
         for i in 0..62 as usize {
             let rand = STATIC_BYTE_MAP[(key[i as usize % key.len()] as usize + nonce) % 255];
 
-            let index_index = rand as usize % current_indicies.len();
-            let put_index = current_indicies.remove(index_index);
+            let index_index = rand as usize % current_indices.len();
+            let put_index = current_indices.remove(index_index);
 
             charset[put_index] = BASE62_CHARS[i];
         }

base62/src/lib.rs

@@ -1,11 +1,8 @@
-mod aes_decrypt;
-mod aes_encrypt;
-#[allow(dead_code)]
+mod aes;
 mod base62;
 
 // Exports
-pub use aes_decrypt::{decrypt_aes, decrypt_aes_lines};
-pub use aes_encrypt::{encrypt_aes, encrypt_aes_lines};
+pub use aes::{decrypt_aes, decrypt_aes_lines, encrypt_aes, encrypt_aes_lines};
 pub use base62::Base62;
 
 pub const STATIC_IV: [u8; 16] = [
@@ -35,3 +32,19 @@ pub fn hash(input: &[u8]) -> [u8; 32] {
     hasher.update(input);
     hasher.finalize().into()
 }
+
+pub fn encode_usize(value: usize) -> Vec<u8> {
+    if value == 0 {
+        return vec![0];
+    }
+    let bytes = value.to_be_bytes();
+    let leading_zeros = bytes.iter().take_while(|&&b| b == 0).count();
+    bytes[leading_zeros..].to_vec()
+}
+
+pub fn decode_usize(bytes: &[u8]) -> usize {
+    let mut buf = [0u8; size_of::<usize>()];
+    let offset = buf.len() - bytes.len();
+    buf[offset..].copy_from_slice(bytes);
+    usize::from_be_bytes(buf)
+}