Web3 applications, such as on-chain gaming, require unbiased and publicly verifiable randomness that can be obtained quickly and cost-effectively whenever needed. Existing services, such as those based on Verifiable Random Functions (VRF), incur network delays and high fees due to their highly interactive nature. FlexiRand [CCS 2023] addressed these problems by hiding the output of the VRF and using that as a seed to derive many randomnesses locally. These randomnesses are instantly available for usage. However, these randomnesses can not be verified independently (or instantly) without disclosing the seed, leaving scope for malicious actors to cheat. To solve this problem, we introduce a new notion, called instantly-verifiable VRF (iVRF), which enables the generation of many randomnesses from one VRF output seed, such that each of them is verifiable independently - this enables the solution to generate randomnesses, such that they are and also . To instantiate we propose a generic construction called InstaRand - it combines any (possibly distributed) VRF at the server's end with another VRF at the client's end to construct an iVRF. Our specific instantiation uses the BLS-based GLOW-DVRF [Euro S&P 2021] at the server's end and the DDH-based VRF of Goldberg et al. [RFC 2023] at the client's end. We use the universal composability framework to analyze the security. Moreover, due to its generality, InstaRand can be instantiated with any post-quantum secure VRF to yield a post-quantum secure iVRF. Our experiments demonstrate that our instantiation of InstaRand is . The client incurs a cost to generate the seed (server's VRF output) by querying the GLOW-dVRF servers once. Once the seed is set up, the client locally generates the pseudorandom value on demand in , avoiding the client-server round-trip delay. Each value can be independently verified in . This yields a improvement in terms of output generation and improvement in verification cost over existing solutions.
Christos Karapapas, Iakovos Pittaras, George C. Polyzos, Constantinos Patsakis
The InterPlanetary File System~(IPFS) offers a decentralized approach to file storage and sharing, promising resilience and efficiency while also realizing the Web3 paradigm. Simultaneously, the offered anonymity raises significant questions about potential misuse. In this study, we explore methods that malicious actors can exploit IPFS to upload and disseminate harmful content while remaining anonymous. We evaluate the role of pinning services and public gateways, identifying their capabilities and limitations in maintaining content availability. Using scripts, we systematically test the behavior of these services by uploading malicious files. Our analysis reveals that pinning services and public gateways lack mechanisms to assess or restrict the propagation of malicious content.
With the growing integration of cloud computing and the increasing adoption of Internet-of-Things (IoT) devices, ensuring the integrity and privacy of data has become critical in digital systems. Data integrity is fundamental to maintain the completeness and reliability of data throughout the data lifecycle. Its importance is particularly evident in domains such as healthcare, where accurate diagnoses rely on trustworthy data. However, as systems evolve and become more complex, traditional centralised solutions often lack transparency and resilience, while resource-constrained devices make it more difficult to guarantee security and privacy. This thesis addresses these challenges by proposing a framework that integrates Distributed Ledger Technology (DLT) to support privacy-preserving data sharing and strengthen trust among system stakeholders. Based on this framework, an architecture was designed with three main modules: a middleware integrator for service interoperability, an authorisation manager for fine-grained access control, and a data integrity validator leveraging metadata anchored on a distributed ledger to ensure compliance with the General Data Protection Regulation. A proof of concept was designed and implemented using IoT devices, healthcare data, and low-resource hardware. Experimental results demonstrate that the proposed solution enables efficient data sharing and integrity validation with minimal overhead on the system. The DLT layer validated the integrity of shared data through a metadata model while preserving user privacy. Furthermore, the access control mechanism supported scalable and granular authorisation policies, and the middleware facilitated interoperability across heterogeneous stakeholders. This work contributes to new insights into the security of digital systems and provides responsible entities with a trustworthy approach for sharing data among diverse entities.
Jan 1, 2025·Proceedings of the 4th International Conference on Information Technology, Civil Innovation, Science, and Management, ICITSM 2025, 28-29 April 2025, Tiruchengode, Tamil Nadu, India, Part I
G. Sowmya Bala, P. S. G. Aruna Sri, Satyanarayana Korada, Suneel Gone
Traditional ticketing systems are at risk of fraud, counterfeiting, and issues concerning scalability. In this research, we investigate the application of blockchain technology towards the revolutionary concept of event tickets. We analyze how fundamental attributes of blockchain technology, such as
Muhammad Rashid, Imran Rasool, Nazir Ahmad Zafar, Hamra Afzaal
Ethereum 2.0 stands out as a progressive decentralized blockchain platform, drawing attention for its security, scalability, and flexibility. Central to Ethereum 2.0 is the Beacon Chain, serving as the cornerstone managing validator rewards, penalties, attestations, and slashing mechanisms. Rewards and Penalties Mechanism (RPM) is of particular importance within the Beacon Chain as it includes validator balances based on their attestation behavior. Despite the critical role of RPM in maintaining the reliability and security of the Beacon Chain, the absence of formal verification work employing model checking is notable. Therefore, this research endeavors to fill this gap by employing formal verification technique to assess the RPM’s behavior concerning Friendly Finality Gadget (FFG) attestations. Utilizing Process Meta Language (PROMELA), a formal model of the RPM is specified, encompassing safety and liveness properties crucial for its robust functioning. The properties, including invalid attestation, integrity, fairness, availability, failure to attest, and inactivity imposition, are formalized through Linear Temporal Logic (LTL). Subsequently, the formal model alongside the specified properties is subjected to verification using the SPIN model checker. The properties are analyzed with respect to verification time, states visited, and memory usage. The outcome of this research contributes to a rigorous analysis of the RPM’s behavior. This work not only enhances an understanding of Beacon Chain’s operational dynamics but also underscores the importance of formal verification in ensuring the reliability and security of blockchain protocols.
This research provides a detailed analysis of multi-factor authentication (MFA) in Zero-Trust Architecture (ZTA).It focused the discussion on current practices and critical challenges encountered, sharing some insights into the future direction by finding "gaps.""The field of Cyber security is a constantly changing environment.From the beginning of "trust but verify," it has gradually changed to "always verify, never trust."In this case, MFA becomes a key and effective measure to enhance confidentiality in ZTA.ZTA requires that all entities within the system must verify their identities on an ongoing basis, often using MFA.With the widespread use of telecommuting, cloud services, and the Internet of Things, the demand for identity authentication is also increasing.The MFA uses multiple authentication steps to enhance security and trust in the system.However, implementing and applying MFA in the ZTA environment has not been smooth sailing.Some schemes directly affect the popularity of MFA in their implementation, such as poor user experience, complex integration, and poor scalability.The author first reviewed some of the existing MFA programs to get to the root cause and try to fix the problem.By analyzing these typical cases, best practices are found, and strategies for improvement are proposed.The aim is to promote a balance between ease of use and security in MFA.Finally, through literature review and case studies, as well as the exploration of emerging technologies such as adaptive MFA and zero-knowledge proof, The author explore some new approaches to improve the ease and efficiency of MFA in ZTA systems.
Hamra Afzaal, Nazir Ahmad Zafar, Aqsa Tehseen, Shaheen Kousar
Ethereum 2.0 Beacon Chain has adopted the Proof of Stake (PoS) consensus mechanism to significantly advance the security, scalability, and decentralization of blockchain technology. It has played an integral role in organizing validator operations and addressing scalability issues. The Beacon Chain’s rewards and penalty system incentivizes honest behavior and penalizes dishonest actors inside the network. Ensuring the correctness of this mechanism is paramount for guaranteeing the system’s integrity. Therefore, this work formally verifies the rewards and penalty mechanism in the Beacon Chain using model checking, a formal methods-based technique. The formal specification of the rewards and penalties processes and several other epoch operations are described using the Communicating Sequential Programs (CSP#) language. The properties for rewards and penalties procedures are specified with Linear Temporal Logic (LTL). The Process Analysis Toolkit (PAT) model checker is utilized for verifying the formal model against the properties. The PAT model checker takes the specified formal model as input and determines whether the properties are satisfied or violated. The properties are examined in terms of verification time, visited states, total transitions, and memory utilization.
Yibin Yang, David Heath, Carmit Hazay, Vladimir Kolesnikov · 5 authors
We explore Zero-Knowledge Proofs (ZKPs) of statements expressed as programs written in high-level languages, e.g., C or assembly. At the core of executing such programs in ZK is the repeated evaluation of a CPU step, achieved by branching over the CPU's instruction set. This approach is general and covers traversal-execution of a program's control flow graph (CFG): here CPU instructions are straight-line program fragments (of various sizes) associated with the CFG nodes. This highlights the usefulness of ZK CPUs with a large number of instructions of varying sizes.
The frequent security incidents of contracts indicate a pressing need to ensure contract security from deployment to running stages, but the state-of-the-art (SOTA) analysis methods cannot work well for three requirements.(i) Identify contract defective code snippets, while generating exploit call sequences to help developers fix them.(ii) Monitor abnormal call behaviors, especially for multiple continuous transactions.(iii) Validate numerous unexploitable detection results automatically because manual verification is labor-intensive.To tackle these problems, we propose SymX, a symbolic executionbased security analysis art accounting for contract development and running stages.The experiment results demonstrate that it can accurately identify 90.22% of contracts and 98.04% of call transactions, as well as validate misreports as intended, which is superior to SOTAs, thereby protecting contracts better during the contract lifecycle.Currently, SymX is available at https://github.com/Secbrain/SymX.
Interactive theorem provers (ITPs), such as Lean and Coq, can express formal proofs for a large category of theorems, from abstract math to software correctness. Consider Alice who has a Lean proof for some public statement T. Alice wants to convince the world that she has such a proof, without revealing the actual proof. Perhaps the proof shows that a secret program is correct or safe, but the proof itself might leak information about the program's source code. A natural way for Alice to proceed is to construct a succinct, zero-knowledge, non-interactive argument of knowledge (zkSNARK) to prove that she has a Lean proof for the statement T.
Carmit Hazay, Muthuramakrishnan Venkitasubramaniam, Mor Weiss
Abstract Leakage-resilient cryptography aims to protect cryptographic primitives from so-called “side channel attacks” that exploit their physical implementation to learn their input or secret state. Starting from the works of Ishai, Sahai and Wagner (CRYPTO‘03) and Micali and Reyzin (TCC‘04), most works on leakage-resilient cryptography either focus on protecting general computations, such as circuits or multiparty computation protocols, or on specific non-interactive primitives such as storage, encryption, and signatures. This work focuses on leakage resilience for the middle ground, namely for distributed and interactive cryptographic primitives. Our main technical contribution is designing the first secret sharing scheme that is equivocal , resists adaptive probing of a constant fraction of bits from each share, while incurs only a constant blowup in share size. Equivocation is a strong leakage-resilience guarantee, recently introduced by Hazay et al. (ITC, 2021). Our construction is obtained via a general compiler which we introduce, that transforms any secret sharing scheme into an equivocal scheme against adaptive leakage. An attractive feature of our compiler is that it respects additive reconstruction; namely, if the original scheme has additive reconstruction, then the transformed scheme has linear reconstruction. We extend our compiler to a general paradigm for protecting distributed primitives against leakage and show its applicability to various primitives, including secret sharing, verifiable secret sharing, function secret sharing, distributed encryption and signatures, and distributed zero-knowledge proofs. For each of these primitives, our paradigm transforms any construction of the primitive into a scheme that resists adaptive party corruptions, as well as adaptive probing leakage of a constant fraction of bits in each share when the share is stored in memory (but not when it is used in computations). Moreover, the transformation incurs only a constant blowup in the share size and respects additive reconstruction—an important feature for several of these primitives, such as function secret sharing and distributed encryption.
Ken Lew, Arijet Sarker, Simeon Wuthier, Jinoh Kim · 6 authors
Computing and networking are increasingly implemented in software. We design and build a software build assurance scheme detecting if there have been injections or modifications in the various steps in the software supply chain, including the source code, compiling, and distribution. Building on the reproducible build and software bill of materials (SBOM), our work is distinguished from previous research in assuring multiple software artifacts across the software supply chain. Reproducible build, in particular, enables our scheme, as our scheme requires the software materials/artifacts to be consistent across machines with the same operating system/specifications. Furthermore, we use blockchain to deliver the proof reference, which enables our scheme to be distributed so that the assurance beneficiary and verifier are the same, i.e., the node downloading the software verifies its own materials, artifacts, and outputs. Blockchain also significantly improves the assurance efficiency. We first describe and explain our scheme using abstraction and then implement our scheme to assure Ethereum as the target software to provide concrete proof-of-concept implementation, validation, and experimental analyses. Our scheme enables more significant performance gains than relying on a centralized server thanks to the use of blockchain (e.g., two to three orders of magnitude quicker in verification) and adds small overheads (e.g., generating and verifying proof have an overhead of approximately one second, which is two orders of magnitude smaller than the software download or build processes).
Arijet Sarker, Simeon Wuthier, Jinoh Kim, Jonghyun Kim · 5 authors
Cryptocurrency software implements cryptocurrency operations (including the distributed consensus protocol and peer-to-peer networking) and often involves the open-source community. We design a software assurance scheme for cryptocurrency and advance the cryptocurrency handshaking protocol by providing the verification capability of the Bitcoin software by peers and preventing any potential peer from establishing a connection with modified Bitcoin software. Since we focus on Bitcoin (the most popular cryptocurrency) for implementation and integration, we call our scheme Version++, built on and advancing the current Bitcoin handshaking protocol based on the Version message. Our Version++ protocol providing software assurance is distinguishable from previous research because it is permissionless, distributed, and lightweight for its cryptocurrency application. Our scheme is permissionless since it does not require a centralized trusted authority (unlike the remote software attestation techniques from trusted computing); it is distributed since the peer checks the software assurances of its own peer connections; and it is designed for efficiency/lightweight to support the dynamic nature of the peer connections and large-scale broadcasting in cryptocurrency networking. Utilizing Merkle Tree for the efficiency of the proof verification, we implement and test Version++ on Bitcoin software and conduct experiments in an active Bitcoin node prototype connected to the Bitcoin Mainnet. Our prototype-based performance analyses demonstrate the lightweight design of Version++. The peer-specific verification grows logarithmically with the number of software files in processing time and in storage. Furthermore, the Version++ verification overhead is small compared to the version-verack handshaking process; we measure the overhead to be 0.524% in our local networking environment between virtual machines and between 0.057% and 0.282% (depending on the peer location) in our more realistic cloud-based experiments with remote peer machines.
Yibin Xu, Tijs Slaats, Boris Düdder, Thomas Hildebrandt · 5 authors
Abstract Smart contracts executed on blockchains are interactive programs where external actors generate events that trigger function invocations. Events can be emitted by participants asynchronously. However, some functionalities should be restricted to participants inhabiting specific roles in the system, which might be dynamically adjusted while the system evolves. We argue that current smart contract languages adopting imperative programming paradigms require additional complicated access control code. Furthermore, smart contracts are often developed and evolved independently and cannot share a joint access control policy. This makes it challenging to ensure the correctness of access control properties and to maintain correctness when the contracts are adapted. We propose using dynamic condition response (DCR) graphs for role‐based and declarative access control for smart contracts and techniques for test‐driven modelling and refinement of DCR graphs to support the safe design and evolution of smart contracts. We show that they allow for capturing and visualizing a form of dynamic access control where access rights evolve as the contract state progresses. Their use supports the straightforward declaration of access control rights, improved code auditing, test‐driven modelling, and safe evolution of smart contracts and improves users' understanding.
Decompilation of binary code has arisen as a highly-important application in the space of Ethereum VM (EVM) smart contracts. Major new decompilers appear nearly every year and attain popularity, for a multitude of reverse-engineering or tool-building purposes. Technically, the problem is fundamental: it consists of recovering high-level control flow from a highly-optimized continuation-passing-style (CPS) representation. Architecturally, decompilers can be built using either static analysis or symbolic execution techniques. We present Shrnkr, a static-analysis-based decompiler succeeding the state-of-the-art Elipmoc decompiler. Shrnkr manages to achieve drastic improvements relative to the state of the art, in all significant dimensions: scalability, completeness, precision. Chief among the techniques employed is a new variant of static analysis context: shrinking context sensitivity. Shrinking context sensitivity performs deep cuts in the static analysis context, eagerly “forgetting” control-flow history, in order to leave room for further precise reasoning. We compare Shrnkr to state-of-the-art decompilers, both static-analysis- and symbolic-execution-based. In a standard benchmark set, Shrnkr scales to over 99.5% of contracts (compared to ∼95% for Elipmoc), covers (i.e., reaches and manages to decompile) 67% more code than Heimdall-rs, and reduces key imprecision metrics by over 65%, compared again to Elipmoc.
Proofs are powerful tools for integrity and privacy, enabling the verifier to delegate a computation and still verify its correct execution, and enabling the prover to keep the details of the computation private. Both CCP and ZKP can achieve soundness and zero-knowledge but with important differences. CCP relies on hardware trust assumptions, which yield high performance and additional confidentiality protection for the prover but may be unacceptable for some applications. CCP is also often easier to use, notably with existing code, whereas ZKP comes with a large prover overhead that may be unpractical for some applications.
A. S. Santhosh Kumar, S. (Sarah) Thompson, N. (Noor) Al-Zubaidi
The rapid adoption of multi-cloud architectures enables organizations to balance cost, performance, and resilience by distributing workloads across different providers. However, this distributed environment introduces significant security and access control challenges, including inconsistent policies, fragmented identity management, and heightened risks of insider threats and data breaches. Traditional access control models—such as Role-Based Access Control (RBAC) and Attribute-Based Access Control (ABAC)—struggle to provide unified enforcement across heterogeneous cloud platforms while ensuring transparency, auditability, and trust. This paper explores the potential of blockchain-based access control models to secure multi-cloud software systems by leveraging the immutability, decentralization, and consensus mechanisms of distributed ledger technology. Blockchain smart contracts can automate access control enforcement, eliminate reliance on centralized identity providers, and ensure tamper-proof audit trails of access decisions. Recent studies highlight that 80% of enterprises already operate in hybrid or multi-cloud environments (Flexera 2023), while 45% of cloud security incidents are linked to misconfigured or inconsistent access policies (IBM Cloud Security Report 2022)—underscoring the urgency for innovative solutions. We analyze blockchain-enhanced RBAC and ABAC frameworks, discuss hybrid on-chain/off-chain policy enforcement, and evaluate the trade-offs of performance, scalability, and compliance. Case studies from healthcare and financial systems illustrate how blockchain access models improve accountability and regulatory alignment (e.g., HIPAA, GDPR, PCI DSS) in mission-critical workloads. Furthermore, we address key challenges such as transaction latency, interoperability across cloud providers, and privacy-preserving access control. The paper concludes that blockchain-based access control provides a paradigm shift in securing multi-cloud environments, offering organizations a path toward transparent, verifiable, and adaptive identity and access management. By integrating blockchain with AI-driven monitoring and zero trust architectures, the future of multi-cloud security will move toward autonomous, trustless, and regulation-compliant ecosystems capable of sustaining the demands of next-generation digital services.
We present VirtSecIO, a hypervisor-based platform for executing secure modules. VirtSecIO provides the modules with secure paths to peripheral devices, which can be shared between the modules and the operating system. Moreover, VirtSecIO is a thin hypervisor with a negligible performance overhead and a minimal attack surface. We demonstrate VirtSecIO’s abilities by developing HyperWallet, a secure module that acts as a hardware crypto-wallet, without requiring any dedicated hardware.
Open access
Security and Verification in Computing
Advanced Malware Detection Techniques
Physical Unclonable Functions (PUFs) and Hardware Security
Mikel Cortes-Goicoechea, Tarun Mohandas-Daryanani, José L. Muñoz, Leonardo Bautista-Gomez
Abstract Modern public blockchains like Ethereum rely on p2p networks to run distributed and censorship-resistant applications. With its wide adoption, it operates as a highly critical public ledger. On its transition to become more scalable and sustainable, shifting to PoS without sacrificing the security and resilience of PoW, Ethereum offers a range of consensus client implementations to participate in the network. In this paper, we present a methodology to measure the performance of the consensus clients based on the latency to receive messages from the p2p network. The paper includes a study that identifies the incentives and limitations that the network experiences, presenting insights about the latency impact derived from running the different consensus implementations at different locations. Our study highlights the need for a holistic approach to node deployment, where hardware, software, and geographic factors have to be carefully considered. Properly dimensioned hardware is essential to mitigate latency-related performance issues and ensure the reliable operation of beacon nodes, especially in geographically distant locations.
The goal of this thesis is to verify smart contracts in Blockchain. In particular, we focus on smart contracts in Bitcoin and Solidity. In order to specify the correctness of smart contracts, we use weakest preconditions. For this, we develop a model of smart contracts in the interactive theorem prover and dependent type programming language Agda and prove the correctness of smart contracts in it. In the context of Bitcoin, our verification of Bitcoin scripts consists of non-conditional and conditional scripts. For Solidity, we refer to programs using object-oriented features of Solidity, such as calling of other contracts, full recursion, and the use of gas in order to guarantee termination while having a Turing-complete language. We have developed a simulator for Solidity-style smart contracts. As a main example, we executed a reentrancy attack in our model. We have verified smart contracts in Bitcoin and Solidity using weakest precondition in Agda. Furthermore, Agda, combined with the fact that it is a theorem prover and programming language, allows the writing of verified programs, where the verification takes place in the same language in which the program is written, avoiding the problem of translation from one language to another (with possible translation mistakes).
Mohammed Alghazwi, Tariq Bontekoe, Leon Visscher, Fatih Türkmen
Abstract Non-interactive zero-knowledge (NIZK) proofs of knowledge have proven to be highly relevant for securely realizing a wide array of applications that rely on both privacy and correctness . They enable a prover to convince any party of the correctness of a public statement for a secret witness . However, most NIZKs do not natively support proving knowledge of a secret witness that is distributed over multiple provers. Previously, collaborative proofs [54] have been proposed to overcome this limitation. We investigate the notion of composability in this setting, following the Commit-and-Prove design of LegoSNARK [19]. Composability allows users to combine different, specialized NIZKs (e.g., one for arithmetic circuits, one for boolean circuits, and one for range proofs) with the aim of reducing the proof generation time. Moreover, it opens the door to efficient realizations of many applications in the collaborative setting such as mutually exclusive prover groups, combining collaborative and single-party proofs and efficiently implementing publicly auditable secure multiparty computing (PA-MPC). We present the first, general definition for collaborative commitand- prove NIZK (CP-NIZK) proofs of knowledge and construct MPC protocols to enable their realization. We implement our protocols for two commonly used NIZKs, Groth16 and Bulletproofs, and evaluate their practicality in a variety of computational settings. Our findings indicate that composability adds only minor overhead, especially for large circuits. We also evaluated our construction in two application settings, one of which shows 18– $$55\times $$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mn>55</mml:mn> <mml:mo>×</mml:mo> </mml:mrow> </mml:math> runtime reduction when compared to prior works while requiring only a fraction ( $$0.2\%$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mn>0.2</mml:mn> <mml:mo>%</mml:mo> </mml:mrow> </mml:math> ) of the communication.
Abstract Suppose that a sequence of $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards, numbered 1 to $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> , is placed face up in random order. Let $${\varvec{k}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>k</mml:mi> </mml:mrow> </mml:math> be the number on the first card in the sequence. Then take the first $${\varvec{k}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>k</mml:mi> </mml:mrow> </mml:math> cards from the sequence, rearrange that subsequence of $${\varvec{k}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>k</mml:mi> </mml:mrow> </mml:math> cards in reverse order, and return them to the original sequence. Repeat this prefix reversal until the number on the first card in the sequence becomes 1. This is a one-player card game called Topswops. The computational complexity of Topswops has not been thoroughly investigated. For example, letting $${\varvec{f}}({\varvec{n}})$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mrow> <mml:mi>f</mml:mi> </mml:mrow> <mml:mo>(</mml:mo> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> <mml:mo>)</mml:mo> </mml:mrow> </mml:math> denote the maximum number of prefix reversals for Topswops with $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards, values of $${\varvec{f}}({\varvec{n}})$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mrow> <mml:mi>f</mml:mi> </mml:mrow> <mml:mo>(</mml:mo> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> <mml:mo>)</mml:mo> </mml:mrow> </mml:math> for $${\varvec{n}}\ge 20$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> <mml:mo>≥</mml:mo> <mml:mn>20</mml:mn> </mml:mrow> </mml:math> remain unknown. In general, there is no known efficient algorithm for finding an initial sequence of $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards that requires exactly $$\ell $$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mi>ℓ</mml:mi> </mml:math> prefix reversals for any integers $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> and $${\varvec{\ell }}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>ℓ</mml:mi> </mml:mrow> </mml:math> . In this paper, using a deck of cards, we propose a physical zero-knowledge proof protocol that allows a prover to convince a verifier that the prover knows an initial sequence of $${\varvec{n}}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>n</mml:mi> </mml:mrow> </mml:math> cards that requires $${\varvec{\ell }}$$ <mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML"> <mml:mrow> <mml:mi>ℓ</mml:mi> </mml:mrow> </mml:math> prefix reversals without leaking knowledge of that sequence. We also deal with Botdrops, a variant of Topswops.
Luca Aceto, Daniele Gorla, Stian Lybech, Mohammad Hamdaqa
We continue the development of TinySol, a minimal object-oriented language based on Solidity, the standard smart-contract language used for the Ethereum platform. We first extend TinySol with exceptions and a gas mechanism, and equip it with a small-step operational semantics. Introducing the gas mechanism is fundamental for modelling real-life smart contracts in TinySol, since this is the way in which termination of Ethereum smart contracts is usually ensured. We then devise a type system for smart contracts guaranteeing that such programs never run out of gas at runtime. This is a desirable property for smart contracts, since a transaction that runs out of gas is aborted, but the price paid to run the code is not returned to the invoker.