ZEROBASE 백서

ZEROBASE

원문

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 3쪽 중 2쪽

r a specified Worker node. •FIND HUB: Requests the target Hub to return detailed routing information (IP, Port, Node ID) for the K Hubs closest (in logical distance) to a specified target ID. If the optimal K-Bucket does not contain enough entries, results are merged from multiple buckets until K entries are obtained. If fewer than K are known, all available entries are returned. •FIND WORKER: Similar in operation to FIND HUB, but targets a specific Worker node, returning its unique identity information. D. Routing Table Maintenance: K-Bucket Update Mechanism ZEROBASE employs a Kademlia-inspired mechanism for maintaining the integrity and freshness of routing tables. Each Hub maintains 160 K-Buckets, each corresponding to a distinct range of logical distances. The system supports three primary modes of updating K-Buckets: •Active Hub Discovery: A Hub proactively issues FIND HUB requests to refresh the entries in its K- Buckets. •Passive Hub Discovery: Upon receiving RPC requests such as FIND HUB or FIND WORKER from other Hubs, the recipient updates its corresponding K-Bucket with the sender’s information. •Liveness Check and Failure Detection: Periodic PING messages are sent to peers in K-Buckets to determine their availability. Non-responsive nodes are subsequently purged from the table. Upon receiving an RPC message from another Hub y, Hub x executes the following update procedure: •Distance Calculation: Compute the logical distance d(x, y) =x⊕y,, wherexandyare the 160-bit Node IDs. •Bucket Selection: Identify the corresponding K-Bucket based on the value of d(x,y). •Update Logic –If y’s IP is already recorded in the selected K-Bucket, move its entry to the tail of the bucket (indicating recent activity). –If y’s IP is not recorded and the bucket contains fewer than k entries, append (IP, Port, Node ID) of y to the tail. –If the bucket is full: ∗Select the oldest entry z at the head of the bucket and issue a PING. ∗If z fails to respond, remove z and append y’s entry to the tail. ∗If z responds, retain z by moving it to the tail and discard y. This update mechanism implements an efficient least recently seen replacement policy, allowing active, long-lived nodes to persist in the routing table, thereby enhancing network stability and reducing maintenance overhead. By prioritizing persistent nodes, the likelihood that entries remain online in subsequent intervals increases, thereby reducing churn-related inefficiencies. Additionally, this mechanism contributes to resilience against denial-of-service (DoS) attacks, since new entries can only replace existing ones if the latter are verified to be offline, thereby mitigating routing table flooding via malicious node injection. To prevent K-Bucket staleness, the system periodically selects a random Hub from each K-Bucket to perform a PING check if no updates have occurred within a predefined timeout window. This ensures responsiveness without incurring signif- icant overhead. E. Node Admission and Recursive Discovery Mechanisms Maintaining robust network connectivity and efficient task assignment in ZEROBASE relies heavily on dynamic node onboarding and recursive node localization algorithms. This section details the procedures for Worker registration, Hub node admission and departure, and recursive lookup protocols for both node types. 1) Worker Node Admission Protocol:Worker nodes are the computational backbone of the execution layer, responsible for off-chain computation and proof generation. When a new Worker node attempts to join the network, the following admission process is initiated: •Proximity Discovery: A Hub calculates the logical XOR distance between the Worker’s Node ID and all known Hubs, identifying the K closest Hubs. •Registration Broadcast: The initiating Hub sends ADD WORKER commands to these K Hubs, informing them of the new Worker’s existence. •State Recording: Each recipient Hub updates its local state table, adding the Worker to its distributed index. •Periodic Re-advertisement: Each of the K Hubs period- ically (e.g., hourly) re-broadcasts Worker information to ensure discoverability. •Expiration Policy: Worker records automatically expire 24 hours after publication to prevent outdated or invalid references. This protocol enables fault-tolerant, decentralized indexing of Worker nodes while ensuring discoverability and consistency across the network. 2) Hub Node Admission and Departure Protocol:To join the network, a new Hub node x must connect to at least one existing bootstrap node y. The admission proceeds as follows: 6 •Bootstrap Contact: Node x initiates a connection to bootstrap node y and adds y to its initial K-Bucket. •Initial Lookup: Hub x sends a FIND HUB request to y, using x’s own Node ID as the target. •Neighbor Discovery: Node y replies with the K Hubs closest to x, which x then adds to its own routing table. •Iterative Expansion: Hub x recursively issues FIND HUB requests to the newly discovered Hubs until its routing table reaches sufficient coverage. This process guarantees rapid integration of new nodes into the network’s logical topology. Hub departures are handled implicitly through passive ex- piration. Neighboring Hubs detect failed nodes via periodic PINGs and automatically remove them from their K-Buckets. This self-healing property aligns with the “Sleepy Model” of asynchronous consensus [21], allowing nodes to temporarily go offline without compromising the system’s security or liveness guarantees. 3) Recursive Hub Lookup Algorithm:To locate a Hub with target Node ID y, Hub x initiates a recursive lookup as follows: •Distance Computation: Calculate the logical distance d(x, y) =x⊕y. •Bucket Selection: Determine the appropriate K-Bucket by computing⌊logd⌋and select up toαcandidate Hubs. •Initial Query: Send FIND HUB to theseαcandidates. •Recursive Expansion: –If any queried node has ID y, it responds with its own metadata. –Otherwise, each queried Hub measures its own dis- tance to y and returnsαcloser candidates from its routing table. –Hub x repeats this process until it collects K Hubs closest to y, or until no closer candidates can be found. This recursive approach ensures convergence even if the exact target does not exist in the network, and provides robust pathfinding through the XOR metric. The parameterα= 3is chosen to balance search parallelism with messaging overhead. F . Recursive Worker Lookup Protocol To discover a specific Worker node, a recursive lookup is initiated, analogous to Hub resolution. For instance: •Let Hub 1 have ID = 00000110, and it aims to locate a Worker with Node ID = 00010000. •The XOR distance is00000110⊕00010000 = 00010110, i.e., decimal 22, which falls within the distance range of K-Bucket 5 (i.e.,[24,25)[2 4,2 5)[24,25)). •Hub 1 examines its K-Bucket 5: –If the Worker is managed by a known Hub (e.g., Hub2), Hub 1 directly queries Hub 5. –If not, Hub 1 selects a candidate Hub 3 from the bucket and instructs it to continue the search. –If Hub 3 lacks the desired Worker, it returns a closer Hub4, and the search continues recursively. This recursive convergence ensures resilient and efficient Worker localization, even under frequent topology changes or partial routing failures. G. Threat Models and Security Analysis in Distributed Net- works In the context of the open-access and highly decentralized architecture of the ZEROBASE network, the system is in- herently exposed to a wide range of adversarial threats. The permissionless nature of node participation and the dynamic evolution of routing state significantly heighten the attack surface. This section identifies and analyzes four critical attack vectors that pose substantial risks to network stability and integrity: Sybil Attacks, Eclipse Attacks, Churn Attacks, and Adversarial Routing Attacks. 1) Sybil Attacks:A Sybil attack refers to a scenario in which a malicious Hub node illegitimately assumes multiple identities within the network, with each instance referred to as a Sybil Hub [22], [23]. The attacker leverages these false identities to gain disproportionate influence over the network. The implications of such an attack include: •Injection of Fake Hubs: In a permissionless network, at- tackers may issue repeated join requests to elicit neighbor lists from responding nodes. This enables the attacker to map out large portions of the network topology, facilitating further targeted disruption. •Routing Table Manipulation: Routing in ZEROBASE relies on timely inter-Hub announcements to maintain accurate routing tables. By impersonating multiple Hubs, a Sybil attacker can infiltrate the routing tables of honest nodes and mislead their routing decisions. In extreme cases, this behavior may escalate into an Eclipse attack. •Fake Resource Publication: Malicious nodes may regis- ter fabricated Worker nodes and advertise them to the network. Upon receiving computational tasks, these fake Workers drop requests silently. A proliferation of such bogus Workers degrades the system’s proof-generation efficiency and reduces overall throughput. 2) Eclipse Attacks:An Eclipse attack occurs when an attacker successfully populates a victim Hub’s K-Buckets with malicious nodes, thereby isolating the victim from the legitimate network [24], [25]. To execute such an attack, the adversary must first establish a sufficient number of Sybil Hubs and then strategically position them into the routing table of the target Hub. The impact of Eclipse attacks includes: •Data Inaccessibility: The victim is unable to communicate with legitimate nodes, leading to failed or delayed data queries. •Routing Degradation: Polluted routing tables may cause recursive loops or redirections to invalid nodes, severely impairing query efficiency. •Network Partitioning: When multiple Hubs are simulta- neously compromised, the network may fragment into isolated subnetworks, undermining both decentralization and fault tolerance. 3) Churn Attacks:Churn attacks exploit the natural toler- ance of distributed networks to dynamic node participation. In such attacks, adversaries intentionally induce high rates of node join and leave events to disrupt the system’s operational stability. Though distributed systems are generally resilient to 7 organic churn, artificially elevated churn levels can lead to the following consequences: •Degraded Network Performance: Constant reconfigura- tion of routing tables and rebalancing of data increase latency and reduce query success rates. •Reduced Worker Availability: Frequent node churn causes Workers to disappear or become unreachable, interrupting proof generation and task execution. •Diminished Hub Reliability: Legitimate Hubs may appear unstable due to frequent route inconsistencies or update failures, diminishing their trust scores and participation. 4) Adversarial Routing Attacks:Adversarial routing at- tacks involve the deliberate manipulation of routing paths by a malicious entity to intercept, misdirect, or suppress network traffic. These attacks target the integrity and availability of routing operations, and their effects include: •Routing Table Corruption: By injecting falsified routing information or exploiting vulnerabilities in route prop- agation, adversaries can steer the routing behavior of legitimate nodes. •Path Hijacking and Traffic Control: The attacker may redirect traffic through compromised nodes, enabling eavesdropping, tampering, or traffic analysis. •Response Forgery and Data Poisoning: During routing or query resolution, attackers may forge or alter response messages, leading to failed queries or data inconsisten- cies. •Communication Disruption: By obstructing connectivity between selected nodes and the broader network, ad- versaries can induce partial network outages or create partitioned subgraphs. IV. PRIVACY-PRESERVINGCOMPUTATION The ZEROBASE architecture realizes a native privacy- preserving execution environment through tightly coordinated layers of TEE + ZKP + Proof Mesh, enabling sensitive off- chain data to be processed under trusted conditions while publishing verifiable results in zero-knowledge. This ensures confidentiality, verifiability, and immutability throughout the computation lifecycle. This privacy-computation framework not only enforces data security but also encapsulates a reusable set of mechanisms and algorithmic constructs. A. Data Confidentiality Mechanisms: End-to-End Encryption & Enclosed Execution ZEROBASE’s privacy framework safeguards data across its full lifecycle, maintaining encryption especially during untrusted off-chain processing: •On-chain Input Encryption. Prior to on-chain submission or dispatch to a Worker, all user data is encrypted, denoted as Enc(data), via symmetric encryption combined with session key wrapping, ensuring that only the target Worker’s TEE can decrypt and process it. This protocol preserves confidentiality during transit, thwarting man-in- the-middle exposures. •TEE Enclosed Execution Model. Within the Worker node’s local Trusted Execution Environment, the en- crypted data is decrypted and processed in isolation [26] . The execution pipeline comprises: –Decryption of input data strictly within the TEE boundary; –Execution of the private model or strategy logic in a sealed environment; –Output generation, re-encrypting results before ex- posing them; –Zero-Knowledge Proof (ZKP) generation, enabling verifiable correctness without revealing inputs or internal states. •Intermediate states are purged, and no residual traces are left, ensuring both data confidentiality and resistance to tampering. •Cryptographic Hardware Protections. ZEROBASE lever- ages hardware-backed isolation technologies such as AMD SEV , Intel TDX, and ARM CCA to enforce en- cryption of memory and logical I/O barriers [13–15], ensuring data confidentiality even during computation. Future extensibility includes optional Fully Homomor- phic Encryption (FHE) to support end-to-end private computation without exposing plaintext at any stage [27]. This architecture’s use of encryption, secure execution en- claves, and hardware isolation reflects an evolution from predecessors that decoupled verification and privacy within blockchain systems [28], [29], promoting a decentralized, minimally-trusted privacy infrastructure. B. Verifiability Mechanisms: ZKP Generation from Execution Context To support on-chain verification of privately computed results, ZEROBASE introduces a formal modeling framework that translates off-chain computation into zero-knowledge con- straints: •Context-Aware Circuit Templates. ZEROBASE supplies a library of standardized ZKP circuit templates tailored to various private computation tasks: –Range Checks (range check): Assert numerical val- ues fall within prescribed intervals. –Model Inference Proofs (model inference): Verify the correctness of model output given an input. –Data Transformation Checks (data transformation): Confirm validity of state transitions. •Each template maps a specific task type to an appropriate circuit construction. •Constraint System Assembly:Upon completion of TEE execution, essential elements—input, state, intermediate variables, and output—are extracted to construct an R1CS or AIR constraint system. Efficient proof systems (e.g., Groth16, PLONK) are then instantiated to generate zk- SNARK or zk-STARK proofs. The public inputs covering the state and context enable on-chain smart contract verification of correctness without exposing sensitive information. 8 •Algorithmic Optimizations: –Witness Compression: Reduces proof size by pruning redundant witness components. –Recursive Proofs: Enable merging or nesting of mul- tiple proof stages to streamline on-chain verification. –Circuit Parameterization: Tailors templates to spe- cific application requirements, aiding rapid deploy- ment and efficiency. C. Composability Mechanisms: Encapsulation within the Proof Mesh The Proof Mesh layer acts not only as a transport inter- mediary but also as an orchestrator of composable privacy operations, as detailed below: •Modular Task Abstraction: Each privacy computation is encapsulated as a self-contained module: Task := (Inpu- tEnc, StrategyHash, ZKP Circuit ID, OutputDigest, Proof π) –InputEnc: Encrypted input payload [30] –StrategyHash: Digest of the execution logic –ZKP Circuit ID: Identifier for the applicable circuit template –OutputDigest: Hash summarizing the result –Proofπ: ZK proof certifying correct execution •Inter-Module Proof Reuse: –Cross-module chaining: Outputs of one task can serve as inputs for another, supporting sequences of private computations. –Off-chain closed-loop flows: Users can trigger pri- vate model inferences, followed by further private computation or contract interactions. –Cross-DApp privacy interoperability: Different ap- plications can share validated proofs, fostering a decentralized privacy-computation network. •Versioning & Context Packaging. Each task carries ex- ecution metadata—e.g., user ID hash, timestamp, and strategy hash—and forms part of a proof chain with traceability. Subscribers can monitor proof publication events or task status, supporting transparent, composable orchestration. This embraces recent advances in privacy- aware domain-specific languages that embed safety guar- antees at the abstraction layer [31]. D. Security Foundations & Attack-Resistance Strategies ZEROBASE embeds multi-layered security constructs across its execution, proof, and mediation layers, establishing defense-in-depth against adversarial threats, passive snooping, and tampering. 1) TEE Layer Protections: •Remote Attestation. Prior to execution, each Worker exchanges hardware-signed attestations with the network, ensuring only genuine TEEs participate [23], [32]. •Encrypted Storage & Isolated I/O. Data remains en- crypted within TEE storage, with all in/out channels logi- cally isolated to resist side-channel and memory snooping attacks. Hardware-enforced safeguards (e.g., AMD SEV , Intel TDX) underpin this confidentiality. •Strategy-Fingerprint Binding. Each execution task ref- erences a StrategyHash bound to the proof context to validate that only vetted computation logic was executed, preventing code tampering or malicious substitution. 2) ZKP Layer Protections: •Data Confidentiality by Construction. The proof systems completely conceal input data while validating correct- ness. Optional differential privacy mechanisms can be employed to resist statistical inference from proof leaks [33]. •Anti-Replay Protections. Proof bundles include unique task identifiers and timestamps to prevent replay or con- text substitution attacks. •Circuit Auditing & Registry. All ZKP circuit templates are subject to mandatory security audits and registration to ensure correctness, absence of backdoors, and logical consistency. 3) Proof Mesh Layer Protections: •Multi-Signature Validation. Every proof package in- cludes cryptographic signatures and metadata annota- tions—indicating task provenance, execution lineage, and node identity—to enable verifiers to authenticate proof integrity. •Linked Proof Chain for Traceability. Proofs are chained by including previous output hashes as public inputs to subsequent tasks. This constructs an auditable directed acyclic structure that resists partial tampering or disloca- tion attacks. •Zero-Trace Mode. For high-security tasks, metadata can be encrypted or suppressed so that proof publication leaves no observable traces, mitigating metadata analysis and profiling. Through these layered security mechanisms—spanning hardware-based trust, cryptographic soundness, and orchestrated mediation—ZEROBASE delivers a robust privacy-computation framework. It is intrinsically resistant to manipulation, eavesdropping, and structural vulnerability, empowering trustworthy execution in applications ranging from DeFi to privacy-preserving AI inference. V. USERENGAGEMENTPATHWAYS ANDAPPLICATION ARCHITECTURE The ZEROBASE network is design
프로젝트로 돌아가기