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프로젝트로 돌아가기