ensures the anonymity of the measurement data, no
statement can be made regarding the integrity of the
algorithm.
3.3 Proof Systems
The verification of correctness in case of outsourced
computations is an important general distributed com-
puting issue. One possible solution is provided by
proof systems, whereby the server executing the com-
putation provides proof of its correctness in addition
to the result of the computation. Formally, such a
proof system can be generally described as a tuple of
probabilistic polynomial-time algorithms:
• (vk, sk, evk) ← Gen(1
λ
, f ) is the key generation
algorithm, λ the unary security parameter and f
denotes the algorithm to be proven. The result of
key generation is a key-triple, where vk is the ver-
ification key, sk is a secret key and evk is a public
evaluation key.
• σ
x
← InputEncode(x, sk) describes the process of
encoding a given input x.
• σ
y
← Prove(σ
x
, evk) is the proof generation algo-
rithm, which generates a proof of correctness for
the calculation determined by ek and encoded in-
put data.
• y or ⊥← Veri f y(σ
y
, pk) confirms or refutes the
correctness of the calculation.
Roughly, such proof systems can be differenti-
ated into interactive and argument-based systems.
While interactive systems assume a super-polynomial
prover, the argument-based systems establish a
polynomial-bound prover and are thus more practice-
oriented. The argument-based approaches can also
be realized as non-interactive proof systems, which is
important from a practical point of view, since the ad-
ditional communication between the verifier and the
prover can ideally be limited to sending the proof.
Especially the efficiency of such processes plays an
important role in their practical application. In this
context, the literature distinguishes between absolute
efficiency and amortized efficiency. In the first case,
the total computation time for calculating and evalu-
ating the proof is set in relation to the computational
time required by the algorithm to be verified. In the
second case, only the time necessary for verification
is considered. Many practical implementations there-
fore distinguish between the setup phase, which is ex-
ecuted once for each algorithm and involves a high
computational effort and the proof and verification
phase, which is set in relation to the computation time
of the algorithm to be tested and serves as an impor-
tant efficiency measure. Some of the approaches have
already gained practical importance and offer imple-
mentation evaluations such as Pinocchio(Parno et al.,
2016), SNARKS for C(Ben-Sasson et al., 2013) and
Geppetto(Costello et al., 2015). The main purpose
of such proof systems is to prove the correctness of
the (unencrypted) execution of an algorithm, there-
fore they could serve as a replacement to the soft-
ware integrity hashes, especially in cloud environ-
ments. Even if they solve the problem of algorithm
integrity checking, the core algorithm must continue
to run with unencrypted data in the distributed system,
which will not solve the privacy problem.
It is conceivable to combine such a proof method (in-
put privacy assumed) with homomorphic encryption
in order to take advantage of the benefits of both ap-
proaches. From a practical point of view, it must be
said that proof methods and homomorphic encryp-
tion require considerable computational resources and
generally have a strong dependency on the depth of
the circuit which represents the core algorithm. How-
ever, in environments where computing power does
not matter much, such a solution may be applicable.
3.4 Functional Encryption
Functional encryption, similar to homomorphic en-
cryption, allows calculations to be performed on en-
crypted data. The main difference, however, is that
the functional encryption provides a plaintext result
of the calculation. Formally, a functional encryption
can be defined as a tuple of probabilistic polynomial
time algorithms:
• (pk, sk) ← Setup(1
λ
) is the key generation algo-
rithm, λ the unary security parameter. The result
of key generation is a key tuple, where pk is the
public key and sk is a secret key.
• ek ← Gen(sk, f ) generates an evaluation key with
respect to a function f
• c ← Enc(x, pk) encrypts a value x
• f (x)or ⊥← Dec(c, ek) computes f (x) and pro-
vides the decrypted result.
The functional encryption was proposed in 2005 (Sa-
hai and Waters, 2005) and formalized in 2011 (Boneh
et al., 2011). Theoretically, the functional encryption
allows execution of arbitrary functions on encrypted
data, but in practice there are only a few implemen-
tations with a strong limitation on the functions to be
performed. In contrast to homomorphic encryption,
the calculations cannot be cascaded because the result
is decrypted directly after an (albeit complex) opera-
tion, which also undermines output privacy.
Nevertheless, such a method offers many advantages.
First, it guarantees privacy of the input data, if we as-
Security for Distributed Smart Meter: Blockchain-based Approach, Ensuring Privacy by Functional Encryption
295