What Is Groestlcoin (GRS)?

What Is Groestlcoin (GRS)? Complete Guide Review About Groestlcoin.

What Is Groestlcoin (GRS)?

Groestlcoin borrows components from the AES block cipher, which became a United States federal government standard in 2001 [17]. The AES is known for its good performance on a wide variety of platforms, which is due to a large amount of flexibility in the choice of implementation methods. Recently, Intel introduced an instruction set extension for computing AES rounds [9], which makes encryption using the AES on CPUs implementing this instruction set very efficient.

Although several underlying components in Grøstl differ from the ones used in the AES, Grøstl still enjoys many of the same implementation benefits as the AES. Even the AES instruction set extension can be used to significantly speed up Grøstl. In this paper, we describe various software implementation techniques for Grøstl suitable for platforms ranging from 8-bit micro controllers to processors with SIMD and AES instruction set extensions.

Groestlcoin Storage Key Points

Coin BasicInformation
Coin NameGroestlcoin
Short NameGRS
Circulating Supply79,762,593.89 GRS
Total Supply79,762,594
Source CodeClick Here To View Source Code
ExplorersClick Here To View Explorers
Twitter PageClick Here To Visit Twitter Group
WhitepaperClick Here To View
Support24/7
Official Project WebsiteClick Here To Visit Project Website

Description of Grøstl

The Groestlcoin hash function iterates an underlying compression function in a variant of the Merkle-Laggard construction [7, 15], where the size of the state (or chaining value) passed on from one iteration to the next is at least twice as large as the final hash value. The final hash value is computed from the last chaining value using an output transformation. Hence, Grøstl is known as a wide pipe design.

The Hash Function

Groestlcoin comes in several variants with different output sizes. They denote by n the number of bits in the output, and the variant returning n bits is denoted Grøstl-n. Here, focus on Grøstl-256 and Grøstl512. Variants returning less than 256 bits differ from Grøstl-256 only in the initial value and in the final truncation to produce the hash value. Similarly, variants returning more than 256 bits differ from Grøstl-512 in the same two respects.

T-Table Implementation

Daemen and Rijmen have presented a table-based approach for AES in [6], which efficiently computes the combined Sub Bytes and Mix Columns transformation. The same approach can be applied to Grøstl. Using this technique, at least one table lookup is needed for each S-box. The Mix Bytes transformation is computed in parallel for rows of the state and can be combined with the S-box lookup.

Groestlcoin This approach is most efficient if the column size matches the register size. This is the case on 32-bit platforms for AES and on 64-bits platforms for Grøstl. Since many current and future small-scale 32-bit processors also provide 64-bit instructions (MMX, NEON), Grøstl can be implemented very efficiently on these platforms using the T-table approach.

Byte Slice Implementation

Another option to implement Groestlcoin is a byte-wise parallel computation of columns. All round transformations except Shift Bytes and Add Round Constant apply exactly the same computation to each column of the Grøstl state independently. Therefore, they can use a Single Instruction Multiple Data (SIMD) approach to compute these identical operations on more than one column at the same time.

They call this a byte slice implementation [1] since the Grøstl state is cut into column slices of bytes. The state is stored in row ordering. Using w-bit registers, w/8 columns can be computed in parallel (see Figure 9). This approach is most efficient for small (8-bit) and large register sizes (128-bit and more).

Bit Slice Implementation

The fastest AES software implementations are bit slice implementations running at 7.6 cycles/byte on an Intel Core2 if multiple blocks are encrypted in parallel in counter mode [14]. Also the hash function Whirlpool which shares some similarities to Grøstl has been implemented efficiently using bit slicing techniques in [20]. Preliminary assembly implementations of Groestlcoin show a speed of 29.7 cycles/byte on an Intel Core2 Duo processor for the computation of the hash of a single message [21]. Additionally, bit slice implementations of Grøstl-0 get even more efficient if two or more messages are hashed in parallel [4].