Add json content files
This commit is contained in:
parent
389c7abe96
commit
dab169a51e
7 changed files with 917 additions and 0 deletions
136
content/brawl.json
Normal file
136
content/brawl.json
Normal file
|
|
@ -0,0 +1,136 @@
|
||||||
|
{
|
||||||
|
"id": "brawl",
|
||||||
|
"url": "/brawl/",
|
||||||
|
"blocks": [
|
||||||
|
{
|
||||||
|
"block_id": "brawl",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "hero",
|
||||||
|
"level": 1,
|
||||||
|
"title": "Brawl"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#overview",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "A WebAssembly Runtime for Portable, Updatable IoT Applications",
|
||||||
|
"text": "BRAWL is RIoT Secure’s lightweight WebAssembly (WASM) runtime designed specifically for resource-constrained IoT devices. Built on open standards such as WebAssembly and WASI, BRAWL enables developers to write portable, device-agnostic application logic that can be securely deployed, updated, and executed across heterogeneous hardware platforms. By adopting WebAssembly’s sandboxed binary format - the same technology powering modern browsers and cloud runtimes - BRAWL introduces a standardized execution layer for embedded systems. This allows application logic, AI-related workloads, and business rules to evolve independently of long-lived device firmware, dramatically simplifying lifecycle management in the field.",
|
||||||
|
"emphasis": [
|
||||||
|
"BRAWL",
|
||||||
|
"WebAssembly (WASM)",
|
||||||
|
"dramatically simplifying lifecycle management"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#wasm-runtime",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "callout",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "BRAWL runs WASM bytecode, delivered via RIoT Secure's management platform. This lets you leverage standard tooling (wasm-opt, language compilers, debuggers), for microcontroller firmware development.",
|
||||||
|
"emphasis": []
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#portable",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Write Once, Run Anywhere - Now for IoT",
|
||||||
|
"text": "In traditional embedded development, identical application logic must be recompiled and redeployed separately for each target architecture, resulting in widely varying firmware sizes and complex validation processes. BRAWL changes this model by standardizing application logic into WebAssembly bytecode.",
|
||||||
|
"emphasis": ["recompiled and redeployed separately", "BRAWL"]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#firmware-sketch",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"src": "images/brawl-sketch-sizes.png",
|
||||||
|
"alt": "Diagram showing the Arduino Sketch and compiled native sizes"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#firmware-size-explained",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "Despite identical logic, firmware sizes vary dramatically. When compiled to WebAssembly and executed within the BRAWL runtime, the same application logic results in a 256-byte WASM module, deployable across all targets - independent of CPU architecture. This consistency reduces bandwidth usage, simplifies validation, and enables reliable firmware-over-the-air (FOTA) updates even over narrowband networks.\n\nWebAssembly: → [`Blink.wat`](Blink.wat.txt). Using `wat2wasm` the resulting [`Blink.wasm`](Blink.wasm) file produced is a miniscule 256 bytes!",
|
||||||
|
"emphasis": ["firmware sizes vary dramatically", "BRAWL"]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#wasm-interpreter-visual",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 2,
|
||||||
|
"title": null,
|
||||||
|
"src": "images/brawl-translation.png",
|
||||||
|
"alt": "Diagram showing the BRAWL translation process from source to WebAssembly"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#designed-for-constrained",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Designed for Constrained Devices - Without Compromise",
|
||||||
|
"text": "BRAWL is purpose-built for embedded systems, delivering a secure, sandboxed runtime with near-native performance through optimized native bindings. The runtime provides controlled access to essential device functionality while preserving isolation and predictability. BRAWL is purpose-built for IoT, bringing the power of WebAssembly directly to microcontrollers. It delivers a secure, sandboxed runtime with lightweight execution, offering built-in bindings for essential peripherals like GPIO, I2C, SPI, UART and 1-Wire, while safely extending to native functions when needed. By adopting WebAssembly’s standardized instruction set, BRAWL ensures portability and predictability across devices.",
|
||||||
|
"emphasis": ["BRAWL", "BRAWL"]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#wasi-api",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 4,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "WASM System Interface Definitions:\n\n- [`brawl/device.gpio`](/brawl?api=brawl.device.gpio)\n- [`brawl/device.i2c`](/brawl?api=brawl.device.i2c)\n- [`brawl/device.onewire`](/brawl?api=brawl.device.onewire)\n- [`brawl/device.spi`](/brawl?api=brawl.device.spi)\n- [`brawl/device.uart`](/brawl?api=brawl.device.uart)\n- [`brawl/device.matrix`](/brawl?api=brawl.device.matrix)",
|
||||||
|
"emphasis": ["WASM System Interface Definitions"]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#enable-ai",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Enabling AI and Intelligent Edge Workloads",
|
||||||
|
"text": "As AI and advanced data processing move closer to the edge, application logic and models evolve far more rapidly than underlying device firmware. **BRAWL** provides a natural execution layer for these fast-moving workloads, enabling AI-related logic to be delivered as compact, updatable WebAssembly modules. Combined with RIoT Secure’s lifecycle management platform, this allows organizations to:\n\n- Update application logic and AI workflows without touching base firmware\n- Reduce deployment risk through smaller, verifiable updates\n- Maintain long-lived devices while continuously improving functionality\n\nThis decoupling is critical for operating intelligent IoT systems at scale.",
|
||||||
|
"emphasis": []
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#secure-delivery",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Secure Delivery and Lifecycle Integration",
|
||||||
|
"text": "BRAWL is tightly integrated with the RIoT Secure Platform. WebAssembly modules are securely delivered and managed through OASIS, using µTLS for efficient, encrypted communication. This ensures that every deployed module is authenticated, versioned, and traceable throughout its lifecycle. For environments where a dedicated application microcontroller is preferred, BRAWL complements - and can replace - FUSION, offering a software-defined alternative to hardware sandboxing while retaining the same lifecycle governance model.",
|
||||||
|
"emphasis": ["BRAWL", "OASIS", "µTLS", "FUSION"]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#future-iot",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Built for the Future of IoT",
|
||||||
|
"text": "As the WebAssembly ecosystem continues to evolve, BRAWL is designed to take advantage of emerging standards such as WASI, WASI-IoT, and next-generation cryptographic extensions. This positions BRAWL as a future-ready execution environment capable of spanning microcontrollers at the edge, simulation environments, and even digital twins in the cloud. Just as Java and .NET standardized application development for servers and desktops, WebAssembly is standardizing execution across the web and cloud. BRAWL brings that same level of portability, safety, and predictability to IoT - enabling a single execution model from prototype to production, and from device to cloud.",
|
||||||
|
"emphasis": ["BRAWL"]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "brawl#footnote",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "footnote",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "BRAWL - portable execution for intelligent IoT, built on WebAssembly and designed for lifecycle management at scale.",
|
||||||
|
"emphasis": []
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
158
content/fusion.json
Normal file
158
content/fusion.json
Normal file
|
|
@ -0,0 +1,158 @@
|
||||||
|
{
|
||||||
|
"id": "fusion",
|
||||||
|
"url": "/fusion/",
|
||||||
|
"blocks": [
|
||||||
|
{
|
||||||
|
"block_id": "fusion",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "hero",
|
||||||
|
"level": 1,
|
||||||
|
"title": "Fusion"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#overview",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Hardware Sandbox for Deterministic, Developer-Owned Execution",
|
||||||
|
"text": "FUSION is RIoT Secure's hardware sandbox architecture, designed to give device developers full, unrestricted control over their own execution environment, while preserving secure communication and lifecycle management through an independent system component. At its core, FUSION enables a strict separation of concerns by dedicating a microcontroller exclusively to the customer’s application logic. This dedicated microcontroller is fully owned and controlled by the developer or device manufacturer - free from interference, shared resources, or runtime constraints imposed by the communication and lifecycle management stack.",
|
||||||
|
"emphasis": [
|
||||||
|
"FUSION",
|
||||||
|
"full, unrestricted control over their own execution environment",
|
||||||
|
"strict separation of concerns"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#seperation-of-concerns",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "True Hardware Separation - Not Time Slicing"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#architecture",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Custom Hardware - Lifecycle Management and Security Guaranteed",
|
||||||
|
"src": "images/fusion-overview.png",
|
||||||
|
"alt": "Diagram of lifecycle-first hardware architecture with separated application and security/communication domains"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#sandbox",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "Unlike software-based sandboxes or shared-runtime approaches, FUSION enforces isolation at the hardware level. Customer applications run on their own microcontroller, with guaranteed access to CPU, memory, peripherals, and real-time scheduling - entirely independent of the RIoT Secure client. This means:\n\n- No competition for CPU cycles\n- No shared memory or runtime contention\n- No impact on real-time behavior\n- No restrictions on programming models or toolchains\n\nDevelopers are free to use any programming language, framework, RTOS, or bare-metal approach that best suits their application - from hard real-time control loops to advanced signal processing or AI acceleration.",
|
||||||
|
"emphasis": [
|
||||||
|
"FUSION",
|
||||||
|
"hardware level",
|
||||||
|
"any programming language, framework, RTOS, or bare-metal approach"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#independent-communication",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Independent Communication & Lifecycle Control",
|
||||||
|
"text": "FUSION ensures the customer application runs independently, the RIoT Secure client executes on a separate communication module or microcontroller. This component is responsible for secure communication, provisioning, identity, and lifecycle operations - and operates entirely independently of the customer’s execution environment. This architectural split ensures that:\n\n- Communication and security updates never interfere with application timing\n- Lifecycle management can evolve without impacting customer firmware\n- Application failures cannot compromise device identity or connectivity\n\nThe result is a robust system where long-lived device control and fast-evolving application logic coexist safely, without forcing trade-offs between security and determinism.",
|
||||||
|
"emphasis": [
|
||||||
|
"FUSION",
|
||||||
|
"entirely independently",
|
||||||
|
"long-lived device control and fast-evolving application logic coexist safely"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#real-world",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Designed for Real-World Embedded Systems",
|
||||||
|
"text": "FUSION is purpose-built for real-world embedded deployments where determinism, reliability, and long-term maintainability are non-negotiable. By isolating responsibilities across dedicated hardware components, FUSION avoids the complexity and fragility often introduced by monolithic firmware designs. This approach is particularly valuable in environments that require:\n\n- Hard real-time guarantees\n- Safety- or mission-critical behavior\n- Long operational lifetimes\n- Heterogeneous hardware and peripherals\n\nFUSION allows device makers to evolve communication stacks, security mechanisms, and lifecycle features independently — without requiring invasive changes to application firmware.",
|
||||||
|
"emphasis": [
|
||||||
|
"FUSION"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#foundation",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "A Foundation for Scalable Lifecycle Management",
|
||||||
|
"text": "Within the RIoT Secure Platform, FUSION acts as the hardware foundation for secure lifecycle management. It ensures that provisioning, updates, and fleet-wide operations can be performed reliably across large deployments, while preserving complete autonomy for customer applications. For teams that prefer a portable, software-defined execution model instead of a dedicated application microcontroller, FUSION can be complemented or replaced by BRAWL, RIoT Secure’s WebAssembly-based execution environment - without changing the surrounding lifecycle infrastructure.",
|
||||||
|
"emphasis": [
|
||||||
|
"FUSION",
|
||||||
|
"BRAWL",
|
||||||
|
"hardware foundation for secure lifecycle management"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#hardware",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Arduino Shield for Rapid Prototyping & Evaluation"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#hardware-shield",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Arduino Shield for Rapid Prototyping & Evaluation",
|
||||||
|
"src": "images/fusion-shield.png",
|
||||||
|
"alt": "RIoT Secure Arduino-compatible FUSION shield for prototyping"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#hardware-sheild-explained",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "To simplify evaluation and early development, RIoT Secure has created an Arduino-compatible FUSION shield that demonstrates the hardware sandbox architecture in a practical, hands-on form. The shield integrates a dedicated communication and lifecycle management microcontroller alongside an Arduino-compatible application processor, clearly illustrating the separation of concerns enforced by FUSION. Using the shield, developers can:\n\n- Prototype applications using familiar Arduino tools and workflows\n- Run application code on a fully independent microcontroller\n- Observe real-time behavior without interference from communication or security tasks\n- Evaluate secure communication, provisioning, and lifecycle management in a controlled environment\n\nImportantly, the Arduino shield is a reference platform, not a constraint. Production systems are free to use any microcontroller architecture, toolchain, or programming environment - from bare-metal C to RTOS-based designs - while retaining the same FUSION-based hardware separation.",
|
||||||
|
"emphasis": [
|
||||||
|
"FUSION",
|
||||||
|
"Arduino-compatible",
|
||||||
|
"shield",
|
||||||
|
"reference platform"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#hardware-uno-r4",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Native Support for Arduino UNO R4",
|
||||||
|
"text": "FUSION also supports platforms where the separation of concerns is already present at the hardware level. A notable example is the Arduino UNO R4, which integrates an ESP32-based communication subsystem alongside a Renesas Cortex-M4 application processor. On the Arduino UNO R4, FUSION can be deployed without an external shield, leveraging the existing dual-processor architecture to maintain the same separation between communication, security, and customer-controlled application logic. The ESP32 handles secure communication and lifecycle operations, while the Cortex-M4 remains fully dedicated to application execution, real-time behavior, and peripheral control.\n\nThis native support demonstrates that FUSION is not tied to a specific form factor or board design. Whether implemented using a reference Arduino shield or a modern dual-processor platform like the UNO R4, FUSION consistently enforces hardware-level isolation and predictable execution - from prototyping through to production.",
|
||||||
|
"emphasis": [
|
||||||
|
"FUSION",
|
||||||
|
"Arduino UNO R4",
|
||||||
|
"ESP32-based communication subsystem",
|
||||||
|
"Renesas Cortex-M4",
|
||||||
|
"without an external shield"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "fusion#footnote",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "footnote",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "FUSION - absolute control for developers, hardware-rooted isolation for security, and a clean foundation for long-term device lifecycle management.",
|
||||||
|
"emphasis": [ ]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
104
content/microTLS.json
Normal file
104
content/microTLS.json
Normal file
|
|
@ -0,0 +1,104 @@
|
||||||
|
{
|
||||||
|
"id": "microTLS",
|
||||||
|
"url": "/microTLS/",
|
||||||
|
"blocks": [
|
||||||
|
{
|
||||||
|
"block_id": "microTLS",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "hero",
|
||||||
|
"level": 1,
|
||||||
|
|
||||||
|
"title": "microTLS (µTLS)"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#overview",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Patented Lightweight Secure Communications for Constrained IoT Environments",
|
||||||
|
"text": "µTLS (microTLS) is RIoT Secure’s patented communication protocol, purpose-built to provide strong, end-to-end security for resource-constrained IoT devices without the overhead, complexity, or inefficiency of traditional TLS-based approaches. Designed specifically for microcontrollers and embedded environments, µTLS enables secure device communication even in scenarios where bandwidth, power, and memory are severely limited. Protected by US Patent 11,997,165 B2, µTLS represents original work in secure communication tailored to constrained systems. The protocol dramatically reduces communication overhead - by up to 95% compared to MQTT over TLS - while preserving cryptographic integrity, confidentiality, and trust throughout the device lifecycle.",
|
||||||
|
"emphasis": [ "µTLS", "strong, end-to-end security for resource-constrained IoT devices", "US Patent 11,997,165 B2" ]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#security",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Security Without Compromise",
|
||||||
|
"text": "µTLS handles the full complexity of secure communication on behalf of the device. From secure device identification and trust establishment, to key exchange, encryption, and continuous integrity verification, µTLS ensures that all data exchanged between devices and backend systems remains confidential, authenticated, and tamper-proof. While inspired by the principles of the Transport Layer Security (TLS) standard, µTLS is not a lightweight re-implementation of TLS. Instead, it rethinks secure communication from the ground up to meet the realities of embedded systems - eliminating unnecessary overhead while retaining strong security guarantees.",
|
||||||
|
"emphasis": [ "µTLS", "not a lightweight re-implementation of TLS" ]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#token",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "µTLS Token Exchange",
|
||||||
|
"src": "images/microTLS-workflow.png",
|
||||||
|
"alt": "Diagram showing µTLS token exchange."
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#constrained",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Designed for Constrained Environments",
|
||||||
|
"text": "Traditional security protocols often assume ample memory, processing power, and stable network conditions - assumptions that rarely hold true in real-world IoT deployments. µTLS is explicitly designed to operate within the tight constraints of microcontrollers, making secure communication viable even on low-power, low-bandwidth devices. Well-known cryptographic algorithms have been carefully adapted and optimized to minimize code size and memory footprint. Developers can select the algorithms best suited to their target hardware, and additional algorithms can be added modularly as requirements evolve - extending device lifetimes without sacrificing security.",
|
||||||
|
"emphasis": [ "µTLS" ]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#transport",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Transport-Agnostic by Design",
|
||||||
|
"text": "µTLS operates independently of the underlying transport, enabling secure communication across any bi-directional data stream. This includes, but is not limited to TCP/IP, Serial (RS323, TTL), 6LoWPAN, Zigbee, BLE (Bluetooth Low Energy), RF and proprietary radio links. This flexibility allows µTLS to secure communication not only between devices and cloud services, but also within sensor meshes and gateway-based topologies - ensuring consistent security across heterogeneous networks.",
|
||||||
|
"emphasis": [ "µTLS", "any bi-directional data stream" ]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#topology",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "µTLS Network Topologies",
|
||||||
|
"src": "images/microTLS-topology.png",
|
||||||
|
"alt": "Diagram showing µTLS network topologies."
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#integration",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Built for Developers, Trusted for Production",
|
||||||
|
"text": "From a developer perspective, µTLS is intentionally simple to integrate. Familiar development patterns - such as those used in Arduino-based environments - allow developers to focus on application logic rather than cryptography or networking internals. Two clearly defined callbacks handle message creation and response processing, while µTLS manages the underlying security mechanisms transparently. In production, this simplicity translates into predictable behavior, reduced attack surface, and long-term maintainability - critical properties for devices expected to operate securely for many years in the field.",
|
||||||
|
"emphasis": [ "µTLS", "predictable behavior, reduced attack surface, and long-term maintainability" ]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#foundation",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "A Foundational Security Layer for Lifecycle Management",
|
||||||
|
"text": "Within the RIoT Secure Platform, µTLS serves as the foundational communication security layer, underpinning device provisioning, lifecycle operations, Over-the-Air (OTA) updates, and fleet management. Whether devices are running native firmware within a hardware sandbox or executing portable WebAssembly-based application logic, µTLS ensures that all communication remains secure, efficient, and verifiable throughout the device lifecycle.",
|
||||||
|
"emphasis": [ "µTLS", "foundational communication security layer" ]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "microTLS#footnote",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "footnote",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "µTLS - patented security, engineered for the realities of embedded IoT.",
|
||||||
|
"emphasis": [ ]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
163
content/oasis.json
Normal file
163
content/oasis.json
Normal file
|
|
@ -0,0 +1,163 @@
|
||||||
|
{
|
||||||
|
"id": "oasis",
|
||||||
|
"url": "/oasis/",
|
||||||
|
"blocks": [
|
||||||
|
{
|
||||||
|
"block_id": "oasis",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "hero",
|
||||||
|
"level": 1,
|
||||||
|
"title": "Oasis"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#control-plane",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Lifecycle Control Plane for Intelligent IoT Fleets",
|
||||||
|
"text": "OASIS is RIoT Secure’s lifecycle management and integration layer - the control plane where IoT fleets are provisioned, operated, updated, and governed over time. Designed as a Platform-as-a-Service, OASIS provides secure, end-to-end lifecycle management for deployed devices, from initial onboarding through active operation, updates, repurposing, and decommissioning. As IoT devices evolve into intelligent, software-defined systems - combining long-lived firmware with rapidly changing application logic and AI-enabled functionality - lifecycle management becomes a continuous operational concern. OASIS addresses this challenge by providing a centralized, secure, and scalable environment for managing device state, software versions, and fleet-wide operations across heterogeneous deployments.",
|
||||||
|
"emphasis": [
|
||||||
|
"OASIS",
|
||||||
|
"control plane where IoT fleets are provisioned, operated, updated, and governed over time"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#fleet-management",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Fleet Management Without Friction"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#fleet-management-visual",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Fleet Management Without Friction",
|
||||||
|
"src": "images/oasis-integration.png",
|
||||||
|
"alt": "OASIS integration diagram showing fleet management"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#fleet-management-explained",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "OASIS provides a comprehensive management console that gives operators immediate visibility into their IoT deployment. Devices can be monitored in real time, visualized geographically, and grouped according to deployment, function, or lifecycle state. Firmware versions, update campaigns, and device status can all be managed from a single interface - reducing operational overhead and eliminating the need for physical access to devices in the field. At the same time, OASIS is designed to stay out of the way. For organizations that already operate their own IoT dashboards, analytics platforms, or operational tools, OASIS does not force a new user experience or workflow.",
|
||||||
|
"emphasis": [
|
||||||
|
"OASIS",
|
||||||
|
"comprehensive management console",
|
||||||
|
"stay out of the way"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#api-first",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "API-First by Design - Management That Can Be Invisible",
|
||||||
|
"text": "At the core of OASIS is a complete, fully featured REST API that exposes all lifecycle management functionality. The OASIS web interface itself is built on top of this API, ensuring that every capability - from provisioning and configuration to firmware updates and lifecycle state management - can be integrated directly into existing systems. This API-first approach allows OASIS to operate as an embedded lifecycle engine within larger IoT platforms. Device manufacturers, system integrators, and AI solution providers can integrate RIoT Secure’s lifecycle management invisibly into their own products, maintaining a consistent end-user experience while relying on OASIS for secure device control behind the scenes.",
|
||||||
|
"emphasis": [
|
||||||
|
"OASIS",
|
||||||
|
"complete, fully featured REST API",
|
||||||
|
"embedded lifecycle engine"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#lifecycle",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Secure Firmware and Software Lifecycle Management"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#lifecycle-visual",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Secure Firmware and Software Lifecycle Management",
|
||||||
|
"src": "images/oasis-lifecycle.png",
|
||||||
|
"alt": "OASIS firmware and software lifecycle management diagram"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#firmware",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "Firmware remains the foundation of any IoT device, and managing its evolution securely is critical - especially as devices increasingly perform local processing, real-time decision-making, and AI-driven workloads at the edge. OASIS enables secure Over-the-Air (OTA) updates of device firmware, ensuring that devices remain up to date, resilient, and protected throughout their operational lifetime. By coordinating updates through the RIoT Secure platform, OASIS ensures that lifecycle operations are performed safely and predictably, even across large, geographically distributed fleets. This capability is important in environments where devices are difficult or costly to access, and where downtime or failed updates are unacceptable.",
|
||||||
|
"emphasis": [
|
||||||
|
"local processing, real-time decision-making, and AI-driven workloads at the edge",
|
||||||
|
"OASIS"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#integration",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Built for Integration and Scale",
|
||||||
|
"text": "OASIS is designed to coexist with existing IoT ecosystems rather than replace them. It integrates seamlessly with RIoT Secure’s communication layer (µTLS), hardware sandboxing (FUSION), and portable execution environments (BRAWL), while remaining agnostic to higher-level visualization, analytics, and business logic platforms. This modular approach allows organizations to adopt OASIS incrementally - using it as a standalone management console, a backend lifecycle service, or a deeply integrated component within a broader IoT solution.",
|
||||||
|
"emphasis": [
|
||||||
|
"OASIS",
|
||||||
|
"µTLS",
|
||||||
|
"FUSION",
|
||||||
|
"BRAWL",
|
||||||
|
"designed to coexist with existing IoT ecosystems rather than replace them",
|
||||||
|
"modular approach"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#real-world",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Proven in Real-World Deployments"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#real-world-visual",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Proven in Real-World Deployments: SAS Ground Service Handling at Stockholm Arlanda Airport, Sweden.",
|
||||||
|
"src": "images/oasis-map.png",
|
||||||
|
"alt": "OASIS management console map showing real-world deployment"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#real-world-proven",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Proven in Real-World Deployments",
|
||||||
|
"text": "OASIS has been used to manage production IoT deployments in demanding operational environments, including aviation ground services at Stockholm Arlanda Airport in collaboration with Scandinavian Airlines (SAS). In this context, OASIS supports mission-critical systems where reliability, security, and long-term maintainability are non-negotiable. Deployed across ground service operations, connected devices continuously collect operational data from activities such as aircraft towing, pushback, baggage handling, and other time-critical ground service tasks. OASIS securely aggregates this data and manages the lifecycle of the underlying device firmware, ensuring consistent operation across a geographically distributed fleet operating under strict time and safety constraints.\n\nBeyond device management, the data captured through OASIS-enabled deployments is used to digitize ground operations that were previously manual, fragmented, or paper-based. Operational events generated by connected equipment feed directly into higher-level business systems, enabling automated task assignment, real-time status tracking, and accurate recording of completed services. This data foundation supports downstream processes such as automated billing, performance reporting, and operational analytics - transforming raw device telemetry into actionable business intelligence. By combining secure device lifecycle management with reliable data collection at the edge, OASIS enables organizations like SAS to move from reactive operations to data-driven workflows. The result is improved operational efficiency, reduced administrative overhead, and increased transparency across complex ground service processes - all while maintaining full control over device security and long-term system evolution.",
|
||||||
|
"emphasis": [
|
||||||
|
"OASIS",
|
||||||
|
"mission-critical systems where reliability, security, and long-term maintainability are non-negotiable",
|
||||||
|
"digitize ground operations that were previously manual, fragmented, or paper-based",
|
||||||
|
"transforming raw device telemetry into actionable business intelligence"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "oasis#summary",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "footnote",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "OASIS - full lifecycle control when you need it, seamless integration when you don’t.",
|
||||||
|
"emphasis": [ ]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
206
content/platform.json
Normal file
206
content/platform.json
Normal file
|
|
@ -0,0 +1,206 @@
|
||||||
|
{
|
||||||
|
"id": "platform",
|
||||||
|
"url": "/platform/",
|
||||||
|
"blocks": [
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "hero",
|
||||||
|
"level": 1,
|
||||||
|
|
||||||
|
"title": "Secure Device Lifecycle Management for IoT"
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-explainer",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "video",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "RIoT Secure - Explainer Video",
|
||||||
|
"embed_url": "https://vimeo.com/996920984",
|
||||||
|
"provider": "Vimeo",
|
||||||
|
"author": "Aaron Ardiri"
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-lead",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "The RIoT Secure platform manages the full lifecycle of intelligent IoT devices, from initial provisioning and onboarding to long-term operation, software updates, and eventual decommissioning. Designed specifically for resource-constrained environments, the platform enables secure deployment and controlled evolution of devices that combine long-lived native firmware with rapidly evolving application logic, AI workloads, and portable execution environments such as WebAssembly. Rather than replacing existing cloud or connectivity solutions, the RIoT Secure platform integrates alongside them as a foundational lifecycle component. By providing hardware-rooted identity, secure communication, and lifecycle governance, the platform addresses a critical gap in many IoT deployments: consistent lifecycle management across heterogeneous devices, software stacks, and execution models.",
|
||||||
|
"emphasis": [ "RIoT Secure platform" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-architecture",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Client-Server Architecture",
|
||||||
|
"text": "The RIoT Secure platform follows a client-server architecture designed for secure lifecycle management of IoT devices. On the device side, a minimal embedded security core provides hardware-rooted trust, secure communication, and strict separation of concerns from the application processor. In the cloud, the RIoT Secure control plane manages device provisioning, ownership, software updates, policy enforcement, and lifecycle state across the entire device fleet. Together, the device security core and the cloud control plane provide consistent visibility and control from device provisioning through operation and retirement, without compromising performance on resource-constrained hardware.",
|
||||||
|
"emphasis": [ "RIoT Secure platform", "RIoT Secure control plane" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-software-delivery",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Secure software delivery and OTA updates",
|
||||||
|
"text": "Secure and efficient software delivery is a core capability of the RIoT Secure platform. Native firmware, application logic, AI models, and WebAssembly modules can all be securely deployed and updated over the air without requiring physical access to the device. This capability allows organizations to operate large, geographically distributed fleets while minimizing downtime, reducing operational risk, and avoiding costly on-site maintenance. By decoupling long-lived firmware from rapidly evolving application logic and AI workloads, the RIoT Secure platform enables software components to be updated safely and independently as system requirements evolve.",
|
||||||
|
"emphasis": [ "RIoT Secure platform" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-stack-intro",
|
||||||
|
"type": "text",
|
||||||
|
"chunked": false,
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Platform Technology Stack",
|
||||||
|
"text": "The RIoT Secure platform is built as a modular technology stack that separates communication, security, execution environments, and lifecycle management. Each layer is designed to address a specific responsibility in the lifecycle of intelligent IoT devices. Together, these components form a cohesive platform that enables secure communication, controlled software evolution, and long-term operational governance across heterogeneous device fleets."
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-microtls",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "microTLS",
|
||||||
|
"text": "The µTLS communication layer provides secure and efficient communication between IoT devices and the RIoT Secure control plane. µTLS reduces transmission overhead compared to traditional HTTPS or MQTT-based approaches, making secure communication practical even for low-power and bandwidth-constrained devices. Despite its efficiency, µTLS preserves strong cryptographic guarantees and maintains end-to-end trust between devices and cloud infrastructure.",
|
||||||
|
"emphasis": [ "µTLS", "RIoT Secure control plane" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-fusion",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "FUSION",
|
||||||
|
"text": "FUSION provides a secure hardware sandbox for native firmware and external microcontrollers within the RIoT Secure platform. By isolating communication and security functions from application logic, FUSION allows developers to run custom firmware or control external hardware while preserving the platform’s lifecycle and security guarantees.",
|
||||||
|
"emphasis": [ "FUSION" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-oasis",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "OASIS",
|
||||||
|
"text": "OASIS is the REST API and web-based control interface for the RIoT Secure platform. Through OASIS, operators can manage device identities, software versions, update campaigns, and lifecycle state across heterogeneous device fleets. The interface provides centralized visibility and operational control, enabling organizations to maintain consistent policies and traceability throughout the lifecycle of their IoT deployments.",
|
||||||
|
"emphasis": [ "OASIS" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-brawl",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "BRAWL",
|
||||||
|
"text": "BRAWL provides a WebAssembly-based execution environment within the RIoT Secure platform. By running application logic inside a portable WebAssembly runtime, BRAWL allows functionality and AI workloads to be deployed and updated independently of native firmware. This approach enables faster iteration while maintaining strict isolation from security-critical platform components.",
|
||||||
|
"emphasis": [ "BRAWL" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-shield",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "SHIELD",
|
||||||
|
"text": "SHIELD adds an additional encryption layer for WebAssembly binaries deployed through the RIoT Secure platform. By encrypting application modules before deployment, SHIELD protects intellectual property and prevents reverse engineering even when devices operate in physically accessible or untrusted environments.",
|
||||||
|
"emphasis": [ "SHIELD" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-separation-of-concerns",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Separation of Concerns",
|
||||||
|
"text": "The RIoT Secure platform enforces a strict separation of concerns on the device by isolating security, communication, and application execution environments. This architecture prevents application logic from interfering with security-critical operations and ensures that lifecycle management functions remain protected even if application code is modified or updated.",
|
||||||
|
"emphasis": [ "RIoT Secure platform", "separation of concerns" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-stack-links",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "links",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "Explore the individual technology stacks below to learn more about how each component contributes to secure, long-term lifecycle management:",
|
||||||
|
"links": [
|
||||||
|
{ "label": "µTLS", "url": "/microTLS/" },
|
||||||
|
{ "label": "FUSION", "url": "/fusion/" },
|
||||||
|
{ "label": "OASIS", "url": "/oasis/" },
|
||||||
|
{ "label": "BRAWL", "url": "/brawl/" },
|
||||||
|
{ "label": "SHIELD", "url": "/shield/" }
|
||||||
|
],
|
||||||
|
"size": 3
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#lcm-summary",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Secure Lifecycle Management for Intelligent Devices",
|
||||||
|
"text": "Through its modular architecture and clear separation between communication, security, execution environments, and lifecycle governance, the RIoT Secure platform enables organizations to deploy intelligent IoT systems that remain secure, maintainable, and adaptable over time. Whether devices rely on native firmware, WebAssembly modules, AI models, or a combination of these technologies, the platform provides the lifecycle control required to manage them safely at scale.",
|
||||||
|
"emphasis": [ "RIoT Secure platform" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#hardware",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "hero",
|
||||||
|
"level": 1,
|
||||||
|
|
||||||
|
"title": "Lifecycle-First Hardware Architecture (Custom Hardware)"
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#hardware-visual",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Custom Hardware - Lifecycle Management and Security Guaranteed",
|
||||||
|
"src": "images/platform-lifecycle-first-architecture.png",
|
||||||
|
"alt": "Diagram of lifecycle-first hardware architecture with separated application and security/communication domains"
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#hardware-need",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "The RIoT Secure platform is delivered as a Platform as a Service (PaaS), but some deployments require hardware architectures that standard off-the-shelf telematics devices do not provide. Many commercial devices tightly couple application logic, communication, and security within a single processing environment, which makes strict separation of concerns difficult to enforce over long device lifetimes. When hardware limitations prevent reliable isolation, RIoT Secure designs custom hardware platforms optimized for secure lifecycle management. These platforms enforce a hardware sandbox architecture in which application logic - including AI workloads - runs on a dedicated microcontroller, while communication, security, and lifecycle management operate independently.",
|
||||||
|
"emphasis": [ "RIoT Secure platform", "Platform as a Service (PaaS)" ]
|
||||||
|
},
|
||||||
|
|
||||||
|
{
|
||||||
|
"block_id": "platform#hardware-pcbs",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Custom Hardware Platforms and PCBs",
|
||||||
|
"text": "RIoT Secure has designed and deployed custom printed circuit boards (PCBs) tailored to customer operational environments when required to enforce lifecycle and security guarantees. These hardware designs are aligned with the RIoT Secure platform separation-of-concerns architecture and are intentionally flexible, allowing network topology, GNSS modules, and sensor configurations to be adapted as customer requirements evolve. While some modern development platforms support this separation naturally, many industrial telematics devices do not. By providing hardware options where necessary, RIoT Secure enables customers to maintain a strong lifecycle and security posture without being constrained by off-the-shelf device architectures.",
|
||||||
|
"emphasis": [ "RIoT Secure platform" ]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
150
content/shield.json
Normal file
150
content/shield.json
Normal file
|
|
@ -0,0 +1,150 @@
|
||||||
|
{
|
||||||
|
"id": "shield",
|
||||||
|
"url": "/shield/",
|
||||||
|
"blocks": [
|
||||||
|
{
|
||||||
|
"block_id": "shield",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "hero",
|
||||||
|
"level": 1,
|
||||||
|
"title": "Shield"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#overview",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": "Runtime Firmware Encryption for WebAssembly-Based IoT Applications",
|
||||||
|
"text": "SHIELD is RIoT Secure's runtime firmware protection layer, designed to safeguard application logic and intellectual property on physically accessible IoT devices. Built as a security extension tightly integrated with BRAWL, SHIELD protects WebAssembly-based firmware against reverse engineering, memory inspection, and unauthorized modification - even when an attacker has direct access to the device hardware. Unlike communication security or hardware sandboxing, SHIELD addresses a different threat model: the moment firmware is at rest or executing on the device itself.",
|
||||||
|
"emphasis": [
|
||||||
|
"SHIELD",
|
||||||
|
"BRAWL",
|
||||||
|
"runtime firmware protection layer",
|
||||||
|
"the moment firmware is at rest or executing on the device itself"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#physical-attack",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
|
||||||
|
"level": 3,
|
||||||
|
"title": "When Physical Access Becomes the Attack Vector"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#physical-attack-visual",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"src": "images/shield-unprotected.png",
|
||||||
|
"alt": "Diagram showing the risk of unprotected firmware under physical access"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#physical-access",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "In many real-world deployments, IoT devices operate in environments where physical access cannot be prevented. Once a device is accessed, traditional protections often fall apart: firmware can be extracted from flash memory, disassembled using standard toolchains, and analyzed or modified at leisure. This risk is amplified in embedded systems where application logic is compiled into well-known instruction sets such as ARM, AVR, or MIPS. With readily available debugging tools, reverse engineering becomes a practical - and often straightforward - attack.\n\nSHIELD exists specifically to address this gap.",
|
||||||
|
"emphasis": [
|
||||||
|
"SHIELD",
|
||||||
|
"physical access cannot be prevented",
|
||||||
|
"extracted from flash memory",
|
||||||
|
"and often straightforward"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#layer-secutiry",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "A Different Layer of Security - Beyond Transport and Hardware Isolation",
|
||||||
|
"text": "Many security approaches focus on protecting communication channels or isolating execution through hardware mechanisms. While these measures are essential, they do not prevent an attacker from extracting or analyzing firmware once it resides on the device. SHIELD operates inside the execution environment itself, encrypting application logic and memory regions in real time. Firmware is delivered to each device in encrypted form, decrypted only within the controlled context of the BRAWL runtime. This ensures that:\n\n- Extracted firmware images are unusable\n- Application logic cannot be statically analyzed\n- Memory inspection yields encrypted data\n- Firmware modification attempts are detected or rendered ineffective\n\nEach device receives a unique encrypted firmware instance, further reducing the value of any single compromise.",
|
||||||
|
"emphasis": [
|
||||||
|
"SHIELD",
|
||||||
|
"BRAWL"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#protection",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Runtime Protection Without Custom Hardware"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#protection-visual",
|
||||||
|
"chunked": false,
|
||||||
|
"type": "image",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"src": "images/shield-overview.png",
|
||||||
|
"alt": "Overview diagram of SHIELD runtime protection architecture"
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#protection-benefit",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "Traditional approaches to firmware protection often rely on intrusive hardware countermeasures - secure memory regions, proprietary chips, or vendor-specific IP protection features - which must be designed into the hardware early and can significantly increase cost and complexity. SHIELD provides comparable protection without requiring specialized hardware. By integrating encryption directly into the WebAssembly execution model, SHIELD delivers strong intellectual property protection as part of the software lifecycle - making it deployable across a wide range of hardware platforms without redesign. This makes SHIELD particularly well-suited for scalable IoT deployments where hardware diversity and long product lifetimes are the norm.",
|
||||||
|
"emphasis": [
|
||||||
|
"SHIELD",
|
||||||
|
"must be designed into the hardware early",
|
||||||
|
"increase cost and complexity",
|
||||||
|
"integrating encryption directly"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#designed-for-webassembly",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Designed for WebAssembly, Integrated with BRAWL",
|
||||||
|
"text": "SHIELD is purpose-built for WebAssembly-based execution and operates as a native extension of the BRAWL runtime. This tight integration allows SHIELD to protect firmware dynamically, rather than relying on static encryption schemes that can be bypassed once decrypted in memory. Together, BRAWL and SHIELD provide:\n\n- A portable, standardized execution layer (WebAssembly)\n- A sandboxed runtime environment\n- Continuous, real-time protection of application logic and memory\n- Secure lifecycle delivery through OASIS and µTLS\n\nThis layered approach ensures that WebAssembly modules remain protected from delivery, through execution, and throughout the device lifecycle.",
|
||||||
|
"emphasis": [
|
||||||
|
"SHIELD",
|
||||||
|
"BRAWL",
|
||||||
|
"OASIS",
|
||||||
|
"µTLS",
|
||||||
|
"WebAssembly-based execution",
|
||||||
|
"from delivery, through execution, and throughout the device lifecycle"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#protect-intellecutual-property",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "text",
|
||||||
|
"level": 3,
|
||||||
|
|
||||||
|
"title": "Protecting Intellectual Property at Scale",
|
||||||
|
"text": "SHIELD is designed for organizations whose competitive advantage depends on proprietary algorithms, business logic, or data processing workflows deployed at the edge. By protecting firmware at runtime, SHIELD enables companies to deploy advanced functionality - including AI-related logic - without exposing valuable intellectual property to reverse engineering or cloning. This protection remains effective even as firmware is updated over the air, ensuring that intellectual property stays protected throughout the entire lifecycle of the device.",
|
||||||
|
"emphasis": [
|
||||||
|
"SHIELD",
|
||||||
|
"competitive advantage depends on proprietary algorithms",
|
||||||
|
"without exposing valuable intellectual property"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"block_id": "shield#footnote",
|
||||||
|
"chunked": true,
|
||||||
|
"type": "footnote",
|
||||||
|
"level": 2,
|
||||||
|
|
||||||
|
"title": null,
|
||||||
|
"text": "SHIELD - runtime protection for WebAssembly firmware, securing what matters most when devices are physically accessible.",
|
||||||
|
"emphasis": [
|
||||||
|
"SHIELD", "runtime protection for WebAssembly firmware, securing what matters most when devices are physically accessible."
|
||||||
|
]
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
0
fetchContent.sh
Normal file → Executable file
0
fetchContent.sh
Normal file → Executable file
Loading…
Reference in a new issue