From 490d36e65ac24e34e3021c2a0947384aee138c88 Mon Sep 17 00:00:00 2001 From: Malf Furious Date: Wed, 13 Apr 2016 21:05:14 -0400 Subject: Root commit for new Compass repository This is the Alpha version of ComPASS, originally developed sometime in 2014. --- cryptopp562/sha3.cpp | 284 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 284 insertions(+) create mode 100644 cryptopp562/sha3.cpp (limited to 'cryptopp562/sha3.cpp') diff --git a/cryptopp562/sha3.cpp b/cryptopp562/sha3.cpp new file mode 100644 index 0000000..7db82c1 --- /dev/null +++ b/cryptopp562/sha3.cpp @@ -0,0 +1,284 @@ +// sha3.cpp - modified by Wei Dai from Ronny Van Keer's public domain Keccak-simple.c +// all modifications here are placed in the public domain by Wei Dai + +/* +The Keccak sponge function, designed by Guido Bertoni, Joan Daemen, +Michael Peeters and Gilles Van Assche. For more information, feedback or +questions, please refer to our website: http://keccak.noekeon.org/ + +Implementation by Ronny Van Keer, +hereby denoted as "the implementer". + +To the extent possible under law, the implementer has waived all copyright +and related or neighboring rights to the source code in this file. +http://creativecommons.org/publicdomain/zero/1.0/ +*/ + +#include "pch.h" +#include "sha3.h" + +NAMESPACE_BEGIN(CryptoPP) + +static const word64 KeccakF_RoundConstants[24] = +{ + W64LIT(0x0000000000000001), W64LIT(0x0000000000008082), W64LIT(0x800000000000808a), + W64LIT(0x8000000080008000), W64LIT(0x000000000000808b), W64LIT(0x0000000080000001), + W64LIT(0x8000000080008081), W64LIT(0x8000000000008009), W64LIT(0x000000000000008a), + W64LIT(0x0000000000000088), W64LIT(0x0000000080008009), W64LIT(0x000000008000000a), + W64LIT(0x000000008000808b), W64LIT(0x800000000000008b), W64LIT(0x8000000000008089), + W64LIT(0x8000000000008003), W64LIT(0x8000000000008002), W64LIT(0x8000000000000080), + W64LIT(0x000000000000800a), W64LIT(0x800000008000000a), W64LIT(0x8000000080008081), + W64LIT(0x8000000000008080), W64LIT(0x0000000080000001), W64LIT(0x8000000080008008) +}; + +static void KeccakF1600(word64 *state) +{ + { + word64 Aba, Abe, Abi, Abo, Abu; + word64 Aga, Age, Agi, Ago, Agu; + word64 Aka, Ake, Aki, Ako, Aku; + word64 Ama, Ame, Ami, Amo, Amu; + word64 Asa, Ase, Asi, Aso, Asu; + word64 BCa, BCe, BCi, BCo, BCu; + word64 Da, De, Di, Do, Du; + word64 Eba, Ebe, Ebi, Ebo, Ebu; + word64 Ega, Ege, Egi, Ego, Egu; + word64 Eka, Eke, Eki, Eko, Eku; + word64 Ema, Eme, Emi, Emo, Emu; + word64 Esa, Ese, Esi, Eso, Esu; + + //copyFromState(A, state) + typedef BlockGetAndPut Block; + 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); + + for( unsigned int round = 0; round < 24; round += 2 ) + { + // prepareTheta + BCa = Aba^Aga^Aka^Ama^Asa; + BCe = Abe^Age^Ake^Ame^Ase; + BCi = Abi^Agi^Aki^Ami^Asi; + BCo = Abo^Ago^Ako^Amo^Aso; + BCu = Abu^Agu^Aku^Amu^Asu; + + //thetaRhoPiChiIotaPrepareTheta(round , A, E) + Da = BCu^rotlFixed(BCe, 1); + De = BCa^rotlFixed(BCi, 1); + Di = BCe^rotlFixed(BCo, 1); + Do = BCi^rotlFixed(BCu, 1); + Du = BCo^rotlFixed(BCa, 1); + + Aba ^= Da; + BCa = Aba; + Age ^= De; + BCe = rotlFixed(Age, 44); + Aki ^= Di; + BCi = rotlFixed(Aki, 43); + Amo ^= Do; + BCo = rotlFixed(Amo, 21); + Asu ^= Du; + BCu = rotlFixed(Asu, 14); + Eba = BCa ^((~BCe)& BCi ); + Eba ^= (word64)KeccakF_RoundConstants[round]; + Ebe = BCe ^((~BCi)& BCo ); + Ebi = BCi ^((~BCo)& BCu ); + Ebo = BCo ^((~BCu)& BCa ); + Ebu = BCu ^((~BCa)& BCe ); + + Abo ^= Do; + BCa = rotlFixed(Abo, 28); + Agu ^= Du; + BCe = rotlFixed(Agu, 20); + Aka ^= Da; + BCi = rotlFixed(Aka, 3); + Ame ^= De; + BCo = rotlFixed(Ame, 45); + Asi ^= Di; + BCu = rotlFixed(Asi, 61); + Ega = BCa ^((~BCe)& BCi ); + Ege = BCe ^((~BCi)& BCo ); + Egi = BCi ^((~BCo)& BCu ); + Ego = BCo ^((~BCu)& BCa ); + Egu = BCu ^((~BCa)& BCe ); + + Abe ^= De; + BCa = rotlFixed(Abe, 1); + Agi ^= Di; + BCe = rotlFixed(Agi, 6); + Ako ^= Do; + BCi = rotlFixed(Ako, 25); + Amu ^= Du; + BCo = rotlFixed(Amu, 8); + Asa ^= Da; + BCu = rotlFixed(Asa, 18); + Eka = BCa ^((~BCe)& BCi ); + Eke = BCe ^((~BCi)& BCo ); + Eki = BCi ^((~BCo)& BCu ); + Eko = BCo ^((~BCu)& BCa ); + Eku = BCu ^((~BCa)& BCe ); + + Abu ^= Du; + BCa = rotlFixed(Abu, 27); + Aga ^= Da; + BCe = rotlFixed(Aga, 36); + Ake ^= De; + BCi = rotlFixed(Ake, 10); + Ami ^= Di; + BCo = rotlFixed(Ami, 15); + Aso ^= Do; + BCu = rotlFixed(Aso, 56); + Ema = BCa ^((~BCe)& BCi ); + Eme = BCe ^((~BCi)& BCo ); + Emi = BCi ^((~BCo)& BCu ); + Emo = BCo ^((~BCu)& BCa ); + Emu = BCu ^((~BCa)& BCe ); + + Abi ^= Di; + BCa = rotlFixed(Abi, 62); + Ago ^= Do; + BCe = rotlFixed(Ago, 55); + Aku ^= Du; + BCi = rotlFixed(Aku, 39); + Ama ^= Da; + BCo = rotlFixed(Ama, 41); + Ase ^= De; + BCu = rotlFixed(Ase, 2); + Esa = BCa ^((~BCe)& BCi ); + Ese = BCe ^((~BCi)& BCo ); + Esi = BCi ^((~BCo)& BCu ); + Eso = BCo ^((~BCu)& BCa ); + Esu = BCu ^((~BCa)& BCe ); + + // prepareTheta + BCa = Eba^Ega^Eka^Ema^Esa; + BCe = Ebe^Ege^Eke^Eme^Ese; + BCi = Ebi^Egi^Eki^Emi^Esi; + BCo = Ebo^Ego^Eko^Emo^Eso; + BCu = Ebu^Egu^Eku^Emu^Esu; + + //thetaRhoPiChiIotaPrepareTheta(round+1, E, A) + Da = BCu^rotlFixed(BCe, 1); + De = BCa^rotlFixed(BCi, 1); + Di = BCe^rotlFixed(BCo, 1); + Do = BCi^rotlFixed(BCu, 1); + Du = BCo^rotlFixed(BCa, 1); + + Eba ^= Da; + BCa = Eba; + Ege ^= De; + BCe = rotlFixed(Ege, 44); + Eki ^= Di; + BCi = rotlFixed(Eki, 43); + Emo ^= Do; + BCo = rotlFixed(Emo, 21); + Esu ^= Du; + BCu = rotlFixed(Esu, 14); + Aba = BCa ^((~BCe)& BCi ); + Aba ^= (word64)KeccakF_RoundConstants[round+1]; + Abe = BCe ^((~BCi)& BCo ); + Abi = BCi ^((~BCo)& BCu ); + Abo = BCo ^((~BCu)& BCa ); + Abu = BCu ^((~BCa)& BCe ); + + Ebo ^= Do; + BCa = rotlFixed(Ebo, 28); + Egu ^= Du; + BCe = rotlFixed(Egu, 20); + Eka ^= Da; + BCi = rotlFixed(Eka, 3); + Eme ^= De; + BCo = rotlFixed(Eme, 45); + Esi ^= Di; + BCu = rotlFixed(Esi, 61); + Aga = BCa ^((~BCe)& BCi ); + Age = BCe ^((~BCi)& BCo ); + Agi = BCi ^((~BCo)& BCu ); + Ago = BCo ^((~BCu)& BCa ); + Agu = BCu ^((~BCa)& BCe ); + + Ebe ^= De; + BCa = rotlFixed(Ebe, 1); + Egi ^= Di; + BCe = rotlFixed(Egi, 6); + Eko ^= Do; + BCi = rotlFixed(Eko, 25); + Emu ^= Du; + BCo = rotlFixed(Emu, 8); + Esa ^= Da; + BCu = rotlFixed(Esa, 18); + Aka = BCa ^((~BCe)& BCi ); + Ake = BCe ^((~BCi)& BCo ); + Aki = BCi ^((~BCo)& BCu ); + Ako = BCo ^((~BCu)& BCa ); + Aku = BCu ^((~BCa)& BCe ); + + Ebu ^= Du; + BCa = rotlFixed(Ebu, 27); + Ega ^= Da; + BCe = rotlFixed(Ega, 36); + Eke ^= De; + BCi = rotlFixed(Eke, 10); + Emi ^= Di; + BCo = rotlFixed(Emi, 15); + Eso ^= Do; + BCu = rotlFixed(Eso, 56); + Ama = BCa ^((~BCe)& BCi ); + Ame = BCe ^((~BCi)& BCo ); + Ami = BCi ^((~BCo)& BCu ); + Amo = BCo ^((~BCu)& BCa ); + Amu = BCu ^((~BCa)& BCe ); + + Ebi ^= Di; + BCa = rotlFixed(Ebi, 62); + Ego ^= Do; + BCe = rotlFixed(Ego, 55); + Eku ^= Du; + BCi = rotlFixed(Eku, 39); + Ema ^= Da; + BCo = rotlFixed(Ema, 41); + Ese ^= De; + BCu = rotlFixed(Ese, 2); + Asa = BCa ^((~BCe)& BCi ); + Ase = BCe ^((~BCi)& BCo ); + Asi = BCi ^((~BCo)& BCu ); + Aso = BCo ^((~BCu)& BCa ); + Asu = BCu ^((~BCa)& BCe ); + } + + //copyToState(state, A) + Block::Put(NULL, 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); + } +} + +void SHA3::Update(const byte *input, size_t length) +{ + size_t spaceLeft; + while (length >= (spaceLeft = r() - m_counter)) + { + xorbuf(m_state.BytePtr() + m_counter, input, spaceLeft); + KeccakF1600(m_state); + input += spaceLeft; + length -= spaceLeft; + m_counter = 0; + } + + xorbuf(m_state.BytePtr() + m_counter, input, length); + m_counter += (unsigned int)length; +} + +void SHA3::Restart() +{ + memset(m_state, 0, m_state.SizeInBytes()); + m_counter = 0; +} + +void SHA3::TruncatedFinal(byte *hash, size_t size) +{ + ThrowIfInvalidTruncatedSize(size); + m_state.BytePtr()[m_counter] ^= 1; + m_state.BytePtr()[r()-1] ^= 0x80; + KeccakF1600(m_state); + memcpy(hash, m_state, size); + Restart(); +} + +NAMESPACE_END -- cgit v1.2.3