Hash Families Research Articles

On tight bounds for binary frameproof codes

In this paper, we study $$w$$w-frameproof codes, which are equivalent to $$\{1,w\}$${1,w}-separating hash families. Our main results concern binary codes, which are defined over an alphabet of two symbols. For all $$w \ge 3$$w?3, and for $$w+1 \le N \le 3w$$w+1≤N≤3w, we show that an $${\mathsf {SHF}}(N; n,2, \{1,w \})$$SHF(N?n,2,{1,w}) exists only if $$n \le N$$n≤N, and an $${\mathsf {SHF}}(N; N,2, \{1,w \})$$SHF(N?N,2,{1,w}) must be a permutation matrix of degree $$N$$N.

Enhanced FPGA Implementation of the SHA-512 Hash Function

In modern cryptographic hash function plays an important role. Hash function algorithms are widely used to provide authentication, security and services of integrity. The main computation block in SHA-512 algorithm is governed by a loop with high data dependence for which one implementation strategy is explored in this work as well as design efficiently mapped to hardware architecture. We propose an improved implementation of the SHA-512 hash family, with minimal operator latency, reduced hardware requirements, high frequency, and high throughput. The proposed design were implemented and validated in the FPGA Virtex. The FPGAs targets are XC5VLX30-3ff324, XC6VLX75T-3ff784.

Generic construction for secure and efficient handoff authentication schemes in EAP-based wireless networks

As a promising application scenario of wireless technologies, roaming communication initiates the demand for secure and efficient handoff authentication schemes. However, it seems that no existing scheme can simultaneously provide provable security and enjoy desirable efficiency. In this paper, we first utilize the double-trapdoor chameleon hash family to develop a generic method for secure and efficient handoff authentication in EAP-based wireless networks. The main idea is that the verification information, deduced from the one-time trapdoor, provides an authenticated transient Diffie–Hellman key exchange only between a mobile node and an access point. Moreover, we present an instantiation of the generic method based on a special double-trapdoor chameleon hashing. The proposed scheme not only provides robust security, but also enjoys desirable efficiency. To be specific, our scheme is proved to be secure in the random oracle model based on the computational Diffie–Hellman assumption and the unforgeability of an elliptic curve digital signature. Furthermore, formal verification by using the AVISPA tool shows that our scheme resists various malicious attacks. Finally, we evaluate the latency performance by the theoretical analysis and simulation. The results indicate that the proposed scheme achieves desirable efficiency in terms of the computation cost, the communication overhead and the storage requirement.

Algebraic Fault Attack on the SHA-256 Compression Function

The cryptographic hash function SHA-256 is one member of the SHA-2 hash family, which was proposed in 2000 and was standardized by NIST in 2002 as a successor of SHA-1. Although the differential fault attack on SHA-1compression function has been proposed, it seems hard to be directly adapted to SHA-256. In this paper, an efficient algebraic fault attack on SHA-256 compression function is proposed under the word-oriented random fault model. During the attack, an automatic tool STP is exploited, which constructs binary expressions for the word-based operations in SHA-256 compression function and then invokes a SAT solver to solve the equations. The simulation of the new attack needs about 65 fault injections to recover the chaining value and the input message block with about 200 seconds on average. Moreover, based on the attack on SHA-256 compression function, an almost universal forgery attack on HMAC-SHA-256 is presented. Our algebraic fault analysis is generic, automatic and can be applied to other ARX-based primitives..

On the development of high-throughput and area-efficient multi-mode cryptographic hash designs in FPGAs

In this paper, area-efficient and high-throughput multi-mode architectures for the SHA-1 and SHA-2 hash families are proposed and implemented in several FPGA technologies. Additionally a systematic flow for designing multi-mode architectures (implementing more than one function) of these families is introduced. Compared to the corresponding architectures that are produced by a commercial synthesis tool, the proposed ones are better in terms of both area (at least 40%) and throughput/area (from 32% up to 175%). Finally, the proposed architectures outperform similar existing ones in terms of throughput and throughput/area, from 4.2× up to 279.4× and from 1.2× up to 5.5×, respectively.

Optimal Lower Bounds for Locality-Sensitive Hashing (Except When q is Tiny)

We study lower bounds for Locality-Sensitive Hashing (LSH) in the strongest setting: point sets in {0,1} d under the Hamming distance. Recall that H is said to be an ( r , cr , p , q )-sensitive hash family if all pairs x , y ∈ {0,1} d with dist( x , y ) ≤ r have probability at least p of collision under a randomly chosen h ∈ H, whereas all pairs x , y ∈ {0, 1} d with dist( x , y ) ≥ cr have probability at most q of collision. Typically, one considers d → ∞, with c > 1 fixed and q bounded away from 0. For its applications to approximate nearest-neighbor search in high dimensions, the quality of an LSH family H is governed by how small its ρ parameter ρ = ln(1/ p )/ln(1/ q ) is as a function of the parameter c . The seminal paper of Indyk and Motwani [1998] showed that for each c ≥ 1, the extremely simple family H = { x ↦ x i : i ∈ [ d ]} achieves ρ ≤ 1/ c . The only known lower bound, due to Motwani et al. [2007], is that ρ must be at least ( e 1/c - 1)/( e 1/c + 1) ≥ .46/ c (minus o d (1)). The contribution of this article is twofold. (1) We show the “optimal” lower bound for ρ : it must be at least 1/ c (minus o d (1)). Our proof is very simple, following almost immediately from the observation that the noise stability of a boolean function at time t is a log-convex function of t . (2) We raise and discuss the following issue: neither the application of LSH to nearest-neighbor search nor the known LSH lower bounds hold as stated if the q parameter is tiny. Here, “tiny” means q = 2 -Θ(d) , a parameter range we believe is natural.

On the relationships between perfect nonlinear functions and universal hash families

In this paper, the relationships between perfect nonlinear (in brief, PN) functions and optimal universal hash families are discussed. We point out the equivalence of constructions between them, i.e., from PN functions, one can obtain optimal universal hash families and vice versa. As an application of our construction, a message authentication code is proposed, which provides better resistance to substitution attack than a known construction given by Carlet et al. in 2006. More generally, the connections between functions with given differential uniformity and some universal hash families are studied.

Explicit and Efficient Hash Families Suffice for Cuckoo Hashing with a Stash

It is shown that for cuckoo hashing with a stash as proposed by Kirsch et al. (Proc. 16th European Symposium on Algorithms (ESA), pp. 611–622, Springer, Berlin, 2008) families of very simple hash functions can be used, maintaining the favorable performance guarantees: with constant stash size s the probability of a rehash is O(1/n s+1), the lookup time and the deletion time are O(s) in the worst case, and the amortized expected insertion time is O(s) as well. Instead of the full randomness needed for the analysis of Kirsch et al. and of Kutzelnigg (Discrete Math. Theor. Comput. Sci., 12(3):81–102, 2010) (resp. Θ(logn)-wise independence for standard cuckoo hashing) the new approach even works with 2-wise independent hash families as building blocks. Both construction and analysis build upon the work of Dietzfelbinger and Woelfel (Proc. 35th ACM Symp. on Theory of Computing (STOC), pp. 629–638, 2003). The analysis, which can also be applied to the fully random case, utilizes a graph counting argument and is much simpler than previous proofs. The results can be generalized to situations where the stash size is non-constant.

A SYSTEMATIC FLOW FOR DEVELOPING TOTALLY SELF-CHECKING ARCHITECTURES FOR SHA-1 AND SHA-2 CRYPTOGRAPHIC HASH FAMILIES

Hash functions are among the crucial modules of modern hardware cryptographic systems. These systems frequently operate in harsh and noisy environments where permanent and/or transient faults are often causing erroneous authentication results and collapsing of the whole authentication procedure. Hence, their on-time detection is an urgent feature. In this paper, a systematic development flow towards totally self-checking (TSC) architectures of the most widely-used cryptographic hash families, SHA-1 and SHA-2, is proposed. Novel methods and techniques are introduced to determine the appropriate concurrent error detection scheme at high level avoiding gate-level implementations and comparisons. The resulted TSC architectures achieve 100% fault detection of odd erroneous bits, while, depending on the designer's choice, even number of erroneous bits can also be detected. Two representative functions of the above families, namely the SHA-1 and SHA-256, are used as case studies. For each of them, two TSC architectures (one un-optimized and one optimized for throughput) were developed via the proposed flow and implemented in TSMC 0.18 μm CMOS technology. The produced architectures are more efficient in terms of throughput/area than the corresponding duplicated-with-checking ones by 19.5% and 23.8% regarding the un-optimized TSC SHA-1 and SHA-256 and by 20.2% and 24.6% regarding the optimized ones.

Super-simple balanced incomplete block designs with block size 5 and index 3

Super-simple designs are useful in constructing codes and designs such as superimposed codes and perfect hash families. In this article, we investigate the existence of a super-simple (v,5,3) balanced incomplete block design and show that such a design exists if and only if v≡1,5(mod20) and v≥21 except possibly when v=45,65.

Refereed delegation of computation

Consider a weak client that wishes to delegate a computation to an untrusted server, and then verify the correctness of the result. When the client uses only a single untrusted server, current techniques suffer from disadvantages such as computational inefficiency for the client or the server, limited functionality, or high round complexity.We demonstrate relatively efficient and general solutions where the client delegates the computation to several servers, and is guaranteed to determine the correct answer as long as even a single server is honest. We call such protocols Refereed Delegation of Computation (RDoC) and show:1.A computationally secure protocol for any efficiently computable function, with logarithmically many rounds, based on any collision-resistant hash family. In our description of this protocol, we model the computation as running on a Turing Machine, but the protocol can be adapted to other computation models. We present an adaptation for the X86 computation model and a prototype implementation, called Quin, for Windows executables. We describe the architecture of Quin and experiment with several parameters on live cloud servers. We show that the protocol is practical, can work with real-world cloud servers, and is efficient for both the servers and for the client.2.A 1-round statistically secure protocol for any log-space uniform NC circuit. In contrast, in the single server setting all known one-round delegation protocols are computationally sound. The protocol extends the arithemetization techniques of Goldwasser, Kalai and Rothblum (STOC 08) and Feige and Kilian (STOC 97).

A tight bound for frameproof codes viewed in terms of separating hash families

Frameproof codes have been introduced for use in digital fingerprinting that prevent a coalition of $$w$$ or fewer legitimate users from constructing a fingerprint of another user not in the coalition. It turns out that $$w$$ -frameproof codes are equivalent to separating hash families of type $$\{1,w\}$$ . In this paper we prove a tight bound for frameproof codes in terms of separating hash families.

Cryptanalysis of Reduced-Round DASH

In ACISP 2008, the hash family DASH has been proposed by Billet et al., which considers the design of Rijndael and RC6. DASH family has two variants that support 256-bit and 512-bit output length respectively. This paper presents the first third-party cryptanalysis of DASH-256 with a focus on the underlying block cipher \( {{\mathcal{A}}_{256 }} \). In particular, we study the distinguisher using differential and boomerang attack. As a result, we build a distinguishing attack for the compression function of DASH-256 with 8-round \( {{\mathcal{A}}_{256 }} \) using the differential cryptanalysis. Finally, we obtain a boomerang distinguisher of 9-round \( {{\mathcal{A}}_{256 }} \).

Balls and Bins: Smaller Hash Families and Faster Evaluation

A fundamental fact in the analysis of randomized algorithms is that when $n$ balls are hashed into $n$ bins independently and uniformly at random, with high probability each bin contains at most $O(\log n/\log\log n)$ balls. In various applications, however, the assumption that a truly random hash function is available is not always valid, and explicit functions are required. In this paper we study the size of families (or, equivalently, the description length of their functions) that guarantee a maximal load of $O(\log n/\log\log n)$ with high probability, as well as the evaluation time of their functions. Whereas such functions must be described using $\Omega(\log n)$ bits, the best upper bound was formerly $O(\log^{2}n/\log\log n)$ bits, which is attained by $O(\log n/\log\log n)$-wise independent functions. Traditional constructions of $O(\log n/\log\log n)$-wise independent functions offer an evaluation time of $O(\log n/\log\log n)$, which according to Siegel's lower bound [A. Siegel, Proceedings of the $30$th Annual IEEE Symposium on Foundations of Computer Science, 1989, pp. 20--25] can be reduced only at the cost of significantly increasing the description length. We construct two families that guarantee a maximal load of $O(\log n/\log\log n)$ with high probability. Our constructions are based on two different approaches and exhibit different trade-offs between the description length and the evaluation time. The first construction shows that $O(\log n/\log\log n)$-wise independence can in fact be replaced by “gradually increasing independence,” resulting in functions that are described using $O(\log n\log\log n)$ bits and evaluated in time $O(\log n\log\log n)$. The second construction is based on derandomization techniques for space-bounded computations combined with a tailored construction of a pseudorandom generator, resulting in functions that are described using $O(\log^{3/2}n)$ bits and evaluated in time $O(\sqrt{\log n})$. Our second construction can be compared to Siegel's lower bound stating that $O(\log n/\log\log n)$-wise independent functions that are evaluated in time $O(\sqrt{\log n})$ must be described using $\Omega(2^{\sqrt{\log n}})$ bits.

Improved bounds for separating hash families

An $${(N;n,m,\{w_1,\ldots, w_t\})}$$ -separating hash family is a set $${\mathcal{H}}$$ of N functions $${h: \; X \longrightarrow Y}$$ with $${|X|=n, |Y|=m, t \geq 2}$$ having the following property. For any pairwise disjoint subsets $${C_1, \ldots, C_t \subseteq X}$$ with $${|C_i|=w_i, i=1, \ldots, t}$$ , there exists at least one function $${h \in \mathcal{H}}$$ such that $${h(C_1), h(C_2), \ldots, h(C_t)}$$ are pairwise disjoint. Separating hash families generalize many known combinatorial structures such as perfect hash families, frameproof codes, secure frameproof codes, identifiable parent property codes. In this paper we present new upper bounds on n which improve many previously known bounds. Further we include constructions showing that some of these bounds are tight.

A new multi-linear universal hash family

A new universal hash family is described which generalises a previously known multi-linear hash family. Messages are sequences over a finite field $${\mathbb{F}_q}$$ while keys are sequences over an extension field $${\mathbb{F}_{q^n}}$$ . A linear map $${\psi}$$ from $${\mathbb{F}_{q^n}}$$ to itself is used to compute the output digest. Of special interest is the case q = 2. For this case, we show that there is an efficient way to implement $${\psi}$$ using a tower field representation of $${\mathbb{F}_{q^n}}$$ . From a practical point of view, the focus of our constructions is small hardware and other resource constrained applications. For such platforms, our constructions compare favourably to previous work.

Strengthening hash families and compressive sensing

The deterministic construction of measurement matrices for compressive sensing is a challenging problem, for which a number of combinatorial techniques have been developed. One of them employs a widely used column replacement technique based on hash families. It is effective at producing larger measurement matrices from smaller ones, but it can only preserve the strength (level of sparsity supported), not increase it. Column replacement is extended here to produce measurement matrices with larger strength from ingredient arrays with smaller strength. To do this, a new type of hash family, called a strengthening hash family, is introduced. Using these hash families, column replacement is shown to increase strength under two standard notions of recoverability. Then techniques to construct strengthening hash families, both probabilistically and deterministically, are developed. Using a variant of the Stein–Lovász–Johnson theorem, a deterministic, polynomial time algorithm for constructing a strengthening hash family of fixed strength is derived.

The parazoa family: generalizing the sponge hash functions

Sponge functions were introduced by Bertoni et al. as an alternative to the classical Merkle-Damgard design. Many hash function submissions to the SHA-3 competition launched by NIST in 2007, such as CubeHash, Fugue, Hamsi, JH, Keccak and Luffa, derive from the original sponge design, and security guarantees from some of these constructions are typically based on indifferentiability results. Although indifferentiability proofs for these designs often bear significant similarities, these have so far been obtained independently for each construction. In this work, we introduce the parazoa family of hash functions as a generalization of “sponge-like” functions. Similarly to the sponge design, the parazoa family consists of compression and extraction phases. The parazoa hash functions, however, extend the sponge construction by enabling the use of a wider class of compression and extraction functions that need to satisfy certain properties. More importantly, we prove that the parazoa functions satisfy the indifferentiability notion of Maurer et al. under the assumption that the underlying permutation is ideal. Not surprisingly, our indifferentiability result confirms the bound on the original sponge function, but it also carries over to a wider spectrum of hash functions and eliminates the need for a separate indifferentiability analysis.

The Parameterized Complexity of Unique Coverage and Its Variants

In this paper we study the parameterized complexity of the Unique Coverage problem, a variant of the classic Set Cover problem. This problem admits several parameterizations and we show that all, except the standard parameterization and a generalization of it, are unlikely to be fixed-parameter tractable. We use results from extremal combinatorics to obtain the best-known kernel for Unique Coverage and the well-known color-coding technique of Alon et al. (J. ACM 42(4), 844---856, 1995) to show that a weighted version of this problem is fixed-parameter tractable. Our application of color-coding uses an interesting variation of s-perfect hash families called (k,s)-hash families which were studied by Alon et al. (J. Comb. Theory Ser. A 104(1), 207---215, 2003) in the context of a class of codes called parent identifying codes (Barg et al. in SIAM J. Discrete Math. 14(3), 423---431, 2001). To the best of our knowledge, this is the first application of (k,s)-hash families outside the domain of coding theory. We prove the existence of such families of size smaller than the best-known s-perfect hash families using the probabilistic method (Alon and Spencer in The Probabilistic Method, Wiley, New York, 2000). Explicit constructions of such families of size promised by the probabilistic method is open.

Cores of random r-partite hypergraphs

We show that the threshold cr,k (in terms of the average degree of the graph) for appearance of a k-core in a random r-partite r-uniform hypergraph Gr,n,m is the same as for a random r-uniform hypergraph with cn/r edges without the r-partite restriction, where r,k⩾2. In both cases, the average degree is c. The case r,k=2 was analyzed in Botelho et al. (2007) [4] but the general case r⩾3, k⩾2 is still open. Besides the proof for the general case, we have also provided a simpler proof for the case r,k=2. This problem was provided without a proof (but with strong experimental evidence) in the analysis of the algorithm presented in Botelho et al. (2007) [2]. This algorithm constructs a family of minimal perfect hash functions based on random r-partite r-uniform hypergraphs with an empty k-core subgraph, for k⩾2. For an input key set S with m keys, the family of minimal perfect hash functions generated by the algorithm can be stored in O(m) bits, where the hidden constant is within a factor of two from the information theoretical lower bound.