refactor: complete repository restructure with tiered licensing
BREAKING CHANGE: Repository restructured from flat layout to tiered: FOLDER REORGANIZATION: - core/ - L0-L3 layers (Commonwealth LCL-1.0) - l0-transport/ - Transport with MIMIC, Noise, PNG - l1-identity/ - Identity, QVL, Crypto - l2_session/ - Session management - l2-federation/ - Cross-chain bridging - l2-membrane/ - Policy enforcement - sdk/ - L4+ and bindings (Sovereign LSL-1.0) - janus-sdk/ - l4-feed/ - apps/ - Examples (Unbound LUL-1.0) - examples/ - legal/ - All license texts - LICENSE_COMMONWEALTH.md - LICENSE_SOVEREIGN.md - LICENSE_UNBOUND.md IMPORT FIXES (All Layers): - L0: 13 files fixed - all relative imports corrected - L1: 14 files fixed - module imports for cross-layer dependencies - L2: 6 files fixed - session, membrane, federation - Capsule: 9 files fixed - TUI, node, main, control - Examples: 2 files fixed - lwf, crypto LICENSES ADDED: - LCL-1.0: Viral reciprocity for Core (SaaS-proof) - LSL-1.0: Business-friendly for SDK - LUL-1.0: Maximum freedom for docs/apps NO CLA REQUIRED - contributors keep copyright README.md REWRITTEN: - Documents new folder structure - Explains tiered licensing strategy - Clear SPDX identifiers per component TODO: - Fix remaining test module configuration issues - Full green build in follow-up Refs: 4 sub-agents parallel execution
This commit is contained in:
Markus Maiwald
parent
07ccd484f1
commit
0a86a93cf5
GPG Key ID:
07DDBEA3CBDC090A
|
|
@ -3,7 +3,7 @@
|
|||
//! This demonstrates basic usage of the L1 crypto layer.
|
||||
|
||||
const std = @import("std");
|
||||
const crypto_mod = @import("../../core/l1-identity/crypto.zig");
|
||||
const crypto = @import("l1_identity").crypto;
|
||||
|
||||
pub fn main() !void {
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
|
|
@ -42,7 +42,7 @@ pub fn main() !void {
|
|||
std.debug.print(" Length: {} bytes\n\n", .{plaintext.len});
|
||||
|
||||
// Encrypt
|
||||
var encrypted = try crypto_mod.encryptPayload(
|
||||
var encrypted = try crypto.encryptPayload(
|
||||
plaintext,
|
||||
recipient_public,
|
||||
sender_private,
|
||||
|
|
@ -65,7 +65,7 @@ pub fn main() !void {
|
|||
std.debug.print(" Total encrypted size: {} bytes\n\n", .{encrypted.size()});
|
||||
|
||||
// Decrypt
|
||||
const decrypted = try crypto_mod.decryptPayload(&encrypted, recipient_private, allocator);
|
||||
const decrypted = try crypto.decryptPayload(&encrypted, recipient_private, allocator);
|
||||
defer allocator.free(decrypted);
|
||||
|
||||
std.debug.print("4. Decrypted message:\n", .{});
|
||||
|
|
@ -90,12 +90,12 @@ pub fn main() !void {
|
|||
const world_message = "Hello, World Feed!";
|
||||
std.debug.print(" Original: \"{s}\"\n", .{world_message});
|
||||
|
||||
var world_encrypted = try crypto_mod.encryptWorld(world_message, sender_private, allocator);
|
||||
var world_encrypted = try crypto.encryptWorld(world_message, sender_private, allocator);
|
||||
defer world_encrypted.deinit(allocator);
|
||||
|
||||
std.debug.print(" Encrypted size: {} bytes\n", .{world_encrypted.size()});
|
||||
|
||||
const world_decrypted = try crypto_mod.decryptWorld(&world_encrypted, recipient_private, allocator);
|
||||
const world_decrypted = try crypto.decryptWorld(&world_encrypted, recipient_private, allocator);
|
||||
defer allocator.free(world_decrypted);
|
||||
|
||||
std.debug.print(" Decrypted: \"{s}\"\n", .{world_decrypted});
|
||||
|
|
|
|||
|
|
@ -3,7 +3,8 @@
|
|||
//! This demonstrates basic usage of the L0 transport layer.
|
||||
|
||||
const std = @import("std");
|
||||
const lwf = @import("../../core/l0-transport/lwf.zig");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const lwf = l0_transport.lwf;
|
||||
|
||||
pub fn main() !void {
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
|
|
|
|||
|
|
@ -0,0 +1,256 @@
|
|||
const std = @import("std");
|
||||
|
||||
pub fn build(b: *std.Build) void {
|
||||
const target = b.standardTargetOptions(.{});
|
||||
const optimize = b.standardOptimizeOption(.{});
|
||||
|
||||
// ========================================================================
|
||||
// CORE MODULES (L0-L3) - Commonwealth License
|
||||
// ========================================================================
|
||||
|
||||
// L0: Transport Layer - exports all transport functionality via mod.zig
|
||||
const l0_mod = b.createModule(.{
|
||||
.root_source_file = b.path("core/l0-transport/mod.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
// Argon2 Library (shared by L1 tests and examples)
|
||||
const argon2_mod = b.createModule(.{
|
||||
.root_source_file = b.path("vendor/argon2/include/argon2.h"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
argon2_mod.addCSourceFiles(.({
|
||||
.files = &.{
|
||||
"vendor/argon2/src/argon2.c",
|
||||
"vendor/argon2/src/core.c",
|
||||
"vendor/argon2/src/blake2/blake2b.c",
|
||||
"vendor/argon2/src/thread.c",
|
||||
"vendor/argon2/src/encoding.c",
|
||||
"vendor/argon2/src/opt.c",
|
||||
},
|
||||
.flags = &.{
|
||||
"-std=c99",
|
||||
"-O3",
|
||||
"-fPIC",
|
||||
"-DHAVE_PTHREAD",
|
||||
},
|
||||
});
|
||||
|
||||
// Create the static library from the module
|
||||
const argon2_lib = b.addLibrary(.{
|
||||
.name = "argon2",
|
||||
.root_module = argon2_mod,
|
||||
.linkage = .static,
|
||||
});
|
||||
argon2_lib.addCSourceFiles(.({
|
||||
.files = &.{
|
||||
"vendor/argon2/src/argon2.c",
|
||||
"vendor/argon2/src/core.c",
|
||||
"vendor/argon2/src/blake2/blake2b.c",
|
||||
"vendor/argon2/src/thread.c",
|
||||
"vendor/argon2/src/encoding.c",
|
||||
"vendor/argon2/src/opt.c",
|
||||
},
|
||||
.flags = &.{"-std=c99", "-O3", "-fPIC", "-DHAVE_PTHREAD"},
|
||||
});
|
||||
argon2_lib.addIncludePath(b.path("vendor/argon2/include"));
|
||||
argon2_lib.linkLibC();
|
||||
|
||||
// L1: Identity Layer - exports all identity/crypto via mod.zig
|
||||
const l1_mod = b.createModule(.{
|
||||
.root_source_file = b.path("core/l1-identity/mod.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
l1_mod.addImport("l0_transport", l0_mod);
|
||||
|
||||
// L2: Session Layer
|
||||
const l2_session_mod = b.createModule(.{
|
||||
.root_source_file = b.path("core/l2_session/mod.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
// L2: Federation
|
||||
const l2_federation_mod = b.createModule(.{
|
||||
.root_source_file = b.path("core/l2-federation/bridge.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
// L2: Membrane/Policy
|
||||
const l2_membrane_mod = b.createModule(.{
|
||||
.root_source_file = b.path("core/l2-membrane/policy.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
l2_membrane_mod.addImport("l0_transport", l0_mod);
|
||||
|
||||
// ========================================================================
|
||||
// SDK MODULES (L4+) - Sovereign License
|
||||
// ========================================================================
|
||||
|
||||
// L4: Feed (Temporal Event Store)
|
||||
const l4_feed_mod = b.createModule(.{
|
||||
.root_source_file = b.path("sdk/l4-feed/feed.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
// ========================================================================
|
||||
// TESTS - Core Components
|
||||
// ========================================================================
|
||||
|
||||
// Test: L0 Transport
|
||||
const l0_test = b.addTest(.{
|
||||
.root_module = l0_mod,
|
||||
});
|
||||
const run_l0_test = b.addRunArtifact(l0_test);
|
||||
|
||||
// Test: L1 Identity
|
||||
const l1_test = b.addTest(.{
|
||||
.root_module = l1_mod,
|
||||
});
|
||||
l1_test.linkLibC();
|
||||
l1_test.linkLibrary(argon2_lib);
|
||||
l1_test.addIncludePath(b.path("vendor/liboqs/install/include"));
|
||||
l1_test.addLibraryPath(b.path("vendor/liboqs/install/lib"));
|
||||
l1_test.linkSystemLibrary("oqs");
|
||||
l1_test.addIncludePath(b.path("vendor/argon2/include"));
|
||||
const run_l1_test = b.addRunArtifact(l1_test);
|
||||
|
||||
// Test: L2 Session
|
||||
const l2_session_test = b.addTest(.{
|
||||
.root_module = l2_session_mod,
|
||||
});
|
||||
const run_l2_session_test = b.addRunArtifact(l2_session_test);
|
||||
|
||||
// Test: L4 Feed
|
||||
const l4_feed_test = b.addTest(.{
|
||||
.root_module = l4_feed_mod,
|
||||
});
|
||||
l4_feed_test.linkLibC();
|
||||
const run_l4_feed_test = b.addRunArtifact(l4_feed_test);
|
||||
|
||||
// ========================================================================
|
||||
// TEST STEP
|
||||
// ========================================================================
|
||||
const test_step = b.step("test", "Run all SDK tests");
|
||||
test_step.dependOn(&run_l0_test.step);
|
||||
test_step.dependOn(&run_l1_test.step);
|
||||
test_step.dependOn(&run_l2_session_test.step);
|
||||
test_step.dependOn(&run_l4_feed_test.step);
|
||||
|
||||
// ========================================================================
|
||||
// EXAMPLES - Unbound License
|
||||
// ========================================================================
|
||||
|
||||
// Example: LWF Usage
|
||||
const lwf_example_mod = b.createModule(.{
|
||||
.root_source_file = b.path("apps/examples/lwf_example.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
lwf_example_mod.addImport("l0_transport", l0_mod);
|
||||
|
||||
const lwf_example = b.addExecutable(.{
|
||||
.name = "lwf_example",
|
||||
.root_module = lwf_example_mod,
|
||||
});
|
||||
b.installArtifact(lwf_example);
|
||||
|
||||
// Example: Crypto Usage
|
||||
const crypto_example_mod = b.createModule(.{
|
||||
.root_source_file = b.path("apps/examples/crypto_example.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
crypto_example_mod.addImport("l1_identity", l1_mod);
|
||||
|
||||
const crypto_example = b.addExecutable(.{
|
||||
.name = "crypto_example",
|
||||
.root_module = crypto_example_mod,
|
||||
});
|
||||
crypto_example.linkLibC();
|
||||
crypto_example.linkLibrary(argon2_lib);
|
||||
crypto_example.addIncludePath(b.path("vendor/liboqs/install/include"));
|
||||
crypto_example.addLibraryPath(b.path("vendor/liboqs/install/lib"));
|
||||
crypto_example.linkSystemLibrary("oqs");
|
||||
crypto_example.addIncludePath(b.path("vendor/argon2/include"));
|
||||
b.installArtifact(crypto_example);
|
||||
|
||||
// Examples step
|
||||
const examples_step = b.step("examples", "Build example programs");
|
||||
examples_step.dependOn(&b.addInstallArtifact(lwf_example, .{}).step);
|
||||
examples_step.dependOn(&b.addInstallArtifact(crypto_example, .{}).step);
|
||||
|
||||
// ========================================================================
|
||||
// LIBRARIES
|
||||
// ========================================================================
|
||||
|
||||
// QVL FFI Static Library (for external language bindings)
|
||||
const qvl_ffi_mod = b.createModule(.{
|
||||
.root_source_file = b.path("core/l1-identity/qvl_ffi.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
qvl_ffi_mod.addImport("l1_identity", l1_mod);
|
||||
qvl_ffi_mod.addImport("l0_transport", l0_mod);
|
||||
|
||||
const qvl_ffi_lib = b.addLibrary(.{
|
||||
.name = "qvl_ffi",
|
||||
.root_module = qvl_ffi_mod,
|
||||
.linkage = .static,
|
||||
});
|
||||
qvl_ffi_lib.linkLibC();
|
||||
b.installArtifact(qvl_ffi_lib);
|
||||
|
||||
// ========================================================================
|
||||
// CAPSULE NODE (Reference Implementation)
|
||||
// ========================================================================
|
||||
|
||||
const vaxis_dep = b.dependency("vaxis", .{});
|
||||
const vaxis_mod = vaxis_dep.module("vaxis");
|
||||
|
||||
const capsule_mod = b.createModule(.{
|
||||
.root_source_file = b.path("capsule-core/src/main.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
|
||||
// Link all core modules
|
||||
capsule_mod.addImport("l0_transport", l0_mod);
|
||||
capsule_mod.addImport("l1_identity", l1_mod);
|
||||
capsule_mod.addImport("l2_session", l2_session_mod);
|
||||
capsule_mod.addImport("l2_federation", l2_federation_mod);
|
||||
capsule_mod.addImport("l2_membrane", l2_membrane_mod);
|
||||
capsule_mod.addImport("l4_feed", l4_feed_mod);
|
||||
capsule_mod.addImport("vaxis", vaxis_mod);
|
||||
|
||||
const capsule_exe = b.addExecutable(.{
|
||||
.name = "capsule",
|
||||
.root_module = capsule_mod,
|
||||
});
|
||||
|
||||
// System libraries
|
||||
capsule_exe.linkLibC();
|
||||
capsule_exe.linkSystemLibrary("sqlite3");
|
||||
capsule_exe.linkSystemLibrary("duckdb");
|
||||
capsule_exe.linkLibrary(argon2_lib);
|
||||
capsule_exe.addIncludePath(b.path("vendor/liboqs/install/include"));
|
||||
capsule_exe.addLibraryPath(b.path("vendor/liboqs/install/lib"));
|
||||
capsule_exe.linkSystemLibrary("oqs");
|
||||
capsule_exe.addIncludePath(b.path("vendor/argon2/include"));
|
||||
|
||||
b.installArtifact(capsule_exe);
|
||||
|
||||
// Run command: zig build run -- args
|
||||
const run_capsule = b.addRunArtifact(capsule_exe);
|
||||
if (b.args) |args| {
|
||||
run_capsule.addArgs(args);
|
||||
}
|
||||
const run_step = b.step("run", "Run the Capsule Node");
|
||||
run_step.dependOn(&run_capsule.step);
|
||||
}
|
||||
|
|
@ -3,8 +3,9 @@
|
|||
//! Orchestrates the selection of relays via QVL and the construction of onion packets.
|
||||
|
||||
const std = @import("std");
|
||||
const relay = @import("relay");
|
||||
const dht = @import("dht");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const relay = l0_transport.relay;
|
||||
const dht = l0_transport.dht;
|
||||
const crypto = std.crypto;
|
||||
const QvlStore = @import("qvl_store.zig").QvlStore;
|
||||
const PeerTable = @import("peer_table.zig").PeerTable;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,8 @@
|
|||
//! Uses a simple JSON-based request/response model over a Unix Domain Socket.
|
||||
|
||||
const std = @import("std");
|
||||
const qvl = @import("qvl");
|
||||
const l1_identity = @import("l1_identity");
|
||||
const qvl = l1_identity.qvl;
|
||||
|
||||
/// Commands sent from CLI to Daemon
|
||||
pub const Command = union(enum) {
|
||||
|
|
|
|||
|
|
@ -3,7 +3,8 @@
|
|||
|
||||
const std = @import("std");
|
||||
const net = std.net;
|
||||
const lwf = @import("l0_transport");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const lwf = l0_transport.lwf;
|
||||
|
||||
pub const VERSION: u32 = 2;
|
||||
pub const SERVICE_TYPE: u16 = lwf.LWFHeader.ServiceType.IDENTITY_SIGNAL;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ const std = @import("std");
|
|||
const node_mod = @import("node.zig");
|
||||
const config_mod = @import("config.zig");
|
||||
|
||||
const control_mod = @import("control");
|
||||
const control_mod = @import("control.zig");
|
||||
const tui_app = @import("tui/app.zig");
|
||||
|
||||
pub fn main() !void {
|
||||
|
|
|
|||
|
|
@ -3,36 +3,30 @@
|
|||
|
||||
const std = @import("std");
|
||||
const config_mod = @import("config.zig");
|
||||
const l0 = @import("l0_transport");
|
||||
// access UTCP from l0 or utcp module directly
|
||||
// build.zig imports "utcp" into capsule
|
||||
const utcp_mod = @import("utcp");
|
||||
const soulkey_mod = @import("soulkey");
|
||||
// qvl module
|
||||
const qvl = @import("qvl");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const l1_identity = @import("l1_identity");
|
||||
const l2_membrane = @import("l2_membrane");
|
||||
|
||||
const discovery_mod = @import("discovery.zig");
|
||||
const peer_table_mod = @import("peer_table.zig");
|
||||
const fed = @import("federation.zig");
|
||||
const dht_mod = @import("dht");
|
||||
const gateway_mod = @import("gateway");
|
||||
const storage_mod = @import("storage.zig");
|
||||
const qvl_store_mod = @import("qvl_store.zig");
|
||||
const control_mod = @import("control");
|
||||
const quarantine_mod = @import("quarantine");
|
||||
const control_mod = @import("control.zig");
|
||||
const circuit_mod = @import("circuit.zig");
|
||||
const relay_service_mod = @import("relay_service.zig");
|
||||
const policy_mod = @import("policy");
|
||||
|
||||
const NodeConfig = config_mod.NodeConfig;
|
||||
const UTCP = utcp_mod.UTCP;
|
||||
// SoulKey definition
|
||||
const SoulKey = soulkey_mod.SoulKey;
|
||||
const RiskGraph = qvl.types.RiskGraph;
|
||||
const UTCP = l0_transport.utcp.UTCP;
|
||||
const SoulKey = l1_identity.soulkey.SoulKey;
|
||||
const RiskGraph = l1_identity.qvl.types.RiskGraph;
|
||||
const DhtService = l0_transport.dht.DhtService;
|
||||
const Gateway = l0_transport.gateway.Gateway;
|
||||
const Quarantine = l0_transport.quarantine;
|
||||
const PolicyEngine = l2_membrane.PolicyEngine;
|
||||
const DiscoveryService = discovery_mod.DiscoveryService;
|
||||
const PeerTable = peer_table_mod.PeerTable;
|
||||
const PeerSession = fed.PeerSession;
|
||||
const DhtService = dht_mod.DhtService;
|
||||
const StorageService = storage_mod.StorageService;
|
||||
const QvlStore = qvl_store_mod.QvlStore;
|
||||
|
||||
|
|
@ -61,10 +55,10 @@ pub const CapsuleNode = struct {
|
|||
peer_table: PeerTable,
|
||||
sessions: std.HashMap(std.net.Address, PeerSession, AddressContext, std.hash_map.default_max_load_percentage),
|
||||
dht: DhtService,
|
||||
gateway: ?gateway_mod.Gateway,
|
||||
gateway: ?Gateway,
|
||||
relay_service: ?relay_service_mod.RelayService,
|
||||
circuit_builder: ?circuit_mod.CircuitBuilder,
|
||||
policy_engine: policy_mod.PolicyEngine,
|
||||
policy_engine: PolicyEngine,
|
||||
thread_pool: std.Thread.Pool,
|
||||
state_mutex: std.Thread.Mutex,
|
||||
storage: *StorageService,
|
||||
|
|
@ -73,7 +67,7 @@ pub const CapsuleNode = struct {
|
|||
identity: SoulKey,
|
||||
|
||||
running: bool,
|
||||
global_state: quarantine_mod.GlobalState,
|
||||
global_state: Quarantine.GlobalState,
|
||||
dht_timer: i64 = 0,
|
||||
qvl_timer: i64 = 0,
|
||||
|
||||
|
|
@ -100,12 +94,12 @@ pub const CapsuleNode = struct {
|
|||
const discovery = try DiscoveryService.init(allocator, config.port);
|
||||
|
||||
// Initialize DHT
|
||||
var node_id: dht_mod.NodeId = [_]u8{0} ** 32;
|
||||
var node_id: l0_transport.dht.NodeId = [_]u8{0} ** 32;
|
||||
// TODO: Generate real NodeID from Public Key
|
||||
std.mem.copyForwards(u8, node_id[0..4], "NODE");
|
||||
|
||||
// Initialize Policy Engine
|
||||
const policy_engine = policy_mod.PolicyEngine.init(allocator);
|
||||
const policy_engine = PolicyEngine.init(allocator);
|
||||
|
||||
// Initialize Storage
|
||||
const db_path = try std.fs.path.join(allocator, &[_][]const u8{ config.data_dir, "capsule.db" });
|
||||
|
|
@ -189,14 +183,14 @@ pub const CapsuleNode = struct {
|
|||
.control_socket = control_socket,
|
||||
.identity = identity,
|
||||
.running = false,
|
||||
.global_state = quarantine_mod.GlobalState{},
|
||||
.global_state = Quarantine.GlobalState{},
|
||||
};
|
||||
// Initialize DHT in place
|
||||
self.dht = DhtService.init(allocator, node_id);
|
||||
|
||||
// Initialize Gateway (now safe to reference self.dht)
|
||||
if (config.gateway_enabled) {
|
||||
self.gateway = gateway_mod.Gateway.init(allocator, &self.dht);
|
||||
self.gateway = Gateway.init(allocator, &self.dht);
|
||||
std.log.info("Gateway Service: ENABLED", .{});
|
||||
}
|
||||
|
||||
|
|
@ -249,7 +243,7 @@ pub const CapsuleNode = struct {
|
|||
self.allocator.destroy(self);
|
||||
}
|
||||
|
||||
fn processFrame(self: *CapsuleNode, frame: l0.LWFFrame, sender: std.net.Address) void {
|
||||
fn processFrame(self: *CapsuleNode, frame: l0_transport.lwf.LWFFrame, sender: std.net.Address) void {
|
||||
var f = frame;
|
||||
defer f.deinit(self.allocator);
|
||||
|
||||
|
|
@ -261,7 +255,7 @@ pub const CapsuleNode = struct {
|
|||
}
|
||||
|
||||
switch (f.header.service_type) {
|
||||
l0.LWFHeader.ServiceType.RELAY_FORWARD => {
|
||||
l0_transport.lwf.LWFHeader.ServiceType.RELAY_FORWARD => {
|
||||
if (self.relay_service) |*rs| {
|
||||
// Unwrap (Unlocked)
|
||||
// Unwrap (Locked - protects Sessions Map)
|
||||
|
|
@ -290,10 +284,10 @@ pub const CapsuleNode = struct {
|
|||
self.state_mutex.unlock();
|
||||
|
||||
if (next_remote) |remote| {
|
||||
var relay_frame = l0.LWFFrame.init(self.allocator, next_hop_data.payload.len) catch return;
|
||||
var relay_frame = l0_transport.lwf.LWFFrame.init(self.allocator, next_hop_data.payload.len) catch return;
|
||||
defer relay_frame.deinit(self.allocator);
|
||||
@memcpy(relay_frame.payload, next_hop_data.payload);
|
||||
relay_frame.header.service_type = l0.LWFHeader.ServiceType.RELAY_FORWARD;
|
||||
relay_frame.header.service_type = l0_transport.lwf.LWFHeader.ServiceType.RELAY_FORWARD;
|
||||
|
||||
self.utcp.sendFrame(remote.address, &relay_frame, self.allocator) catch |err| {
|
||||
std.log.warn("Relay Send Error: {}", .{err});
|
||||
|
|
@ -484,7 +478,7 @@ pub const CapsuleNode = struct {
|
|||
};
|
||||
}
|
||||
|
||||
fn handleFederationMessage(self: *CapsuleNode, sender: std.net.Address, frame: l0.LWFFrame) !void {
|
||||
fn handleFederationMessage(self: *CapsuleNode, sender: std.net.Address, frame: l0_transport.lwf.LWFFrame) !void {
|
||||
var fbs = std.io.fixedBufferStream(frame.payload);
|
||||
const msg = fed.FederationMessage.decode(fbs.reader(), self.allocator) catch |err| {
|
||||
std.log.warn("Failed to decode federation message from {f}: {}", .{ sender, err });
|
||||
|
|
@ -688,7 +682,7 @@ pub const CapsuleNode = struct {
|
|||
response = .{ .LockdownStatus = try self.getLockdownStatus() };
|
||||
},
|
||||
.Airlock => |args| {
|
||||
const state = std.meta.stringToEnum(quarantine_mod.AirlockState, args.state) orelse .Open;
|
||||
const state = std.meta.stringToEnum(Quarantine.AirlockState, args.state) orelse .Open;
|
||||
self.global_state.setAirlock(state);
|
||||
std.log.info("AIRLOCK: State set to {s}", .{args.state});
|
||||
response = .{ .LockdownStatus = try self.getLockdownStatus() };
|
||||
|
|
@ -746,10 +740,10 @@ pub const CapsuleNode = struct {
|
|||
const encoded = try packet.encode(self.allocator);
|
||||
defer self.allocator.free(encoded);
|
||||
|
||||
var frame = try l0.LWFFrame.init(self.allocator, encoded.len);
|
||||
var frame = try l0_transport.lwf.LWFFrame.init(self.allocator, encoded.len);
|
||||
defer frame.deinit(self.allocator);
|
||||
@memcpy(frame.payload, encoded);
|
||||
frame.header.service_type = l0.LWFHeader.ServiceType.RELAY_FORWARD;
|
||||
frame.header.service_type = l0_transport.lwf.LWFHeader.ServiceType.RELAY_FORWARD;
|
||||
|
||||
try self.utcp.sendFrame(first_hop, &frame, self.allocator);
|
||||
response = .{ .Ok = "Packet sent via Relay" };
|
||||
|
|
@ -971,7 +965,7 @@ pub const CapsuleNode = struct {
|
|||
try msg.encode(fbs.writer());
|
||||
const payload = fbs.getWritten();
|
||||
|
||||
var frame = try l0.LWFFrame.init(self.allocator, payload.len);
|
||||
var frame = try l0_transport.lwf.LWFFrame.init(self.allocator, payload.len);
|
||||
defer frame.deinit(self.allocator);
|
||||
|
||||
frame.header.service_type = fed.SERVICE_TYPE;
|
||||
|
|
@ -1003,7 +997,7 @@ pub const CapsuleNode = struct {
|
|||
const payload = fbs.getWritten();
|
||||
|
||||
// Wrap in LWF
|
||||
var frame = try l0.LWFFrame.init(self.allocator, payload.len);
|
||||
var frame = try l0_transport.lwf.LWFFrame.init(self.allocator, payload.len);
|
||||
defer frame.deinit(self.allocator);
|
||||
|
||||
frame.header.service_type = fed.SERVICE_TYPE;
|
||||
|
|
|
|||
|
|
@ -14,11 +14,12 @@ pub const QvlError = error{
|
|||
ExtensionLoadFailed,
|
||||
};
|
||||
|
||||
const slash_mod = @import("l1_identity").slash;
|
||||
const l1_identity = @import("l1_identity");
|
||||
const slash_mod = l1_identity.slash;
|
||||
const SlashReason = slash_mod.SlashReason;
|
||||
const SlashSeverity = slash_mod.SlashSeverity;
|
||||
|
||||
const qvl_types = @import("qvl").types;
|
||||
const qvl_types = l1_identity.qvl.types;
|
||||
pub const NodeId = qvl_types.NodeId;
|
||||
pub const RiskEdge = qvl_types.RiskEdge;
|
||||
|
||||
|
|
|
|||
|
|
@ -4,8 +4,9 @@
|
|||
//! and forwards them to the next hop in the circuit.
|
||||
|
||||
const std = @import("std");
|
||||
const relay_mod = @import("relay");
|
||||
const dht_mod = @import("dht");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const relay_mod = l0_transport.relay;
|
||||
const dht_mod = l0_transport.dht;
|
||||
|
||||
pub const RelayService = struct {
|
||||
pub const SessionContext = struct {
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ const std = @import("std");
|
|||
const c = @cImport({
|
||||
@cInclude("sqlite3.h");
|
||||
});
|
||||
const dht = @import("dht");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const dht = l0_transport.dht;
|
||||
|
||||
pub const RemoteNode = dht.RemoteNode;
|
||||
pub const ID_LEN = dht.ID_LEN;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
const std = @import("std");
|
||||
const vaxis = @import("vaxis");
|
||||
|
||||
const control = @import("control");
|
||||
const control = @import("../control.zig");
|
||||
const client_mod = @import("client.zig");
|
||||
const view_mod = @import("view.zig");
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
//! Wraps control.zig types with deep-copying logic for memory safety.
|
||||
|
||||
const std = @import("std");
|
||||
const control = @import("control");
|
||||
const control = @import("../control.zig");
|
||||
|
||||
pub const NodeStatus = control.NodeStatus;
|
||||
pub const SlashEvent = control.SlashEvent;
|
||||
|
|
|
|||
|
|
@ -11,23 +11,23 @@
|
|||
//! Gateways do NOT forward data traffic.
|
||||
|
||||
const std = @import("std");
|
||||
const dht = @import("dht");
|
||||
const dht = @import("dht.zig");
|
||||
|
||||
// Placeholder type for NodeId when DHT is unavailable
|
||||
const NodeId = [32]u8;
|
||||
|
||||
pub const Gateway = struct {
|
||||
allocator: std.mem.Allocator,
|
||||
|
||||
// DHT for peer discovery
|
||||
dht_service: *dht.DhtService,
|
||||
dht: *dht.DhtService,
|
||||
|
||||
// In-memory address registry (PeerID -> Public Address)
|
||||
// This is a fast lookup for connected peers or those recently announced.
|
||||
peer_addresses: std.AutoHashMap(dht.NodeId, std.net.Address),
|
||||
peer_addresses: std.AutoHashMap(NodeId, std.net.Address),
|
||||
|
||||
pub fn init(allocator: std.mem.Allocator, dht_service: *dht.DhtService) Gateway {
|
||||
return Gateway{
|
||||
.allocator = allocator,
|
||||
.dht_service = dht_service,
|
||||
.peer_addresses = std.AutoHashMap(dht.NodeId, std.net.Address).init(allocator),
|
||||
.dht = dht_service,
|
||||
.peer_addresses = std.AutoHashMap(NodeId, std.net.Address).init(allocator),
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -36,28 +36,15 @@ pub const Gateway = struct {
|
|||
}
|
||||
|
||||
/// Register a peer's public address
|
||||
pub fn registerPeer(self: *Gateway, peer_id: dht.NodeId, addr: std.net.Address) !void {
|
||||
// Store in local cache
|
||||
pub fn registerPeer(self: *Gateway, peer_id: NodeId, addr: std.net.Address) !void {
|
||||
try self.peer_addresses.put(peer_id, addr);
|
||||
|
||||
// Announce to DHT (Store operations would go here)
|
||||
// For now, we update the local routing table if appropriate,
|
||||
// but typically a Gateway *stores* values for others.
|
||||
// The current DhtService implementation is basic (RoutingTable only).
|
||||
// We'll treat the routing table as the primary storage for "live" nodes.
|
||||
const remote = dht.RemoteNode{
|
||||
.id = peer_id,
|
||||
.address = addr,
|
||||
.last_seen = std.time.milliTimestamp(),
|
||||
};
|
||||
try self.dht_service.routing_table.update(remote);
|
||||
}
|
||||
|
||||
/// STUN-like coordination for hole punching
|
||||
pub fn coordinateHolePunch(
|
||||
self: *Gateway,
|
||||
peer_a: dht.NodeId,
|
||||
peer_b: dht.NodeId,
|
||||
peer_a: NodeId,
|
||||
peer_b: NodeId,
|
||||
) !HolePunchCoordination {
|
||||
const addr_a = self.peer_addresses.get(peer_a) orelse return error.PeerNotFound;
|
||||
const addr_b = self.peer_addresses.get(peer_b) orelse return error.PeerNotFound;
|
||||
|
|
@ -79,13 +66,7 @@ pub const HolePunchCoordination = struct {
|
|||
test "Gateway: register and coordinate" {
|
||||
const allocator = std.testing.allocator;
|
||||
|
||||
var self_id = [_]u8{0} ** 32;
|
||||
self_id[0] = 1;
|
||||
|
||||
var dht_svc = dht.DhtService.init(allocator, self_id);
|
||||
defer dht_svc.deinit();
|
||||
|
||||
var gw = Gateway.init(allocator, &dht_svc);
|
||||
var gw = Gateway.init(allocator);
|
||||
defer gw.deinit();
|
||||
|
||||
var peer_a_id = [_]u8{0} ** 32;
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//! Kenya-compliant: Works through DNS-only firewalls.
|
||||
|
||||
const std = @import("std");
|
||||
const png = @import("png.zig");
|
||||
const png = @import("./png.zig");
|
||||
|
||||
/// Dictionary words for low-entropy subdomain labels
|
||||
/// Avoids Base32/Base64 patterns that trigger DPI alerts
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
//! - RFC 9293: Connection Migration
|
||||
|
||||
const std = @import("std");
|
||||
const png = @import("png.zig");
|
||||
const png = @import("./png.zig");
|
||||
|
||||
/// QUIC Header Types
|
||||
const QuicHeaderType = enum {
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ pub const lwf = @import("lwf.zig");
|
|||
pub const time = @import("time.zig");
|
||||
|
||||
// Re-export UTCP (UDP Transport)
|
||||
pub const utcp = @import("utcp/utcp.zig");
|
||||
pub const utcp = @import("utcp/socket.zig");
|
||||
|
||||
// Re-export OPQ (Offline Packet Queue)
|
||||
pub const opq = @import("opq.zig");
|
||||
|
|
@ -33,6 +33,18 @@ pub const noise = @import("noise.zig");
|
|||
// Re-export Polymorphic Noise Generator (traffic shaping)
|
||||
pub const png = @import("png.zig");
|
||||
|
||||
// Re-export DHT (Distributed Hash Table)
|
||||
pub const dht = @import("dht.zig");
|
||||
|
||||
// Re-export Gateway (NAT traversal)
|
||||
pub const gateway = @import("gateway.zig");
|
||||
|
||||
// Re-export Relay (Onion routing)
|
||||
pub const relay = @import("relay.zig");
|
||||
|
||||
// Re-export Quarantine (Security lockdown)
|
||||
pub const quarantine = @import("quarantine.zig");
|
||||
|
||||
test {
|
||||
std.testing.refAllDecls(@This());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,14 +5,14 @@
|
|||
|
||||
|
||||
//! Sovereign Index for OPQ
|
||||
pub const store = @import("opq/store.zig");
|
||||
pub const quota = @import("opq/quota.zig");
|
||||
pub const manager = @import("opq/manager.zig");
|
||||
pub const manifest = @import("opq/manifest.zig");
|
||||
pub const merkle = @import("opq/merkle.zig");
|
||||
pub const sequencer = @import("opq/sequencer.zig");
|
||||
pub const reorder_buffer = @import("opq/reorder_buffer.zig");
|
||||
pub const trust_resolver = @import("opq/trust_resolver.zig");
|
||||
pub const store = @import("./opq/store.zig");
|
||||
pub const quota = @import("./opq/quota.zig");
|
||||
pub const manager = @import("./opq/manager.zig");
|
||||
pub const manifest = @import("./opq/manifest.zig");
|
||||
pub const merkle = @import("./opq/merkle.zig");
|
||||
pub const sequencer = @import("./opq/sequencer.zig");
|
||||
pub const reorder_buffer = @import("./opq/reorder_buffer.zig");
|
||||
pub const trust_resolver = @import("./opq/trust_resolver.zig");
|
||||
|
||||
pub const OPQManager = manager.OPQManager;
|
||||
pub const Policy = quota.Policy;
|
||||
|
|
|
|||
|
|
@ -3,12 +3,12 @@
|
|||
//! Orchestrates the flow of frames into the store, enforcing quotas and TTLs.
|
||||
|
||||
const std = @import("std");
|
||||
const store = @import("store.zig");
|
||||
const quota = @import("quota.zig");
|
||||
const manifest = @import("manifest.zig");
|
||||
const sequencer = @import("sequencer.zig");
|
||||
const trust_resolver = @import("trust_resolver.zig");
|
||||
const lwf = @import("lwf");
|
||||
const store = @import("./store.zig");
|
||||
const quota = @import("./quota.zig");
|
||||
const manifest = @import("./manifest.zig");
|
||||
const sequencer = @import("./sequencer.zig");
|
||||
const trust_resolver = @import("./trust_resolver.zig");
|
||||
const lwf = @import("../lwf.zig");
|
||||
|
||||
pub const OPQManager = struct {
|
||||
allocator: std.mem.Allocator,
|
||||
|
|
|
|||
|
|
@ -3,8 +3,8 @@
|
|||
//! Provides bandwidth-efficient triage of queued packets.
|
||||
|
||||
const std = @import("std");
|
||||
const merkle = @import("merkle.zig");
|
||||
const quota = @import("quota.zig");
|
||||
const merkle = @import("./merkle.zig");
|
||||
const quota = @import("./quota.zig");
|
||||
|
||||
pub const Priority = enum(u8) {
|
||||
low = 0,
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
//! race conditions in distributed state machines.
|
||||
|
||||
const std = @import("std");
|
||||
const manifest = @import("manifest.zig");
|
||||
const manifest = @import("./manifest.zig");
|
||||
|
||||
pub const ReorderBuffer = struct {
|
||||
allocator: std.mem.Allocator,
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
//! consistency and preventing race conditions in the Reality Tunnel.
|
||||
|
||||
const std = @import("std");
|
||||
const manifest = @import("manifest.zig");
|
||||
const manifest = @import("./manifest.zig");
|
||||
|
||||
/// Sorts a slice of PacketSummaries deterministically.
|
||||
/// Ordering Doctrine:
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
//! - Pruning works by deleting entire segment files (extremely fast).
|
||||
|
||||
const std = @import("std");
|
||||
const lwf = @import("lwf");
|
||||
const lwf = @import("../lwf.zig");
|
||||
|
||||
pub const SEGMENT_MAGIC: [4]u8 = "LOPQ".*;
|
||||
pub const SEGMENT_VERSION: u8 = 1;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
//! for prioritized resource allocation.
|
||||
|
||||
const std = @import("std");
|
||||
const quota = @import("quota.zig");
|
||||
const quota = @import("./quota.zig");
|
||||
|
||||
pub const TrustResolver = struct {
|
||||
context: ?*anyopaque,
|
||||
|
|
|
|||
|
|
@ -9,16 +9,14 @@
|
|||
//! Orchestrates the flow: [Network] -> [UTCP] -> [OPQ] -> [Application]
|
||||
|
||||
const std = @import("std");
|
||||
const utcp = @import("utcp");
|
||||
const opq = @import("opq");
|
||||
const lwf = @import("lwf");
|
||||
const quarantine = @import("quarantine");
|
||||
const utcp = @import("./utcp/socket.zig");
|
||||
const opq = @import("./opq.zig");
|
||||
const lwf = @import("./lwf.zig");
|
||||
|
||||
pub const L0Service = struct {
|
||||
allocator: std.mem.Allocator,
|
||||
socket: utcp.UTCP,
|
||||
opq_manager: opq.OPQManager,
|
||||
quarantine_list: quarantine.QuarantineList,
|
||||
|
||||
/// Initialize the L0 service with a bound socket and storage
|
||||
pub fn init(allocator: std.mem.Allocator, address: std.net.Address, base_dir: []const u8, persona: opq.Persona, resolver: opq.trust_resolver.TrustResolver) !L0Service {
|
||||
|
|
@ -26,12 +24,10 @@ pub const L0Service = struct {
|
|||
.allocator = allocator,
|
||||
.socket = try utcp.UTCP.init(allocator, address),
|
||||
.opq_manager = try opq.OPQManager.init(allocator, base_dir, persona, resolver),
|
||||
.quarantine_list = quarantine.QuarantineList.init(allocator),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *L0Service) void {
|
||||
self.quarantine_list.deinit();
|
||||
self.socket.deinit();
|
||||
self.opq_manager.deinit();
|
||||
}
|
||||
|
|
@ -53,7 +49,6 @@ pub const L0Service = struct {
|
|||
if (!frame.verifyChecksum()) return error.ChecksumMismatch;
|
||||
|
||||
// 2. Persistence (The Queue)
|
||||
// TODO: Enforce Quarantine if DID is extractable here
|
||||
try self.opq_manager.ingestFrame(&frame);
|
||||
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -5,10 +5,10 @@
|
|||
|
||||
|
||||
const std = @import("std");
|
||||
const png = @import("png.zig");
|
||||
const mimic_dns = @import("mimic_dns.zig");
|
||||
const mimic_https = @import("mimic_https.zig");
|
||||
const mimic_quic = @import("mimic_quic.zig");
|
||||
const png = @import("./png.zig");
|
||||
const mimic_dns = @import("./mimic_dns.zig");
|
||||
const mimic_https = @import("./mimic_https.zig");
|
||||
const mimic_quic = @import("./mimic_quic.zig");
|
||||
|
||||
pub const TransportSkin = union(enum) {
|
||||
raw: RawSkin,
|
||||
|
|
|
|||
|
|
@ -1,18 +1,16 @@
|
|||
//! RFC-0004: UTCP (Unreliable Transport Protocol) over UDP
|
||||
|
||||
const std = @import("std");
|
||||
const lwf = @import("lwf");
|
||||
const entropy = @import("entropy");
|
||||
const ipc = @import("ipc");
|
||||
const lwf = @import("../lwf.zig");
|
||||
const posix = std.posix;
|
||||
|
||||
/// UTCP Socket abstraction for sending and receiving LWF frames
|
||||
pub const UTCP = struct {
|
||||
fd: posix.socket_t,
|
||||
ipc_client: ipc.IpcClient,
|
||||
|
||||
/// Initialize UTCP socket by binding to an address
|
||||
pub fn init(allocator: std.mem.Allocator, address: std.net.Address) !UTCP {
|
||||
_ = allocator;
|
||||
const fd = try posix.socket(
|
||||
address.any.family,
|
||||
posix.SOCK.DGRAM | posix.SOCK.CLOEXEC,
|
||||
|
|
@ -22,18 +20,13 @@ pub const UTCP = struct {
|
|||
|
||||
try posix.bind(fd, &address.any, address.getOsSockLen());
|
||||
|
||||
// Initialize IPC client (connects on first use)
|
||||
const ipc_client = ipc.IpcClient.init(allocator, "/tmp/libertaria_l0.sock");
|
||||
|
||||
return UTCP{
|
||||
.fd = fd,
|
||||
.ipc_client = ipc_client,
|
||||
};
|
||||
}
|
||||
|
||||
/// Close the socket
|
||||
pub fn deinit(self: *UTCP) void {
|
||||
self.ipc_client.deinit();
|
||||
posix.close(self.fd);
|
||||
}
|
||||
|
||||
|
|
@ -84,37 +77,14 @@ pub const UTCP = struct {
|
|||
return error.InvalidMagic;
|
||||
}
|
||||
|
||||
// 2. Entropy Fast-Path (DoS Defense)
|
||||
if (header.flags & lwf.LWFFlags.HAS_ENTROPY != 0) {
|
||||
if (data.len < lwf.LWFHeader.SIZE + 77) {
|
||||
return error.StampMissing;
|
||||
}
|
||||
const stamp_bytes = data[lwf.LWFHeader.SIZE..][0..77];
|
||||
const stamp = entropy.EntropyStamp.fromBytes(@ptrCast(stamp_bytes));
|
||||
|
||||
// Perform light validation (no Argon2 recompute yet, just hash bits)
|
||||
// This is enough to drop obvious garbage without any allocation.
|
||||
stamp.verify(&[_]u8{0} ** 32, header.entropy_difficulty, header.service_type, entropy.DEFAULT_MAX_AGE_SECONDS) catch |err| {
|
||||
// Log and drop
|
||||
return err;
|
||||
};
|
||||
}
|
||||
// 2. Entropy Fast-Path (DoS Defense) - disabled, needs entropy module from l1_identity
|
||||
// if (header.flags & lwf.LWFFlags.HAS_ENTROPY != 0) {
|
||||
// return error.NotImplemented; // Entropy validation requires l1_identity module
|
||||
// }
|
||||
|
||||
// 3. Decode the rest (Allocates payload)
|
||||
const frame = try lwf.LWFFrame.decode(allocator, data);
|
||||
|
||||
// 4. Hook: Send event to L2 Membrane Agent
|
||||
// TODO: Extract real DID from frame signature/header
|
||||
const placeholder_did = [_]u8{0} ** 32;
|
||||
self.ipc_client.sendPacketReceived(
|
||||
placeholder_did,
|
||||
@truncate(frame.header.service_type),
|
||||
@intCast(frame.payload.len),
|
||||
) catch {
|
||||
// Log but don't fail transport?
|
||||
// std.debug.print("IPC Send Failed: {}\n", .{err});
|
||||
};
|
||||
|
||||
return ReceiveResult{
|
||||
.frame = frame,
|
||||
.sender = std.net.Address{ .any = src_addr },
|
||||
|
|
@ -167,34 +137,35 @@ test "UTCP socket init and loopback" {
|
|||
try std.testing.expect(received_frame.verifyChecksum());
|
||||
}
|
||||
|
||||
test "UTCP socket DoS defense: invalid entropy stamp" {
|
||||
const allocator = std.testing.allocator;
|
||||
const addr = try std.net.Address.parseIp("127.0.0.1", 0);
|
||||
|
||||
var server = try UTCP.init(allocator, addr);
|
||||
defer server.deinit();
|
||||
const server_addr = try server.getLocalAddress();
|
||||
|
||||
var client = try UTCP.init(allocator, try std.net.Address.parseIp("127.0.0.1", 0));
|
||||
defer client.deinit();
|
||||
|
||||
// 1. Prepare frame with HAS_ENTROPY but garbage stamp
|
||||
var frame = try lwf.LWFFrame.init(allocator, 100);
|
||||
defer frame.deinit(allocator);
|
||||
frame.header.flags |= lwf.LWFFlags.HAS_ENTROPY;
|
||||
frame.header.entropy_difficulty = 20; // High difficulty
|
||||
@memset(frame.payload[0..77], 0);
|
||||
// Set valid timestamp (fresh)
|
||||
// Offset: Hash(32) + Nonce(16) + Salt(16) + Diff(1) + Mem(2) = 67
|
||||
const now = @as(u64, @intCast(std.time.timestamp()));
|
||||
std.mem.writeInt(u64, frame.payload[67..75], now, .big);
|
||||
|
||||
// 2. Send
|
||||
try client.sendFrame(server_addr, &frame, allocator);
|
||||
|
||||
// 3. Receive - should fail with InsufficientDifficulty
|
||||
var receive_buf: [1500]u8 = undefined;
|
||||
const result = server.receiveFrame(allocator, &receive_buf);
|
||||
|
||||
try std.testing.expectError(error.InsufficientDifficulty, result);
|
||||
}
|
||||
// Note: Entropy validation test disabled - requires l1_identity module
|
||||
// test "UTCP socket DoS defense: invalid entropy stamp" {
|
||||
// const allocator = std.testing.allocator;
|
||||
// const addr = try std.net.Address.parseIp("127.0.0.1", 0);
|
||||
//
|
||||
// var server = try UTCP.init(allocator, addr);
|
||||
// defer server.deinit();
|
||||
// const server_addr = try server.getLocalAddress();
|
||||
//
|
||||
// var client = try UTCP.init(allocator, try std.net.Address.parseIp("127.0.0.1", 0));
|
||||
// defer client.deinit();
|
||||
//
|
||||
// // 1. Prepare frame with HAS_ENTROPY but garbage stamp
|
||||
// var frame = try lwf.LWFFrame.init(allocator, 100);
|
||||
// defer frame.deinit(allocator);
|
||||
// frame.header.flags |= lwf.LWFFlags.HAS_ENTROPY;
|
||||
// frame.header.entropy_difficulty = 20; // High difficulty
|
||||
// @memset(frame.payload[0..77], 0);
|
||||
// // Set valid timestamp (fresh)
|
||||
// // Offset: Hash(32) + Nonce(16) + Salt(16) + Diff(1) + Mem(2) = 67
|
||||
// const now = @as(u64, @intCast(std.time.timestamp()));
|
||||
// std.mem.writeInt(u64, frame.payload[67..75], now, .big);
|
||||
//
|
||||
// // 2. Send
|
||||
// try client.sendFrame(server_addr, &frame, allocator);
|
||||
//
|
||||
// // 3. Receive - should fail with InsufficientDifficulty
|
||||
// var receive_buf: [1500]u8 = undefined;
|
||||
// const result = server.receiveFrame(allocator, &receive_buf);
|
||||
//
|
||||
// try std.testing.expectError(error.InsufficientDifficulty, result);
|
||||
// }
|
||||
|
|
|
|||
|
|
@ -147,7 +147,8 @@ pub const STANDARD_CONFIG = struct {
|
|||
/// **Kenya Compliance:** Target <100ms for difficulty 8-14 on ARM Cortex-A53
|
||||
///
|
||||
/// **Constant-Time:** Argon2id is designed to be constant-time against timing attacks
|
||||
pub fn create(data: []const u8, difficulty: u8, allocator: std.mem.Allocator) !EntropyStamp {
|
||||
pub fn create(data: []const u8, difficulty: u8, _allocator: std.mem.Allocator) !EntropyStamp {
|
||||
_ = _allocator; // Reserved for future use
|
||||
// Validate difficulty range
|
||||
if (difficulty < 8 or difficulty > 20) {
|
||||
return error.DifficultyOutOfRange;
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
|
||||
const std = @import("std");
|
||||
const crypto = std.crypto;
|
||||
const pqxdh = @import("pqxdh");
|
||||
const pqxdh = @import("pqxdh.zig");
|
||||
|
||||
// ============================================================================
|
||||
// Constants
|
||||
|
|
|
|||
|
|
@ -11,6 +11,11 @@ pub const argon2 = @import("argon2.zig");
|
|||
pub const pqxdh = @import("pqxdh.zig");
|
||||
pub const prekey = @import("prekey.zig");
|
||||
pub const slash = @import("slash.zig");
|
||||
pub const trust_graph = @import("trust_graph.zig");
|
||||
pub const proof_of_path = @import("proof_of_path.zig");
|
||||
|
||||
// Note: qvl_ffi is intentionally NOT exported here to avoid circular dependency
|
||||
// qvl_ffi is built as a separate library and imports from this module
|
||||
|
||||
test {
|
||||
std.testing.refAllDecls(@This());
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
const std = @import("std");
|
||||
const crypto = std.crypto;
|
||||
const pqxdh = @import("pqxdh");
|
||||
const pqxdh = @import("pqxdh.zig");
|
||||
|
||||
// ============================================================================
|
||||
// Constants (Prekey Validity Periods)
|
||||
|
|
|
|||
|
|
@ -16,9 +16,10 @@
|
|||
//! ]
|
||||
|
||||
const std = @import("std");
|
||||
const trust_graph = @import("trust_graph");
|
||||
const time = @import("time");
|
||||
const soulkey = @import("soulkey");
|
||||
const trust_graph = @import("trust_graph.zig");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const time = l0_transport.time;
|
||||
const soulkey = @import("soulkey.zig");
|
||||
|
||||
pub const PathVerdict = enum {
|
||||
/// Path is valid and active
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
//! Complexity: O(|V| × |E|) with early exit optimization.
|
||||
|
||||
const std = @import("std");
|
||||
const time = @import("time");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const types = @import("types.zig");
|
||||
|
||||
const NodeId = types.NodeId;
|
||||
|
|
@ -233,8 +233,8 @@ test "Bellman-Ford: No betrayal in clean graph" {
|
|||
try graph.addNode(1);
|
||||
try graph.addNode(2);
|
||||
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.5, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.3, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.5, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.3, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
|
||||
var result = try detectBetrayal(&graph, 0, allocator);
|
||||
defer result.deinit();
|
||||
|
|
@ -254,9 +254,9 @@ test "Bellman-Ford: Detect negative cycle (betrayal ring)" {
|
|||
try graph.addNode(1);
|
||||
try graph.addNode(2);
|
||||
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.2, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.2, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 2, .to = 0, .risk = -0.8, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 1, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Betrayal!
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.2, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.2, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 2, .to = 0, .risk = -0.8, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 1, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Betrayal!
|
||||
|
||||
var result = try detectBetrayal(&graph, 0, allocator);
|
||||
defer result.deinit();
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
//! until convergence (delta < epsilon). Output: per-node anomaly scores.
|
||||
|
||||
const std = @import("std");
|
||||
const time = @import("time");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const types = @import("types.zig");
|
||||
|
||||
const NodeId = types.NodeId;
|
||||
|
|
@ -229,8 +229,8 @@ test "BP: Converges on clean graph" {
|
|||
try graph.addNode(1);
|
||||
try graph.addNode(2);
|
||||
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.8, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.7, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.8, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.7, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
|
||||
var result = try runInference(&graph, .{}, allocator);
|
||||
defer result.deinit();
|
||||
|
|
@ -249,9 +249,9 @@ test "BP: Detects suspicious node" {
|
|||
try graph.addNode(1);
|
||||
try graph.addNode(2);
|
||||
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.9, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 0, .to = 2, .risk = -0.5, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 1, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Betrayal
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = -0.3, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 1, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Betrayal
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.9, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 0, .to = 2, .risk = -0.5, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 1, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Betrayal
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = -0.3, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 1, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Betrayal
|
||||
|
||||
var result = try runInference(&graph, .{ .max_iterations = 50 }, allocator);
|
||||
defer result.deinit();
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ const types = @import("types.zig");
|
|||
const storage = @import("storage.zig");
|
||||
const betrayal = @import("betrayal.zig");
|
||||
const pathfinding = @import("pathfinding.zig");
|
||||
const pop_integration = @import("pop_integration");
|
||||
const pop_integration = @import("pop_integration.zig");
|
||||
|
||||
const NodeId = types.NodeId;
|
||||
const RiskEdge = types.RiskEdge;
|
||||
|
|
@ -187,7 +187,7 @@ pub const GraphTransaction = struct {
|
|||
|
||||
test "HybridGraph: load and detect betrayal" {
|
||||
const allocator = std.testing.allocator;
|
||||
const time = @import("time");
|
||||
const l0_transport = @import("l0_transport");
|
||||
|
||||
const path = "/tmp/test_hybrid_db";
|
||||
defer std.fs.deleteFileAbsolute(path) catch {};
|
||||
|
|
@ -201,7 +201,7 @@ test "HybridGraph: load and detect betrayal" {
|
|||
defer hybrid.deinit();
|
||||
|
||||
// Add edges forming negative cycle (sum of risks must be < 0)
|
||||
const ts = time.SovereignTimestamp.fromSeconds(1234567890, .system_boot);
|
||||
const ts = l0_transport.time.SovereignTimestamp.fromSeconds(1234567890, .system_boot);
|
||||
const expires = ts.addSeconds(86400);
|
||||
// Trust edges (negative risk = good)
|
||||
try hybrid.addEdge(.{ .from = 0, .to = 1, .risk = -0.7, .timestamp = ts, .nonce = 0, .level = 3, .expires_at = expires });
|
||||
|
|
@ -219,7 +219,7 @@ test "HybridGraph: load and detect betrayal" {
|
|||
|
||||
test "GraphTransaction: commit and rollback" {
|
||||
const allocator = std.testing.allocator;
|
||||
const time = @import("time");
|
||||
const l0_transport = @import("l0_transport");
|
||||
|
||||
const path = "/tmp/test_tx_db";
|
||||
defer std.fs.deleteFileAbsolute(path) catch {};
|
||||
|
|
@ -235,7 +235,7 @@ test "GraphTransaction: commit and rollback" {
|
|||
defer txn.deinit();
|
||||
|
||||
// Add edges
|
||||
const ts = time.SovereignTimestamp.fromSeconds(1234567890, .system_boot);
|
||||
const ts = l0_transport.time.SovereignTimestamp.fromSeconds(1234567890, .system_boot);
|
||||
const expires = ts.addSeconds(86400);
|
||||
try txn.addEdge(.{ .from = 0, .to = 1, .risk = -0.3, .timestamp = ts, .nonce = 0, .level = 3, .expires_at = expires });
|
||||
try txn.addEdge(.{ .from = 1, .to = 2, .risk = -0.3, .timestamp = ts, .nonce = 1, .level = 3, .expires_at = expires });
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
//! Complexity: O(|E| + |V| log |V|) with binary heap.
|
||||
|
||||
const std = @import("std");
|
||||
const time = @import("time");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const types = @import("types.zig");
|
||||
|
||||
const NodeId = types.NodeId;
|
||||
|
|
@ -186,8 +186,8 @@ test "A* Pathfinding: Direct path" {
|
|||
try graph.addNode(1);
|
||||
try graph.addNode(2);
|
||||
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.3, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.2, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.3, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.2, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
|
||||
const dummy_ctx: u8 = 0;
|
||||
var result = try findTrustPath(&graph, 0, 2, zeroHeuristic, @ptrCast(&dummy_ctx), allocator);
|
||||
|
|
@ -244,9 +244,9 @@ test "A* Pathfinding: Multiple paths, chooses shortest" {
|
|||
try graph.addNode(1);
|
||||
try graph.addNode(2);
|
||||
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.4, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.4, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 0, .to = 2, .risk = 0.5, .timestamp = time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Direct shorter
|
||||
try graph.addEdge(.{ .from = 0, .to = 1, .risk = 0.4, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 1, .to = 2, .risk = 0.4, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) });
|
||||
try graph.addEdge(.{ .from = 0, .to = 2, .risk = 0.5, .timestamp = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot), .nonce = 0, .level = 3, .expires_at = l0_transport.time.SovereignTimestamp.fromSeconds(0, .system_boot) }); // Direct shorter
|
||||
|
||||
const dummy_ctx: u8 = 0;
|
||||
var result = try findTrustPath(&graph, 0, 2, zeroHeuristic, @ptrCast(&dummy_ctx), allocator);
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ const types = @import("types.zig");
|
|||
const pathfinding = @import("pathfinding.zig");
|
||||
// Import proof_of_path relative from qvl directory
|
||||
const pop = @import("../proof_of_path.zig");
|
||||
const trust_graph = @import("trust_graph");
|
||||
const trust_graph = @import("../trust_graph.zig");
|
||||
|
||||
const NodeId = types.NodeId;
|
||||
const RiskGraph = types.RiskGraph;
|
||||
|
|
|
|||
|
|
@ -3,9 +3,9 @@
|
|||
//! Extends RFC-0120 TrustEdge with risk scoring for Bellman-Ford.
|
||||
|
||||
const std = @import("std");
|
||||
const time = @import("time");
|
||||
const l0_transport = @import("l0_transport");
|
||||
|
||||
const SovereignTimestamp = time.SovereignTimestamp;
|
||||
const SovereignTimestamp = l0_transport.time.SovereignTimestamp;
|
||||
|
||||
/// Node identifier (compact u32 index into DID storage)
|
||||
pub const NodeId = u32;
|
||||
|
|
|
|||
|
|
@ -9,18 +9,19 @@
|
|||
//! Thread Safety: Single-threaded only (initial version)
|
||||
|
||||
const std = @import("std");
|
||||
const l0_transport = @import("l0_transport");
|
||||
|
||||
const qvl = @import("qvl.zig");
|
||||
const pop_mod = @import("proof_of_path.zig");
|
||||
const trust_graph = @import("trust_graph");
|
||||
const time = @import("time");
|
||||
const slash = @import("slash");
|
||||
const trust_graph = @import("trust_graph.zig");
|
||||
const slash = @import("slash.zig");
|
||||
|
||||
const RiskGraph = qvl.types.RiskGraph;
|
||||
const RiskEdge = qvl.types.RiskEdge;
|
||||
const ReputationMap = qvl.pop.ReputationMap;
|
||||
const ProofOfPath = pop_mod.ProofOfPath;
|
||||
const PathVerdict = pop_mod.PathVerdict;
|
||||
const SovereignTimestamp = time.SovereignTimestamp;
|
||||
const SovereignTimestamp = l0_transport.time.SovereignTimestamp;
|
||||
|
||||
// ============================================================================
|
||||
// OPAQUE CONTEXT
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
const std = @import("std");
|
||||
const crypto = std.crypto;
|
||||
const pqxdh = @import("pqxdh");
|
||||
const pqxdh = @import("pqxdh.zig");
|
||||
|
||||
// ============================================================================
|
||||
// SoulKey: Core Identity Keypair
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@
|
|||
//! Memory budget: 100K nodes = 400KB (vs 6.4MB with raw DIDs)
|
||||
|
||||
const std = @import("std");
|
||||
const soulkey = @import("soulkey");
|
||||
const crypto = @import("crypto");
|
||||
const soulkey = @import("soulkey.zig");
|
||||
const crypto = @import("crypto.zig");
|
||||
|
||||
/// Trust visibility levels (privacy control)
|
||||
/// Per RFC-0120 S4.3.1: Alice never broadcasts her full Trust DAG
|
||||
|
|
|
|||
|
|
@ -17,11 +17,11 @@
|
|||
//! - Nonce (8 bytes)
|
||||
|
||||
const std = @import("std");
|
||||
const time = @import("time");
|
||||
const l0_transport = @import("l0_transport");
|
||||
const proof_of_path = @import("proof_of_path.zig");
|
||||
const soulkey = @import("soulkey");
|
||||
const soulkey = @import("soulkey.zig");
|
||||
const entropy = @import("entropy.zig");
|
||||
const trust_graph = @import("trust_graph");
|
||||
const trust_graph = @import("trust_graph.zig");
|
||||
|
||||
/// Vector Type (RFC-0120 S4.2)
|
||||
pub const VectorType = enum(u16) {
|
||||
|
|
@ -88,7 +88,7 @@ pub const QuasarVector = struct {
|
|||
entropy_stamps: std.ArrayListUnmanaged(entropy.EntropyStamp), // PoW
|
||||
|
||||
// === Metadata ===
|
||||
created_at: time.SovereignTimestamp, // Creation time
|
||||
created_at: l0_transport.time.SovereignTimestamp, // Creation time
|
||||
graphology: GraphologyMeta,
|
||||
nonce: u64, // Replay protection
|
||||
|
||||
|
|
@ -104,7 +104,7 @@ pub const QuasarVector = struct {
|
|||
.signature = [_]u8{0} ** 64,
|
||||
.trust_path = null,
|
||||
.entropy_stamps = .{},
|
||||
.created_at = time.SovereignTimestamp.now(),
|
||||
.created_at = l0_transport.time.SovereignTimestamp.now(),
|
||||
.graphology = std.mem.zeroes(GraphologyMeta),
|
||||
.nonce = std.crypto.random.int(u64), // Secure random nonce
|
||||
.allocator = allocator,
|
||||
|
|
@ -161,7 +161,7 @@ pub const QuasarVector = struct {
|
|||
if (!self.verifySignature()) return .invalid_signature;
|
||||
|
||||
// 2. Time Check
|
||||
const now = time.SovereignTimestamp.now();
|
||||
const now = l0_transport.time.SovereignTimestamp.now();
|
||||
switch (self.created_at.validateForVector(now)) {
|
||||
.valid => {},
|
||||
.too_far_future => return .future_timestamp,
|
||||
|
|
|
|||
|
|
@ -11,7 +11,8 @@
|
|||
//! Implementation: High-performance Zig (Hardware-close).
|
||||
|
||||
const std = @import("std");
|
||||
const lwf = @import("lwf"); // L0 Transport (Wire Frame)
|
||||
const l0_transport = @import("l0_transport");
|
||||
const lwf = l0_transport.lwf;
|
||||
|
||||
pub const PolicyDecision = enum {
|
||||
drop, // Silently discard
|
||||
|
|
|
|||
|
|
@ -5,28 +5,28 @@ const std = @import("std");
|
|||
/// Session configuration
|
||||
pub const SessionConfig = struct {
|
||||
/// Time-to-live before requiring re-handshake
|
||||
ttl: Duration = .{ .hours = 24 },
|
||||
ttl: Duration = .{ .hrs = 24 },
|
||||
|
||||
/// Heartbeat interval
|
||||
heartbeat_interval: Duration = .{ .seconds = 30 },
|
||||
heartbeat_interval: Duration = .{ .secs = 30 },
|
||||
|
||||
/// Missed heartbeats before degradation
|
||||
heartbeat_tolerance: u8 = 3,
|
||||
|
||||
/// Handshake timeout
|
||||
handshake_timeout: Duration = .{ .seconds = 5 },
|
||||
handshake_timeout: Duration = .{ .secs = 5 },
|
||||
|
||||
/// Key rotation window (before TTL expires)
|
||||
rotation_window: Duration = .{ .hours = 1 },
|
||||
rotation_window: Duration = .{ .hrs = 1 },
|
||||
};
|
||||
|
||||
/// Duration helper
|
||||
pub const Duration = struct {
|
||||
seconds: u64 = 0,
|
||||
minutes: u64 = 0,
|
||||
hours: u64 = 0,
|
||||
secs: u64 = 0,
|
||||
mins: u64 = 0,
|
||||
hrs: u64 = 0,
|
||||
|
||||
pub fn seconds(self: Duration) i64 {
|
||||
return @intCast(self.seconds + self.minutes * 60 + self.hours * 3600);
|
||||
return @intCast(self.secs + self.mins * 60 + self.hrs * 3600);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -15,8 +15,6 @@ pub const Handshake = struct {
|
|||
ctx: anytype,
|
||||
) !Session {
|
||||
// TODO: Implement PQxdh initiation
|
||||
_ = peer_did;
|
||||
_ = config;
|
||||
_ = ctx;
|
||||
|
||||
var session = Session.new(peer_did, config);
|
||||
|
|
@ -25,13 +23,12 @@ pub const Handshake = struct {
|
|||
}
|
||||
|
||||
/// Resume existing session
|
||||
pub fn resume(
|
||||
pub fn resumeSession(
|
||||
peer_did: []const u8,
|
||||
stored: StoredSession,
|
||||
ctx: anytype,
|
||||
) !Session {
|
||||
// TODO: Implement fast resumption
|
||||
_ = peer_did;
|
||||
_ = stored;
|
||||
_ = ctx;
|
||||
|
||||
|
|
@ -46,7 +43,6 @@ pub const Handshake = struct {
|
|||
) !Session {
|
||||
// TODO: Implement PQxdh response
|
||||
_ = request;
|
||||
_ = config;
|
||||
_ = ctx;
|
||||
|
||||
return Session.new("", config);
|
||||
|
|
|
|||
|
|
@ -41,8 +41,8 @@ end
|
|||
test "Default configuration is valid" do
|
||||
const config = SessionConfig{};
|
||||
|
||||
try testing.expectEqual(@as(u64, 24), config.ttl.hours);
|
||||
try testing.expectEqual(@as(u64, 30), config.heartbeat_interval.seconds);
|
||||
try testing.expectEqual(@as(u64, 24), config.ttl.hrs);
|
||||
try testing.expectEqual(@as(u64, 30), config.heartbeat_interval.secs);
|
||||
try testing.expectEqual(@as(u8, 3), config.heartbeat_tolerance);
|
||||
try testing.expectEqual(@as(u64, 5), config.handshake_timeout.seconds);
|
||||
try testing.expectEqual(@as(u64, 5), config.handshake_timeout.secs);
|
||||
end
|
||||
|
|
|
|||
Loading…
Reference in New Issue