thuban 0.4.0 → 0.4.2

package/dist/packages/crucible/seeds/rust/seed-023 3.rs

@@ -1,22 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: path_traversal
-// severity: critical
-// language: rust
-// expected: fs::read with user-supplied path — no canonicalization or prefix check
-
-use std::fs;
-use std::path::Path;
-
-pub fn read_file(base_dir: &str, filename: &str) -> Result<Vec<u8>, std::io::Error> {
-    let path = format!("{}/{}", base_dir, filename);
-    fs::read(&path)
-}
-
-pub fn get_file_content(user_path: &str) -> String {
-    let full_path = format!("/var/app/uploads/{}", user_path);
-    fs::read_to_string(&full_path).unwrap_or_default()
-}
-
-pub fn file_exists(base: &str, name: &str) -> bool {
-    Path::new(&format!("{}/{}", base, name)).exists()
-}

package/dist/packages/crucible/seeds/rust/seed-024 3.rs

@@ -1,24 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: path_traversal
-// severity: critical
-// language: rust
-// expected: Axum handler reads file from path parameter without validation
-
-use axum::{extract::Path, response::IntoResponse};
-use std::fs;
-
-pub async fn serve_file(Path(filename): Path<String>) -> impl IntoResponse {
-    let path = format!("/app/static/{}", filename);
-    match fs::read_to_string(&path) {
-        Ok(content) => (axum::http::StatusCode::OK, content),
-        Err(_) => (axum::http::StatusCode::NOT_FOUND, "Not found".to_string()),
-    }
-}
-
-pub async fn download_resource(Path((dir, file)): Path<(String, String)>) -> impl IntoResponse {
-    let full_path = format!("/data/{}/{}", dir, file);
-    match fs::read(&full_path) {
-        Ok(bytes) => (axum::http::StatusCode::OK, format!("{} bytes", bytes.len())),
-        Err(e) => (axum::http::StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
-    }
-}

package/dist/packages/crucible/seeds/rust/seed-025 3.rs

@@ -1,29 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: path_traversal
-// severity: critical
-// language: rust
-// expected: Zip extraction writes to path from ZipFile entry without canonicalization
-
-use std::fs::{self, File};
-use std::io;
-use std::path::Path;
-use zip::ZipArchive;
-
-pub fn extract_zip(zip_path: &str, dest: &str) -> io::Result<()> {
-    let file = File::open(zip_path)?;
-    let mut archive = ZipArchive::new(file)?;
-    for i in 0..archive.len() {
-        let mut entry = archive.by_index(i)?;
-        let out_path = Path::new(dest).join(entry.name());
-        if entry.is_dir() {
-            fs::create_dir_all(&out_path)?;
-        } else {
-            if let Some(parent) = out_path.parent() {
-                fs::create_dir_all(parent)?;
-            }
-            let mut outfile = File::create(&out_path)?;
-            io::copy(&mut entry, &mut outfile)?;
-        }
-    }
-    Ok(())
-}

package/dist/packages/crucible/seeds/rust/seed-026 3.rs

@@ -1,23 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: path_traversal
-// severity: high
-// language: rust
-// expected: File write to user-controlled path without restricting to base directory
-
-use std::fs;
-
-pub fn write_report(report_name: &str, content: &str) -> Result<(), std::io::Error> {
-    let path = format!("/var/reports/{}", report_name);
-    fs::write(&path, content)?;
-    Ok(())
-}
-
-pub fn save_template(template_id: &str, subdir: &str, data: &[u8]) -> bool {
-    let full_path = format!("/app/templates/{}/{}.tmpl", subdir, template_id);
-    fs::write(&full_path, data).is_ok()
-}
-
-pub fn cache_response(cache_key: &str, data: &str) -> bool {
-    let path = format!("/tmp/cache/{}", cache_key);
-    fs::write(path, data).is_ok()
-}

package/dist/packages/crucible/seeds/rust/seed-027 3.rs

@@ -1,24 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: path_traversal
-// severity: critical
-// language: rust
-// expected: Config file loaded from user-controlled path — arbitrary file read
-
-use std::fs;
-use serde_json::Value;
-
-pub fn load_config(config_name: &str) -> Value {
-    let path = format!("/etc/app/configs/{}", config_name);
-    let content = fs::read_to_string(&path).unwrap_or_else(|_| "{}".to_string());
-    serde_json::from_str(&content).unwrap_or(Value::Null)
-}
-
-pub fn load_plugin_manifest(plugin_id: &str) -> String {
-    let manifest_path = format!("./plugins/{}/manifest.json", plugin_id);
-    fs::read_to_string(manifest_path).unwrap_or_default()
-}
-
-pub fn read_user_template(user_id: &str, template_name: &str) -> String {
-    let path = format!("/data/users/{}/templates/{}", user_id, template_name);
-    fs::read_to_string(path).unwrap_or_default()
-}

package/dist/packages/crucible/seeds/rust/seed-028 3.rs

@@ -1,25 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: path_traversal
-// severity: high
-// language: rust
-// expected: Directory listing served from user-controlled subdirectory
-
-use std::fs;
-
-pub fn list_directory(base: &str, subdir: &str) -> Vec<String> {
-    let path = format!("{}/{}", base, subdir);
-    match fs::read_dir(&path) {
-        Ok(entries) => entries
-            .filter_map(|e| e.ok())
-            .map(|e| e.file_name().to_string_lossy().to_string())
-            .collect(),
-        Err(_) => vec![],
-    }
-}
-
-pub fn serve_directory(root: &str, user_path: &str) -> String {
-    let full = format!("{}/{}", root, user_path);
-    fs::read_dir(&full)
-        .map(|rd| rd.count().to_string())
-        .unwrap_or_else(|e| e.to_string())
-}

package/dist/packages/crucible/seeds/rust/seed-029 3.rs

@@ -1,25 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: integer_overflow
-// severity: high
-// language: rust
-// expected: Explicit unchecked arithmetic that wraps on overflow in release mode
-
-pub fn calculate_offset(index: usize, stride: usize) -> usize {
-    index * stride
-}
-
-pub fn buffer_size(width: u32, height: u32, channels: u32) -> u32 {
-    width * height * channels
-}
-
-pub fn total_price(unit_price: u32, quantity: u32) -> u32 {
-    unit_price * quantity
-}
-
-pub fn encode_coords(x: i32, y: i32) -> i64 {
-    (x as i64) * 100000 + (y as i64)
-}
-
-pub fn as_usize_unchecked(n: i64) -> usize {
-    n as usize
-}

package/dist/packages/crucible/seeds/rust/seed-030 3.rs

@@ -1,30 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: integer_overflow
-// severity: high
-// language: rust
-// expected: Cast truncation — u64 to u32/u16/u8 silently drops high bits
-
-pub fn truncate_to_u8(val: u64) -> u8 {
-    val as u8
-}
-
-pub fn truncate_to_u16(val: u64) -> u16 {
-    val as u16
-}
-
-pub fn index_from_user_input(input: i64) -> usize {
-    input as usize
-}
-
-pub fn packet_len_from_i32(len: i32) -> usize {
-    len as usize
-}
-
-pub fn compress_timestamp(ts: u64) -> u32 {
-    ts as u32
-}
-
-pub fn negate_unsigned(n: u32) -> u32 {
-    let signed = n as i32;
-    (-signed) as u32
-}

package/dist/packages/crucible/seeds/rust/seed-031 3.rs

@@ -1,22 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: integer_overflow
-// severity: high
-// language: rust
-// expected: Allocation size computed from untrusted user input — potential OOM / overflow
-
-use std::alloc::{alloc, Layout};
-
-pub fn allocate_buffer(user_size: u32, element_size: u32) -> Vec<u8> {
-    let total = (user_size * element_size) as usize;
-    vec![0u8; total]
-}
-
-pub unsafe fn raw_alloc(count: usize, item_size: usize) -> *mut u8 {
-    let size = count * item_size;
-    let layout = Layout::from_size_align_unchecked(size, 8);
-    alloc(layout)
-}
-
-pub fn string_repeat(s: &str, n: u32) -> String {
-    s.repeat(n as usize)
-}

package/dist/packages/crucible/seeds/rust/seed-032 3.rs

@@ -1,25 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: integer_overflow
-// severity: medium
-// language: rust
-// expected: Signed integer arithmetic without overflow check — negative length risk
-
-pub fn calculate_remaining(total: i32, used: i32) -> i32 {
-    total - used
-}
-
-pub fn chunk_count(data_len: i32, chunk_size: i32) -> i32 {
-    (data_len + chunk_size - 1) / chunk_size
-}
-
-pub fn ring_buffer_advance(pos: u32, step: u32, capacity: u32) -> u32 {
-    (pos + step) % capacity
-}
-
-pub fn decode_delta(base: u32, delta: i32) -> u32 {
-    (base as i32 + delta) as u32
-}
-
-pub fn safe_subtract(a: u32, b: u32) -> u32 {
-    a - b
-}

package/dist/packages/crucible/seeds/rust/seed-033 3.rs

@@ -1,25 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: integer_overflow
-// severity: high
-// language: rust
-// expected: Array index from user input without bounds check — potential panic or OOM
-
-pub fn get_element(data: &[u8], index: usize) -> u8 {
-    data[index]
-}
-
-pub fn set_element(data: &mut Vec<u8>, index: usize, value: u8) {
-    data[index] = value;
-}
-
-pub fn read_matrix(matrix: &[Vec<i32>], row: usize, col: usize) -> i32 {
-    matrix[row][col]
-}
-
-pub fn sum_range(data: &[i64], start: usize, end: usize) -> i64 {
-    data[start..end].iter().sum()
-}
-
-pub fn nth_element(data: &[String], n: usize) -> &str {
-    &data[n]
-}

package/dist/packages/crucible/seeds/rust/seed-034 3.rs

@@ -1,20 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: ssrf
-// severity: critical
-// language: rust
-// expected: reqwest::get called with user-controlled URL — SSRF
-
-use reqwest;
-
-pub async fn fetch_url(user_url: &str) -> Result<String, reqwest::Error> {
-    let response = reqwest::get(user_url).await?;
-    let body = response.text().await?;
-    Ok(body)
-}
-
-pub async fn proxy_request(target: &str) -> String {
-    reqwest::get(target)
-        .await
-        .and_then(|r| async { r.text().await }.await.map_err(Into::into))
-        .unwrap_or_default()
-}

package/dist/packages/crucible/seeds/rust/seed-035 3.rs

@@ -1,28 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: ssrf
-// severity: critical
-// language: rust
-// expected: Axum endpoint fetches user-supplied URL server-side — open proxy / SSRF
-
-use axum::{extract::Query, response::IntoResponse};
-use reqwest::Client;
-use std::collections::HashMap;
-
-pub async fn proxy_endpoint(Query(params): Query<HashMap<String, String>>) -> impl IntoResponse {
-    let url = params.get("url").cloned().unwrap_or_default();
-    let client = Client::new();
-    match client.get(&url).send().await {
-        Ok(resp) => resp.text().await.unwrap_or_default(),
-        Err(e) => format!("Error: {}", e),
-    }
-}
-
-pub async fn webhook_relay(Query(params): Query<HashMap<String, String>>) -> impl IntoResponse {
-    let callback = params.get("callback").cloned().unwrap_or_default();
-    let _ = Client::new()
-        .post(&callback)
-        .json(&serde_json::json!({"status": "ok"}))
-        .send()
-        .await;
-    "Triggered"
-}

package/dist/packages/crucible/seeds/rust/seed-036 3.rs

@@ -1,26 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: ssrf
-// severity: critical
-// language: rust
-// expected: URL constructed from user-supplied hostname and path — SSRF
-
-use reqwest::Client;
-
-pub async fn check_endpoint(host: &str, port: u16, path: &str) -> bool {
-    let url = format!("http://{}:{}{}", host, port, path);
-    Client::new().get(&url).send().await.is_ok()
-}
-
-pub async fn fetch_avatar(base_url: &str, user_id: &str) -> Vec<u8> {
-    let url = format!("{}/avatars/{}.png", base_url, user_id);
-    reqwest::get(&url)
-        .await
-        .and_then(|r| async { r.bytes().await }.await.map_err(Into::into))
-        .map(|b| b.to_vec())
-        .unwrap_or_default()
-}
-
-pub async fn import_data(source_url: &str) -> serde_json::Value {
-    let text = reqwest::get(source_url).await.unwrap().text().await.unwrap();
-    serde_json::from_str(&text).unwrap_or(serde_json::Value::Null)
-}

package/dist/packages/crucible/seeds/rust/seed-037 3.rs

@@ -1,31 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: ssrf
-// severity: high
-// language: rust
-// expected: Image URL fetched server-side from user POST body — SSRF via metadata endpoint
-
-use reqwest::Client;
-use serde::Deserialize;
-
-#[derive(Deserialize)]
-pub struct ImageRequest {
-    pub url: String,
-    pub format: String,
-}
-
-pub async fn download_and_process(req: ImageRequest) -> Vec<u8> {
-    let client = Client::new();
-    let bytes = client
-        .get(&req.url)
-        .send()
-        .await
-        .unwrap()
-        .bytes()
-        .await
-        .unwrap();
-    bytes.to_vec()
-}
-
-pub async fn get_og_metadata(page_url: &str) -> String {
-    reqwest::get(page_url).await.unwrap().text().await.unwrap()
-}

package/dist/packages/crucible/seeds/rust/seed-038 3.rs

@@ -1,25 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: ssrf
-// severity: critical
-// language: rust
-// expected: DNS rebinding-vulnerable health check using user-supplied host
-
-use reqwest::Client;
-use std::time::Duration;
-
-pub async fn health_check(host: &str) -> serde_json::Value {
-    let url = format!("http://{}/health", host);
-    let client = Client::builder()
-        .timeout(Duration::from_secs(5))
-        .build()
-        .unwrap();
-    match client.get(&url).send().await {
-        Ok(resp) => resp.json().await.unwrap_or(serde_json::Value::Null),
-        Err(_) => serde_json::json!({"status": "unreachable"}),
-    }
-}
-
-pub async fn resolve_and_fetch(domain: &str, endpoint: &str) -> String {
-    let url = format!("https://{}{}", domain, endpoint);
-    reqwest::get(&url).await.unwrap().text().await.unwrap()
-}

package/dist/packages/crucible/seeds/rust/seed-039 3.rs

@@ -1,28 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: race_condition
-// severity: high
-// language: rust
-// expected: Arc<Mutex<>> lock held across await point — potential deadlock
-
-use std::sync::{Arc, Mutex};
-use tokio::time::{sleep, Duration};
-
-pub struct SharedState {
-    data: Arc<Mutex<Vec<String>>>,
-}
-
-impl SharedState {
-    pub async fn add_and_process(&self, item: String) {
-        let mut guard = self.data.lock().unwrap();
-        guard.push(item);
-        sleep(Duration::from_millis(100)).await;
-        println!("Processed: {:?}", guard.last());
-    }
-
-    pub async fn read_then_write(&self, key: String) -> Option<String> {
-        let guard = self.data.lock().unwrap();
-        let found = guard.iter().find(|s| s.starts_with(&key)).cloned();
-        sleep(Duration::from_secs(1)).await;
-        found
-    }
-}

package/dist/packages/crucible/seeds/rust/seed-040 3.rs

@@ -1,27 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: race_condition
-// severity: high
-// language: rust
-// expected: Check-then-act race condition on shared file resource
-
-use std::fs;
-use std::path::Path;
-
-pub fn create_if_not_exists(path: &str, content: &str) -> bool {
-    if !Path::new(path).exists() {
-        fs::write(path, content).is_ok()
-    } else {
-        false
-    }
-}
-
-pub fn atomic_counter_increment(path: &str) -> u64 {
-    let current: u64 = fs::read_to_string(path)
-        .unwrap_or("0".to_string())
-        .trim()
-        .parse()
-        .unwrap_or(0);
-    let next = current + 1;
-    fs::write(path, next.to_string()).unwrap();
-    next
-}

package/dist/packages/crucible/seeds/rust/seed-041 3.rs

@@ -1,32 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: race_condition
-// severity: critical
-// language: rust
-// expected: Unsafe impl Send for type containing raw pointer — data race
-
-use std::ptr;
-
-pub struct RawBuffer {
-    ptr: *mut u8,
-    len: usize,
-}
-
-unsafe impl Send for RawBuffer {}
-unsafe impl Sync for RawBuffer {}
-
-impl RawBuffer {
-    pub fn new(size: usize) -> Self {
-        let mut data = vec![0u8; size];
-        let ptr = data.as_mut_ptr();
-        std::mem::forget(data);
-        RawBuffer { ptr, len: size }
-    }
-
-    pub fn write_at(&self, offset: usize, value: u8) {
-        unsafe { ptr::write(self.ptr.add(offset), value) }
-    }
-
-    pub fn read_at(&self, offset: usize) -> u8 {
-        unsafe { ptr::read(self.ptr.add(offset)) }
-    }
-}

package/dist/packages/crucible/seeds/rust/seed-042 3.rs

@@ -1,27 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: race_condition
-// severity: high
-// language: rust
-// expected: Multiple threads access static mut without synchronization
-
-static mut GLOBAL_COUNTER: u64 = 0;
-static mut INITIALIZED: bool = false;
-
-pub fn increment_global() {
-    unsafe {
-        GLOBAL_COUNTER += 1;
-    }
-}
-
-pub fn get_global() -> u64 {
-    unsafe { GLOBAL_COUNTER }
-}
-
-pub fn initialize_once(value: u64) {
-    unsafe {
-        if !INITIALIZED {
-            GLOBAL_COUNTER = value;
-            INITIALIZED = true;
-        }
-    }
-}

package/dist/packages/crucible/seeds/rust/seed-043 3.rs

@@ -1,29 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: race_condition
-// severity: high
-// language: rust
-// expected: Mutex poisoning ignored with unwrap — may expose partial state
-
-use std::sync::{Arc, Mutex};
-use std::thread;
-
-pub fn parallel_updates(shared: Arc<Mutex<Vec<i32>>>, items: Vec<i32>) {
-    let handles: Vec<_> = items.into_iter().map(|item| {
-        let shared = Arc::clone(&shared);
-        thread::spawn(move || {
-            let mut guard = shared.lock().unwrap();
-            guard.push(item);
-            if item == 42 {
-                panic!("Special case panic — poisons the Mutex");
-            }
-        })
-    }).collect();
-
-    for h in handles {
-        let _ = h.join();
-    }
-}
-
-pub fn read_poisoned(shared: Arc<Mutex<Vec<i32>>>) -> Vec<i32> {
-    shared.lock().unwrap().clone()
-}

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

@@ -1,25 +0,0 @@
-// [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 3.rs

@@ -1,28 +0,0 @@
-// [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 3.rs

@@ -1,25 +0,0 @@
-// [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)
-}