thuban 0.4.11 → 0.4.13

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

@@ -1,22 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: command_injection
-// severity: critical
-// language: rust
-// expected: Command::new with user-controlled string passed to shell
-
-use std::process::Command;
-
-pub fn ping_host(host: &str) -> String {
-    let output = Command::new("sh")
-        .arg("-c")
-        .arg(format!("ping -c 4 {}", host))
-        .output()
-        .expect("Failed to execute ping");
-    String::from_utf8_lossy(&output.stdout).to_string()
-}
-
-pub fn lookup_dns(domain: &str) -> String {
-    let cmd = format!("nslookup {}", domain);
-    let output = Command::new("/bin/sh").arg("-c").arg(cmd).output().unwrap();
-    String::from_utf8_lossy(&output.stdout).to_string()
-}

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

@@ -1,28 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: command_injection
-// severity: critical
-// language: rust
-// expected: User input interpolated into shell command string passed to sh -c
-
-use std::process::Command;
-
-pub fn convert_image(input: &str, output: &str, width: &str, height: &str) -> bool {
-    let cmd = format!("convert {} -resize {}x{} {}", input, width, height, output);
-    Command::new("sh")
-        .arg("-c")
-        .arg(&cmd)
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
-}
-
-pub fn compress_file(path: &str, dest: &str) -> i32 {
-    let cmd = format!("gzip -c {} > {}", path, dest);
-    Command::new("bash")
-        .arg("-c")
-        .arg(cmd)
-        .status()
-        .unwrap()
-        .code()
-        .unwrap_or(-1)
-}

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

@@ -1,21 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: command_injection
-// severity: critical
-// language: rust
-// expected: Actix-web handler passes query param to shell command
-
-use actix_web::{web, HttpResponse};
-use std::process::Command;
-
-pub async fn run_report(query: web::Query<std::collections::HashMap<String, String>>) -> HttpResponse {
-    let report_type = query.get("type").map(|s| s.as_str()).unwrap_or("summary");
-    let date = query.get("date").unwrap_or(&String::new()).clone();
-    let cmd = format!("./scripts/generate_report.sh {} {}", report_type, date);
-    let output = Command::new("sh").arg("-c").arg(cmd).output().unwrap();
-    HttpResponse::Ok().body(String::from_utf8_lossy(&output.stdout).to_string())
-}
-
-pub async fn execute_tool(body: String) -> HttpResponse {
-    let output = Command::new("sh").arg("-c").arg(&body).output().unwrap();
-    HttpResponse::Ok().body(String::from_utf8_lossy(&output.stdout).to_string())
-}

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

@@ -1,36 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: command_injection
-// severity: critical
-// language: rust
-// expected: Git command constructed with user-supplied repository URL
-
-use std::process::Command;
-
-pub fn clone_repo(url: &str, dest: &str) -> bool {
-    let output = Command::new("git")
-        .arg("clone")
-        .arg(url)
-        .arg(dest)
-        .output();
-
-    match output {
-        Ok(o) => o.status.success(),
-        Err(_) => false,
-    }
-}
-
-pub fn git_pull(repo_path: &str, branch: &str) -> String {
-    let cmd = format!("cd {} && git pull origin {}", repo_path, branch);
-    let out = Command::new("sh").arg("-c").arg(cmd).output().unwrap();
-    String::from_utf8_lossy(&out.stdout).to_string()
-}
-
-pub fn run_git_hook(hook_name: &str, args: &str) -> i32 {
-    Command::new("sh")
-        .arg("-c")
-        .arg(format!(".git/hooks/{} {}", hook_name, args))
-        .status()
-        .unwrap()
-        .code()
-        .unwrap_or(-1)
-}

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

@@ -1,27 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: command_injection
-// severity: high
-// language: rust
-// expected: ffmpeg command built from user-controlled filenames without sanitization
-
-use std::process::Command;
-use std::path::Path;
-
-pub fn transcode_video(input: &str, output: &str, codec: &str) -> std::io::Result<()> {
-    let cmd = format!("ffmpeg -i '{}' -c:v {} '{}'", input, codec, output);
-    Command::new("sh").arg("-c").arg(&cmd).status()?;
-    Ok(())
-}
-
-pub fn extract_audio(video_path: &str, audio_path: &str) -> bool {
-    let ffmpeg_cmd = format!(
-        "ffmpeg -i {} -vn -acodec copy {}",
-        video_path, audio_path
-    );
-    Command::new("/bin/sh")
-        .arg("-c")
-        .arg(ffmpeg_cmd)
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
-}

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

@@ -1,26 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: command_injection
-// severity: critical
-// language: rust
-// expected: eval-like dynamic command execution from deserialized task payload
-
-use std::process::Command;
-use serde::Deserialize;
-
-#[derive(Deserialize)]
-pub struct Task {
-    pub command: String,
-    pub args: Vec<String>,
-    pub shell: Option<bool>,
-}
-
-pub fn execute_task(task: &Task) -> String {
-    if task.shell.unwrap_or(false) {
-        let full_cmd = format!("{} {}", task.command, task.args.join(" "));
-        let out = Command::new("sh").arg("-c").arg(&full_cmd).output().unwrap();
-        String::from_utf8_lossy(&out.stdout).to_string()
-    } else {
-        let out = Command::new(&task.command).args(&task.args).output().unwrap();
-        String::from_utf8_lossy(&out.stdout).to_string()
-    }
-}

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

@@ -1,23 +0,0 @@
-// [CRUCIBLE-SEED]
-// category: command_injection
-// severity: high
-// language: rust
-// expected: Log archival uses user-supplied log name in shell command
-
-use std::process::Command;
-
-pub fn archive_logs(log_name: &str, destination: &str) -> bool {
-    let cmd = format!("tar -czf {}/{}.tar.gz /var/log/{}", destination, log_name, log_name);
-    Command::new("sh")
-        .arg("-c")
-        .arg(&cmd)
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
-}
-
-pub fn rotate_log(service_name: &str) -> String {
-    let cmd = format!("logrotate -f /etc/logrotate.d/{}", service_name);
-    let output = Command::new("/bin/sh").arg("-c").arg(cmd).output().unwrap();
-    String::from_utf8_lossy(&output.stdout).to_string()
-}

package/dist/packages/crucible/seeds/rust/seed-023 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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 2.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
-}