bashrs 6.66.0

Rust-to-Shell transpiler for deterministic bootstrap scripts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Minimal runtime loader for embedded scripts
//! This module provides the loader stub that extracts and executes
//! compressed shell scripts from within the binary.

// use core::slice;

/// ELF structures for parsing (repr(C) for binary layout compatibility)
#[repr(C)]
struct _Elf64Ehdr {
    e_ident: [u8; 16],
    e_type: u16,
    e_machine: u16,
    e_version: u32,
    e_entry: u64,
    e_phoff: u64,
    e_shoff: u64,
    e_flags: u32,
    e_ehsize: u16,
    e_phentsize: u16,
    e_phnum: u16,
    e_shentsize: u16,
    e_shnum: u16,
    e_shstrndx: u16,
}

#[repr(C)]
struct _Elf64Phdr {
    p_type: u32,
    p_flags: u32,
    p_offset: u64,
    p_vaddr: u64,
    p_paddr: u64,
    p_filesz: u64,
    p_memsz: u64,
    p_align: u64,
}

#[repr(C)]
struct _Elf64Shdr {
    sh_name: u32,
    sh_type: u32,
    sh_flags: u64,
    sh_addr: u64,
    sh_offset: u64,
    sh_size: u64,
    sh_link: u32,
    sh_info: u32,
    sh_addralign: u64,
    sh_entsize: u64,
}

/// Loader configuration
pub struct LoaderConfig {
    pub script_section: &'static str,
    pub compression: CompressionType,
}

#[derive(Debug, Clone, Copy)]
pub enum CompressionType {
    Zstd,
    Gzip,
    None,
}

impl Default for LoaderConfig {
    fn default() -> Self {
        Self {
            script_section: ".rash_script",
            compression: CompressionType::Zstd,
        }
    }
}

/// Generate loader code for embedding in binary
pub fn generate_loader_code(config: &LoaderConfig) -> String {
    format!(
        r#"
// Auto-generated loader stub
#[no_mangle]
#[link_section = ".rash_loader"]
pub unsafe extern "C" fn _rash_start() -> ! {{
    // Find and execute embedded script
    let script_data = find_section(b"{}\0");
    let decompressed = decompress(script_data, CompressionType::{:?});
    execute_script(decompressed);
}}
"#,
        config.script_section, config.compression
    )
}

/// Simple zstd decompression for no_std environments
pub fn decompress_zstd_minimal(_compressed: &[u8], _output: &mut [u8]) -> usize {
    // This would be implemented with a minimal zstd decoder
    // For now, return 0 to indicate not implemented
    0
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_loader_config_default() {
        let config = LoaderConfig::default();
        assert_eq!(config.script_section, ".rash_script");
        matches!(config.compression, CompressionType::Zstd);
    }

    #[test]
    fn test_generate_loader_code() {
        let config = LoaderConfig::default();
        let code = generate_loader_code(&config);
        assert!(code.contains("_rash_start"));
        assert!(code.contains(".rash_script"));
    }
}