106 lines
3.6 KiB
C
Executable file
106 lines
3.6 KiB
C
Executable file
/*
|
|
* This file is a part of Pcompress, a chunked parallel multi-
|
|
* algorithm lossless compression and decompression program.
|
|
*
|
|
* Copyright (C) 2012-2013 Moinak Ghosh. All rights reserved.
|
|
* Use is subject to license terms.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this program.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* moinakg@belenix.org, http://moinakg.wordpress.com/
|
|
*
|
|
*/
|
|
|
|
/*
|
|
The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
|
|
Michaël Peeters and Gilles Van Assche. For more information, feedback or
|
|
questions, please refer to our website: http://keccak.noekeon.org/
|
|
|
|
Implementation by the designers,
|
|
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 <string.h>
|
|
#include "KeccakNISTInterface.h"
|
|
#include "KeccakF-1600-interface.h"
|
|
|
|
HashReturn Keccak_Init(hashState *state, int hashbitlen)
|
|
{
|
|
switch(hashbitlen) {
|
|
case 0: // Default parameters, arbitrary length output
|
|
InitSponge((spongeState*)state, 1024, 576);
|
|
break;
|
|
case 224:
|
|
InitSponge((spongeState*)state, 1152, 448);
|
|
break;
|
|
case 256:
|
|
InitSponge((spongeState*)state, 1088, 512);
|
|
break;
|
|
case 384:
|
|
InitSponge((spongeState*)state, 832, 768);
|
|
break;
|
|
case 512:
|
|
InitSponge((spongeState*)state, 576, 1024);
|
|
break;
|
|
default:
|
|
return BAD_HASHLEN;
|
|
}
|
|
state->fixedOutputLength = hashbitlen;
|
|
return SUCCESS;
|
|
}
|
|
|
|
HashReturn Keccak_Update(hashState *state, const BitSequence *data, DataLength databitlen)
|
|
{
|
|
if ((databitlen % 8) == 0)
|
|
return (HashReturn)Absorb((spongeState*)state, data, databitlen);
|
|
else {
|
|
HashReturn ret = (HashReturn)Absorb((spongeState*)state, data, databitlen - (databitlen % 8));
|
|
if (ret == SUCCESS) {
|
|
unsigned char lastByte;
|
|
// Align the last partial byte to the least significant bits
|
|
lastByte = data[databitlen/8] >> (8 - (databitlen % 8));
|
|
return (HashReturn)Absorb((spongeState*)state, &lastByte, databitlen % 8);
|
|
}
|
|
else
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
HashReturn Keccak_Final(hashState *state, BitSequence *hashval)
|
|
{
|
|
return (HashReturn)Squeeze(state, hashval, state->fixedOutputLength);
|
|
}
|
|
|
|
HashReturn Keccak_Hash(int hashbitlen, const BitSequence *data, DataLength databitlen, BitSequence *hashval)
|
|
{
|
|
hashState state;
|
|
HashReturn result;
|
|
|
|
if ((hashbitlen != 224) && (hashbitlen != 256) && (hashbitlen != 384) && (hashbitlen != 512))
|
|
return BAD_HASHLEN; // Only the four fixed output lengths available through this API
|
|
result = Keccak_Init(&state, hashbitlen);
|
|
if (result != SUCCESS)
|
|
return result;
|
|
result = Keccak_Update(&state, data, databitlen);
|
|
if (result != SUCCESS)
|
|
return result;
|
|
result = Keccak_Final(&state, hashval);
|
|
return result;
|
|
}
|
|
|