/*-------------------------------------------------------------------------
* drawElements Base Portability Library
* -------------------------------------
*
* Copyright 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief SHA1 hash functions.
*//*--------------------------------------------------------------------*/
#include "deSha1.h"
#include "deMemory.h"
DE_BEGIN_EXTERN_C
enum
{
CHUNK_BIT_SIZE = 512,
CHUNK_BYTE_SIZE = CHUNK_BIT_SIZE / 8
};
static deUint32 leftRotate (deUint32 val, deUint32 count)
{
DE_ASSERT(count < 32);
return (val << count) | (val >> (32 - count));
}
void deSha1Stream_init (deSha1Stream* stream)
{
stream->size = 0;
/* Set the initial 16 deUint32s that contain real data to zeros. */
deMemset(stream->data, 0, 16 * sizeof(deUint32));
stream->hash[0] = 0x67452301u;
stream->hash[1] = 0xEFCDAB89u;
stream->hash[2] = 0x98BADCFEu;
stream->hash[3] = 0x10325476u;
stream->hash[4] = 0xC3D2E1F0u;
}
static void deSha1Stream_flushChunk (deSha1Stream* stream)
{
DE_ASSERT(stream->size % CHUNK_BYTE_SIZE == 0 && stream->size > 0);
{
size_t ndx;
/* Expand the 16 uint32s that contain the data to 80. */
for (ndx = 16; ndx < DE_LENGTH_OF_ARRAY(stream->data); ndx++)
{
stream->data[ndx] = leftRotate(stream->data[ndx - 3]
^ stream->data[ndx - 8]
^ stream->data[ndx - 14]
^ stream->data[ndx - 16], 1);
}
}
{
deUint32 a = stream->hash[0];
deUint32 b = stream->hash[1];
deUint32 c = stream->hash[2];
deUint32 d = stream->hash[3];
deUint32 e = stream->hash[4];
size_t ndx;
for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stream->data); ndx++)
{
deUint32 f;
deUint32 k;
if (ndx < 20)
{
f = (b & c) | ((~b) & d);
k = 0x5A827999u;
}
else if (ndx < 40)
{
f = b ^ c ^ d;
k = 0x6ED9EBA1u;
}
else if (ndx < 60)
{
f = (b & c) | (b & d) | (c & d);
k = 0x8F1BBCDCu;
}
else
{
f = b ^ c ^ d;
k = 0xCA62C1D6u;
}
{
const deUint32 tmp = leftRotate(a, 5) + f + e + k + stream->data[ndx];
e = d;
d = c;
c = leftRotate(b, 30);
b = a;
a = tmp;
}
}
stream->hash[0] += a;
stream->hash[1] += b;
stream->hash[2] += c;
stream->hash[3] += d;
stream->hash[4] += e;
/* Set the initial 16 deUint32s that contain the real data to zeros. */
deMemset(stream->data, 0, 16 * sizeof(deUint32));
}
}
void deSha1Stream_process (deSha1Stream* stream, size_t size, const void* data_)
{
const deUint8* const data = (const deUint8*)data_;
size_t bytesProcessed = 0;
while (bytesProcessed < size)
{
do
{
const size_t bitOffset = (size_t)(8 * (4 - (1 + (stream->size % 4))));
stream->data[(stream->size / 4) % 16] |= ((deUint32)data[bytesProcessed]) << (deUint32)bitOffset;
stream->size++;
bytesProcessed++;
}
while (stream->size % CHUNK_BYTE_SIZE != 0 && bytesProcessed < size);
if (stream->size % CHUNK_BYTE_SIZE == 0)
deSha1Stream_flushChunk(stream);
}
DE_ASSERT(bytesProcessed == size);
}
void deSha1Stream_finalize (deSha1Stream* stream, deSha1* hash)
{
/* \note First element is initialized to 0x80u and rest to 0x0. */
static const deUint8 padding[CHUNK_BYTE_SIZE] = { 0x80u };
const deUint64 length = stream->size * 8;
deUint8 lengthData[sizeof(deUint64)];
size_t ndx;
DE_ASSERT(padding[0] == 0x80u);
DE_ASSERT(padding[1] == 0x0u);
for (ndx = 0; ndx < sizeof(deUint64); ndx++)
lengthData[ndx] = (deUint8)(0xffu & (length >> (8 * (sizeof(deUint64) - 1 - ndx))));
{
const deUint64 spaceLeftInChunk = CHUNK_BYTE_SIZE - (stream->size % CHUNK_BYTE_SIZE);
if (spaceLeftInChunk >= 1 + sizeof(lengthData))
deSha1Stream_process(stream, (size_t)(spaceLeftInChunk - sizeof(lengthData)), padding);
else
deSha1Stream_process(stream, (size_t)(CHUNK_BYTE_SIZE - (sizeof(lengthData)) - spaceLeftInChunk), padding);
}
deSha1Stream_process(stream, sizeof(lengthData), lengthData);
DE_ASSERT(stream->size % CHUNK_BYTE_SIZE == 0);
deMemcpy(hash->hash, stream->hash, sizeof(hash->hash));
}
void deSha1_compute (deSha1* hash, size_t size, const void* data)
{
deSha1Stream stream;
deSha1Stream_init(&stream);
deSha1Stream_process(&stream, size, data);
deSha1Stream_finalize(&stream, hash);
}
void deSha1_render (const deSha1* hash, char* buffer)
{
size_t charNdx;
for (charNdx = 0; charNdx < 40; charNdx++)
{
const deUint32 val32 = hash->hash[charNdx / 8];
const deUint8 val8 = (deUint8)(0x0fu & (val32 >> (4 * (8 - 1 - (charNdx % 8)))));
if (val8 < 10)
buffer[charNdx] = (char)('0' + val8);
else
buffer[charNdx] = (char)('a' + val8 - 10);
}
}
deBool deSha1_parse (deSha1* hash, const char* buffer)
{
size_t charNdx;
deMemset(hash->hash, 0, sizeof(hash->hash));
for (charNdx = 0; charNdx < 40; charNdx++)
{
deUint8 val4;
if (buffer[charNdx] >= '0' && buffer[charNdx] <= '9')
val4 = (deUint8)(buffer[charNdx] - '0');
else if (buffer[charNdx] >= 'a' && buffer[charNdx] <= 'f')
val4 = (deUint8)(10 + (buffer[charNdx] - 'a'));
else if (buffer[charNdx] >= 'A' && buffer[charNdx] <= 'F')
val4 = (deUint8)(10 + (buffer[charNdx] - 'A'));
else
return DE_FALSE;
hash->hash[charNdx / 8] |= ((deUint32)val4) << (4 * (8u - 1u - (charNdx % 8u)));
}
return DE_TRUE;
}
deBool deSha1_equal (const deSha1* a, const deSha1* b)
{
/* \note deMemcmp() can only be used for equality. It doesn't provide correct ordering between hashes. */
return deMemCmp(a->hash, b->hash, sizeof(b->hash)) == 0;
}
void deSha1_selfTest (void)
{
const char* const validHashStrings[] =
{
"ac890cfca05717c05dc831996b2289251da2984e",
"0f87ba807acb3e6effe617249f30453a524a2ea3",
"6f483cc3fa820e58ed9f83c83bdf8d213293b3ad"
};
const char* const invalidHashStrings[] =
{
" c890cfca05717c05dc831996b2289251da2984e",
"0f87ba807acb3e6 ffe617249f30453a524a2ea3",
"6f483cc3fa820e58ed9f83c83bdf8d213293b3a ",
"mc890cfca05717c05dc831996b2289251da2984e",
"0f87ba807acb3e6effe617249fm0453a524a2ea3",
"6f483cc3fa820e58ed9f83c83bdf8d213293b3an",
"ac890cfca05717c05dc83\n996b2289251da2984e",
"0f87ba807acb3e6effe617\t49f30453a524a2ea3",
"ac890cfca05717c05dc831\096b2289251da2984e",
"6f483cc3fa{20e58ed9f83c83bdf8d213293b3ad"
};
const struct
{
const char* const hash;
const char* const data;
} stringHashPairs[] =
{
/* Generated using sha1sum. */
{ "da39a3ee5e6b4b0d3255bfef95601890afd80709", "" },
{ "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d", "hello" },
{ "ec1919e856540f42bd0e6f6c1ffe2fbd73419975",
"Cherry is a browser-based GUI for controlling deqp test runs and analysing the test results."
}
};
const int garbage = 0xde;
/* Test parsing valid sha1 strings. */
{
size_t stringNdx;
for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
{
deSha1 hash;
deMemset(&hash, garbage, sizeof(deSha1));
DE_TEST_ASSERT(deSha1_parse(&hash, validHashStrings[stringNdx]));
}
}
/* Test parsing invalid sha1 strings. */
{
size_t stringNdx;
for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(invalidHashStrings); stringNdx++)
{
deSha1 hash;
deMemset(&hash, garbage, sizeof(deSha1));
DE_TEST_ASSERT(!deSha1_parse(&hash, invalidHashStrings[stringNdx]));
}
}
/* Compare valid hash strings for equality. */
{
size_t stringNdx;
for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
{
deSha1 hashA;
deSha1 hashB;
deMemset(&hashA, garbage, sizeof(deSha1));
deMemset(&hashB, garbage, sizeof(deSha1));
DE_TEST_ASSERT(deSha1_parse(&hashA, validHashStrings[stringNdx]));
DE_TEST_ASSERT(deSha1_parse(&hashB, validHashStrings[stringNdx]));
DE_TEST_ASSERT(deSha1_equal(&hashA, &hashA));
DE_TEST_ASSERT(deSha1_equal(&hashA, &hashB));
DE_TEST_ASSERT(deSha1_equal(&hashB, &hashA));
}
}
/* Compare valid different hash strings for equality. */
{
size_t stringANdx;
size_t stringBNdx;
for (stringANdx = 0; stringANdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringANdx++)
for (stringBNdx = 0; stringBNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringBNdx++)
{
deSha1 hashA;
deSha1 hashB;
if (stringANdx == stringBNdx)
continue;
deMemset(&hashA, garbage, sizeof(deSha1));
deMemset(&hashB, garbage, sizeof(deSha1));
DE_TEST_ASSERT(deSha1_parse(&hashA, validHashStrings[stringANdx]));
DE_TEST_ASSERT(deSha1_parse(&hashB, validHashStrings[stringBNdx]));
DE_TEST_ASSERT(!deSha1_equal(&hashA, &hashB));
DE_TEST_ASSERT(!deSha1_equal(&hashB, &hashA));
}
}
/* Test rendering hash as string. */
{
size_t stringNdx;
for (stringNdx = 0; stringNdx < DE_LENGTH_OF_ARRAY(validHashStrings); stringNdx++)
{
char result[40];
deSha1 hash;
deMemset(&hash, garbage, sizeof(hash));
deMemset(&result, garbage, sizeof(result));
DE_TEST_ASSERT(deSha1_parse(&hash, validHashStrings[stringNdx]));
deSha1_render(&hash, result);
DE_TEST_ASSERT(strncmp(result, validHashStrings[stringNdx], 40) == 0);
}
}
/* Test hash against few pre-computed cases. */
{
size_t ndx;
for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stringHashPairs); ndx++)
{
deSha1 result;
deSha1 reference;
deSha1_compute(&result, strlen(stringHashPairs[ndx].data), stringHashPairs[ndx].data);
DE_TEST_ASSERT(deSha1_parse(&reference, stringHashPairs[ndx].hash));
DE_TEST_ASSERT(deSha1_equal(&reference, &result));
}
}
/* Test hash stream against few pre-computed cases. */
{
size_t ndx;
for (ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stringHashPairs); ndx++)
{
const char* const data = stringHashPairs[ndx].data;
const size_t size = strlen(data);
deSha1Stream stream;
deSha1 result;
deSha1 reference;
deSha1Stream_init(&stream);
deSha1Stream_process(&stream, size/2, data);
deSha1Stream_process(&stream, size - (size/2), data + size/2);
deSha1Stream_finalize(&stream, &result);
deSha1_compute(&result, strlen(stringHashPairs[ndx].data), stringHashPairs[ndx].data);
DE_TEST_ASSERT(deSha1_parse(&reference, stringHashPairs[ndx].hash));
DE_TEST_ASSERT(deSha1_equal(&reference, &result));
}
}
}
DE_END_EXTERN_C