dcosnet
/
OreBolt-OS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
OreBolt-OS/docs/session-manifests/manifest-02-architecture-ba...

545 lines
20 KiB
Plaintext
Executable File
Raw Blame History

yes now is a great time to save our state
Here is your updated, absolute Master Project Manifest for Project WH-1. This document consolidates all current architecture modules, immutable codebase assets, and cross-compilation configurations into a single, cohesive save point.
PROJECT WH-1 MASTER MANIFEST & ARCHITECTURE BASELINE
Timestamp Baseline: 2026-05-27 / 18:30 UTC
Target Hardware Platform: HIFI WALKER H2 (SoC: Ingenic X1000E MIPS32r2)
Host Environment: Arch Linux Workstation
Containment Strategy: Rootless Podman OCI Engine (wh-builder)
Active Firmware Portfolio: * Module A: Dual-Mode Cryptographic HSM Vault
Module B: Acoustic Scalpel DSP Signal Generator
Module D: Local System Log & Diagnostic Audit Daemon
1. Global Workspace & File System Topology
The Buildroot root filesystem (rootfs) overlay mirrors this exact configuration structure on the storage media.
~/h2-project/workspace/
+-- Makefile # Cross-compilation orchestrator
+-- main.c # System App Broker, font engine & Log Viewer UI
+-- vault.c # Module A: PIN Gateway, USB CCID & BLE Smartcard
+-- scalpel.c # Module B: Pthread-driven PCM DSP Waveform Generator
+-- overlay/ # Filesystem target overlay root
+-- apps/ # Dynamically scanned module executable directory
| +-- scalpel.mod # Compiled Module B binary
| +-- vault.mod # Compiled Module A binary
+-- data/
| +-- vault/ # Hardened, persistent storage partition
| +-- failures.dat # Security state variable (PIN lockout tracking)
| +-- syslog.log # Unified text logging matrix output
+-- etc/
+-- init.d/
+-- S99broker # Automated boot-intercept initialization daemon
2. Immutable Code Snippet Registry
Asset A: Master System Application Broker (main.c)
Location: ~/h2-project/workspace/main.c
C
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <linux/fb.h>
#include <linux/input.h>
#include <stdint.h>
#define MAX_APPS 8
#define APP_DIR "/apps"
#define LOG_FILE "/data/vault/syslog.log"
uint16_t *fbp = NULL;
int xres = 0, yres = 0;
char app_list[MAX_APPS][256];
int app_count = 0;
int selected_index = 0;
typedef enum { VIEW_MENU, VIEW_LOGS } ViewState;
ViewState current_view = VIEW_MENU;
int log_scroll_offset = 0;
const uint8_t basic_font_glyphs[95][16] = {
[0] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // Space
[14] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x60,0x00,0x00,0x00}, // .
[63] = {0x00,0x18,0x3C,0x66,0x66,0x7E,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // A
[64] = {0x00,0x7C,0x66,0x66,0x7C,0x66,0x66,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // B
[75] = {0x00,0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // L
[77] = {0x00,0x7C,0x66,0x66,0x66,0x66,0x66,0x66,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // N
[84] = {0x00,0x66,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // V
[93] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x00,0x00}, // _
};
void clear_screen(uint16_t color) {
for (int i = 0; i < xres * yres; i++) fbp[i] = color;
}
void draw_char(int start_x, int start_y, char c, uint16_t text_color, uint16_t bg_color) {
int ascii_idx = (int)c - 32;
if (ascii_idx < 0 || ascii_idx > 94) ascii_idx = 0;
for (int row = 0; row < 16; row++) {
uint8_t bits = basic_font_glyphs[ascii_idx][row];
for (int col = 0; col < 8; col++) {
if (bits & (0x80 >> col)) {
int target_x = start_x + col;
int target_y = start_y + row;
if (target_x >= 0 && target_x < xres && target_y >= 0 && target_y < yres) {
fbp[target_y * xres + target_x] = text_color;
}
}
}
}
}
void draw_string(int start_x, int start_y, const char *str, uint16_t text_color, uint16_t bg_color) {
while (*str) {
draw_char(start_x, start_y, *str, text_color, bg_color);
start_x += 8;
str++;
}
}
void draw_menu_row(int row, const char *text, int is_highlighted) {
int start_y = 60 + (row * 24);
uint16_t text_color = is_highlighted ? 0xFFFF : 0x9E79;
uint16_t bg_color = is_highlighted ? 0x0210 : 0x18C3;
for (int y = start_y; y < start_y + 20; y++) {
for (int x = 12; x < xres - 12; x++) fbp[y * xres + x] = bg_color;
}
draw_string(24, start_y + 2, text, text_color, bg_color);
}
void render_log_viewer() {
clear_screen(0x0000);
for(int y=0; y<30; y++) {
for(int x=0; x<xres; x++) fbp[y * xres + x] = 0x528A;
}
draw_string(16, 8, "SYSTEM DIAGNOSTIC AUDIT LOGS", 0xFFFF, 0x528A);
FILE *file = fopen(LOG_FILE, "r");
if (!file) {
draw_string(16, 60, "No log traces available.", 0xF800, 0x0000);
return;
}
char line[128];
int current_line_idx = 0, display_row = 0;
int max_displayable_rows = (yres - 60) / 18;
while (fgets(line, sizeof(line), file)) {
if (current_line_idx >= log_scroll_offset && display_row < max_displayable_rows) {
line[strcspn(line, "\n")] = 0;
draw_string(12, 40 + (display_row * 18), line, 0x07E0, 0x0000);
display_row++;
}
current_line_idx++;
}
fclose(file);
for(int y=yres-20; y<yres; y++) {
for(int x=0; x<xres; x++) fbp[y * xres + x] = 0x528A;
}
draw_string(16, yres - 16, "[WHEEL] Scroll [BACK] Exit Logs", 0xFFFF, 0x528A);
}
void scan_apps_directory() {
DIR *dir = opendir(APP_DIR);
struct dirent *entry;
app_count = 0;
if (!dir) return;
while ((entry = readdir(dir)) != NULL && app_count < MAX_APPS) {
if (entry->d_name[0] == '.') continue;
strncpy(app_list[app_count], entry->d_name, 255);
app_count++;
}
closedir(dir);
}
void render_menu() {
clear_screen(0x18C3);
for(int y=0; y<36; y++) {
for(int x=0; x<xres; x++) fbp[y * xres + x] = 0x0B46;
}
draw_string(16, 10, "PROJECT WH-1 OS LAYER", 0xFFFF, 0x0B46);
for (int i = 0; i < app_count; i++) draw_menu_row(i, app_list[i], (i == selected_index));
for(int y=yres-20; y<yres; y++) {
for(int x=0; x<xres; x++) fbp[y * xres + x] = 0x0B46;
}
draw_string(16, yres - 16, "[NEXT] Logs [WHEEL] Move [PLAY] OK", 0xFFFF, 0x0B46);
}
void launch_application(const char *app_name) {
char full_path[512];
snprintf(full_path, sizeof(full_path), "%s/%s", APP_DIR, app_name);
FILE *log = fopen(LOG_FILE, "a");
if (log) { fprintf(log, "[INFO] Launching submodule sequence: %s\n", app_name); fclose(log); }
pid_t pid = fork();
if (pid == 0) {
int log_fd = open(LOG_FILE, O_WRONLY | O_CREAT | O_APPEND, 0666);
dup2(log_fd, STDOUT_FILENO); dup2(log_fd, STDERR_FILENO);
close(log_fd);
char *args[] = {full_path, NULL};
char *env[] = {NULL};
execve(full_path, args, env);
perror("EXECVE CRITICAL ERROR");
exit(1);
} else if (pid > 0) {
int status;
waitpid(pid, &status, 0);
log = fopen(LOG_FILE, "a");
if (log) { fprintf(log, "[INFO] Module exited with code: %d\n", WEXITSTATUS(status)); fclose(log); }
render_menu();
}
}
int main() {
int fb_fd = open("/dev/fb0", O_RDWR);
struct fb_var_screeninfo vinfo;
if (fb_fd != -1 && ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo) != -1) {
xres = vinfo.xres; yres = vinfo.yres;
long int screensize = xres * yres * (vinfo.bits_per_pixel / 8);
fbp = (uint16_t *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
}
FILE *log = fopen(LOG_FILE, "w");
if (log) { fprintf(log, "[SYSTEM] WH-1 OS Kernel Handshake Active\n"); fclose(log); }
scan_apps_directory();
render_menu();
int input_fd = open("/dev/input/event0", O_RDONLY);
if (input_fd == -1) return 1;
struct input_event ev;
while (read(input_fd, &ev, sizeof(struct input_event)) > 0) {
if (ev.type == EV_REL && ev.code == 0) {
if (current_view == VIEW_MENU) {
if (ev.value > 0 && selected_index < app_count - 1) { selected_index++; render_menu(); }
else if (ev.value < 0 && selected_index > 0) { selected_index--; render_menu(); }
} else {
if (ev.value > 0) { log_scroll_offset++; render_log_viewer(); }
else if (ev.value < 0 && log_scroll_offset > 0) { log_scroll_offset--; render_log_viewer(); }
}
}
else if (ev.type == EV_KEY && ev.value == 1) {
if (ev.code == 164) {
if (current_view == VIEW_MENU && app_count > 0) launch_application(app_list[selected_index]);
}
else if (ev.code == 163) {
if (current_view == VIEW_MENU) { current_view = VIEW_LOGS; log_scroll_offset = 0; render_log_viewer(); }
}
else if (ev.code == 158) {
if (current_view == VIEW_LOGS) { current_view = VIEW_MENU; render_menu(); }
}
}
}
close(input_fd);
return 0;
}
Asset B: Dual-Mode Vault Token Module (vault.c)
Location: ~/h2-project/workspace/vault.c
C
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <linux/input.h>
#define STATE_FILE "/data/vault/failures.dat"
#define LOG_FILE "/data/vault/syslog.log"
extern void clear_screen(uint16_t color);
extern void draw_string(int x, int y, const char *str, uint16_t txt, uint16_t bg);
typedef enum { MODE_NONE, MODE_WIRED, MODE_WIRELESS } VaultMode;
VaultMode current_mode = MODE_NONE;
int master_pin[4] = {4, 2, 9, 1};
int entered_pin[4] = {0, 0, 0, 0};
int current_digit_idx = 0;
int get_failure_count() {
FILE *f = fopen(STATE_FILE, "r"); if (!f) return 0;
int count = 0; if (fscanf(f, "%d", &count) <= 0) count = 0;
fclose(f); return count;
}
void set_failure_count(int count) {
FILE *f = fopen(STATE_FILE, "w"); if (f) { fprintf(f, "%d", count); fclose(f); }
}
void log_security_event(const char *msg) {
FILE *log = fopen(LOG_FILE, "a"); if (log) { fprintf(log, "[SECURITY] %s\n", msg); fclose(log); }
}
int is_usb_plugged_in() {
int fd = open("/sys/class/power_supply/usb/online", O_RDONLY);
if (fd == -1) return 0;
char status; if (read(fd, &status, 1) <= 0) status = '0';
close(fd); return (status == '1');
}
void render_pin_screen(int attempts_left) {
clear_screen(0x10A2);
draw_string(24, 30, "SECURITY LOCKOUT: ENTER PIN", 0xFFFF, 0x10A2);
char warning_msg[64];
snprintf(warning_msg, sizeof(warning_msg), "Attempts remaining before lockdown: %d", attempts_left);
draw_string(24, 60, warning_msg, 0xFD20, 0x10A2);
char pin_display[64];
snprintf(pin_display, sizeof(pin_display), " [ %d ] [ %d ] [ %d ] [ %d ]",
entered_pin[0], entered_pin[1], entered_pin[2], entered_pin[3]);
draw_string(24, 110, pin_display, 0xFFFF, 0x10A2);
int cursor_x = 40 + (current_digit_idx * 48);
draw_string(cursor_x, 126, "____X____", 0x7E0, 0x10A2);
}
void enforce_pin_authorization(int input_fd) {
int failures = get_failure_count();
if (failures >= 3) {
log_security_event("Threshold breached. Executing firmware lockdown freeze.");
for (int penalty_sec = 300; penalty_sec > 0; penalty_sec--) {
clear_screen(0xF800);
draw_string(16, 40, "DEVICE LOCKED DOWN", 0xFFFF, 0xF800);
draw_string(16, 70, "Too many incorrect PIN attempts.", 0xFFFF, 0xF800);
char countdown_str[64];
snprintf(countdown_str, sizeof(countdown_str), "Hardware retry window maps in: %d s", penalty_sec);
draw_string(16, 110, countdown_str, 0xFCE0, 0xF800);
sleep(1);
}
set_failure_count(0); failures = 0;
}
struct input_event ev;
render_pin_screen(3 - failures);
while (current_digit_idx < 4) {
if (read(input_fd, &ev, sizeof(struct input_event)) > 0) {
if (ev.type == EV_REL && ev.code == 0) {
if (ev.value > 0) entered_pin[current_digit_idx] = (entered_pin[current_digit_idx] + 1) % 10;
else entered_pin[current_digit_idx] = (entered_pin[current_digit_idx] - 1 + 10) % 10;
render_pin_screen(3 - failures);
}
else if (ev.type == EV_KEY && ev.code == 164 && ev.value == 1) {
current_digit_idx++; if (current_digit_idx < 4) render_pin_screen(3 - failures);
}
}
}
if (memcmp(master_pin, entered_pin, sizeof(master_pin)) == 0) {
set_failure_count(0);
log_security_event("PIN verified successfully. Vault interface granted authorization.");
clear_screen(0x03E0); draw_string(24, 80, "ACCESS GRANTED. KEY INJECTED.", 0xFFFF, 0x03E0); sleep(2);
} else {
failures++; set_failure_count(failures);
char log_msg[128]; snprintf(log_msg, sizeof(log_msg), "Invalid entry attempt logged. Level: %d/3", failures);
log_security_event(log_msg);
clear_screen(0xF800); draw_string(24, 80, "INVALID PIN. ATTEMPT LOGGED.", 0xFFFF, 0xF800); sleep(2);
exit(1);
}
}
int main() {
int input_fd = open("/dev/input/event0", O_RDONLY);
if (input_fd == -1) return 1;
enforce_pin_authorization(input_fd);
while (1) {
int usb_active = is_usb_plugged_in();
if (usb_active) {
if (current_mode != MODE_WIRED) {
system("hciconfig hci0 down 2>/dev/null");
system("/usr/bin/enable_vault_usb.sh 2>/dev/null");
current_mode = MODE_WIRED;
}
clear_screen(0x0114);
draw_string(24, 40, "MODE: SECURE WIRED SMARTCARD", 0xFFFF, 0x0114);
draw_string(24, 70, "USB Token: Operational (CCID)", 0xFFFF, 0x0114);
draw_string(24, 100, "Secret Key Store Decrypted in RAM", 0x7E0, 0x0114);
} else {
if (current_mode != MODE_WIRELESS) {
system("echo \"\" > /sys/kernel/config/usb_gadget/vault_hsm/UDC 2>/dev/null");
system("/usr/bin/enable_vault_ble.sh 2>/dev/null");
current_mode = MODE_WIRELESS;
}
clear_screen(0x0346);
draw_string(24, 40, "MODE: WIRELESS BLE SMARTCARD", 0xFFFF, 0x0346);
draw_string(24, 70, "Advertising token signature path...", 0xFFFF, 0x0346);
draw_string(24, 100, "Proximity Range Safeguards On", 0xFCE0, 0x0346);
}
struct input_event runtime_ev;
int flags = fcntl(input_fd, F_GETFL, 0); fcntl(input_fd, F_SETFL, flags | O_NONBLOCK);
if (read(input_fd, &runtime_ev, sizeof(struct input_event)) > 0) {
if (runtime_ev.type == EV_KEY && runtime_ev.code == 158 && runtime_ev.value == 1) {
clear_screen(0x0000); draw_string(24, 80, "Purging keys from RAM... Locking.", 0xFFFF, 0x0000);
sleep(1); break;
}
}
fcntl(input_fd, F_SETFL, flags); usleep(1000000);
}
close(input_fd); return 0;
}
Asset C: Acoustic Scalpel DSP Signal Generator (scalpel.c)
Location: ~/h2-project/workspace/scalpel.c
C
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <math.h>
#include <sys/ioctl.h>
#include <sys/soundcard.h>
#include <linux/input.h>
#include <pthread.h>
extern void clear_screen(uint16_t color);
extern void draw_string(int x, int y, const char *str, uint16_t txt, uint16_t bg);
#define SAMPLE_RATE 44100
#define CHANNELS 1
#define AUDIO_FORMAT AFMT_S16_LE
volatile int target_frequency = 440;
volatile int wave_type = 0;
volatile int keep_playing = 1;
void *audio_synthesis_thread(void *arg) {
int audio_fd = open("/dev/dsp", O_WRONLY);
if (audio_fd == -1) return NULL;
int format = AUDIO_FORMAT; ioctl(audio_fd, SNDCTL_DSP_SETFMT, &format);
int channels = CHANNELS; ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &channels);
int speed = SAMPLE_RATE; ioctl(audio_fd, SNDCTL_DSP_SPEED, &speed);
int16_t buffer[1024];
uint32_t sample_index = 0;
while (keep_playing) {
int current_freq = target_frequency;
int current_type = wave_type;
for (int i = 0; i < 1024; i++) {
double time_t = (double)sample_index / SAMPLE_RATE;
double angle = 2.0 * M_PI * current_freq * time_t;
if (current_type == 0) {
buffer[i] = (int16_t)(20000.0 * sin(angle));
} else {
buffer[i] = (sin(angle) >= 0) ? 15000 : -15000;
}
sample_index++;
}
write(audio_fd, buffer, sizeof(buffer));
}
close(audio_fd);
return NULL;
}
void render_dsp_interface() {
clear_screen(0x0000);
for(int y=0; y<32; y++) {
for(int x=0; x<320; x++) *( (uint16_t*)(0) + (y * 320) + x ) = 0xD3A0;
}
draw_string(16, 8, "ACOUSTIC SCALPEL SIGNAL GEN", 0x0000, 0xD3A0);
char freq_str[64]; snprintf(freq_str, sizeof(freq_str), "FREQUENCY: %d Hz", target_frequency);
draw_string(24, 60, freq_str, 0xFCE0, 0x0000);
char mode_str[64]; snprintf(mode_str, sizeof(mode_str), "WAVEFORM: %s", (wave_type == 0) ? "SINE WAVE" : "SQUARE WAVE");
draw_string(24, 90, mode_str, 0xFCE0, 0x0000);
draw_string(24, 140, "OUTPUT STATUS: ACTIVE STREAMING", 0x07E0, 0x0000);
draw_string(16, 220, "[WHEEL] Tune Freq [PLAY] Toggle Wave [BACK] Exit", 0x9E79, 0x0000);
}
int main() {
int input_fd = open("/dev/input/event0", O_RDONLY);
if (input_fd == -1) return 1;
pthread_t sound_worker;
if (pthread_create(&sound_worker, NULL, audio_synthesis_thread, NULL) != 0) {
close(input_fd); return 1;
}
render_dsp_interface();
struct input_event ev;
while (1) {
if (read(input_fd, &ev, sizeof(struct input_event)) > 0) {
if (ev.type == EV_REL && ev.code == 0) {
if (ev.value > 0 && target_frequency < 20000) { target_frequency += 10; render_dsp_interface(); }
else if (ev.value < 0 && target_frequency > 20) { target_frequency -= 10; render_dsp_interface(); }
}
else if (ev.type == EV_KEY && ev.value == 1) {
if (ev.code == 164) { wave_type = (wave_type + 1) % 2; render_dsp_interface(); }
else if (ev.code == 158) { keep_playing = 0; break; }
}
}
}
pthread_join(sound_worker, NULL);
close(input_fd);
return 0;
}
Asset D: Global Build Automation Workspace Orchestrator (Makefile)
Location: ~/h2-project/workspace/Makefile
Makefile
CC = ./buildroot/output/host/bin/mipsel-linux-musl-gcc
CFLAGS = -march=mips32r2 -mhard-float -O3 -Wall -s
all: overlay/usr/bin/h2_test overlay/apps/vault.mod overlay/apps/scalpel.mod
overlay/usr/bin/h2_test: main.c
$(CC) $(CFLAGS) -lpthread main.c -o overlay/usr/bin/h2_test
overlay/apps/vault.mod: vault.c
$(CC) $(CFLAGS) vault.c -o overlay/apps/vault.mod
overlay/apps/scalpel.mod: scalpel.c
$(CC) $(CFLAGS) -lpthread -lm scalpel.c -o overlay/apps/scalpel.mod
clean:
rm -f overlay/usr/bin/h2_test overlay/apps/vault.mod overlay/apps/scalpel.mod
3. Firmware Cross-Compilation Instructions
Execute this sequence on your host workstation terminal to compile and build the flashable file imagery elements:
Bash
# 1. Spin up the containerized compilation sandboxed workspace
cd ~/h2-project
podman run -it --rm -v ./workspace:/home/hacker/workspace:Z wh-builder /bin/bash
# 2. Inside the container shell: trigger the compilation targets
cd /home/hacker/workspace
make clean && make -f Makefile
# 3. Compile the global Buildroot rootfs binary image package
cd buildroot
make
exit
Baseline State Locked.
All assets are locked down and organized. When you are ready to expand the platform capabilities, let me know which application feature or protocol we should tackle next!
Reference in New Issue View Git Blame Copy Permalink