Password-based Key Derivation Research Articles

Parallel Implementation of Scrypt: A Study on GPU Acceleration for Password-Based Key Derivation Function

Parallel Implementation of Scrypt: A Study on GPU Acceleration for Password-Based Key Derivation Function

Mathematical Solution of ULTE Based Salt Generation Password Based Key Derivation Function (PBKDF)

In modern life, users use the cloud spaces for storing important data and valuable information. To avoid security problems, every cloud storage provider requires help from several security mechanisms. Every mechanism has its own security scheme. Most of them use the PBKDF (Password-Based Key Derivation Function) and Salt for generating encryption keys. By analyzing, we found that unique and random Salt plays a vital role for generating keys. But to create powerful keys, we must avoid pseudorandom generators for making salt because hackers can easily crack the key by using it. We have to take inputs from beyond expected sources. We proposed an algorithm by which we can generate Salt by using the client’s real-time environmental information known as Location Information of user, User Time Information with Entropy Data at key generation time. In this paper, we focus on simulation result and compare each algorithm with the proposed algorithm ULTE. Simulation result represents the whole statistical distribution as stated in the algorithm. The result shows that ULTE has provided excellent performance than other algorithms.

Efficient Architectures for Full Hardware Scrypt-Based Block Hashing System

The password-based key derivation function Scrypt has been employed for many services and applications due to its protection ability. It has also been employed as a proof-of-work algorithm in blockchain implementations. Although this cryptographic hash function provides very high security, the processing speed and power consumption to generate a hashed block for the blockchain network are low-performance. In this paper, a high-speed and low-power hardware architecture of the Scrypt function is proposed to generate blocks for the Scrypt-based blockchain network. This architecture minimizes the number of main computational blocks to reduce the power consumption of the system. In addition, the proposed sharing resources and pipelined architectures make the calculation speed increase significantly while the hardware cost is reduced by half compared to the parallel non-pipelined architecture. The full hardware system is designed and implemented on Xilinx Virtex-7 and Aveo U280 FPGA platforms. The hash rate of the proposed system reaches 229.1 kHash/s. Its hash rate, hardware and energy efficiencies are much higher than those of the other works implemented on FPGA and GPU hardware platforms. The proposed hardware architecture is also successfully implemented in an ASIC design using ROHM 180 nm CMOS technology.

T-S3RA: Traffic-Aware Scheduling for Secure Slicing and Resource Allocation in SDN/NFVEnabled 5G Networks

Network slicing and resource allocation play pivotal roles in software-defined network (SDN)/network function virtualization (NFV)-assisted 5G networks. In 5G communications, the traffic rate is high, necessitating high data rates and low latency. Deep learning is a potential solution for overcoming these constraints. Secure slicing avoids resource wastage; however, DDoS attackers can exploit the sliced network. Therefore, we focused on secure slicing with resource allocation under massive network traffic. Traffic-aware scheduling is proposed for secure slicing and resource allocation over SDN/NFV-enabled 5G networks. In this approach (T-S3RA), user devices are authenticated using Boolean logic with a password-based key derivation function. The traffic is scheduled in 5G access points, and secure network slicing and resource allocation are implemented using deep learning models such as SliceNet and HopFieldNet, respectively. To predict DDoS attackers, we computed the Renyi entropy for packet classification. Experiments were conducted using a network simulator with 250 nodes in the network topology. Performance was evaluated using metrics such as throughput, latency, packet transmission ratio, packet loss ratio, slice capacity, bandwidth consumption, and slice acceptance ratio. T-S3RA was implemented in three 5G use cases with different requirements including massive machine-type communication, ultrareliable low-latency communication, and enhanced mobile broadband.

Optimization of PBKDF2 Using HMAC-SHA2 and HMAC-LSH Families in CPU Environment

Password-Based Key Derivation Function 2 (PBKDF2) is widely used cryptographic algorithm in order to generate secure keys to a password in various occasions. For example, it is used for file encryption and implementation of authentication systems, and so on. However, the generated derived key has a lower entropy than a general cryptography key, so its use is limited. To compensate for this the number of iteration counts of PBKDF2 should be increased. As the number of repetitive tasks increases, the entropy of the derived key increases, but it takes more time to generate the derived key. We present various optimization methods of PBKDF2. The main idea of our proposed method is reducing redundant block operations and optimizing the internal process of underlying Pseudo Random Function (PRF). In other words, we integrate several redundant operations and make full use of constant values used in PBKDF2. We use two HMAC algorithms: one using SHA-2 family and one using LSH family as the PRF of PBKDF2 (SHA-2 family is the most widely used hash functions, and LSH family is the latest hash function recently developed in South Korea). With our techniques, our implementations outperform Korea Internet & Security Agency (KISA) implementation by 121.26%, 325.91%, and 231.89% for using SHA256, LSH256, and LSH512 respectively; and also outperform <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">OpenSSL</i> implementation by 39.59% using SHA512. In addition, we show that the internal process of PBKDF2 can be computed independently. With our multi thread technique, our PBKDF2 implementations outperform KISA implementation by 2,152.66%, 1,986.85%, and 1,591.36% for using SHA256, LSH256, and LSH512 respectively; and our PBKDF2-HMAC-SHA512 implementation outperforms <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">OpenSSL</i> implementation by 523.57%. With our proposed implementation techniques, higher security can be achieved with more iteration operations. Furthermore, our optimization techniques can be easily expanded to optimize the performance of PBKDF2 on GPGPU and embedded devices.

Exploiting an HMAC-SHA-1 Optimization to Speed up PBKDF2

PBKDF2 [1] is a well-known password-based key derivation function. In order to slow attackers down, PBKDF2 introduces CPU-intensive operations based on an iterated pseudorandom function (in our case HMAC-SHA-1). If we are able to speed up a SHA-1 or an HMAC implementation, we are able to speed up PBKDF2-HMAC-SHA-1. This means that a performance improvement might be exploited by regular users and attackers. Interestingly, FIPS 198-1 [2] suggests that it is possible to precompute first message block of a keyed hash function only once, store such a value and use it each time is needed [3] . Therefore the computation of first message block does not contribute to slowing attackers down, thus making the computation of second message block crucial. In this paper we focus on the latter, investigating the possibility to avoid part of the HMAC-SHA-1 operations. We show that some CPU-intensive operations may be replaced with a set of equivalent, but less onerous, instructions. We identify useless XOR operations exploiting and extending Intel optimizations [4] , and applying the Boyar-Peralta heuristic [5] . In addition, we provide an alternative method to compute the SHA-1 message scheduling function and explain why attackers might exploit these findings to speed up a brute force attack against PBKDF2.

Examining PBKDF2 security margin—Case study of LUKS

Passwords are widely used to protect our sensitive information or to gain access to specific resources. They should be changed frequently and be strong enough to prevent well-known attacks. Unfortunately, user-chosen passwords are usually short and lack sufficient entropy. A possible solution to these problems is to adopt a Key Derivation Function (KDF) that allows legitimate users to spend a moderate amount of time on key derivation, while imposing CPU/memory-intensive operations on the attacker side. In this paper, we focus on long-term passwords secured by the Password-Based Key Derivation Function 2 (PBKDF2) and present the case study of Linux Unified Key Setup (LUKS), a disk-encryption specification commonly implemented in Linux based operating systems. In particular, we describe how LUKS protects long-term keys by means of iteration counts defined at runtime, and analyze how external factors may affect the iteration counts computation. In doing so, we provide means of evaluating the iteration count values defined at run-time and experimentally show to what level PBKDF2 is still capable of providing sufficient security margin for a LUKS implementation.

Towards incorporating honeywords in n‐session recording attack resilient unaided authentication services

Unaided authentication services provide the flexibility to login without being dependent on any external hardware. n-Session recording attack resilient unaided authentication services (n-SRRUASs) are known for setting high security standards against different client side threats. However, because of their authentication procedure, the authors have identified that these services cope poorly with handling the server side issues. Though modern days’ research heavily depends on the honeywords (or fake passwords) as a countermeasure of server side threats, they have shown that the honeywords cannot be directly applied to n-SRRUAS. The authors’ analysis shows that the idea of incorporating the honeywords directly into an n-SRRUAS is particularly difficult as it prevents the system from storing passwords after applying password-based key derivation function or in the form of a hashed string. In this study, they have proposed few generic principles for incorporating the honeywords into n-SRRUAS and show that the proposed principles are sufficient for incorporating the honeywords into any n-SRRUAS. Furthermore, with the help of an existing n-SRRUAS, they have shown that the proposed idea is truly implementable in practice to fill the existing gap.

Optimizing a Password Hashing Function with Hardware-Accelerated Symmetric Encryption

Password-based key derivation functions (PBKDFs) are commonly used to transform user passwords into keys for symmetric encryption, as well as for user authentication, password hashing, and preventing attacks based on custom hardware. We propose two optimized alternatives that enhance the performance of a previously published PBKDF. This design is based on (1) employing a symmetric cipher, the Advanced Encryption Standard (AES), as a pseudo-random generator and (2) taking advantage of the support for the hardware acceleration for AES that is available on many common platforms in order to mitigate common attacks to password-based user authentication systems. We also analyze their security characteristics, establishing that they are equivalent to the security of the core primitive (AES), and we compare their performance with well-known PBKDF algorithms, such as Scrypt and Argon2, with favorable results.

Password-based key derivation function as one of Blum-Blum-Shub pseudo-random generator applications

The main objective of the research is the analysis of the practical applicability of the cryptographically secure software Blum-Blum-Shub pseudo-random number generator for different authentication and encryption tasks. It is shown that the considered pseudo-random sequence generator, which has a high computational complexity, can be effectively used in those cryptographic tasks, which require low key generation rate. An alternative way of implementing the Password-Based Key Derivation Function, which is based on the use of the Blum-Blum-Shub generator as a pseudo-random function, is proposed. The proposed algorithm allows to slow down dictionary and brute-force attacks. Experimental studies have shown that the developed algorithm allows to adaptively adjust the guaranteed minimum time of generating a cryptographic key for specific tasks of authentication and encryption.

A New Handover Scheme for Providing Security in VANET

Ad Hoc Network (VANET) is the subgroup of the Mobile Ad Hoc Network (MANET). VANET interconnects the nodes for transferring secure information between nodes, here vehicle acts as a node. VANET is used to provide safety and efficiency in transportation system. Many traffic signals are used to reduce accidents in the roads, but since it is not much effective. Hence VANET is used; it uses Road Side Unit (RSU). This RSU connects to the internet, and provides information to the Vehicular Ad Hoc Network users. Each and every vehicle is interconnected to each other hence it can send alert message to another vehicle to reduce the speed or increase the speed to avoid accidents. Each and every vehicle can use internet facility while traveling. Since mobile internet is used nowadays but this road side unit internet connection is more speed. The information transferred between vehicle and RSU is more secure, because the road side unit provides unique key for each and every user connected to it. When the vehicle is moved out of the particular range, handover scheme occurs. The bending information will be transferred from old RSU to the new RSU. The service provided by the road side unit is called Service-Oriented Vehicular Ad Hoc Network. Keywords-Oriented Vehicular ad hoc networks, Road Side Units, hierarchical password-based key derivation, anonymity.

Lyra: password-based key derivation with tunable memory and processing costs

We present Lyra, a password-based key derivation scheme based on cryptographic sponges. Lyra was designed to be strictly sequential (i.e., not easily parallelizable), providing strong security even against attackers that use multiple processing cores (e.g., custom hardware or a powerful GPU). At the same time, it is very simple to implement in software and allows legitimate users to fine-tune its memory and processing costs according to the desired level of security against brute force password guessing. We compare Lyra with similar-purpose state-of-the-art solutions, showing how our proposal provides a higher security level and overcomes limitations of existing schemes. Specifically, we show that if we fix Lyra ’s total processing time \(t\) in a legitimate platform, the cost of a memory-free attack against the algorithm is exponential, while the best-known result in the literature (namely, against the scrypt algorithm) is quadratic. In addition, for an identical same processing time, Lyra allows for a higher memory usage than its counterparts, further increasing the cost of brute force attacks.

A pedagogical example of a stretched password-based key derivation function

This paper describes a teaching example of a stretched, pseudo password-based key derivation function. Specifically, this paper will highlight the use of the non-commutative dihedral group D16, digital roots, recurrence relations, modulo operation, and prime numbers in constructing recoverable stretched character string of any length given a weak password seed and a salt of arbitrary byte (octet) length. The algorithm described here can be used to introduce the above topics and their importance in further coursework, and be used as a relatively simple example which can lead to discussion on serious and very technical work in password stretching, random functions, hash functions, and password-based key derivation functions specifically, and cryptography in general.

A Non-Exchanged Password Scheme for Password-Based Authentication in Client-Server Systems

The password-based authentication is widely used in client-server systems. This research presents a non-exchanged password scheme for password-based authentication. This scheme constructs a Digital Signature (DS) that is derived from the user password. The digital signature is then exchanged instead of the password itself for the purpose of authentication. Therefore, we refer to it as a Password-Based Digital Signature (PBDS) scheme. It consists of three phases, in the first phase a password-based Permutation (P) is computed using the Key-Based Random Permutation (KBRP) method. The second phase utilizes P to derive a Key (K) using the Password-Based Key Derivation (PBKD) algorithm. The third phase uses P and K to generate the exchanged DS. The scheme has a number of features that shows its advantages over other password authentication approaches.

A Password-Based Key Derivation Algorithm Using the KBRP Method

This study presents a new efficient password-based strong key derivation algorithm using the key based random permutation the KBRP method. The algorithm consists of five steps, the first three steps are similar to those formed the KBRP method. The last two steps are added to derive a key and to ensure that the derived key has all the characteristics of a strong key. In order to demonstrate the efficiency of the algorithm, a number of keys are derived using various passwords of different content and length. The features of the derived keys show a good agreement with all characteristics of strong keys. In addition, they are compared with features of keys generated using the WLAN strong key generator v2.2 by Warewolf Labs.

Design and Analysis of Password-Based Key Derivation Functions

A password-based key derivation function (KDF)-a function that derives cryptographic keys from a password-is necessary in many security applications. Like any password-based schemes, such KDFs are subject to key search attacks (often called dictionary attacks). Salt and iteration count are used in practice to significantly increase the workload of such attacks. These techniques have also been specified in widely adopted industry standards such as PKCS and IETF. Despite the importance and widespread usage, there has been no formal security analysis on existing constructions. In this correspondence, we propose a general security framework for password-based KDFs and introduce two security definitions each capturing a different attacking scenario. We study the most commonly used construction H/sup (c)/(p/spl par/s) and prove that the iteration count c, when fixed, does have an effect of stretching the password p by log/sub 2/c bits. We then analyze the two standardized KDFs in PKCS #5. We show that both are secure if the adversary cannot influence the parameters but subject to attacks otherwise. Finally, we propose a new password-based KDF that is provably secure even when the adversary has full control of the parameters.