thuban 0.3.4 → 0.4.0

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

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

@@ -0,0 +1,22 @@
+// [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

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

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

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

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

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

@@ -0,0 +1,21 @@
+// [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

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

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

@@ -0,0 +1,36 @@
+// [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

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

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

@@ -0,0 +1,27 @@
+// [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

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

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

@@ -0,0 +1,26 @@
+// [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

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

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

@@ -0,0 +1,23 @@
+// [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

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

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

@@ -0,0 +1,22 @@
+// [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

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