thuban 0.4.3 → 0.4.5

package/dist/packages/crucible/seeds/rust/seed-044 2.rs

@@ -1,25 +1,25 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: high
-// language: rust
-// expected: MD5 crate used for password or data integrity hashing
-
-use md5;
-
-pub fn hash_password(password: &str) -> String {
-    let digest = md5::compute(password.as_bytes());
-    format!("{:x}", digest)
-}
-
-pub fn hash_with_salt(password: &str, username: &str) -> String {
-    let input = format!("{}:{}", username, password);
-    format!("{:x}", md5::compute(input.as_bytes()))
-}
-
-pub fn verify_password(password: &str, stored_hash: &str) -> bool {
-    hash_password(password) == stored_hash
-}
-
-pub fn generate_cache_key(data: &str) -> String {
-    format!("{:x}", md5::compute(data))
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: high
+// language: rust
+// expected: MD5 crate used for password or data integrity hashing
+
+use md5;
+
+pub fn hash_password(password: &str) -> String {
+    let digest = md5::compute(password.as_bytes());
+    format!("{:x}", digest)
+}
+
+pub fn hash_with_salt(password: &str, username: &str) -> String {
+    let input = format!("{}:{}", username, password);
+    format!("{:x}", md5::compute(input.as_bytes()))
+}
+
+pub fn verify_password(password: &str, stored_hash: &str) -> bool {
+    hash_password(password) == stored_hash
+}
+
+pub fn generate_cache_key(data: &str) -> String {
+    format!("{:x}", md5::compute(data))
+}

package/dist/packages/crucible/seeds/rust/seed-044.rs

@@ -1,25 +1,25 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: high
-// language: rust
-// expected: MD5 crate used for password or data integrity hashing
-
-use md5;
-
-pub fn hash_password(password: &str) -> String {
-    let digest = md5::compute(password.as_bytes());
-    format!("{:x}", digest)
-}
-
-pub fn hash_with_salt(password: &str, username: &str) -> String {
-    let input = format!("{}:{}", username, password);
-    format!("{:x}", md5::compute(input.as_bytes()))
-}
-
-pub fn verify_password(password: &str, stored_hash: &str) -> bool {
-    hash_password(password) == stored_hash
-}
-
-pub fn generate_cache_key(data: &str) -> String {
-    format!("{:x}", md5::compute(data))
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: high
+// language: rust
+// expected: MD5 crate used for password or data integrity hashing
+
+use md5;
+
+pub fn hash_password(password: &str) -> String {
+    let digest = md5::compute(password.as_bytes());
+    format!("{:x}", digest)
+}
+
+pub fn hash_with_salt(password: &str, username: &str) -> String {
+    let input = format!("{}:{}", username, password);
+    format!("{:x}", md5::compute(input.as_bytes()))
+}
+
+pub fn verify_password(password: &str, stored_hash: &str) -> bool {
+    hash_password(password) == stored_hash
+}
+
+pub fn generate_cache_key(data: &str) -> String {
+    format!("{:x}", md5::compute(data))
+}

package/dist/packages/crucible/seeds/rust/seed-045 2.rs

@@ -1,28 +1,28 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: critical
-// language: rust
-// expected: Custom XOR cipher implementation — homegrown crypto
-
-pub fn xor_encrypt(data: &[u8], key: &[u8]) -> Vec<u8> {
-    data.iter()
-        .zip(key.iter().cycle())
-        .map(|(d, k)| d ^ k)
-        .collect()
-}
-
-pub fn xor_decrypt(ciphertext: &[u8], key: &[u8]) -> Vec<u8> {
-    xor_encrypt(ciphertext, key)
-}
-
-pub fn rot13(input: &str) -> String {
-    input.chars().map(|c| match c {
-        'a'..='m' | 'A'..='M' => (c as u8 + 13) as char,
-        'n'..='z' | 'N'..='Z' => (c as u8 - 13) as char,
-        _ => c,
-    }).collect()
-}
-
-pub fn caesar_cipher(text: &str, shift: u8) -> String {
-    text.bytes().map(|b| ((b - b'a' + shift) % 26 + b'a') as char).collect()
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: critical
+// language: rust
+// expected: Custom XOR cipher implementation — homegrown crypto
+
+pub fn xor_encrypt(data: &[u8], key: &[u8]) -> Vec<u8> {
+    data.iter()
+        .zip(key.iter().cycle())
+        .map(|(d, k)| d ^ k)
+        .collect()
+}
+
+pub fn xor_decrypt(ciphertext: &[u8], key: &[u8]) -> Vec<u8> {
+    xor_encrypt(ciphertext, key)
+}
+
+pub fn rot13(input: &str) -> String {
+    input.chars().map(|c| match c {
+        'a'..='m' | 'A'..='M' => (c as u8 + 13) as char,
+        'n'..='z' | 'N'..='Z' => (c as u8 - 13) as char,
+        _ => c,
+    }).collect()
+}
+
+pub fn caesar_cipher(text: &str, shift: u8) -> String {
+    text.bytes().map(|b| ((b - b'a' + shift) % 26 + b'a') as char).collect()
+}

package/dist/packages/crucible/seeds/rust/seed-045.rs

@@ -1,28 +1,28 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: critical
-// language: rust
-// expected: Custom XOR cipher implementation — homegrown crypto
-
-pub fn xor_encrypt(data: &[u8], key: &[u8]) -> Vec<u8> {
-    data.iter()
-        .zip(key.iter().cycle())
-        .map(|(d, k)| d ^ k)
-        .collect()
-}
-
-pub fn xor_decrypt(ciphertext: &[u8], key: &[u8]) -> Vec<u8> {
-    xor_encrypt(ciphertext, key)
-}
-
-pub fn rot13(input: &str) -> String {
-    input.chars().map(|c| match c {
-        'a'..='m' | 'A'..='M' => (c as u8 + 13) as char,
-        'n'..='z' | 'N'..='Z' => (c as u8 - 13) as char,
-        _ => c,
-    }).collect()
-}
-
-pub fn caesar_cipher(text: &str, shift: u8) -> String {
-    text.bytes().map(|b| ((b - b'a' + shift) % 26 + b'a') as char).collect()
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: critical
+// language: rust
+// expected: Custom XOR cipher implementation — homegrown crypto
+
+pub fn xor_encrypt(data: &[u8], key: &[u8]) -> Vec<u8> {
+    data.iter()
+        .zip(key.iter().cycle())
+        .map(|(d, k)| d ^ k)
+        .collect()
+}
+
+pub fn xor_decrypt(ciphertext: &[u8], key: &[u8]) -> Vec<u8> {
+    xor_encrypt(ciphertext, key)
+}
+
+pub fn rot13(input: &str) -> String {
+    input.chars().map(|c| match c {
+        'a'..='m' | 'A'..='M' => (c as u8 + 13) as char,
+        'n'..='z' | 'N'..='Z' => (c as u8 - 13) as char,
+        _ => c,
+    }).collect()
+}
+
+pub fn caesar_cipher(text: &str, shift: u8) -> String {
+    text.bytes().map(|b| ((b - b'a' + shift) % 26 + b'a') as char).collect()
+}

package/dist/packages/crucible/seeds/rust/seed-046 2.rs

@@ -1,25 +1,25 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: high
-// language: rust
-// expected: rand::random used for security token generation — not cryptographically secure
-
-use rand::Rng;
-
-pub fn generate_session_token() -> String {
-    let mut rng = rand::thread_rng();
-    (0..32).map(|_| format!("{:02x}", rng.gen::<u8>())).collect()
-}
-
-pub fn generate_otp() -> u32 {
-    rand::thread_rng().gen_range(100000..999999)
-}
-
-pub fn generate_api_key(prefix: &str) -> String {
-    let mut rng = rand::thread_rng();
-    let suffix: String = (0..24).map(|_| {
-        let idx = rng.gen_range(0..36usize);
-        "abcdefghijklmnopqrstuvwxyz0123456789".chars().nth(idx).unwrap()
-    }).collect();
-    format!("{}_{}", prefix, suffix)
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: high
+// language: rust
+// expected: rand::random used for security token generation — not cryptographically secure
+
+use rand::Rng;
+
+pub fn generate_session_token() -> String {
+    let mut rng = rand::thread_rng();
+    (0..32).map(|_| format!("{:02x}", rng.gen::<u8>())).collect()
+}
+
+pub fn generate_otp() -> u32 {
+    rand::thread_rng().gen_range(100000..999999)
+}
+
+pub fn generate_api_key(prefix: &str) -> String {
+    let mut rng = rand::thread_rng();
+    let suffix: String = (0..24).map(|_| {
+        let idx = rng.gen_range(0..36usize);
+        "abcdefghijklmnopqrstuvwxyz0123456789".chars().nth(idx).unwrap()
+    }).collect();
+    format!("{}_{}", prefix, suffix)
+}

package/dist/packages/crucible/seeds/rust/seed-046.rs

@@ -1,25 +1,25 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: high
-// language: rust
-// expected: rand::random used for security token generation — not cryptographically secure
-
-use rand::Rng;
-
-pub fn generate_session_token() -> String {
-    let mut rng = rand::thread_rng();
-    (0..32).map(|_| format!("{:02x}", rng.gen::<u8>())).collect()
-}
-
-pub fn generate_otp() -> u32 {
-    rand::thread_rng().gen_range(100000..999999)
-}
-
-pub fn generate_api_key(prefix: &str) -> String {
-    let mut rng = rand::thread_rng();
-    let suffix: String = (0..24).map(|_| {
-        let idx = rng.gen_range(0..36usize);
-        "abcdefghijklmnopqrstuvwxyz0123456789".chars().nth(idx).unwrap()
-    }).collect();
-    format!("{}_{}", prefix, suffix)
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: high
+// language: rust
+// expected: rand::random used for security token generation — not cryptographically secure
+
+use rand::Rng;
+
+pub fn generate_session_token() -> String {
+    let mut rng = rand::thread_rng();
+    (0..32).map(|_| format!("{:02x}", rng.gen::<u8>())).collect()
+}
+
+pub fn generate_otp() -> u32 {
+    rand::thread_rng().gen_range(100000..999999)
+}
+
+pub fn generate_api_key(prefix: &str) -> String {
+    let mut rng = rand::thread_rng();
+    let suffix: String = (0..24).map(|_| {
+        let idx = rng.gen_range(0..36usize);
+        "abcdefghijklmnopqrstuvwxyz0123456789".chars().nth(idx).unwrap()
+    }).collect();
+    format!("{}_{}", prefix, suffix)
+}

package/dist/packages/crucible/seeds/rust/seed-047 2.rs

@@ -1,34 +1,34 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: high
-// language: rust
-// expected: RC4 stream cipher implementation — broken cipher, insecure
-
-pub struct Rc4 {
-    s: [u8; 256],
-    i: usize,
-    j: usize,
-}
-
-impl Rc4 {
-    pub fn new(key: &[u8]) -> Self {
-        let mut s = [0u8; 256];
-        for i in 0..256 { s[i] = i as u8; }
-        let mut j = 0usize;
-        for i in 0..256 {
-            j = (j + s[i] as usize + key[i % key.len()] as usize) % 256;
-            s.swap(i, j);
-        }
-        Rc4 { s, i: 0, j: 0 }
-    }
-
-    pub fn apply(&mut self, data: &mut [u8]) {
-        for byte in data.iter_mut() {
-            self.i = (self.i + 1) % 256;
-            self.j = (self.j + self.s[self.i] as usize) % 256;
-            self.s.swap(self.i, self.j);
-            let k = self.s[(self.s[self.i] as usize + self.s[self.j] as usize) % 256];
-            *byte ^= k;
-        }
-    }
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: high
+// language: rust
+// expected: RC4 stream cipher implementation — broken cipher, insecure
+
+pub struct Rc4 {
+    s: [u8; 256],
+    i: usize,
+    j: usize,
+}
+
+impl Rc4 {
+    pub fn new(key: &[u8]) -> Self {
+        let mut s = [0u8; 256];
+        for i in 0..256 { s[i] = i as u8; }
+        let mut j = 0usize;
+        for i in 0..256 {
+            j = (j + s[i] as usize + key[i % key.len()] as usize) % 256;
+            s.swap(i, j);
+        }
+        Rc4 { s, i: 0, j: 0 }
+    }
+
+    pub fn apply(&mut self, data: &mut [u8]) {
+        for byte in data.iter_mut() {
+            self.i = (self.i + 1) % 256;
+            self.j = (self.j + self.s[self.i] as usize) % 256;
+            self.s.swap(self.i, self.j);
+            let k = self.s[(self.s[self.i] as usize + self.s[self.j] as usize) % 256];
+            *byte ^= k;
+        }
+    }
+}

package/dist/packages/crucible/seeds/rust/seed-047.rs

@@ -1,34 +1,34 @@
-// [CRUCIBLE-SEED]
-// category: crypto_misuse
-// severity: high
-// language: rust
-// expected: RC4 stream cipher implementation — broken cipher, insecure
-
-pub struct Rc4 {
-    s: [u8; 256],
-    i: usize,
-    j: usize,
-}
-
-impl Rc4 {
-    pub fn new(key: &[u8]) -> Self {
-        let mut s = [0u8; 256];
-        for i in 0..256 { s[i] = i as u8; }
-        let mut j = 0usize;
-        for i in 0..256 {
-            j = (j + s[i] as usize + key[i % key.len()] as usize) % 256;
-            s.swap(i, j);
-        }
-        Rc4 { s, i: 0, j: 0 }
-    }
-
-    pub fn apply(&mut self, data: &mut [u8]) {
-        for byte in data.iter_mut() {
-            self.i = (self.i + 1) % 256;
-            self.j = (self.j + self.s[self.i] as usize) % 256;
-            self.s.swap(self.i, self.j);
-            let k = self.s[(self.s[self.i] as usize + self.s[self.j] as usize) % 256];
-            *byte ^= k;
-        }
-    }
-}
+// [CRUCIBLE-SEED]
+// category: crypto_misuse
+// severity: high
+// language: rust
+// expected: RC4 stream cipher implementation — broken cipher, insecure
+
+pub struct Rc4 {
+    s: [u8; 256],
+    i: usize,
+    j: usize,
+}
+
+impl Rc4 {
+    pub fn new(key: &[u8]) -> Self {
+        let mut s = [0u8; 256];
+        for i in 0..256 { s[i] = i as u8; }
+        let mut j = 0usize;
+        for i in 0..256 {
+            j = (j + s[i] as usize + key[i % key.len()] as usize) % 256;
+            s.swap(i, j);
+        }
+        Rc4 { s, i: 0, j: 0 }
+    }
+
+    pub fn apply(&mut self, data: &mut [u8]) {
+        for byte in data.iter_mut() {
+            self.i = (self.i + 1) % 256;
+            self.j = (self.j + self.s[self.i] as usize) % 256;
+            self.s.swap(self.i, self.j);
+            let k = self.s[(self.s[self.i] as usize + self.s[self.j] as usize) % 256];
+            *byte ^= k;
+        }
+    }
+}

package/dist/packages/crucible/seeds/rust/seed-048 2.rs

@@ -1,21 +1,21 @@
-// [CRUCIBLE-SEED]
-// category: env_injection
-// severity: high
-// language: rust
-// expected: Secret from env var logged to stdout/stderr — credential exposure in logs
-
-use std::env;
-
-pub fn initialize_client() {
-    let api_key = env::var("API_KEY").expect("API_KEY not set");
-    let db_password = env::var("DB_PASSWORD").expect("DB_PASSWORD not set");
-    println!("Starting client with API_KEY={}", api_key);
-    eprintln!("DB connection using password: {}", db_password);
-    log::info!("Auth token: {}", env::var("AUTH_TOKEN").unwrap_or_default());
-}
-
-pub fn debug_config() {
-    for (key, value) in env::vars() {
-        println!("{}={}", key, value);
-    }
-}
+// [CRUCIBLE-SEED]
+// category: env_injection
+// severity: high
+// language: rust
+// expected: Secret from env var logged to stdout/stderr — credential exposure in logs
+
+use std::env;
+
+pub fn initialize_client() {
+    let api_key = env::var("API_KEY").expect("API_KEY not set");
+    let db_password = env::var("DB_PASSWORD").expect("DB_PASSWORD not set");
+    println!("Starting client with API_KEY={}", api_key);
+    eprintln!("DB connection using password: {}", db_password);
+    log::info!("Auth token: {}", env::var("AUTH_TOKEN").unwrap_or_default());
+}
+
+pub fn debug_config() {
+    for (key, value) in env::vars() {
+        println!("{}={}", key, value);
+    }
+}

package/dist/packages/crucible/seeds/rust/seed-048.rs

@@ -1,21 +1,21 @@
-// [CRUCIBLE-SEED]
-// category: env_injection
-// severity: high
-// language: rust
-// expected: Secret from env var logged to stdout/stderr — credential exposure in logs
-
-use std::env;
-
-pub fn initialize_client() {
-    let api_key = env::var("API_KEY").expect("API_KEY not set");
-    let db_password = env::var("DB_PASSWORD").expect("DB_PASSWORD not set");
-    println!("Starting client with API_KEY={}", api_key);
-    eprintln!("DB connection using password: {}", db_password);
-    log::info!("Auth token: {}", env::var("AUTH_TOKEN").unwrap_or_default());
-}
-
-pub fn debug_config() {
-    for (key, value) in env::vars() {
-        println!("{}={}", key, value);
-    }
-}
+// [CRUCIBLE-SEED]
+// category: env_injection
+// severity: high
+// language: rust
+// expected: Secret from env var logged to stdout/stderr — credential exposure in logs
+
+use std::env;
+
+pub fn initialize_client() {
+    let api_key = env::var("API_KEY").expect("API_KEY not set");
+    let db_password = env::var("DB_PASSWORD").expect("DB_PASSWORD not set");
+    println!("Starting client with API_KEY={}", api_key);
+    eprintln!("DB connection using password: {}", db_password);
+    log::info!("Auth token: {}", env::var("AUTH_TOKEN").unwrap_or_default());
+}
+
+pub fn debug_config() {
+    for (key, value) in env::vars() {
+        println!("{}={}", key, value);
+    }
+}

package/dist/packages/crucible/seeds/rust/seed-049 2.rs

@@ -1,26 +1,26 @@
-// [CRUCIBLE-SEED]
-// category: env_injection
-// severity: high
-// language: rust
-// expected: Environment variable values reflected in HTTP response — credential leak
-
-use axum::{response::IntoResponse, http::StatusCode};
-use std::env;
-
-pub async fn debug_handler() -> impl IntoResponse {
-    let config = serde_json::json!({
-        "database_url": env::var("DATABASE_URL").unwrap_or_default(),
-        "redis_url": env::var("REDIS_URL").unwrap_or_default(),
-        "api_key": env::var("API_KEY").unwrap_or_default(),
-        "jwt_secret": env::var("JWT_SECRET").unwrap_or_default(),
-        "aws_key": env::var("AWS_ACCESS_KEY_ID").unwrap_or_default(),
-        "aws_secret": env::var("AWS_SECRET_ACCESS_KEY").unwrap_or_default(),
-    });
-    (StatusCode::OK, config.to_string())
-}
-
-pub fn get_env_or_log(key: &str) -> String {
-    let value = env::var(key).unwrap_or_default();
-    log::debug!("Reading env {} = {}", key, value);
-    value
-}
+// [CRUCIBLE-SEED]
+// category: env_injection
+// severity: high
+// language: rust
+// expected: Environment variable values reflected in HTTP response — credential leak
+
+use axum::{response::IntoResponse, http::StatusCode};
+use std::env;
+
+pub async fn debug_handler() -> impl IntoResponse {
+    let config = serde_json::json!({
+        "database_url": env::var("DATABASE_URL").unwrap_or_default(),
+        "redis_url": env::var("REDIS_URL").unwrap_or_default(),
+        "api_key": env::var("API_KEY").unwrap_or_default(),
+        "jwt_secret": env::var("JWT_SECRET").unwrap_or_default(),
+        "aws_key": env::var("AWS_ACCESS_KEY_ID").unwrap_or_default(),
+        "aws_secret": env::var("AWS_SECRET_ACCESS_KEY").unwrap_or_default(),
+    });
+    (StatusCode::OK, config.to_string())
+}
+
+pub fn get_env_or_log(key: &str) -> String {
+    let value = env::var(key).unwrap_or_default();
+    log::debug!("Reading env {} = {}", key, value);
+    value
+}

package/dist/packages/crucible/seeds/rust/seed-049.rs

@@ -1,26 +1,26 @@
-// [CRUCIBLE-SEED]
-// category: env_injection
-// severity: high
-// language: rust
-// expected: Environment variable values reflected in HTTP response — credential leak
-
-use axum::{response::IntoResponse, http::StatusCode};
-use std::env;
-
-pub async fn debug_handler() -> impl IntoResponse {
-    let config = serde_json::json!({
-        "database_url": env::var("DATABASE_URL").unwrap_or_default(),
-        "redis_url": env::var("REDIS_URL").unwrap_or_default(),
-        "api_key": env::var("API_KEY").unwrap_or_default(),
-        "jwt_secret": env::var("JWT_SECRET").unwrap_or_default(),
-        "aws_key": env::var("AWS_ACCESS_KEY_ID").unwrap_or_default(),
-        "aws_secret": env::var("AWS_SECRET_ACCESS_KEY").unwrap_or_default(),
-    });
-    (StatusCode::OK, config.to_string())
-}
-
-pub fn get_env_or_log(key: &str) -> String {
-    let value = env::var(key).unwrap_or_default();
-    log::debug!("Reading env {} = {}", key, value);
-    value
-}
+// [CRUCIBLE-SEED]
+// category: env_injection
+// severity: high
+// language: rust
+// expected: Environment variable values reflected in HTTP response — credential leak
+
+use axum::{response::IntoResponse, http::StatusCode};
+use std::env;
+
+pub async fn debug_handler() -> impl IntoResponse {
+    let config = serde_json::json!({
+        "database_url": env::var("DATABASE_URL").unwrap_or_default(),
+        "redis_url": env::var("REDIS_URL").unwrap_or_default(),
+        "api_key": env::var("API_KEY").unwrap_or_default(),
+        "jwt_secret": env::var("JWT_SECRET").unwrap_or_default(),
+        "aws_key": env::var("AWS_ACCESS_KEY_ID").unwrap_or_default(),
+        "aws_secret": env::var("AWS_SECRET_ACCESS_KEY").unwrap_or_default(),
+    });
+    (StatusCode::OK, config.to_string())
+}
+
+pub fn get_env_or_log(key: &str) -> String {
+    let value = env::var(key).unwrap_or_default();
+    log::debug!("Reading env {} = {}", key, value);
+    value
+}