With the rapid development of blockchain technology, different types of blockchains are adopted and interoperability across blockchains has received widespread attention. There have been many cross-chain solutions proposed in recent years, including notary scheme, sidechain, and relay chain. However, most of the existing platforms do not take confidentiality into account, although privacy has become an important concern for blockchain. In this paper, we present TrustCross, a privacy- preserving cross-chain platform to enable confidential interoperability across blockchains. The key insight behind TrustCross is to encrypt cross-chain communication data on the relay chain with the assistance of trusted execution environment and employ fine-grained access control to protect user privacy. Our experimental results show that TrustCross achieves reasonable latency and high scalability on the contract calls across heterogeneous blockchains.
Lital Badash, Nachiket Tapas, Asaf Nadler, Francesco Longo · 5 authors
Bug bounty programs are a popular solution for security researchers to disclose software vulnerabilities in exchange for compensation. They suffer, however, from two main drawbacks that limit their effectiveness: (i) they use a trusted intermediary that charges hefty commission fees and may have a conflict of interest with the software vendor, and (ii) they may mistreat security researchers by compensating less than guaranteed and no means to appeal against it. In this paper, we propose a permissioned Blockchain-based framework that addresses the drawbacks of existing bug bounty programs. The framework allows a confidential exchange of vulnerabilities and compensations using smart contracts. In cases of policy violation, security researchers can appeal to a trusted group of security experts called arbitrators, that can force the software vendors to compensate the security researchers fairly. A formal evaluation of the proposed framework using TLA+ specification supports the viability of the proposal. A Hyperledger Fabric-based prototype is implemented to simulate the proposed framework. The analysis of the framework uses a game-theoretic notion to argue that if the majority of arbitrators behave honestly, then the rational strategy of software vendors is to compensate security researchers that disclose vulnerabilities accurately. Similarly, rational security researchers do not gain any financial profit by playing unfairly.
The exploitation of smart-contract vulnerabilities can lead to catastrophic losses. Formal verification can be a useful tool in identifying these vulnerabilities before deployment. We present an encoding of Solidity and the Ethereum blockchain using Boogie, an intermediate verification language. Based on this formalisation, we create Solidifier: a bounded model checker for Solidity. Distinctive features of our encoding are precisely capturing Solidity's unorthodox memory model, a notion of lazy blockchain exploration, and memory-precise verification harnesses. Unlike much of the work in this area, our modus operandi is not matching contracts against specific known behavioural patterns that might lead to vulnerabilities. Rather, we provide a tool to find errors/bad states - be they vulnerabilities or not - that might be reached through behaviours that might not follow such a pattern.
Smart contracts are self-enforcing agreements that are employed to exchange assets without the approval of trusted third parties. This feature has encouraged various sectors to make use of smart contracts when transacting. Experience shows that many deployed contracts are vulnerable to exploitation due to their poor design, which allows attackers to steal valuable assets from the involved parties. Therefore, an assessment approach that allows developers to recognise the consequences of deploying vulnerable contracts is needed. In this paper, we propose a debt-aware approach for assessing security design vulnerabilities in smart contracts. Our assessment approach involves two main steps: (i) identification of design vulnerabilities using security analysis techniques and (ii) an estimation of the ramifications of the identified vulnerabilities leveraging the technical debt metaphor, its principal and interest. We use examples of vulnerable contracts to demonstrate the applicability of our approach. The results show that our assessment approach increases the visibility of security design issues. It also allows developers to concentrate on resolving smart contract vulnerabilities through technical debt impact analysis and prioritisation. Developers can use our approach to inform the design of more secure contracts and for reducing unintentional debts caused by a lack of awareness of security issues.
Filippo Contro, Marco Crosara, Mariano Ceccato, Mila Dalla Preda
Motivated by the immutable nature of Ethereum smart contracts and of their transactions, quite many approaches have been proposed to detect defects and security problems before smart contracts become persistent in the blockchain and they are granted control on substantial financial value. Because smart contracts source code might not be available, static analysis approaches mostly face the challenge of analysing compiled Ethereum bytecode, that is available directly from the official blockchain. However, due to the intrinsic complexity of Ethereum bytecode (especially in jump resolution), static analysis encounters significant obstacles that reduce the accuracy of exiting automated tools. This paper presents a novel static analysis algorithm based on the symbolic execution of the Ethereum operand stack that allows us to resolve jumps in Ethereum bytecode and to construct an accurate control-flow graph (CFG) of the compiled smart contracts. EtherSolve is a prototype implementation of our approach. Experimental results on a significant set of real world Ethereum smart contracts show that EtherSolve improves the accuracy of the execrated CFGs with respect to the state of the art available approaches. Many static analysis techniques are based on the CFG representation of the code and would therefore benefit from the accurate extraction of the CFG. For example, we implemented a simple extension of EtherSolve that allows to detect instances of the re-entrancy vulnerability.
Filippo Contro, Marco Crosara, Mariano Ceccato, Mila Dalla Preda
Motivated by the immutable nature of Ethereum smart contracts and of their\ntransactions, quite many approaches have been proposed to detect defects and\nsecurity problems before smart contracts become persistent in the blockchain\nand they are granted control on substantial financial value.\n Because smart contracts source code might not be available, static analysis\napproaches mostly face the challenge of analysing compiled Ethereum bytecode,\nthat is available directly from the official blockchain. However, due to the\nintrinsic complexity of Ethereum bytecode (especially in jump resolution),\nstatic analysis encounters significant obstacles that reduce the accuracy of\nexiting automated tools.\n This paper presents a novel static analysis algorithm based on the symbolic\nexecution of the Ethereum operand stack that allows us to resolve jumps in\nEthereum bytecode and to construct an accurate control-flow graph (CFG) of the\ncompiled smart contracts. EtherSolve is a prototype implementation of our\napproach. Experimental results on a significant set of real world Ethereum\nsmart contracts show that EtherSolve improves the accuracy of the execrated\nCFGs with respect to the state of the art available approaches.\n Many static analysis techniques are based on the CFG representation of the\ncode and would therefore benefit from the accurate extraction of the CFG. For\nexample, we implemented a simple extension of EtherSolve that allows to detect\ninstances of the re-entrancy vulnerability.\n
Solidity, a programming language used to write smart contracts, has been improved since its initial release, but a number of vulnerabilities remain. As smart contracts are usually related to cryptocurrency, these vulnerabilities should be avoided to prevent the risk of financial loss. In this paper, we classify common vulnerabilities of function calls of Solidity programs into three groups and suggest a method to avoid them. The proposed method makes use of Ethereum Virtual Machine as well as Solidity extension. Experimental results with real-world smart contracts show that our method will detect and avoid these vulnerabilities.
Abstract Blockchain‐based audit systems suffer from low scalability and high message complexity. The root cause of these shortcomings is the use of “Practical Byzantine Fault Tolerance” (PBFT) consensus protocol in those systems. Alternatives to PBFT have not been used in blockchain‐based audit systems due to the limited knowledge about their functional and operational requirements. Currently, no blockchain testbed supports the execution and benchmarking of different consensus protocols in a unified testing environment. This paper demonstrates building a blockchain testbed that supports the execution of five state‐of‐the‐art consensus protocols in a blockchain system; namely PBFT, Proof‐of‐Work (PoW), Proof‐of‐Stake (PoS), Proof‐of‐Elapsed Time (PoET), and Clique. Performance evaluation of those consensus algorithms is carried out using data from a real‐world audit system. These results show that the Clique protocol is best suited for blockchain‐based audit systems, based on scalability features.
Ryan Song, Zihan Zhao, Yuxi Cai, Andreas Veneris · 5 authors
This paper presents SigVM, a novel blockchain virtual machine that supports an event-driven execution model, enabling developers to build fully autonomous smart contracts. SigVM introduces another way for a contract to interact with another. Contracts in SigVM can emit signal events, on which other contracts can listen. Once an event is triggered, corresponding handler functions are automatically executed as signal transactions. We built an end-to-end blockchain platform SigChain and a contract language compiler SigSolid to realize the potential of SigVM. Experimental results show that SigVM enables contracts in our benchmark applications to be reimplemented in a fully autonomous way, eliminating the dependency on unreliable mechanisms like off-chain relay servers. SigVM can significantly simplify the execution flow of our benchmark applications, and can avoid security risks such as front-run attacks.
We propose three constructions of classically verifiable non-interactive zero-knowledge proofs and arguments (CV-NIZK) for QMA in various preprocessing models. - We construct a CV-NIZK for QMA in the quantum secret parameter model where a trusted setup sends a quantum proving key to the prover and a classical verification key to the verifier. It is information theoretically sound and zero-knowledge. - Assuming the quantum hardness of the learning with errors problem, we construct a CV-NIZK for QMA in a model where a trusted party generates a CRS and the verifier sends an instance-independent quantum message to the prover as preprocessing. This model is the same as one considered in the recent work by Coladangelo, Vidick, and Zhang (CRYPTO '20). Our construction has the so-called dual-mode property, which means that there are two computationally indistinguishable modes of generating CRS, and we have information theoretical soundness in one mode and information theoretical zero-knowledge property in the other. This answers an open problem left by Coladangelo et al, which is to achieve either of soundness or zero-knowledge information theoretically. To the best of our knowledge, ours is the first dual-mode NIZK for QMA in any kind of model. - We construct a CV-NIZK for QMA with quantum preprocessing in the quantum random oracle model. This quantum preprocessing is the one where the verifier sends a random Pauli-basis states to the prover. Our construction uses the Fiat-Shamir transformation. The quantum preprocessing can be replaced with the setup that distributes Bell pairs among the prover and the verifier, and therefore we solve the open problem by Broadbent and Grilo (FOCS '20) about the possibility of NIZK for QMA in the shared Bell pair model via the Fiat-Shamir transformation.
Michael Neuder, Daniel J. Moroz, Rithvik Rao, David C. Parkes
We outline two dishonest strategies that can be cheaply executed on the Ethereum 2.0 beacon chain, even by validators holding less than one-third of the total stake: malicious chain reorganizations ("reorgs") and finality delays. In a malicious reorg, an attacker withholds their blocks and attestations before releasing them at an opportune time in order to force a chain reorganization, which they can take advantage of by double-spending or front-running transactions. To execute a finality delay an attacker uses delayed block releases and withholding of attestations to increase the mean and variance of the time it takes blocks to become finalized. This impacts the efficiency and predictability of the system. We provide a probabilistic and cost analysis for each of these attacks, considering a validator with 30% of the total stake.
Since the advent of Bitcoin in 2008, the interest in blockchain technology has surged tremendously. Numerous applications have been proposed in the field of finance, healthcare, and supply chain over the last decade. And, as the popularity of blockchains continue to rise, blockchain platforms must be enhanced to support new application needs. \nWe propose one such enhancement that is essential for financial applications and online marketplaces – support for time-based logic. Online marketplaces may need to validate transaction time-stamps against a perishable product’s expiry date to prevent sale of expired products. Similarly, financial applications in banking may also need a history of recent transactions for extending credit (like an overdraft) to a customer. As nodes in a blockchain operate in a distributed and trustless setting, it is imperative that they can access a global and trusted clock for verifying deadlines or examining a window of recent activity. \nIn this thesis, we present a lightweight solution that assigns time-stamps to blocks at transaction validation time, which can be referenced as a global clock by all nodes in the network. Moreover, our solution also maintains a cache \nreflecting the effects of recent transactions. We implement our solution, called TimeFabric, in Hyperledger Fabric, a popular permissioned blockchain platform, and experimentally demonstrate high throughput and minimal overhead (approximately 3%) of maintaining trusted time. We also demonstrate a 2x performance improvement due to the cache, compared to retrieving transaction histories directly from the ledger.
Konrad Wrona, Frank Micevski Scharf, Michał Jarosz
Security accreditation is a vital process used by governmental, military, and international organizations to verify a proper security posture of communication and information systems. Currently, it is a largely manual, time consuming, and highly repetitive process. Smart contracts could offer an opportunity to automate some parts of the security review, increasing speed, transparency, and predictability of the security accreditation, as well as software approval. We analyze the feasibility of supporting security accreditation with smart contracts and present our proof-of-concept implementation based on Hyperledger Fabric.
Benjamin Breiling, Bernhard Dieber, Martin Pinzger, Stefan Raß
With the growing popularity of robots, the development of robot applications is subject to an ever increasing number of additional requirements from e.g., safety, legal and ethical sides. The certification of an application for compliance to such requirements is an essential step in the development of a robot program. However, at this point in time it must be ensured that the integrity of this program is preserved meaning that no intentional or unintentional modifications happen to the program until the robot executes it. Based on the abstraction of robot programs as workflows we present in this work a cryptography-powered distributed infrastructure for the preservation of robot workflows. A client composes a robot program and once it is accepted a separate entity provides a digital signature for the workflow and its parameters which can be verified by the robot before executing it. We demonstrate a real-world implementation of this infrastructure using a mobile manipulator and its software stack. We also provide an outlook on the integration of this work into our larger undertaking to provide a distributed ledger-based compliant robot application development environment.
This demonstration presents a new trust model for Internet of Things, based on TLS1.3 sessions authenticated by pre-shared key (PSK). According to TLS1.3, security relies on Diffie-Hellman exchanges, optionally authenticated by symmetric secret (PSK) shared by client and server. A major security issue is PSK protection against eavesdropping, in order to avoid device cloning or illegitimate use. We present two secure elements TLS-IM used on client side, and TLS-SE used on server side, which enforce PSK security. TLS-IM is a smartcard associated with TLS1.3 client running in laptop. TLS-SE is a standalone TLS1.3 server running in a secure element, which embeds an application computing signature for blockchain transaction. TLS-SE has a SIM form factor, and is plugged in a hardware module working with a Wi-Fi SoC, providing TCP/IP connectivity.
Physical Unclonable Functions (PUFs) and Hardware Security
Nami Ashizawa, Naoto Yanai, Jason Paul Cruz, Shingo Okamura
Ethereum smart contracts are computer programs that are deployed and executed on the Ethereum blockchain to enforce agreements among untrusting parties. Being the most prominent platform that supports smart contracts, Ethereum has been targeted by many attacks and plagued by security incidents. Consequently, many smart contract vulnerabilities have been discovered in the past decade. To detect and prevent such vulnerabilities, different security analysis tools, including static and dynamic analysis tools, have been created, but their performance decreases drastically when codes to be analyzed are constantly being rewritten. In this paper, we propose Eth2Vec, a machine-learning-based static analysis tool that detects smart contract vulnerabilities. Eth2Vec maintains its robustness against code rewrites; i.e., it can detect vulnerabilities even in rewritten codes. Other machine-learning-based static analysis tools require features, which analysts create manually, as inputs. In contrast, Eth2Vec uses a neural network for language processing to automatically learn the features of vulnerable contracts. In doing so, Eth2Vec can detect vulnerabilities in smart contracts by comparing the similarities between the codes of a target contract and those of the learned contracts. We performed experiments with existing open databases, such as Etherscan, and Eth2Vec was able to outperform a recent model based on support vector machine in terms of well-known metrics, i.e., precision, recall, and F1-score.
Smart contracts are distributed, self-enforcing programs executing on top of blockchain networks. They have the potential to revolutionize many industries such as financial institutes and supply chains. However, smart contracts are subject to code-based vulnerabilities, which casts a shadow on its applications. As smart contracts are unpatchable (due to the immutability of blockchain), it is essential that smart contracts are guaranteed to be free of vulnerabilities. Unfortunately, smart contract languages such as Solidity are Turing-complete, which implies that verifying them statically is infeasible. Thus, alternative approaches must be developed to provide the guarantee. In this work, we develop an approach which automatically transforms smart contracts so that they are provably free of 4 common kinds of vulnerabilities. The key idea is to apply run-time verification in an efficient and provably correct manner. Experiment results with 5000 smart contracts show that our approach incurs minor run-time overhead in terms of time (i.e., 14.79%) and gas (i.e., 0.79%).
The relational database has become one of the mainstream tools for data storage and management. However, there are two main types of threats to relational databases: external attacks and internal tampering threats. In this paper, we focus on the internal tampering threats and propose a tamper-proof detection middleware named TDRB to provide efficient tamper-proof detection for relational databases. Within the TDRB middleware framework, raw data is still stored and queried from the relational database, while the hash digest of the critical data in the relational database is synchronously migrated to the blockchain for tamper detection. Based on this method, we leverage blockchain’s immutability to detect data tamper and maintain the advanced features of relational databases to better support ease of data persistence, complex queries, and large storage capacity. We also propose a performance improvement mechanism that involves connecting the blockchain and relational database to improve throughput and mitigate performance impact. A series of experiments indicate that the TDRB middleware can accurately detect the tampering information during arbitrary tampering with the relational database and the cache database. Compare with the baseline, with the increase of cache hit rate, the TDRB middleware query speed increased by 93.1%, update speed increased by 16.3%, delete speed increased by 16.1%, and join operation average speed increased by 95.2%. Given its generality, the TDRB middleware can be flexibly and conveniently integrated into third-party platforms.
Hyunyoung Oh, Kevin Nam, Seongil Jeon, Yeongpil Cho · 5 authors
Remote computing has emerged as a trendy computing model that enables users to process an immense number of computations efficiently on the remote server where the necessary data and high-performance computing power are provisioned. Unfortunately, despite such an advantage, this computing model suffers from insider threats that are committed by adversarial administrators of remote servers who attempt to steal or corrupt users' private data. These security threats are somewhat innate to remote computing in that there is no means to control administrators' unlimited data access. In this paper, we present our novel hardware-centric solution, called MeetGo, to address the intrinsic threats to remote computing. MeetGo is a field-programmable gate array (FPGA)-based trusted execution environment (TEE) that aims to operate independently of the host system architecture. To exhibit the ability and effectiveness of MeetGo as a TEE ensuring secure remote computing, we have built two concrete applications: cryptocurrency wallet and GPGPU. MeetGo provides a trust anchor for these applications that enable their users to trade cryptocurrency or to run a GPGPU program server on a remote server while staying safe from threats by insiders. Our experimental results clearly demonstrate that MeetGo incurs only a negligible performance overhead to the applications.
Open access
Security and Verification in Computing
Physical Unclonable Functions (PUFs) and Hardware Security