diff --git a/.gitignore b/.gitignore
index 70e39ba..d9ddc1c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,7 @@ target
 log.txt
 /AuthSchema/
 .vscode
-secureData*.txt
+*secureData*.txt
 logfile.txt
+logfileConf.txt
 rmc_log.txt
diff --git a/.jules/sentinel.md b/.jules/sentinel.md
new file mode 100644
index 0000000..be2a8dc
--- /dev/null
+++ b/.jules/sentinel.md
@@ -0,0 +1,11 @@
+# Sentinel Security Journal 🛡️
+
+## 2026-01-31 - Timing Attack in Password Verification
+**Vulnerability:** Password verification used `equalsIgnoreCase`, which is vulnerable to timing attacks.
+**Learning:** Even if the input is hashed, comparing hex strings with non-constant-time functions can leak information about the correct hash.
+**Prevention:** Always use `MessageDigest.isEqual` for comparing security-sensitive data like hashes or tokens.
+
+## 2026-01-31 - Platform-Dependent Charset in Cryptography
+**Vulnerability:** Usage of `Charset.defaultCharset()` and implicit default charsets in `new String(byte[])` and `String.getBytes()`.
+**Learning:** This leads to inconsistent hashes and encodings across different environments, which can be exploited or cause authentication failures.
+**Prevention:** Always specify `StandardCharsets.UTF_8` for all cryptographic and data transmission operations.
diff --git a/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/algorithm/SHA256.java b/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/algorithm/SHA256.java
index f1f7103..d6552e2 100644
--- a/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/algorithm/SHA256.java
+++ b/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/algorithm/SHA256.java
@@ -3,6 +3,8 @@
 import org.bouncycastle.crypto.digests.SHA256Digest;
 import it.richkmeli.jframework.util.TypeConverter;
 
+import java.nio.charset.StandardCharsets;
+
 public class SHA256 {
     public static byte[] hash(byte[] input) {
         SHA256Digest digest = new SHA256Digest();
@@ -15,7 +17,7 @@ public static byte[] hash(byte[] input) {
 
     // sha256: string to hex
     public static String hash(String input) {
-        return TypeConverter.bytesToHex(hash(input.getBytes()));
+        return TypeConverter.bytesToHex(hash(input.getBytes(StandardCharsets.UTF_8)));
     }
 
     public static String hashToString(byte[] input) {
diff --git a/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/controller/PasswordManager.java b/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/controller/PasswordManager.java
index 7d2b934..59cf2be 100644
--- a/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/controller/PasswordManager.java
+++ b/JFramework/crypto/src/main/java/it/richkmeli/jframework/crypto/controller/PasswordManager.java
@@ -3,7 +3,8 @@
 import it.richkmeli.jframework.crypto.algorithm.SHA256;
 import it.richkmeli.jframework.util.RandomStringGenerator;
 
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
 import java.util.Base64;
 
 public class PasswordManager {
@@ -26,13 +27,13 @@ public static String hashPassword(String password, boolean saltEnabled) {
 
         //System.out.println("hashPassword, saltS: " + saltS + " " + saltS.length() + " | hashedPassword: " + hashedPassword + " " + hashedPassword.length());
         String out = saltS + hashedPassword;
-        return Base64.getUrlEncoder().encodeToString(out.getBytes(Charset.defaultCharset()));
+        return Base64.getUrlEncoder().encodeToString(out.getBytes(StandardCharsets.UTF_8));
     }
 
     // hashedPassword = db password, hashedSaltPassword = login password
     public static boolean verifyPassword(String hashedPassword, String hashedSaltPassword) {
-        String decodedHashedPassword = new String(Base64.getUrlDecoder().decode(hashedPassword));
-        String decodedHashedSaltPassword = new String(Base64.getUrlDecoder().decode(hashedSaltPassword));
+        String decodedHashedPassword = new String(Base64.getUrlDecoder().decode(hashedPassword), StandardCharsets.UTF_8);
+        String decodedHashedSaltPassword = new String(Base64.getUrlDecoder().decode(hashedSaltPassword), StandardCharsets.UTF_8);
         String salt = decodedHashedSaltPassword.substring(0, 9);
         String hashSP = decodedHashedSaltPassword.substring(9);
         String hashP = decodedHashedPassword.substring(9);
@@ -40,6 +41,6 @@ public static boolean verifyPassword(String hashedPassword, String hashedSaltPas
         //System.out.println("verifyPassword, saltS: " + salt + " " + salt.length() + " | hashedSaltPassword: " + hashSP + " " + hashSP.length());
         String hp = SHA256.hash(hashP + salt);
 
-        return hashSP.equalsIgnoreCase(hp);
+        return MessageDigest.isEqual(hashSP.getBytes(StandardCharsets.UTF_8), hp.getBytes(StandardCharsets.UTF_8));
     }
 }
diff --git a/JFramework/util/src/main/java/it/richkmeli/jframework/util/RandomStringGenerator.java b/JFramework/util/src/main/java/it/richkmeli/jframework/util/RandomStringGenerator.java
index a0a9007..3baa345 100644
--- a/JFramework/util/src/main/java/it/richkmeli/jframework/util/RandomStringGenerator.java
+++ b/JFramework/util/src/main/java/it/richkmeli/jframework/util/RandomStringGenerator.java
@@ -4,6 +4,7 @@
 import java.security.SecureRandom;
 
 public class RandomStringGenerator {
+    private static final SecureRandom secureRandom = new SecureRandom();
     public static final String ALPHANUMERIC_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     public static final String NUMERIC_ALPHABET = "0123456789";
 
@@ -21,7 +22,6 @@ private static String generateString(int length, String alphabet) {
         int alphabetLength = alphabet.length();
 
         StringBuilder result = new StringBuilder();
-        SecureRandom secureRandom = new SecureRandom();
 
         for (int i = 0; i < length; ++i) {
             result.append(alphabet.charAt(secureRandom.nextInt(alphabetLength)));
@@ -42,11 +42,10 @@ public static String generateBoundedString(int targetStringLength, int leftLimit
         //int leftLimit = 97; // letter 'a'
         //int rightLimit = 122; // letter 'z'
         //int targetStringLength = 10;
-        SecureRandom random = new SecureRandom();
         StringBuilder buffer = new StringBuilder(targetStringLength);
         for (int i = 0; i < targetStringLength; i++) {
             int randomLimitedInt = leftLimit + (int)
-                    (random.nextFloat() * (rightLimit - leftLimit + 1));
+                    (secureRandom.nextFloat() * (rightLimit - leftLimit + 1));
             buffer.append((char) randomLimitedInt);
         }
         return buffer.toString();
@@ -55,19 +54,19 @@ public static String generateBoundedString(int targetStringLength, int leftLimit
 
     public static String generateUtf8String(int length) {
         byte[] array = new byte[length]; // length is bounded by 7
-        new SecureRandom().nextBytes(array);
+        secureRandom.nextBytes(array);
         return new String(array, StandardCharsets.UTF_8);
     }
 
     public static String generateUtf16String(int length) {
         byte[] array = new byte[length]; // length is bounded by 7
-        new SecureRandom().nextBytes(array);
+        secureRandom.nextBytes(array);
         return new String(array, StandardCharsets.UTF_16);
     }
 
     public static String generateASCIItring(int length) {
         byte[] array = new byte[length]; // length is bounded by 7
-        new SecureRandom().nextBytes(array);
+        secureRandom.nextBytes(array);
         return new String(array, StandardCharsets.US_ASCII);
     }