12 research outputs found
Chameleon: a Blind Double Trapdoor Hash Function for Securing AMI Data Aggregation
Data aggregation is an integral part of Advanced Metering Infrastructure (AMI) deployment that is implemented by the concentrator. Data aggregation reduces the number of transmissions, thereby reducing communication costs and increasing the bandwidth utilization of AMI. However, the concentrator poses a great risk of being tampered with, leading to erroneous bills and possible consumer disputes. In this paper, we propose an end-to-end integrity protocol using elliptic curve based chameleon hashing to provide data integrity and authenticity. The concentrator generates and sends a chameleon hash value of the aggregated readings to the Meter Data Management System (MDMS) for verification, while the smart meter with the trapdoor key computes and sends a commitment value to the MDMS so that the resulting chameleon hash value calculated by the MDMS is equivalent to the previous hash value sent by the concentrator. By comparing the two hash values, the MDMS can validate the integrity and authenticity of the data sent by the concentrator. Compared with the discrete logarithm implementation, the ECC implementation reduces the computational cost of MDMS, concentrator and smart meter by approximately 36.8%, 80%, and 99% respectively. We also demonstrate the security soundness of our protocol through informal security analysis
Space-efficient quantum multiplication of polynomials for binary finite fields with sub-quadratic Toffoli gate count
Multiplication is an essential step in a lot of calculations. In this paper
we look at multiplication of 2 binary polynomials of degree at most ,
modulo an irreducible polynomial of degree with input and output
qubits, without ancillary qubits, assuming no errors. With straightforward
schoolbook methods this would result in a quadratic number of Toffoli gates and
a linear number of CNOT gates. This paper introduces a new algorithm that uses
the same space, but by utilizing space-efficient variants of Karatsuba
multiplication methods it requires only Toffoli gates at the
cost of a higher CNOT gate count: theoretically up to but in examples
the CNOT gate count looks a lot better.Comment: 15 pages, 5 figure
Fast in-place accumulated bilinear formulae
Bilinear operations are ubiquitous in computer science and in particular in
computer algebra and symbolic computation. One of the most fundamental
arithmetic operation is the multiplication, and when applied to, e.g.,
polynomials or matrices, its result is a bilinear function of its inputs. In
terms of arithmetic operations, many sub-quadratic (resp. sub-cubic) algorithms
were developed for these tasks. But these fast algorithms come at the expense
of (potentially large) extra temporary space to perform the computation. On the
contrary, classical, quadratic (resp. cubic) algorithms, when computed
sequentially, quite often require very few (constant) extra registers. Further
work then proposed simultaneously ``fast'' and ``in-place'' algorithms, for
both matrix and polynomial operations We here propose algorithms to extend the
latter line of work for accumulated algorithms arising from a bilinear formula.
Indeed one of the main ingredient of the latter line of work is to use the
(free) space of the output as intermediate storage. When the result has to be
accumulated, i.e., if the output is also part of the input, this free space
thus does not even exist. To be able to design accumulated in-place algorithm
we thus relax the in-place model to allow algorithms to also modify their
input, therefore to use them as intermediate storage for instance, provided
that they are restored to their initial state after completion of the
procedure. This is in fact a natural possibility in many programming
environments. Furthermore, this restoration allows for recursive combinations
of such procedures, as the (non concurrent) recursive calls will not mess-up
the state of their callers. We propose here a generic technique transforming
any bilinear algorithm into an in-place algorithm under this model. This then
directly applies to polynomial and matrix multiplication algorithms, including
fast ones
Fast In-place Algorithms for Polynomial Operations: Division, Evaluation, Interpolation
We consider space-saving versions of several important operations on
univariate polynomials, namely power series inversion and division, division
with remainder, multi-point evaluation, and interpolation. Now-classical
results show that such problems can be solved in (nearly) the same asymptotic
time as fast polynomial multiplication. However, these reductions, even when
applied to an in-place variant of fast polynomial multiplication, yield
algorithms which require at least a linear amount of extra space for
intermediate results. We demonstrate new in-place algorithms for the
aforementioned polynomial computations which require only constant extra space
and achieve the same asymptotic running time as their out-of-place
counterparts. We also provide a precise complexity analysis so that all
constants are made explicit, parameterized by the space usage of the underlying
multiplication algorithms
Another Concrete Quantum Cryptanalysis of Binary Elliptic Curves
This paper presents concrete quantum cryptanalysis for binary elliptic
curves for a time-efficient implementation perspective (i.e., reducing the circuit
depth), complementing the previous research by Banegas et al., that focuses on the
space-efficiency perspective (i.e., reducing the circuit width). To achieve the depth
optimization, we propose an improvement to the existing circuit implementation of
the Karatsuba multiplier and FLT-based inversion, then construct and analyze the
resource in Qiskit quantum computer simulator. The proposed multiplier architecture,
improving the quantum Karatsuba multiplier by Van Hoof et al., reduces the
depth and yields lower number of CNOT gates that bounds to O(nlog2(3)) while
maintaining a similar number of Toffoli gates and qubits. Furthermore, our improved
FLT-based inversion reduces CNOT count and overall depth, with a tradeoff
of higher qubit size. Finally, we employ the proposed multiplier and FLT-based inversion
for performing quantum cryptanalysis of binary point addition as well as the
complete Shor’s algorithm for elliptic curve discrete logarithm problem (ECDLP).
As a result, apart from depth reduction, we are also able to reduce up to 90% of the
Toffoli gates required in a single-step point addition compared to prior work, leading
to significant improvements and give a new insights on quantum cryptanalysis for a
depth-optimized implementation
Saber on ARM CCA-secure module lattice-based key encapsulation on ARM
The CCA-secure lattice-based post-quantum key encapsulation scheme Saber is a candidate in the NIST\u27s post-quantum cryptography standardization process. In this paper, we study the implementation aspects of Saber in resource-constrained microcontrollers from the ARM Cortex-M series which are very popular for realizing IoT applications. In this work, we carefully optimize various parts of Saber for speed and memory. We exploit digital signal processing instructions and efficient memory access for a fast implementation of polynomial multiplication. We also use memory efficient Karatsuba and just-in-time strategy for generating the public matrix of the module lattice to reduce the memory footprint. We also show that our optimizations can be combined with each other seamlessly to provide various speed-memory trade-offs. Our speed optimized software takes just 1,147K, 1,444K, and 1,543K clock cycles on a Cortex-M4 platform for key generation, encapsulation and decapsulation respectively. Our memory efficient software takes 4,786K, 6,328K, and 7,509K clock cycles on an ultra resource-constrained Cortex-M0 platform for key generation, encapsulation, and decapsulation respectively while consuming only 6.2 KB of memory at most. These results show that lattice-based key encapsulation schemes are perfectly practical for securing IoT devices from quantum computing attacks
Saber on ARM:CCA-secure module lattice-based key encapsulation on ARM
The CCA-secure lattice-based post-quantum key encapsulation scheme Saber is a candidate in the NIST’s post-quantum cryptography standardization process. In this paper, we study the implementation aspects of Saber in resourceconstrained microcontrollers from the ARM Cortex-M series which are very popular for realizing IoT applications. In this work, we carefully optimize various parts of Saber for speed and memory. We exploit digital signal processing instructions and efficient memory access for a fast implementation of polynomial multiplication. We also use memory efficient Karatsuba and just-in-time strategy for generating the public matrix of the module lattice to reduce the memory footprint. We also show that our optimizations can be combined with each other seamlessly to provide various speed-memory trade-offs. Our speed optimized software takes just 1,147K, 1,444K, and 1,543K clock cycles on a Cortex-M4 platform for key generation, encapsulation and decapsulation respectively. Our memory efficient software takes 4,786K, 6,328K, and 7,509K clock cycles on an ultra resource-constrained Cortex-M0 platform for key generation, encapsulation, and decapsulation respectively while consuming only 6.2 KB of memory at most. These results show that lattice-based key encapsulation schemes are perfectly practical for securing IoT devices from quantum computing attacks