Abstract A smart contract fundamentally consists of code deployed on the blockchain, noted for its transparent and unchangeable execution. These characteristics, however, also expose it to attackers once any weaknesses are present. In recent years, attacks targeting smart contracts have caused substantial financial losses, highlighting the importance of robust vulnerability detection approaches. Conventional detection techniques, which rely on contextual semantics or symbolic execution, often face limitations in efficiency. Although neural network-based approaches have enhanced detection speed, they frequently compromise accuracy. This study introduces a framework for identifying and repairing vulnerabilities in smart contracts by utilizing multi-relational graphs combined with a pre-trained model. Initially, a Multi-Relational Graph (MRG) is constructed to represent the multi-dimensional aspects of execution logic and data dependencies by integrating multiple program feature graphs. To reduce interference from extraneous code, contract slices are then generated according to node and edge types defined within the MRG. These vectorized slices are subsequently processed by a pre-trained model called SCCodeBERT for both detection and repair of potential vulnerabilities. Experiments show that SCCodeBERT achieves an average accuracy of 96.06% and an F1-score of 90.90% on mainstream vulnerability datasets. Moreover, it reaches an average repair effectiveness of 86.42%, significantly outperforming current baseline approaches. This work presents a highly effective automated solution for enhancing smart contract security, offering notable theoretical and practical contributions.
Modern information protection methods are primarily focused on increasing computational complexity: it is assumed that a task becomes secure if finding the true message requires too many resources. However, virtually all existing models --- from classical cryptanalysis to autonomous AI agents and retrospective analysis systems (Harvest \& Analyze) --- rely on one common assumption: there exists a verification signal that allows distinguishing the true interpretation from the set of false ones. In this work, we present the \textbf{HYBRA MIRAGE} storage architecture, which is based on a different problem formulation. Instead of increasing computational complexity, we propose to eliminate the very criterion of truth upon which directed search is based. The system constructs a space of plausible interpretations and physically excludes the possibility of repeated access to the used reference space~$V$: each of its vectors is applied exactly once and then destroyed on both sides. As a result, the function $\mathsf{Assemble}(C,K,p)$ remains deterministic and total, and any valid access parameter produces a formally correct result. Even with full access to the reference space $V$ and the PIN code, an autonomous analytical agent does not obtain a mechanism to confirm that the found interpretation corresponds to the original message: each vector from $V$ was used exactly once and physically destroyed. The $\mathsf{Assemble}$ algorithm is a trade secret and is not available to the analyst. Consequently, knowledge of $V$ without knowledge of the algorithm allows generating $10^{35}+$ equivalent interpretations, but does not allow singling out the single true one among them. The proposed approach does not make brute force computationally impossible; it makes the claim that the found interpretation is precisely the one embedded by the sender unprovable. Increasing computational resources, applying more sophisticated models, or massive enumeration can produce more candidates, but do not create a procedure that allows mathematically justifying the choice of a single true interpretation. For autonomous AI agents, this leads to the disappearance of the verification signal necessary for directed search. The loss function surface degenerates into a plane with zero gradient: no iterative optimization algorithm can converge to the true parameter faster than random guessing. HYBRA MIRAGE does not compete with classical cryptographic algorithms and does not replace them. The architecture serves as an environment model for analyzing the behavior of autonomous agents under conditions of the absence of a reliable verification signal and can be used as an infrastructure layer on top of existing storage methods. The architecture does not eliminate the agent's ability to generate candidates; it eliminates the possibility of using the generation result as proof of achieving truth. The analyst finds themselves trapped in a state of epistemic equilibrium, where truth and hallucination are architecturally indistinguishable from each other.
Blockchains have evolved from simple distributed ledgers into programmable platforms that process complex application logic and carry significant financial value. All modern Web3 systems share a common goal: providing secure, decentralized, and trustworthy execution in an increasingly interconnected environment. However, this evolution has shifted the attack surface from isolated infrastructure disruptions to programmable economic abuse and cross-domain exploits. In this article, we focus on the research of blockchain attacks and defenses. In particular, we categorize the threat landscape and corresponding mitigation strategies according to both a four-tier layered architecture (network, cryptographic, consensus, and application) and cross-domain trust boundaries. We seek to answer these important questions: How has the research in blockchain security evolved over the past decade, especially with the rise of decentralized finance (DeFi) and cross-chain interoperability? How do local security assumptions fail when protocols are composed, and what are the driving needs for Web3 security research in the future?
CapIX is a decentralized physical infrastructure network (DePIN) designed to aggregate volatile, untrusted consumer-grade hardware and public container fleets into a single high-performance compute fabric. This technical report presents a practical dual-runtime execution model that addresses the core multi-tenant security challenges on untrusted permissionless hosts. On hardware-virtualization-capable bare-metal nodes, CapIX deploys lightweight micro-VMs isolated by hardware Trusted Execution Environments (TEEs). On standard unprivileged edge containers, it utilizes strict process-level sandboxing, syscall filtering allow-lists, and direct GPU passthrough to achieve native CUDA/ROCm execution performance. The system coordinates fleet routing using a transparent, multi-factor weighted geometric scoring engine resistant to economic manipulation. To achieve scalable, lightweight state verification without the prohibitive overhead of full zero-knowledge proofs on every job, the architecture introduces an interactive bisection fraud game that isolates deterministic instruction disputes to a single step for targeted zkVM proof generation, relying on probabilistic canary spot-checking for non-deterministic workloads.
Open access
2 source records
Security and Verification in Computing
Physical Unclonable Functions (PUFs) and Hardware Security
Aletheia is a knowledge substrate organized around a write-time admission gate: a fact is accepted only if it does not structurally contradict what the base already holds. The gate inherits a Lean 4 soundness proof, so the admitted store stays acyclic, asymmetric, type-disjoint, and temporally consistent under any stream of typed edges. We bind the proof to the implementation by differential testing over 104 adversarial inputs, zero divergences. We first tried to build a partial-truth disinformation detector on this gate. Measurement refused. On real political claims almost nothing decomposes into the gate’s six relations: 0 of 155 atoms were gate-testable, and where it did fire it lost to a cold language model, 0 of 21 against 17. Most real disinformation violates truth, not structure, so a structural gate is the wrong instrument. We retract the detector claim. What remains is a guarantee rather than a rate. Each catch names the axiom it violated; the verdict is bit-exact and carries a machine-checked admission proof; and a safety property whose core is now machine-checked in Lean holds that no finite feed of self-asserted credibility can mint a false endorsement, conditional on authority granted upstream (0 of 210 adversarial sequences, against 140 of 210 for a credibility-naive baseline). A frontier model matches our hit-rate on constructed distortions, and a reasoning model matches even our one structural edge, so we claim no detection advantage. We claim instead that the jurisdiction of a structural guarantee can be measured, and we measure it across two regimes: where the base lets it adjudicate, and where it abstains.
Smart contract vulnerabilities are predominantly logic bugs whose detection requires structured, step-by-step procedural knowledge of attack patterns and contract semantics. Existing LLM-based methods struggle to generate this knowledge automatically: prompt-based methods rely on manually crafted detection rules, while fine-tuning requires massive labeled datasets that are inherently scarce in this domain. We present EvoVuln, an automated framework that reformulates vulnerability detection as a procedural knowledge evolution problem, synthesizing and refining detection logic using only a minimal number of labeled samples. To achieve this, EvoVuln introduces two key mechanisms. First, a Runtime with an Inversion of Control (IoC) architecture compiles detection rules into Executable Policies. This strictly decouples deterministic control flow from LLM semantic reasoning, ensuring faithful logical adherence and producing dense diagnostic telemetry for precise error localization. Second, a two-phase evolution pipeline refines the rule via abductive semantic debugging without any parameter updates: Cold Start bootstraps and stress-tests an initial rule using auto-synthesized corner cases; Few-Shot Evolving then grounds the policy in real-world semantics using only five vulnerable and five safe examples per vulnerability type. Evaluated across five real-world vulnerability types, EvoVuln achieves a 71% macro-average F1-score, outperforming all baselines. The evolved procedural knowledge is portable across models: it enables a lightweight, low-cost model to surpass a much larger zero-shot model by 19 percentage points, and transfers to other LLMs without retraining, at a one-time evolution cost under $50.
Zero-Knowledge Proof (ZKP) is a cornerstone in privacy-preserving computing, addressing critical challenges in domains such as finance and healthcare by ensuring data confidentiality during computation. However, the high computational overhead of ZKP, particularly in proof generation and verification, limits its scalability and usability in real-world applications. Existing efforts to accelerate ZKP primarily focus on specific components, such as polynomial commitment schemes or elliptic curve operations, but fail to deliver an integrated, flexible, and efficient end-to-end solution that includes witness generation on commercial computing platforms.
Abstract Smart contracts are the fundamental building block of decentralized applications (DApps) and decentralized finance (DeFi). However, their immutability makes security flaws exceptionally costly. Despite advancements in vulnerability detection, such as static and dynamic analysis, formal verification, and Solidity language improvements, vulnerabilities continue to result in substantial financial losses, exceeding $2 billion in 2024 alone. This paper presents a comprehensive analysis of smart contract vulnerabilities derived from real-world exploits, systematically categorized into seven distinct types. Each category is illustrated with Solidity code examples and insights from notable exploits. An Enhanced test suite is developed by restructuring the existing solidity-defects-and-bugs suite and supplementing it with new smart contract implementations to address underrepresented vulnerabilities, including flash loan and price oracle manipulation. We evaluate three widely used analysis tools (Slither, Mythril, and 4naly3er) on both the original and Enhanced suites, revealing substantial limitations in detection coverage. To address these limitations, we introduce the Solidity Defects and Bugs Analysis (SDABA), which incorporates advanced analyses and detectors to identify 28 vulnerability variations across both suites. Results on the SDB and Enhanced test suites show that SDABA improves overall precision, recall, and F1-score compared with the evaluated tools. Finally, we release the source code, test suite, and vulnerability reports to support future research in smart contract security.
Jianzhong Su, Mingxi Ye, Jiachi Chen, Yuhong Nan · 7 authors
With the rapid development of decentralized applications, many malicious actors exploit smart contract vulnerabilities for launching attacks. Moreover, as smart contracts utilize more state variables to support complex functionalities, some vulnerabilities require specific states to trigger (marked as vulnerable states), bringing new challenges to the vulnerability detection task. Although many smart contract fuzzers have been proposed for this task, they face limitations due to their inability to efficiently explore smart contract states. To address this challenge, we propose a novel fuzzer, Odyssey, with fine-grained state modeling and exploration, which increases the probability of reaching vulnerable states. We improve the efficacy of the fuzzer with two key mechanisms: (1) modeling an essential state space consisting of the variables related to sensitive operations to compress the exploration scope; (2) designing state-aware exploration strategies to identify test seeds that cover new state scope or cause new state transitions, to improve the efficiency of exploration. To evaluate the performance in vulnerability detection, we adopt Odyssey to a labeled benchmark consisting of 130 vulnerable contracts. Odyssey detects at least 70% more vulnerabilities than other fuzzers. Moreover, we evaluate Odyssey on a dataset that consists of 143 DApps (involving 437 contracts) from real-world security incidents. The experimental results demonstrate that state-aware feedback enhances the ability of Odyssey in state exploration by achieving 19% higher state coverage. Meanwhile, Odyssey totally finds 15 exploits of vulnerabilities from real-world attacks, showing its advantage in detecting real-world vulnerabilities.
Smart contracts underpin a wide range of decentralized applications—from financial services to supply-chain management—but their immutability and direct control of assets magnify the impact of any security bugs. Although many fuzz approaches have been proposed and have demonstrated their effectiveness in uncovering vulnerabilities, existing methods often rely on unguided random mutation scheduling, generate redundant inputs, and fail to adapt to smart contract-specific characteristics. To overcome these challenges, we present FuzzMaster, a feedback-driven fuzzing framework that combines deep reinforcement learning (DRL) with lightweight probabilistic scheduling to steer mutation selection at runtime intelligently. By continuously analyzing execution feedback—code coverage, function-call sequences, and vulnerability signals—FuzzMaster’s DRL agent and probabilistic tables prioritize high-impact mutations and avoid wasted effort on redundant seeds. On standard VeriSmart and SmartBugs benchmarks, FuzzMaster achieves a 66.2% detection rate with 100% precision (versus 46.9% for ItyFuzz and 43.1% for Confuzzius) and uncovers most bugs within the first second of execution. Meanwhile, in real-world Ethereum contracts, FuzzMaster identified 97 vulnerabilities in 6 categories. These results demonstrate that dynamic, vulnerability-aware mutation scheduling can dramatically improve both the efficiency and effectiveness of smart contract fuzz testing.
Smart contracts have achieved significant success, however, their security remains a long-standing challenge. The immutability and transparency of smart contracts require establishing a strong mechanism to prevent private leakage and trusted data tampering. Apart from traditional logic and code-level vulnerabilities arising from insufficient control over contract variables and function parameters, smart contracts may store private-dependent information in blockchain records, which is a critical type of vulnerability, but often overlooked in existing security analysis. In this paper, we present an automated approach for synthesizing security policies, named SmartIFSyn, to eliminate information flow vulnerabilities in smart contracts. We formalize the semantics of Solidity, the most widely used smart contract language, and analyze information flow security of Solidity smart contracts from two perspectives: local-variable security and global-interaction security. We present a type system to guide the elimination of local-variable vulnerabilities by inferring a policy and resort to constraint solving to synthesize a desired policy in case that the type system fails. The policy ensures both local-variable and global-interaction security while it is maximally aligned with user preference. Furthermore, the policy can be subsequently converted into enforceable specifications. We implement our approach in a tool and evaluate it on 17,160 real-world Ethereum smart contracts. The experimental results demonstrate the efficacy of our approach, e.g., detected 243 vulnerabilities in 223 real-world Ethereum smart contracts.
Abstract When resource-constrained Internet of Things (IoT) terminals connect to industrial control, sensing, and edge systems, it is necessary to balance low-overhead authentication, credential privacy protection, and cross-platform deployment. Traditional password and USBKEY authentication methods rely on static credentials and certificate mechanisms, which are vulnerable to eavesdropping, replay, and forgery attacks, while simultaneously suffering from privacy leakage and high platform adaptation costs. To address these issues, this paper proposes a hardware-assisted zero-knowledge authentication scheme for resource-constrained terminals. It utilizes a USBKEY as the local trusted hardware carrier and introduces a quadratic constrained zero-knowledge proof protocol under the Generalized Subspace Vector Oblivious Linear Evaluation framework (GSVOLE-2DLC) to construct a session-bound dynamic authentication process. In the registration phase, the scheme binds protocol parameters with user credentials and writes them into the USBKEY. In the authentication phase, the server (acting as the verifier \((\mathcal{V})\)) generates a random challenge, and the USBKEY (acting as the prover \((\mathcal{P})\)) generates temporary proof parameters based on local witness information. Subsequently, the verifier \((\mathcal{V})\) completes the verification through constraint consistency and GSVOLE consistency, thereby avoiding the transmission of original identity credentials over the network. To adapt to terminals with varying computational capabilities, this paper further designs configurable finite field parameters and cross-platform modular arithmetic interfaces, which are implemented in a PowerPC-architecture USBKEY prototype and a host-side verification environment. Experimental results demonstrate that under the parameter configuration of a 64-bit prime field, \((n_C=4)\), \((k_C=3)\), \((d_C=3)\), \((\ell=2)\), and \((t=7)\), the total system authentication time is approximately 0.5476 s, and the verification time for the verifier \((\mathcal{V})\) is 0.0031 s. Protocol performance and functional tests indicate that the proposed scheme can correctly execute identity authentication under the assumed threat model, making it suitable for IoT edge scenarios requiring privacy protection and lightweight authentication.
We present SmarTrim, a new symbolic execution technique for detecting vulnerabilities in smart contracts. Smart contracts require rigorous safety validation since flaws in them can cause significant financial loss. Numerous symbolic execution techniques, which generate vulnerable transaction sequences to trigger and help understand vulnerabilities, have been extensively studied to enhance the security and safety of smart contracts. However, their performance remains unsatisfactory due to the extremely large search space for transaction sequences. To mitigate this issue, SmarTrim introduces a novel technique that safely reduces the search space by detecting and pruning redundant transaction sequences. Experimental results show that SmarTrim greatly outperforms eleven state-of-the-art analyzers in detecting critical vulnerabilities in real-world smart contracts.
텔레메트리 데이터의 무결성은 자동화와 안전 의사결정의 핵심 기반이지만, 기존 방식은 애플리케이션 신뢰와 원시데이터 보관에 의존하여 프라이버시 보호와 감사 가능성 측면에서 한계를 가진다. 이에 본 논문은 값을 공개하지 않고 정책 준수 여부를 입증할 수 있는 영지식증명 기반의 무결성 메커니즘을 제안한다. 제안된 메커니즘은 커밋, 증명, 온체인 검증, 정책 버전 앵커링, 집계 운용을 단일 절차로 통합하여, 데이터 노출 없이 정책 준수 판정과 재현 가능한 감사를 가능하게 한다. 또한 블록체인에 판정 결과와 정책 버전을 기록하여 판정의 불변성과 재현성을 확보하고, 집계 증명을 통해 다건 제출의 검증 호출을 줄여 검증 효율성을 향상시킨다. 결과적으로 본 논문은 데이터 무결성, 프라이버시, 감사 가능성, 비용 효율성을 동시에 충족하는 새로운 텔레메트리 신뢰 모델을 제시한다.
Certification of digital documents, such as academic credentials, seems a particularly suitable application for the use of blockchain and distributed ledger technologies. Indeed, these technologies enable decentralized certification systems that rely on the immutability and persistence of their distributed ledgers. However, in the absence of a central trusted authority, it is not easy to guarantee the authenticity of the connection between the real identity of an academic institution and the digital identity of the certificate issuer. In this paper, we demonstrate that one of such systems, known as Block.co, has a vulnerability that allows the production of forged certificates that are recognized as valid by the system. Since this is an inherent limitation of the approach used for blockchain-based certification, our attack is likely to be extendable to other systems adopting the same approach.
Open access
3 source records
cs.CR
Blockchain Technology Applications and Security
Physical Unclonable Functions (PUFs) and Hardware Security
Backdoor attacks on Ethereum smart contracts are a kind of attack in which an adversary exploits the privileges of his/her developed smart contract to manipulate the cryptoassets generated by that contract. Although there are several countermeasures against backdoor attacks, to the best of our knowledge, no empirical study based on the source code of the backdoor attacks has been conducted so far. In this paper, we conduct an empirical study to understand how backdoor attacks on Ethereum smart contracts are performed in the real world by analyzing all smart contracts with source code. To this end, we also propose a new investigation tool for the empirical study, named BACCA. We then identify several key insights. First, we totally found 288,440 contracts for backdoors attacked, called contract backdoors, including potential ones. The most significant backdoor attack is DisableTransfer, which disables transfers of assets to other addresses, and we identify 211,687 smart contracts affected by this attack. Second, several backdoor attacks are combined with other types of backdoor attacks, called combination contract backdoors, and 90.9% of DisableTransfer are combination contract backdoors. Third, GenerateToken, which enables an adversary to generate new cryptoassets, is the largest as a backdoor without any combinations, i.e., unique contract backdoors, and 23.8% of GenerateToken are the unique contract backdoors. Fourth, when we analyze the number of transactions sent to the above contract backdoors to identify their gas consumption in the real world, we identify that about 9 trillion dollars have been consumed by them. We also found a remarkable contract backdoor that receives more than a million transactions, resulting in gas consumption of about two billion dollars. We further discuss implications for the design of analysis tools for subsequent work and the impact of compiler updates on the above backdoor attacks.
The increasing demand for verifiable computation in privacy-sensitive distributed systems has driven the widespread adoption of Zero-Knowledge Proofs (ZKPs). However, the various kinds of current ZKP frameworks—which include zk-SNARKs, zk-STARKs, Bulletproofs, and folding-based systems—introduce complex trade-offs across proof size, prover cost, and trust assumptions, making system selection challenging in actual practice. This paper presents a systematic, application-oriented survey that connects ZKP design choices with real-world deployment constraints. It provides a comparative analysis of major constructions to evaluate their performance and security properties. Furthermore, these trade-offs are mapped to representative application scenarios, including Layer 1/Layer 2 blockchain scaling, Decentralized Identity (DID), and Verifiable Machine Learning (zkML), explaining how different systems are selected based on application-specific requirements. In addition, the paper discusses emerging paradigms such as hardware acceleration, binary field optimizations, and lookup-based zkVMs, which aim to address the prover bottleneck. Overall, this survey provides a structured understanding of the strengths and limitations of existing ZKP systems and offers insights for the design of scalable and privacy-preserving infrastructures.
Hüseyin Ahmet Cemil Özaslan, Şafak Durukan-Odabaşı
Smart contracts have become a fundamental component of blockchain ecosystems, and their reliability is strongly shaped by the programming languages in which they are written. While prior studies have classified vulnerabilities, fewer have quantitatively examined how language design and secure coding practices affect performance and resilience. To address this gap, this study empirically compares Solidity and Vyper under controlled conditions and complements these experiments with a literature-based evaluation of Rust and Move. Test scenarios included deployment, deposits, withdrawals, arithmetic overflow, reentrancy, and transaction origin misuse. For both vulnerable and secure variants in Solidity and Vyper, metrics such as gas consumption, deployment size, and runtime execution time were collected. The results indicate that deployment costs differ substantially between the two languages (Solidity ≈ 177 k gas vs Vyper ≈ 135 k gas, ~24% lower), whereas runtime performance is mixed: deposit calls are nearly identical (Δ ≈ 0.02 ms), whereas withdraw shows a noticeable gap (Δ ≈ 4.97 ms) favoring Vyper; nevertheless, these call-level differences remain small relative to the larger deployment-time gap. Importantly, secure coding practices such as explicit arithmetic checks and the Checks–Effects–Interactions pattern eliminate critical vulnerabilities while adding less than 1% to the overall execution cost. Although Rust and Move are considered through a literature-based review, they illustrate alternative approaches that embed security guarantees directly into the language. Based on these observations, this study proposes a measurable framework to understand how different smart contract programming languages vary in terms of security and efficiency, emphasizing the role of language design and secure coding practices in shaping contract development.
Giulio Segalini, Yigit Çolakoğlu, Marko Putnik, Jérémie Decouchant
Decentralized Finance (DeFi) applications rely heavily on the order in which transactions are executed, making them susceptible to reordering attacks that enable adversaries to extract Blockchain Extractable Value (BEV). While linear blockchain systems such as Ethereum have inspired extensive research into fair ordering mechanisms, DAG-based consensus protocols have remained largely unprotected despite their growing adoption for scalability and performance. In this paper, we introduce Tilikum, a DAG-based ledger protocol that ensures fair transaction ordering without relying on weak edges. Tilikum achieves ordering linearizability by leveraging median-based timestamp aggregation, or batch order fairness, while maintaining low data redundancy and robust garbage collection. We implemented Tilikum in Rust and evaluated it against representative baselines, namely Narwhal/Tusk, Pompē, Themis and FairDAG. Our results show that Tilikum achieves up to $39\times$ higher throughput than other fair-ordering baselines, while fully blocking state-of-the-art DAG-specific reordering attacks.
We propose cryptographic certificates of validity for agentic AI systems. The core idea is to formally specify a correctness or policy condition as a logical predicate, compile this predicate to a witness-checking problem over polynomial constraints, and use a succinct cryptographic proof system (and optionally zero-knowledge) to certify that the condition holds. This offers a middle ground between formal verification of source code, and cryptographic authentication. An agent's action can be accompanied by an independently checkable proof that it satisfies an agreed formal policy, without requiring the verifier to trust the agent or to re-execute computation. We outline the approach at a high level, give the core mathematical translation, relate the proposal to proof-carrying code, zkVMs, formal methods, and agent governance, and note the specification, auditing, and deployment questions that a full implementation must answer.
Local AI inference for browser tasks—including vision-language processing, speech recognition, and neural translation—requires significant computational resources that may exceed the capabilities of low-power devices such as smartphones, tablets, and older laptops. This paper presents the design of a distributed GPU compute sharing system for the Kathon cryptographic browser that enables peer-to-peer AI inference acceleration across trusted devices using libp2p networking. The system partitions neural network inference workloads across participating peers using tensor parallelism, with encrypted communication channels, verifiable computation proofs, and incentive mechanisms based on the .aioss cryptographic ledger. We address key technical challenges: heterogeneous device discovery with capability advertisement, dynamic workload partitioning for variable peer availability, encrypted inference that prevents input reconstruction, and fault tolerance through redundant computation. Simulated benchmarks across a 16-peer testbed demonstrate 3.8x speedup for Whisper transcription and 4.2x speedup for Qwen 2.5 VL inference on low-power client devices. A security analysis confirms that encrypted inference provides semantic security against honest-but-curious peers. The system enables Kathon to deliver AI features on devices that lack the local compute capacity for real-time inference. Part of The Anticloud research corpus by Lois-Kleinner Alpasan (ORCID: 0009-0009-2233-6107). This work explores browser engine, privacy in the context of sovereign AI infrastructure, post-cloud computing architectures, and transparent, blackbox-free systems.
This paper examines the cryptographic foundations of audit ledgers, with particular focus on hash chains, transparency logs, and verifiable data structures as implemented in the 01s Sovereign (Kaiman) operating system's .aioss ledger format. We survey the evolution from simple hash-linked data structures to sophisticated transparency frameworks such as Certificate Transparency (CT), CONIKS, and Trillian, and demonstrate how these technologies converge in the 01s Sovereign OS to create an immutable, verifiable record of all system and AI-assisted decisions. Part of The Anticloud research corpus by Lois-Kleinner Alpasan (ORCID: 0009-0009-2233-6107). This work explores api gateway, ai routing in the context of sovereign AI infrastructure, post-cloud computing architectures, and transparent, blackbox-free systems.
Established threat modelling methodologies (STRIDE, PASTA, Trike, OCTAVE, LINDDUN, attack trees, and adversary-behaviour catalogues such as MITRE ATT&CK) were designed for software products and enterprises with a discernible security perimeter, a single owning organisation, and a clean separation between technical and operational risk. Modern organisations violate all three assumptions: they run on cloud and SaaS control planes they do not own, distribute privileged authority across founders, contractors, vendors, signers, committees, and automation, and expose value through human approval ceremonies and supply-chain edges rather than a network boundary. The dominant failures are authorised-but-malicious actors, collusion across nominally independent parties, control-plane and CI/CD compromise, and operational mishandling of high-value actions, which existing methods largely omit. We present TRACE, a methodology that treats threat actors, roles, assets, critical invariants, and trust/authority edges as first-class, evidence-linked objects spanning three layers: protocols, systems, and organisations. We compare nine widely used frameworks across ten dimensions, show where each falls short in distributed, cloud-first, zero-trust settings, and specify TRACE: its core model, three application pillars, sequential gated workflow, and an evidence-and-traceability discipline for human-AI co-working in which language models accelerate coverage while senior reviewers retain judgement over invariants, severity, and collusion. TRACE was developed through Web3 security practice but is stack-agnostic. We discuss its relationship to zero trust architecture and accountable Byzantine consensus, its limitations, and open questions around empirical validation.