Add Classified Brief 0x02 and remove hardcoded toolchains

0x0014a_cb/src/crypto.c

@@ -0,0 +1,27 @@
+/**
+ * @file crypto.c
+ * @brief Lightweight rolling cipher implementation for Operation Zero Hour ESA
+ * @author Kevin Thomas
+ * @date 2026
+ *
+ * MIT License
+ * Copyright (c) 2026 Kevin Thomas
+ */
+
+#include "crypto.h"
+
+static const uint8_t CIPHERTEXT[TOKEN_LEN] = {
+    0x07, 0x03, 0x03, 0x12, 0x07, 0x7F, 0x70, 0x7A
+};
+
+static const uint8_t CIPHER_KEY[4] = {
+    0x54, 0x41, 0x43, 0x54
+};
+
+void decrypt_auth_token(uint8_t *dest) {
+    volatile const uint8_t *src = CIPHERTEXT;
+    volatile const uint8_t *key = CIPHER_KEY;
+    for (size_t i = 0; i < TOKEN_LEN; i++) {
+        dest[i] = src[i] ^ (key[i % 4] + (uint8_t)i);
+    }
+}

0x0014a_cb/src/gpio_ctrl.c

@@ -0,0 +1,50 @@
+/**
+ * @file gpio_ctrl.c
+ * @brief GPIO hardware control implementation for Operation Zero Hour ESA
+ * @author Kevin Thomas
+ * @date 2026
+ *
+ * MIT License
+ * Copyright (c) 2026 Kevin Thomas
+ */
+
+#include "gpio_ctrl.h"
+#include "pico/stdlib.h"
+
+static void init_led_pins(void) {
+    gpio_init(LED_RED_PIN);
+    gpio_set_dir(LED_RED_PIN, GPIO_OUT);
+    gpio_init(LED_GREEN_PIN);
+    gpio_set_dir(LED_GREEN_PIN, GPIO_OUT);
+}
+
+static void init_tamper_pin(void) {
+    gpio_init(TAMPER_WIRE_PIN);
+    gpio_set_dir(TAMPER_WIRE_PIN, GPIO_IN);
+    gpio_pull_down(TAMPER_WIRE_PIN);
+}
+
+void init_gpio(void) {
+    init_led_pins();
+    init_tamper_pin();
+    set_led_armed();
+}
+
+void set_led_armed(void) {
+    gpio_put(LED_RED_PIN, 1);
+    gpio_put(LED_GREEN_PIN, 0);
+}
+
+void set_led_safe(void) {
+    gpio_put(LED_RED_PIN, 0);
+    gpio_put(LED_GREEN_PIN, 1);
+}
+
+void set_led_tamper_flash(bool state) {
+    gpio_put(LED_RED_PIN, state ? 1 : 0);
+    gpio_put(LED_GREEN_PIN, 0);
+}
+
+bool is_tamper_wire_intact(void) {
+    return gpio_get(TAMPER_WIRE_PIN);
+}

0x0014a_cb/src/lora.c

@@ -0,0 +1,113 @@
+// MIT License
+//
+// Copyright (c) 2026 Kevin Thomas
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// Author:  Kevin Thomas
+// Email:   kevin@mytechnotalent.com
+// GitHub:  https://github.com/mytechnotalent
+// File:    lora.c
+// Desc:    Implements UART1 driver for REYAX RYLR998 LoRa transceiver.
+// Created: 2026
+
+#include "lora.h"
+#include "hardware/gpio.h"
+#include "pico/stdlib.h"
+#include <stdio.h>
+#include <string.h>
+
+static void drain_lora_rx(void) {
+    while (uart_is_readable(LORA_UART)) {
+        (void)uart_getc(LORA_UART);
+    }
+}
+
+static void send_at_cmd(const char *cmd) {
+    uart_write_blocking(LORA_UART, (const uint8_t *)cmd, strlen(cmd));
+    sleep_ms(200);
+    drain_lora_rx();
+}
+
+static void configure_lora_rf(void) {
+    sleep_ms(1500);
+    send_at_cmd("AT\r\n");
+    send_at_cmd("AT+NETWORKID=18\r\n");
+    send_at_cmd("AT+BAND=915000000\r\n");
+    send_at_cmd("AT+PARAMETER=9,7,1,12\r\n");
+    send_at_cmd("AT+ADDRESS=2\r\n");
+}
+
+void init_lora(void) {
+    uart_init(LORA_UART, LORA_BAUD);
+    uart_set_translate_crlf(LORA_UART, false);
+    gpio_set_function(LORA_TX_PIN, GPIO_FUNC_UART);
+    gpio_set_function(LORA_RX_PIN, GPIO_FUNC_UART);
+    configure_lora_rf();
+}
+
+void lora_send(const char *msg) {
+    char cmd[128];
+    int len = (int)strlen(msg);
+    snprintf(cmd, sizeof(cmd), "AT+SEND=0,%d,%s\r\n", len, msg);
+    uart_write_blocking(LORA_UART, (const uint8_t *)cmd, strlen(cmd));
+}
+
+static bool extract_rcv_data(char *line, char *out, size_t max_len) {
+    char *c1 = strchr(line, ',');
+    if (!c1) return false;
+    char *c2 = strchr(c1 + 1, ',');
+    if (!c2) return false;
+    char *c3 = strchr(c2 + 1, ',');
+    if (c3) *c3 = '\0';
+    snprintf(out, max_len, "%s", c2 + 1);
+    return true;
+}
+
+static bool parse_line(char *line, char *out, size_t max_len) {
+    if (strstr(line, "+RCV="))
+        return extract_rcv_data(line, out, max_len);
+    if (strncmp(line, "+", 1) != 0 && strncmp(line, "OK", 2) != 0) {
+        snprintf(out, max_len, "%s", line);
+        return true;
+    }
+    return false;
+}
+
+static bool process_rx_byte(char c, char *buf, size_t *idx, char *out, size_t max_len) {
+    if (c == '\r' || c == '\n') {
+        buf[*idx] = '\0';
+        bool ok = (*idx > 0) && parse_line(buf, out, max_len);
+        *idx = 0;
+        return ok;
+    }
+    if (*idx < 127) buf[(*idx)++] = c;
+    return false;
+}
+
+bool lora_poll_packet(char *payload_out, size_t max_len) {
+    static char buf[128];
+    static size_t idx = 0;
+    while (uart_is_readable(LORA_UART)) {
+        char c = (char)uart_getc(LORA_UART);
+        if (process_rx_byte(c, buf, &idx, payload_out, max_len))
+            return true;
+    }
+    return false;
+}

0x0014a_cb/src/main.c

@@ -0,0 +1,32 @@
+/**
+ * @file main.c
+ * @brief Operation Zero Hour - Electronic Safe-and-Arm (ESA) Firmware
+ * @author Kevin Thomas
+ * @date 2026
+ *
+ * MIT License
+ * Copyright (c) 2026 Kevin Thomas
+ */
+
+#include "pico/stdlib.h"
+#include "gpio_ctrl.h"
+#include "safe_arm.h"
+
+static void init_system(void) {
+    stdio_init_all();
+    init_gpio();
+    init_safe_arm_controller();
+}
+
+static void run_event_loop(void) {
+    while (true) {
+        process_safe_arm_tick();
+        sleep_ms(100);
+    }
+}
+
+int main(void) {
+    init_system();
+    run_event_loop();
+    return 0;
+}

0x0014a_cb/src/safe_arm.c

@@ -0,0 +1,91 @@
+/**
+ * @file safe_arm.c
+ * @brief Electronic Safe-and-Arm (ESA) controller implementation
+ * @author Kevin Thomas
+ * @date 2026
+ *
+ * MIT License
+ * Copyright (c) 2026 Kevin Thomas
+ */
+
+#include "safe_arm.h"
+#include "crypto.h"
+#include "gpio_ctrl.h"
+#include "lora.h"
+#include <stdio.h>
+#include <string.h>
+
+static uint8_t s_disarm_token[TOKEN_LEN + 1];
+
+static void print_banner_armed(void) {
+    printf("\r\n+-----------------------------------------------------------------+\r\n");
+    printf("|               OPERATION ZERO HOUR // ESA CONTROLLER             |\r\n");
+    printf("| STATUS: WARHEAD ARMED      [GP16 RED: ON]   LORA RECEIVER: LIVE |\r\n");
+    printf("+-----------------------------------------------------------------+\r\n");
+}
+
+static void print_banner_safe(const uint8_t *token) {
+    printf("\r\n+-----------------------------------------------------------------+\r\n");
+    printf("| WARHEAD DISARMED // SAFE                   [GP17 GREEN: ON]     |\r\n");
+    printf("| RECOVERED TOKEN: %-8.8s // FUZE NEUTRALIZED                   |\r\n", token);
+    printf("+-----------------------------------------------------------------+\r\n");
+}
+
+static void print_banner_trip(void) {
+    printf("\r\n+-----------------------------------------------------------------+\r\n");
+    printf("| TAMPER DETONATION TRIP                     [GP16 RED: FLASH]    |\r\n");
+    printf("| STATUS: COMMAND DETONATION ACTIVATED // EXPLOSIVE TRAIN ENGAGED |\r\n");
+    printf("+-----------------------------------------------------------------+\r\n");
+}
+
+static void eval_command(const char *cmd, uint8_t *state, uint8_t *faults) {
+    if (strncmp(cmd, (const char *)s_disarm_token, TOKEN_LEN) == 0) {
+        *state = STATE_WARHEAD_SAFE;
+        lora_send("WARHEAD DISARMED // SAFE");
+        print_banner_safe(s_disarm_token);
+    } else {
+        (*faults)++;
+    }
+}
+
+static void check_tamper(uint8_t faults, uint8_t *state) {
+    if (*state == STATE_WARHEAD_ARMED && (faults >= 3 || !is_tamper_wire_intact())) {
+        *state = STATE_TAMPER_TRIP;
+        print_banner_trip();
+    }
+}
+
+static void handle_packet(bool has_pkt, const char *pkt, uint8_t *state, uint8_t *faults) {
+    if (has_pkt && *state != STATE_WARHEAD_SAFE) {
+        eval_command(pkt, state, faults);
+        check_tamper(*faults, state);
+    }
+}
+
+static void update_feedback(uint8_t state, uint32_t tick_idx) {
+    if (state == STATE_WARHEAD_SAFE) {
+        set_led_safe();
+    } else if (state == STATE_TAMPER_TRIP) {
+        set_led_tamper_flash((tick_idx % 2) == 0);
+    } else {
+        set_led_armed();
+    }
+}
+
+void process_safe_arm_tick(void) {
+    static uint8_t warhead_state = STATE_WARHEAD_ARMED;
+    static uint8_t tamper_faults = 0;
+    static uint32_t loop_ticks = 0;
+    char rx_pkt[64] = {0};
+    bool has_pkt = lora_poll_packet(rx_pkt, sizeof(rx_pkt));
+    handle_packet(has_pkt, rx_pkt, &warhead_state, &tamper_faults);
+    check_tamper(tamper_faults, &warhead_state);
+    update_feedback(warhead_state, loop_ticks++);
+}
+
+void init_safe_arm_controller(void) {
+    decrypt_auth_token(s_disarm_token);
+    s_disarm_token[TOKEN_LEN] = '\0';
+    init_lora();
+    print_banner_armed();
+}