5 research outputs found
Formally Verified Verifiable Electronic Voting Scheme
Since the introduction of secret ballots in Victoria, Australia in 1855, paper (ballots) are widely used around the world to record the preferences of eligible voters. Paper ballots provide three important ingredients: correctness, privacy, and verifiability. However, the paper ballot election brings various other challenges, e.g. it is slow for large democracies like India, error prone for complex voting method like single transferable vote, and poses operational challenges for large countries like Australia. In order to solve these problems and various others, many countries are adopting electronic voting. However, electronic voting has a whole new set of problems. In most cases, the software programs used to conduct the election have numerous problems, including, but not limited to, counting bugs, ballot identification, etc. Moreover, these software programs are treated as commercial in confidence and
are not allowed to be inspected by members of the public. As a consequence, the result produced by these software programs can not be substantiated.
In this thesis, we address the three main concerns posed by electronic voting, i.e. correctness, privacy, and verifiability. We address the correctness concern by using theorem prover to implement the vote counting algorithm,
privacy concern by using cryptography, and verifiability concern by generating a independently checkable scrutiny sheet (certificate). Our work has been carried out in the Coq theorem prover
On Reasonable Space and Time Cost Models for the λ-Calculus
Slot and van Emde Boas Invariance Thesis states that a time (respectively, space) cost model is reasonable for a computational model C if there are mutual simulations between Turing machines and C such that the overhead is polynomial in time (respectively, linear in space). The rationale is that under the Invariance Thesis, complexity classes such as LOGSPACE, P, PSPACE, become robust, i.e. machine independent.
In this dissertation, we want to find out if it possible to define a reasonable space cost model for the lambda-calculus, the paradigmatic model for functional programming languages. We start by considering an unusual evaluation mechanism for the lambda-calculus, based on Girard's Geometry of Interaction, that was conjectured to be the key ingredient to
obtain a space reasonable cost model. By a fine complexity analysis of this schema, based on new variants of non-idempotent intersection types, we disprove this conjecture. Then, we change the target of our analysis. We consider a variant over Krivine's abstract machine, a standard evaluation mechanism for the call-by-name lambda-calculus, optimized for space complexity, and implemented without any pointer. A fine analysis of the execution of (a refined version of) the encoding of Turing machines into the lambda-calculus allows us to conclude that the space consumed by this machine is
indeed a reasonable space cost model. In particular, for the first time we are able to measure also
sub-linear space complexities. Moreover, we transfer this result to the call-by-value case.
Finally, we provide also an intersection type system that characterizes compositionally this new reasonable space measure. This is done through a minimal, yet non trivial, modification of the original de Carvalho type system
Recurring Contingent Service Payment
Fair exchange protocols let two mutually distrustful parties exchange digital
data in a way that neither party can cheat. They have various applications such
as the exchange of digital items, or the exchange of digital coins and digital
services between a buyer/client and seller/server.
In this work, we formally define and propose a generic blockchain-based
construction called "Recurring Contingent Service Payment" (RC-S-P). It (i)
lets a fair exchange of digital coins and verifiable service reoccur securely
between clients and a server while ensuring that the server is paid if and only
if it delivers a valid service, and (ii) ensures the parties' privacy is
preserved. RC-S-P supports arbitrary verifiable services, such as "Proofs of
Retrievability" (PoR) or verifiable computation and imposes low on-chain
overheads. Our formal treatment and construction, for the first time, consider
the setting where either client or server is malicious.
We also present a concrete efficient instantiation of RC- S-P when the
verifiable service is PoR. We implemented the concrete instantiation and
analysed its cost. When it deals with a 4-GB outsourced file, a verifier can
check a proof in only 90 milliseconds, and a dispute between a prover and
verifier is resolved in 0.1 milliseconds.
At CCS 2017, two blockchain-based protocols were proposed to support the fair
exchange of digital coins and a certain verifiable service; namely, PoR. In
this work, we show that these protocols (i) are susceptible to a free-riding
attack which enables a client to receive the service without paying the server,
and (ii) are not suitable for cases where parties' privacy matters, e.g., when
the server's proof status or buyer's file size must remain private from the
public. RC- S-P simultaneously mitigates the above attack and preserves the
parties' privacy