thuban 0.4.3 → 0.4.6

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

@@ -1,25 +1,25 @@
-// [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()
-}
+// [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 +1,28 @@
-// [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
-    }
-}
+// [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-039.rs

@@ -1,28 +1,28 @@
-// [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
-    }
-}
+// [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 +1,27 @@
-// [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
-}
+// [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-040.rs

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

@@ -1,32 +1,32 @@
-// [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)) }
-    }
-}
+// [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-041.rs

@@ -1,32 +1,32 @@
-// [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)) }
-    }
-}
+// [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 2.rs

@@ -1,27 +1,27 @@
-// [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;
-        }
-    }
-}
+// [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-042.rs

@@ -1,27 +1,27 @@
-// [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;
-        }
-    }
-}
+// [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 2.rs

@@ -1,29 +1,29 @@
-// [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()
-}
+// [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-043.rs

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