Lyra Key Encryption Algorithms
Password hashing systems are an important part of data security for many companies. The best options are the ones that can save time, money and computer memory in a smart, secure system. For a long time, Lyra was that system. Then its designers went back to the drawing board and created a new, more impressive version in Lyra2.
What Was Lyra?
Lyra was a password-based system that used cryptographic algorithms to decode a sequential system. This is also referred to as a key derivation function or KDF. It was the creation a group of students from Escola Politecnica da Universidade de Sao Paulo.
The original Lyra model was a great example of key encryption algorithms. The idea of this sequential system, rather than one that could be easily paralleled, was that it was much safer. Hackers with the toughest custom hardware and multiple processing cores couldn’t get through this model.
The system was tough, smart and complex. However, there was the benefit of ease-of-use, as it was easy to bring into an existing system. Another important benefit of this system was the fact that it offered a higher memory usage.
The advantage here is that increases the cost of attacks without increasing the processing time. There was a lot to love with Lyra. However, even the best model can be significantly bettered.
Lyra Was Great, But Then Lyra2 Came Into Existence
The same group from Escola Politecnica da Universidade de Sao Paulo later came up with an improvement on the old system. This program was pretty similar to its predecessor on the surface. Again this was a PHS with cryptographic functions that were also purely sequential in style.
It is an impressive design that creates a pseudorandom output for key encryption algorithms or an authentication string. The memory is a matrix; that stays intact through the entire password hashing process. This matrix came about through the operations of the sponge and remains sequential, never resetting to zero.
Lyra2 saw its release as a public domain option with two extensions: Lyra2-δ and Lyra2p. The former gives users greater control over the use of the algorithm’s bandwidth. The latter opens up parallelism capabilities on the user’s platform, something not possible with the first Lyra model.
Despite This, The New Lyra Model Had Some Strength Over The Previous Version
In many ways, the processing, functions, and purpose just followed the lead of the original program. It offered a very similar experience and similar tools to provide the best possible security. However, there are some clear improvements. The most important fact is that it provided much stronger security features.
Again, it required a lot of brute force to get into any system using Lyra2. The difference was the level of customization on offer. The new Lyra encryption algorithm meant that users could adjust the memory and processing costs to meet security needs.
This means that a low-level company with a low threat doesn’t need to use up as much memory for no reason. It is, therefore, more efficient than Lyra1 and cost effective. This new security level means that the system is more appealing to different types of users.
There are other ways that this system shows itself to be an improvement on the old design. One of the most interesting is that extension for parallelism capabilities. This support is now offered over multicore platforms yet still protects against GPU-based attacks. The new features tended to ensure that the new model didn’t lose any of the security, efficiency or flexibility of the former.
This flexibility is apparent in the performance of that other extension and the ability to change settings. This efficiency is also seen in the high resistance to processing memory trade-offs, which lowers memory usage and costs even further. It also happens to be pretty fast thanks to the improvements made to the sponge in the core.
As A Result Of This, Lyra2 Is Now Highly Regarded As A Key Derivation Function And Used By Many Companies
Lyra2 achieved special recognition at the Password Hashing Competition in July 2015. With benefits and improvements like those shown above, this is no big surprise. The small tweaks and extensions showed what designers could do to make a great key derivation function even better.