22 static const word64 KeccakF_RoundConstants[24] =
24 W64LIT(0x0000000000000001), W64LIT(0x0000000000008082), W64LIT(0x800000000000808a),
25 W64LIT(0x8000000080008000), W64LIT(0x000000000000808b), W64LIT(0x0000000080000001),
26 W64LIT(0x8000000080008081), W64LIT(0x8000000000008009), W64LIT(0x000000000000008a),
27 W64LIT(0x0000000000000088), W64LIT(0x0000000080008009), W64LIT(0x000000008000000a),
28 W64LIT(0x000000008000808b), W64LIT(0x800000000000008b), W64LIT(0x8000000000008089),
29 W64LIT(0x8000000000008003), W64LIT(0x8000000000008002), W64LIT(0x8000000000000080),
30 W64LIT(0x000000000000800a), W64LIT(0x800000008000000a), W64LIT(0x8000000080008081),
31 W64LIT(0x8000000000008080), W64LIT(0x0000000080000001), W64LIT(0x8000000080008008)
34 static void KeccakF1600(word64 *state)
37 word64 Aba, Abe, Abi, Abo, Abu;
38 word64 Aga, Age, Agi, Ago, Agu;
39 word64 Aka, Ake, Aki, Ako, Aku;
40 word64 Ama, Ame, Ami, Amo, Amu;
41 word64 Asa, Ase, Asi, Aso, Asu;
42 word64 BCa, BCe, BCi, BCo, BCu;
43 word64 Da, De, Di, Do, Du;
44 word64 Eba, Ebe, Ebi, Ebo, Ebu;
45 word64 Ega, Ege, Egi, Ego, Egu;
46 word64 Eka, Eke, Eki, Eko, Eku;
47 word64 Ema, Eme, Emi, Emo, Emu;
48 word64 Esa, Ese, Esi, Eso, Esu;
52 Block::Get(state)(Aba)(Abe)(Abi)(Abo)(Abu)(Aga)(Age)(Agi)(Ago)(Agu)(Aka)(Ake)(Aki)(Ako)(Aku)(Ama)(Ame)(Ami)(Amo)(Amu)(Asa)(Ase)(Asi)(Aso)(Asu);
54 for(
unsigned int round = 0; round < 24; round += 2 )
57 BCa = Aba^Aga^Aka^Ama^Asa;
58 BCe = Abe^Age^Ake^Ame^Ase;
59 BCi = Abi^Agi^Aki^Ami^Asi;
60 BCo = Abo^Ago^Ako^Amo^Aso;
61 BCu = Abu^Agu^Aku^Amu^Asu;
64 Da = BCu^rotlConstant<1>(BCe);
65 De = BCa^rotlConstant<1>(BCi);
66 Di = BCe^rotlConstant<1>(BCo);
67 Do = BCi^rotlConstant<1>(BCu);
68 Du = BCo^rotlConstant<1>(BCa);
73 BCe = rotlConstant<44>(Age);
75 BCi = rotlConstant<43>(Aki);
77 BCo = rotlConstant<21>(Amo);
79 BCu = rotlConstant<14>(Asu);
80 Eba = BCa ^((~BCe)& BCi );
81 Eba ^= (word64)KeccakF_RoundConstants[round];
82 Ebe = BCe ^((~BCi)& BCo );
83 Ebi = BCi ^((~BCo)& BCu );
84 Ebo = BCo ^((~BCu)& BCa );
85 Ebu = BCu ^((~BCa)& BCe );
88 BCa = rotlConstant<28>(Abo);
90 BCe = rotlConstant<20>(Agu);
92 BCi = rotlConstant<3>(Aka);
94 BCo = rotlConstant<45>(Ame);
96 BCu = rotlConstant<61>(Asi);
97 Ega = BCa ^((~BCe)& BCi );
98 Ege = BCe ^((~BCi)& BCo );
99 Egi = BCi ^((~BCo)& BCu );
100 Ego = BCo ^((~BCu)& BCa );
101 Egu = BCu ^((~BCa)& BCe );
104 BCa = rotlConstant<1>(Abe);
106 BCe = rotlConstant<6>(Agi);
108 BCi = rotlConstant<25>(Ako);
110 BCo = rotlConstant<8>(Amu);
112 BCu = rotlConstant<18>(Asa);
113 Eka = BCa ^((~BCe)& BCi );
114 Eke = BCe ^((~BCi)& BCo );
115 Eki = BCi ^((~BCo)& BCu );
116 Eko = BCo ^((~BCu)& BCa );
117 Eku = BCu ^((~BCa)& BCe );
120 BCa = rotlConstant<27>(Abu);
122 BCe = rotlConstant<36>(Aga);
124 BCi = rotlConstant<10>(Ake);
126 BCo = rotlConstant<15>(Ami);
128 BCu = rotlConstant<56>(Aso);
129 Ema = BCa ^((~BCe)& BCi );
130 Eme = BCe ^((~BCi)& BCo );
131 Emi = BCi ^((~BCo)& BCu );
132 Emo = BCo ^((~BCu)& BCa );
133 Emu = BCu ^((~BCa)& BCe );
136 BCa = rotlConstant<62>(Abi);
138 BCe = rotlConstant<55>(Ago);
140 BCi = rotlConstant<39>(Aku);
142 BCo = rotlConstant<41>(Ama);
144 BCu = rotlConstant<2>(Ase);
145 Esa = BCa ^((~BCe)& BCi );
146 Ese = BCe ^((~BCi)& BCo );
147 Esi = BCi ^((~BCo)& BCu );
148 Eso = BCo ^((~BCu)& BCa );
149 Esu = BCu ^((~BCa)& BCe );
152 BCa = Eba^Ega^Eka^Ema^Esa;
153 BCe = Ebe^Ege^Eke^Eme^Ese;
154 BCi = Ebi^Egi^Eki^Emi^Esi;
155 BCo = Ebo^Ego^Eko^Emo^Eso;
156 BCu = Ebu^Egu^Eku^Emu^Esu;
159 Da = BCu^rotlConstant<1>(BCe);
160 De = BCa^rotlConstant<1>(BCi);
161 Di = BCe^rotlConstant<1>(BCo);
162 Do = BCi^rotlConstant<1>(BCu);
163 Du = BCo^rotlConstant<1>(BCa);
168 BCe = rotlConstant<44>(Ege);
170 BCi = rotlConstant<43>(Eki);
172 BCo = rotlConstant<21>(Emo);
174 BCu = rotlConstant<14>(Esu);
175 Aba = BCa ^((~BCe)& BCi );
176 Aba ^= (word64)KeccakF_RoundConstants[round+1];
177 Abe = BCe ^((~BCi)& BCo );
178 Abi = BCi ^((~BCo)& BCu );
179 Abo = BCo ^((~BCu)& BCa );
180 Abu = BCu ^((~BCa)& BCe );
183 BCa = rotlConstant<28>(Ebo);
185 BCe = rotlConstant<20>(Egu);
187 BCi = rotlConstant<3>(Eka);
189 BCo = rotlConstant<45>(Eme);
191 BCu = rotlConstant<61>(Esi);
192 Aga = BCa ^((~BCe)& BCi );
193 Age = BCe ^((~BCi)& BCo );
194 Agi = BCi ^((~BCo)& BCu );
195 Ago = BCo ^((~BCu)& BCa );
196 Agu = BCu ^((~BCa)& BCe );
199 BCa = rotlConstant<1>(Ebe);
201 BCe = rotlConstant<6>(Egi);
203 BCi = rotlConstant<25>(Eko);
205 BCo = rotlConstant<8>(Emu);
207 BCu = rotlConstant<18>(Esa);
208 Aka = BCa ^((~BCe)& BCi );
209 Ake = BCe ^((~BCi)& BCo );
210 Aki = BCi ^((~BCo)& BCu );
211 Ako = BCo ^((~BCu)& BCa );
212 Aku = BCu ^((~BCa)& BCe );
215 BCa = rotlConstant<27>(Ebu);
217 BCe = rotlConstant<36>(Ega);
219 BCi = rotlConstant<10>(Eke);
221 BCo = rotlConstant<15>(Emi);
223 BCu = rotlConstant<56>(Eso);
224 Ama = BCa ^((~BCe)& BCi );
225 Ame = BCe ^((~BCi)& BCo );
226 Ami = BCi ^((~BCo)& BCu );
227 Amo = BCo ^((~BCu)& BCa );
228 Amu = BCu ^((~BCa)& BCe );
231 BCa = rotlConstant<62>(Ebi);
233 BCe = rotlConstant<55>(Ego);
235 BCi = rotlConstant<39>(Eku);
237 BCo = rotlConstant<41>(Ema);
239 BCu = rotlConstant<2>(Ese);
240 Asa = BCa ^((~BCe)& BCi );
241 Ase = BCe ^((~BCi)& BCo );
242 Asi = BCi ^((~BCo)& BCu );
243 Aso = BCo ^((~BCu)& BCa );
244 Asu = BCu ^((~BCa)& BCe );
248 Block::Put(NULLPTR, state)(Aba)(Abe)(Abi)(Abo)(Abu)(Aga)(Age)(Agi)(Ago)(Agu)(Aka)(Ake)(Aki)(Ako)(Aku)(Ama)(Ame)(Ami)(Amo)(Amu)(Asa)(Ase)(Asi)(Aso)(Asu);
255 if (!length) {
return; }
258 while (length >= (spaceLeft = r() - m_counter))
262 KeccakF1600(m_state);
270 m_counter += (
unsigned int)length;
281 ThrowIfInvalidTruncatedSize(size);
283 m_state.
BytePtr()[m_counter] ^= 0x06;
284 m_state.
BytePtr()[r()-1] ^= 0x80;
285 KeccakF1600(m_state);
286 memcpy(hash, m_state, size);
size_type SizeInBytes() const
Provides the number of bytes in the SecBlock.
Access a block of memory.
Classes for SHA3 message digests.
void Restart()
Restart the hash.
void TruncatedFinal(byte *hash, size_t size)
Computes the hash of the current message.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
void Update(const byte *input, size_t length)
Updates a hash with additional input.
Access a block of memory.
Crypto++ library namespace.
byte * BytePtr()
Provides a byte pointer to the first element in the memory block.