arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-01-20 12:21:01 +00:00
Code Issues Releases Wiki Activity

style(crypto): format blake and groestl

Browse Source
This commit is contained in:
Ondřej Vejpustek 2024-09-24 14:27:29 +02:00
parent 332c0bf365
commit 8bf02cf0a2
10 changed files with 1075 additions and 1216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
crypto/blake256.c
View File

@ -7,8 +7,9 @@
and related and neighboring rights to this software to the public domain and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty. worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with You should have received a copy of the CC0 Public Domain Dedication along
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>. with this software. If not, see
<http://creativecommons.org/publicdomain/zero/1.0/>.
*/ */
#include "blake256.h" #include "blake256.h"
@ -19,11 +20,12 @@
((uint32_t)((p)[2]) << 8) | ((uint32_t)((p)[3]))) ((uint32_t)((p)[2]) << 8) | ((uint32_t)((p)[3])))
#define U32TO8_BIG(p, v) \ #define U32TO8_BIG(p, v) \
(p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \ (p)[0] = (uint8_t)((v) >> 24); \
(p)[2] = (uint8_t)((v) >> 8); (p)[3] = (uint8_t)((v) ); (p)[1] = (uint8_t)((v) >> 16); \
(p)[2] = (uint8_t)((v) >> 8); \
(p)[3] = (uint8_t)((v));
static const uint8_t sigma[][16] = static const uint8_t sigma[][16] = {
{
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}, {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4}, {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
@ -39,31 +41,22 @@ static const uint8_t sigma[][16] =
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4}, {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
{7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8}, {7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
{9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13}, {9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 } {2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9}};
};
static const uint32_t u256[16] = static const uint32_t u256[16] = {
{ 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917};
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917
};
static const uint8_t padding[129] = static const uint8_t padding[129] = {
{ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
static void blake256_compress( BLAKE256_CTX *S, const uint8_t *block ) static void blake256_compress(BLAKE256_CTX *S, const uint8_t *block) {
{
uint32_t v[16] = {0}, m[16] = {0}, i = 0; uint32_t v[16] = {0}, m[16] = {0}, i = 0;
#define ROT(x, n) (((x) << (32 - n)) | ((x) >> (n))) #define ROT(x, n) (((x) << (32 - n)) | ((x) >> (n)))
#define G(a, b, c, d, e) \ #define G(a, b, c, d, e) \
@ -90,16 +83,14 @@ static void blake256_compress( BLAKE256_CTX *S, const uint8_t *block )
v[15] = u256[7]; v[15] = u256[7];
/* don't xor t when the block is only padding */ /* don't xor t when the block is only padding */
if ( !S->nullt ) if (!S->nullt) {
{
v[12] ^= S->t[0]; v[12] ^= S->t[0];
v[13] ^= S->t[0]; v[13] ^= S->t[0];
v[14] ^= S->t[1]; v[14] ^= S->t[1];
v[15] ^= S->t[1]; v[15] ^= S->t[1];
} }
for( i = 0; i < 14; ++i ) for (i = 0; i < 14; ++i) {
{
/* column step */ /* column step */
G(0, 4, 8, 12, 0); G(0, 4, 8, 12, 0);
G(1, 5, 9, 13, 2); G(1, 5, 9, 13, 2);
@ -117,9 +108,7 @@ static void blake256_compress( BLAKE256_CTX *S, const uint8_t *block )
for (i = 0; i < 8; ++i) S->h[i] ^= S->s[i % 4]; for (i = 0; i < 8; ++i) S->h[i] ^= S->s[i % 4];
} }
void blake256_Init(BLAKE256_CTX *S) {
void blake256_Init( BLAKE256_CTX *S )
{
S->h[0] = 0x6a09e667; S->h[0] = 0x6a09e667;
S->h[1] = 0xbb67ae85; S->h[1] = 0xbb67ae85;
S->h[2] = 0x3c6ef372; S->h[2] = 0x3c6ef372;
@ -132,15 +121,12 @@ void blake256_Init( BLAKE256_CTX *S )
S->s[0] = S->s[1] = S->s[2] = S->s[3] = 0; S->s[0] = S->s[1] = S->s[2] = S->s[3] = 0;
} }
void blake256_Update(BLAKE256_CTX *S, const uint8_t *in, size_t inlen) {
void blake256_Update( BLAKE256_CTX *S, const uint8_t *in, size_t inlen )
{
size_t left = S->buflen; size_t left = S->buflen;
size_t fill = 64 - left; size_t fill = 64 - left;
/* data left and data received fill a block */ /* data left and data received fill a block */
if( left && ( inlen >= fill ) ) if (left && (inlen >= fill)) {
{
memcpy((void *)(S->buf + left), (void *)in, fill); memcpy((void *)(S->buf + left), (void *)in, fill);
S->t[0] += 512; S->t[0] += 512;
@ -153,8 +139,7 @@ void blake256_Update( BLAKE256_CTX *S, const uint8_t *in, size_t inlen )
} }
/* compress blocks of data received */ /* compress blocks of data received */
while( inlen >= 64 ) while (inlen >= 64) {
{
S->t[0] += 512; S->t[0] += 512;
if (S->t[0] == 0) S->t[1]++; if (S->t[0] == 0) S->t[1]++;
@ -165,17 +150,13 @@ void blake256_Update( BLAKE256_CTX *S, const uint8_t *in, size_t inlen )
} }
/* store any data left */ /* store any data left */
if( inlen > 0 ) if (inlen > 0) {
{ memcpy((void *)(S->buf + left), (void *)in, (size_t)inlen);
memcpy( ( void * ) ( S->buf + left ), \
( void * ) in, ( size_t ) inlen );
} }
S->buflen = left + inlen; S->buflen = left + inlen;
} }
void blake256_Final(BLAKE256_CTX *S, uint8_t *out) {
void blake256_Final( BLAKE256_CTX *S, uint8_t *out )
{
uint8_t msglen[8] = {0}, zo = 0x01, oo = 0x81; uint8_t msglen[8] = {0}, zo = 0x01, oo = 0x81;
uint32_t lo = S->t[0] + (S->buflen << 3), hi = S->t[1]; uint32_t lo = S->t[0] + (S->buflen << 3), hi = S->t[1];
@ -189,17 +170,14 @@ void blake256_Final( BLAKE256_CTX *S, uint8_t *out )
{ {
S->t[0] -= 8; S->t[0] -= 8;
blake256_Update(S, &oo, 1); blake256_Update(S, &oo, 1);
} } else {
else
{
if (S->buflen < 55) /* enough space to fill the block */ if (S->buflen < 55) /* enough space to fill the block */
{ {
if (!S->buflen) S->nullt = 1; if (!S->buflen) S->nullt = 1;
S->t[0] -= 440 - (S->buflen << 3); S->t[0] -= 440 - (S->buflen << 3);
blake256_Update(S, padding, 55 - S->buflen); blake256_Update(S, padding, 55 - S->buflen);
} } else /* need 2 compressions */
else /* need 2 compressions */
{ {
S->t[0] -= 512 - (S->buflen << 3); S->t[0] -= 512 - (S->buflen << 3);
blake256_Update(S, padding, 64 - S->buflen); blake256_Update(S, padding, 64 - S->buflen);
@ -224,9 +202,7 @@ void blake256_Final( BLAKE256_CTX *S, uint8_t *out )
U32TO8_BIG(out + 28, S->h[7]); U32TO8_BIG(out + 28, S->h[7]);
} }
void blake256(const uint8_t *in, size_t inlen, uint8_t *out) {
void blake256( const uint8_t *in, size_t inlen, uint8_t *out )
{
BLAKE256_CTX S = {0}; BLAKE256_CTX S = {0};
blake256_Init(&S); blake256_Init(&S);
blake256_Update(&S, in, inlen); blake256_Update(&S, in, inlen);

46
crypto/blake256.h
View File

@ -2,37 +2,43 @@
// //
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without modification, are // Redistribution and use in source and binary forms, with or without
// permitted provided that the following conditions are met: // modification, are permitted provided that the following conditions are met:
// //
// 1. Redistributions of source code must retain the above copyright notice, this list of // 1. Redistributions of source code must retain the above copyright notice,
// this list of
// conditions and the following disclaimer. // conditions and the following disclaimer.
// //
// 2. Redistributions in binary form must reproduce the above copyright notice, this list // 2. Redistributions in binary form must reproduce the above copyright notice,
// of conditions and the following disclaimer in the documentation and/or other // this list
// materials provided with the distribution. // of conditions and the following disclaimer in the documentation and/or
// other materials provided with the distribution.
// //
// 3. Neither the name of the copyright holder nor the names of its contributors may be // 3. Neither the name of the copyright holder nor the names of its contributors
// used to endorse or promote products derived from this software without specific // may be
// prior written permission. // used to endorse or promote products derived from this software without
// specific prior written permission.
// //
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// //
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote
// developers
#ifndef __BLAKE256_H__ #ifndef __BLAKE256_H__
#define __BLAKE256_H__ #define __BLAKE256_H__
#include <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h>
#define BLAKE256_DIGEST_LENGTH 32 #define BLAKE256_DIGEST_LENGTH 32
#define BLAKE256_BLOCK_LENGTH 64 #define BLAKE256_BLOCK_LENGTH 64

93
crypto/blake2b.c
View File

@ -15,13 +15,12 @@
#include <string.h> #include <string.h>
#include "blake2b.h"
#include "blake2_common.h" #include "blake2_common.h"
#include "blake2b.h"
#include "memzero.h" #include "memzero.h"
#include "options.h" #include "options.h"
typedef struct blake2b_param__ typedef struct blake2b_param__ {
{
uint8_t digest_length; /* 1 */ uint8_t digest_length; /* 1 */
uint8_t key_length; /* 2 */ uint8_t key_length; /* 2 */
uint8_t fanout; /* 3 */ uint8_t fanout; /* 3 */
@ -36,16 +35,12 @@ typedef struct blake2b_param__
uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */ uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */
} __attribute__((packed)) blake2b_param; } __attribute__((packed)) blake2b_param;
static const uint64_t blake2b_IV[8] = static const uint64_t blake2b_IV[8] = {
{ 0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL,
0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL};
0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
};
static const uint8_t blake2b_sigma[12][16] = static const uint8_t blake2b_sigma[12][16] = {
{
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}, {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4}, {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
@ -57,36 +52,25 @@ static const uint8_t blake2b_sigma[12][16] =
{6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5}, {6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
{10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0}, {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}};
};
static void blake2b_set_lastnode(blake2b_state *S) { S->f[1] = (uint64_t)-1; }
static void blake2b_set_lastnode( blake2b_state *S )
{
S->f[1] = (uint64_t)-1;
}
/* Some helper functions, not necessarily useful */ /* Some helper functions, not necessarily useful */
static int blake2b_is_lastblock( const blake2b_state *S ) static int blake2b_is_lastblock(const blake2b_state *S) { return S->f[0] != 0; }
{
return S->f[0] != 0;
}
static void blake2b_set_lastblock( blake2b_state *S ) static void blake2b_set_lastblock(blake2b_state *S) {
{
if (S->last_node) blake2b_set_lastnode(S); if (S->last_node) blake2b_set_lastnode(S);
S->f[0] = (uint64_t)-1; S->f[0] = (uint64_t)-1;
} }
static void blake2b_increment_counter( blake2b_state *S, const uint64_t inc ) static void blake2b_increment_counter(blake2b_state *S, const uint64_t inc) {
{
S->t[0] += inc; S->t[0] += inc;
S->t[1] += (S->t[0] < inc); S->t[1] += (S->t[0] < inc);
} }
static void blake2b_init0( blake2b_state *S ) static void blake2b_init0(blake2b_state *S) {
{
size_t i = 0; size_t i = 0;
memzero(S, sizeof(blake2b_state)); memzero(S, sizeof(blake2b_state));
@ -94,25 +78,21 @@ static void blake2b_init0( blake2b_state *S )
} }
/* init xors IV with input parameter block */ /* init xors IV with input parameter block */
int blake2b_init_param( blake2b_state *S, const blake2b_param *P ) int blake2b_init_param(blake2b_state *S, const blake2b_param *P) {
{
const uint8_t *p = (const uint8_t *)(P); const uint8_t *p = (const uint8_t *)(P);
size_t i = 0; size_t i = 0;
blake2b_init0(S); blake2b_init0(S);
/* IV XOR ParamBlock */ /* IV XOR ParamBlock */
for( i = 0; i < 8; ++i ) for (i = 0; i < 8; ++i) S->h[i] ^= load64(p + sizeof(S->h[i]) * i);
S->h[i] ^= load64( p + sizeof( S->h[i] ) * i );
S->outlen = P->digest_length; S->outlen = P->digest_length;
return 0; return 0;
} }
/* Sequential blake2b initialization */ /* Sequential blake2b initialization */
int blake2b_Init( blake2b_state *S, size_t outlen ) int blake2b_Init(blake2b_state *S, size_t outlen) {
{
blake2b_param P[1] = {0}; blake2b_param P[1] = {0};
if ((!outlen) || (outlen > BLAKE2B_OUTBYTES)) return -1; if ((!outlen) || (outlen > BLAKE2B_OUTBYTES)) return -1;
@ -132,8 +112,8 @@ int blake2b_Init( blake2b_state *S, size_t outlen )
return blake2b_init_param(S, P); return blake2b_init_param(S, P);
} }
int blake2b_InitPersonal( blake2b_state *S, size_t outlen, const void *personal, size_t personal_len) int blake2b_InitPersonal(blake2b_state *S, size_t outlen, const void *personal,
{ size_t personal_len) {
blake2b_param P[1] = {0}; blake2b_param P[1] = {0};
if ((!outlen) || (outlen > BLAKE2B_OUTBYTES)) return -1; if ((!outlen) || (outlen > BLAKE2B_OUTBYTES)) return -1;
@ -154,8 +134,8 @@ int blake2b_InitPersonal( blake2b_state *S, size_t outlen, const void *personal,
return blake2b_init_param(S, P); return blake2b_init_param(S, P);
} }
int blake2b_InitKey( blake2b_state *S, size_t outlen, const void *key, size_t keylen ) int blake2b_InitKey(blake2b_state *S, size_t outlen, const void *key,
{ size_t keylen) {
blake2b_param P[1] = {0}; blake2b_param P[1] = {0};
if ((!outlen) || (outlen > BLAKE2B_OUTBYTES)) return -1; if ((!outlen) || (outlen > BLAKE2B_OUTBYTES)) return -1;
@ -220,8 +200,8 @@ static void g(uint64_t *m, int r, int i, uint64_t *a, uint64_t *b, uint64_t *c,
g(m, r, 7, v + 3, v + 4, v + 9, v + 14); \ g(m, r, 7, v + 3, v + 4, v + 9, v + 14); \
} while (0) } while (0)
static void blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOCKBYTES] ) static void blake2b_compress(blake2b_state *S,
{ const uint8_t block[BLAKE2B_BLOCKBYTES]) {
uint64_t m[16] = {0}; uint64_t m[16] = {0};
uint64_t v[16] = {0}; uint64_t v[16] = {0};
size_t i = 0; size_t i = 0;
@ -243,7 +223,6 @@ static void blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOC
v[14] = blake2b_IV[6] ^ S->f[0]; v[14] = blake2b_IV[6] ^ S->f[0];
v[15] = blake2b_IV[7] ^ S->f[1]; v[15] = blake2b_IV[7] ^ S->f[1];
#if OPTIMIZE_SIZE_BLAKE2B #if OPTIMIZE_SIZE_BLAKE2B
for (int r = 0; r < 12; r++) { for (int r = 0; r < 12; r++) {
ROUND(m, v, r); ROUND(m, v, r);
@ -271,20 +250,18 @@ static void blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOC
#undef G #undef G
#undef ROUND #undef ROUND
int blake2b_Update( blake2b_state *S, const void *pin, size_t inlen ) int blake2b_Update(blake2b_state *S, const void *pin, size_t inlen) {
{
const unsigned char *in = (const unsigned char *)pin; const unsigned char *in = (const unsigned char *)pin;
if( inlen > 0 ) if (inlen > 0) {
{
size_t left = S->buflen; size_t left = S->buflen;
size_t fill = BLAKE2B_BLOCKBYTES - left; size_t fill = BLAKE2B_BLOCKBYTES - left;
if( inlen > fill ) if (inlen > fill) {
{
S->buflen = 0; S->buflen = 0;
memcpy(S->buf + left, in, fill); /* Fill buffer */ memcpy(S->buf + left, in, fill); /* Fill buffer */
blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES); blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
blake2b_compress(S, S->buf); /* Compress */ blake2b_compress(S, S->buf); /* Compress */
in += fill; inlen -= fill; in += fill;
inlen -= fill;
while (inlen > BLAKE2B_BLOCKBYTES) { while (inlen > BLAKE2B_BLOCKBYTES) {
blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES); blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
blake2b_compress(S, in); blake2b_compress(S, in);
@ -298,16 +275,13 @@ int blake2b_Update( blake2b_state *S, const void *pin, size_t inlen )
return 0; return 0;
} }
int blake2b_Final( blake2b_state *S, void *out, size_t outlen ) int blake2b_Final(blake2b_state *S, void *out, size_t outlen) {
{
uint8_t buffer[BLAKE2B_OUTBYTES] = {0}; uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
size_t i = 0; size_t i = 0;
if( out == NULL || outlen < S->outlen ) if (out == NULL || outlen < S->outlen) return -1;
return -1;
if( blake2b_is_lastblock( S ) ) if (blake2b_is_lastblock(S)) return -1;
return -1;
blake2b_increment_counter(S, S->buflen); blake2b_increment_counter(S, S->buflen);
blake2b_set_lastblock(S); blake2b_set_lastblock(S);
@ -322,8 +296,7 @@ int blake2b_Final( blake2b_state *S, void *out, size_t outlen )
return 0; return 0;
} }
int blake2b(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen) int blake2b(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen) {
{
BLAKE2B_CTX ctx; BLAKE2B_CTX ctx;
if (0 != blake2b_Init(&ctx, outlen)) return -1; if (0 != blake2b_Init(&ctx, outlen)) return -1;
if (0 != blake2b_Update(&ctx, msg, msg_len)) return -1; if (0 != blake2b_Update(&ctx, msg, msg_len)) return -1;
@ -331,8 +304,8 @@ int blake2b(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen)
return 0; return 0;
} }
int blake2b_Key(const uint8_t *msg, uint32_t msg_len, const void *key, size_t keylen, void *out, size_t outlen) int blake2b_Key(const uint8_t *msg, uint32_t msg_len, const void *key,
{ size_t keylen, void *out, size_t outlen) {
BLAKE2B_CTX ctx; BLAKE2B_CTX ctx;
if (0 != blake2b_InitKey(&ctx, outlen, key, keylen)) return -1; if (0 != blake2b_InitKey(&ctx, outlen, key, keylen)) return -1;
if (0 != blake2b_Update(&ctx, msg, msg_len)) return -1; if (0 != blake2b_Update(&ctx, msg, msg_len)) return -1;

17
crypto/blake2b.h
View File

@ -1,11 +1,10 @@
#ifndef __BLAKE2B_H__ #ifndef __BLAKE2B_H__
#define __BLAKE2B_H__ #define __BLAKE2B_H__
#include <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h>
enum blake2b_constant enum blake2b_constant {
{
BLAKE2B_BLOCKBYTES = 128, BLAKE2B_BLOCKBYTES = 128,
BLAKE2B_OUTBYTES = 64, BLAKE2B_OUTBYTES = 64,
BLAKE2B_KEYBYTES = 64, BLAKE2B_KEYBYTES = 64,
@ -13,8 +12,7 @@ enum blake2b_constant
BLAKE2B_PERSONALBYTES = 16 BLAKE2B_PERSONALBYTES = 16
}; };
typedef struct __blake2b_state typedef struct __blake2b_state {
{
uint64_t h[8]; uint64_t h[8];
uint64_t t[2]; uint64_t t[2];
uint64_t f[2]; uint64_t f[2];
@ -30,12 +28,15 @@ typedef struct __blake2b_state
#define BLAKE2B_KEY_LENGTH BLAKE2B_KEYBYTES #define BLAKE2B_KEY_LENGTH BLAKE2B_KEYBYTES
int blake2b_Init(blake2b_state *S, size_t outlen); int blake2b_Init(blake2b_state *S, size_t outlen);
int blake2b_InitKey(blake2b_state *S, size_t outlen, const void *key, size_t keylen); int blake2b_InitKey(blake2b_state *S, size_t outlen, const void *key,
int blake2b_InitPersonal(blake2b_state *S, size_t outlen, const void *personal, size_t personal_len); size_t keylen);
int blake2b_InitPersonal(blake2b_state *S, size_t outlen, const void *personal,
size_t personal_len);
int blake2b_Update(blake2b_state *S, const void *pin, size_t inlen); int blake2b_Update(blake2b_state *S, const void *pin, size_t inlen);
int blake2b_Final(blake2b_state *S, void *out, size_t outlen); int blake2b_Final(blake2b_state *S, void *out, size_t outlen);
int blake2b(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen); int blake2b(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen);
int blake2b_Key(const uint8_t *msg, uint32_t msg_len, const void *key, size_t keylen, void *out, size_t outlen); int blake2b_Key(const uint8_t *msg, uint32_t msg_len, const void *key,
size_t keylen, void *out, size_t outlen);
#endif #endif

86
crypto/blake2s.c
View File

@ -15,13 +15,12 @@
#include <string.h> #include <string.h>
#include "blake2s.h"
#include "blake2_common.h" #include "blake2_common.h"
#include "blake2s.h"
#include "memzero.h" #include "memzero.h"
#include "options.h" #include "options.h"
typedef struct blake2s_param__ typedef struct blake2s_param__ {
{
uint8_t digest_length; /* 1 */ uint8_t digest_length; /* 1 */
uint8_t key_length; /* 2 */ uint8_t key_length; /* 2 */
uint8_t fanout; /* 3 */ uint8_t fanout; /* 3 */
@ -36,14 +35,11 @@ typedef struct blake2s_param__
uint8_t personal[BLAKE2S_PERSONALBYTES]; /* 32 */ uint8_t personal[BLAKE2S_PERSONALBYTES]; /* 32 */
} __attribute__((packed)) blake2s_param; } __attribute__((packed)) blake2s_param;
static const uint32_t blake2s_IV[8] = static const uint32_t blake2s_IV[8] = {0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL,
{ 0xA54FF53AUL, 0x510E527FUL, 0x9B05688CUL,
0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL, 0x1F83D9ABUL, 0x5BE0CD19UL};
0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
};
static const uint8_t blake2s_sigma[10][16] = static const uint8_t blake2s_sigma[10][16] = {
{
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
{14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}, {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
{11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4}, {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
@ -56,32 +52,23 @@ static const uint8_t blake2s_sigma[10][16] =
{10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0}, {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
}; };
static void blake2s_set_lastnode( blake2s_state *S ) static void blake2s_set_lastnode(blake2s_state *S) { S->f[1] = (uint32_t)-1; }
{
S->f[1] = (uint32_t)-1;
}
/* Some helper functions, not necessarily useful */ /* Some helper functions, not necessarily useful */
static int blake2s_is_lastblock( const blake2s_state *S ) static int blake2s_is_lastblock(const blake2s_state *S) { return S->f[0] != 0; }
{
return S->f[0] != 0;
}
static void blake2s_set_lastblock( blake2s_state *S ) static void blake2s_set_lastblock(blake2s_state *S) {
{
if (S->last_node) blake2s_set_lastnode(S); if (S->last_node) blake2s_set_lastnode(S);
S->f[0] = (uint32_t)-1; S->f[0] = (uint32_t)-1;
} }
static void blake2s_increment_counter( blake2s_state *S, const uint32_t inc ) static void blake2s_increment_counter(blake2s_state *S, const uint32_t inc) {
{
S->t[0] += inc; S->t[0] += inc;
S->t[1] += (S->t[0] < inc); S->t[1] += (S->t[0] < inc);
} }
static void blake2s_init0( blake2s_state *S ) static void blake2s_init0(blake2s_state *S) {
{
size_t i = 0; size_t i = 0;
memzero(S, sizeof(blake2s_state)); memzero(S, sizeof(blake2s_state));
@ -89,25 +76,21 @@ static void blake2s_init0( blake2s_state *S )
} }
/* init2 xors IV with input parameter block */ /* init2 xors IV with input parameter block */
int blake2s_init_param( blake2s_state *S, const blake2s_param *P ) int blake2s_init_param(blake2s_state *S, const blake2s_param *P) {
{
const unsigned char *p = (const unsigned char *)(P); const unsigned char *p = (const unsigned char *)(P);
size_t i = 0; size_t i = 0;
blake2s_init0(S); blake2s_init0(S);
/* IV XOR ParamBlock */ /* IV XOR ParamBlock */
for( i = 0; i < 8; ++i ) for (i = 0; i < 8; ++i) S->h[i] ^= load32(&p[i * 4]);
S->h[i] ^= load32( &p[i * 4] );
S->outlen = P->digest_length; S->outlen = P->digest_length;
return 0; return 0;
} }
/* Sequential blake2s initialization */ /* Sequential blake2s initialization */
int blake2s_Init( blake2s_state *S, size_t outlen ) int blake2s_Init(blake2s_state *S, size_t outlen) {
{
blake2s_param P[1] = {0}; blake2s_param P[1] = {0};
if ((!outlen) || (outlen > BLAKE2S_OUTBYTES)) return -1; if ((!outlen) || (outlen > BLAKE2S_OUTBYTES)) return -1;
@ -127,8 +110,8 @@ int blake2s_Init( blake2s_state *S, size_t outlen )
return blake2s_init_param(S, P); return blake2s_init_param(S, P);
} }
int blake2s_InitPersonal( blake2s_state *S, size_t outlen, const void *personal, size_t personal_len) int blake2s_InitPersonal(blake2s_state *S, size_t outlen, const void *personal,
{ size_t personal_len) {
blake2s_param P[1] = {0}; blake2s_param P[1] = {0};
if ((!outlen) || (outlen > BLAKE2S_OUTBYTES)) return -1; if ((!outlen) || (outlen > BLAKE2S_OUTBYTES)) return -1;
@ -149,9 +132,8 @@ int blake2s_InitPersonal( blake2s_state *S, size_t outlen, const void *personal,
return blake2s_init_param(S, P); return blake2s_init_param(S, P);
} }
int blake2s_InitKey(blake2s_state *S, size_t outlen, const void *key,
int blake2s_InitKey( blake2s_state *S, size_t outlen, const void *key, size_t keylen ) size_t keylen) {
{
blake2s_param P[1] = {0}; blake2s_param P[1] = {0};
if ((!outlen) || (outlen > BLAKE2S_OUTBYTES)) return -1; if ((!outlen) || (outlen > BLAKE2S_OUTBYTES)) return -1;
@ -216,8 +198,8 @@ static void g(uint32_t *m, int r, int i, uint32_t *a, uint32_t *b, uint32_t *c,
g(m, r, 7, v + 3, v + 4, v + 9, v + 14); \ g(m, r, 7, v + 3, v + 4, v + 9, v + 14); \
} while (0) } while (0)
static void blake2s_compress( blake2s_state *S, const uint8_t in[BLAKE2S_BLOCKBYTES] ) static void blake2s_compress(blake2s_state *S,
{ const uint8_t in[BLAKE2S_BLOCKBYTES]) {
uint32_t m[16] = {0}; uint32_t m[16] = {0};
uint32_t v[16] = {0}; uint32_t v[16] = {0};
size_t i = 0; size_t i = 0;
@ -264,20 +246,18 @@ static void blake2s_compress( blake2s_state *S, const uint8_t in[BLAKE2S_BLOCKBY
#undef G #undef G
#undef ROUND #undef ROUND
int blake2s_Update( blake2s_state *S, const void *pin, size_t inlen ) int blake2s_Update(blake2s_state *S, const void *pin, size_t inlen) {
{
const unsigned char *in = (const unsigned char *)pin; const unsigned char *in = (const unsigned char *)pin;
if( inlen > 0 ) if (inlen > 0) {
{
size_t left = S->buflen; size_t left = S->buflen;
size_t fill = BLAKE2S_BLOCKBYTES - left; size_t fill = BLAKE2S_BLOCKBYTES - left;
if( inlen > fill ) if (inlen > fill) {
{
S->buflen = 0; S->buflen = 0;
memcpy(S->buf + left, in, fill); /* Fill buffer */ memcpy(S->buf + left, in, fill); /* Fill buffer */
blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES); blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
blake2s_compress(S, S->buf); /* Compress */ blake2s_compress(S, S->buf); /* Compress */
in += fill; inlen -= fill; in += fill;
inlen -= fill;
while (inlen > BLAKE2S_BLOCKBYTES) { while (inlen > BLAKE2S_BLOCKBYTES) {
blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES); blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
blake2s_compress(S, in); blake2s_compress(S, in);
@ -291,16 +271,13 @@ int blake2s_Update( blake2s_state *S, const void *pin, size_t inlen )
return 0; return 0;
} }
int blake2s_Final( blake2s_state *S, void *out, size_t outlen ) int blake2s_Final(blake2s_state *S, void *out, size_t outlen) {
{
uint8_t buffer[BLAKE2S_OUTBYTES] = {0}; uint8_t buffer[BLAKE2S_OUTBYTES] = {0};
size_t i = 0; size_t i = 0;
if( out == NULL || outlen < S->outlen ) if (out == NULL || outlen < S->outlen) return -1;
return -1;
if( blake2s_is_lastblock( S ) ) if (blake2s_is_lastblock(S)) return -1;
return -1;
blake2s_increment_counter(S, (uint32_t)S->buflen); blake2s_increment_counter(S, (uint32_t)S->buflen);
blake2s_set_lastblock(S); blake2s_set_lastblock(S);
@ -315,8 +292,7 @@ int blake2s_Final( blake2s_state *S, void *out, size_t outlen )
return 0; return 0;
} }
int blake2s(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen) int blake2s(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen) {
{
BLAKE2S_CTX ctx; BLAKE2S_CTX ctx;
if (0 != blake2s_Init(&ctx, outlen)) return -1; if (0 != blake2s_Init(&ctx, outlen)) return -1;
if (0 != blake2s_Update(&ctx, msg, msg_len)) return -1; if (0 != blake2s_Update(&ctx, msg, msg_len)) return -1;
@ -324,8 +300,8 @@ int blake2s(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen)
return 0; return 0;
} }
int blake2s_Key(const uint8_t *msg, uint32_t msg_len, const void *key, size_t keylen, void *out, size_t outlen) int blake2s_Key(const uint8_t *msg, uint32_t msg_len, const void *key,
{ size_t keylen, void *out, size_t outlen) {
BLAKE2S_CTX ctx; BLAKE2S_CTX ctx;
if (0 != blake2s_InitKey(&ctx, outlen, key, keylen)) return -1; if (0 != blake2s_InitKey(&ctx, outlen, key, keylen)) return -1;
if (0 != blake2s_Update(&ctx, msg, msg_len)) return -1; if (0 != blake2s_Update(&ctx, msg, msg_len)) return -1;

17
crypto/blake2s.h
View File

@ -1,11 +1,10 @@
#ifndef __BLAKE2S_H__ #ifndef __BLAKE2S_H__
#define __BLAKE2S_H__ #define __BLAKE2S_H__
#include <stdint.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h>
enum blake2s_constant enum blake2s_constant {
{
BLAKE2S_BLOCKBYTES = 64, BLAKE2S_BLOCKBYTES = 64,
BLAKE2S_OUTBYTES = 32, BLAKE2S_OUTBYTES = 32,
BLAKE2S_KEYBYTES = 32, BLAKE2S_KEYBYTES = 32,
@ -13,8 +12,7 @@ enum blake2s_constant
BLAKE2S_PERSONALBYTES = 8 BLAKE2S_PERSONALBYTES = 8
}; };
typedef struct __blake2s_state typedef struct __blake2s_state {
{
uint32_t h[8]; uint32_t h[8];
uint32_t t[2]; uint32_t t[2];
uint32_t f[2]; uint32_t f[2];
@ -30,12 +28,15 @@ typedef struct __blake2s_state
#define BLAKE2S_KEY_LENGTH BLAKE2S_KEYBYTES #define BLAKE2S_KEY_LENGTH BLAKE2S_KEYBYTES
int blake2s_Init(blake2s_state *S, size_t outlen); int blake2s_Init(blake2s_state *S, size_t outlen);
int blake2s_InitKey(blake2s_state *S, size_t outlen, const void *key, size_t keylen); int blake2s_InitKey(blake2s_state *S, size_t outlen, const void *key,
int blake2s_InitPersonal(blake2s_state *S, size_t outlen, const void *personal, size_t personal_len); size_t keylen);
int blake2s_InitPersonal(blake2s_state *S, size_t outlen, const void *personal,
size_t personal_len);
int blake2s_Update(blake2s_state *S, const void *pin, size_t inlen); int blake2s_Update(blake2s_state *S, const void *pin, size_t inlen);
int blake2s_Final(blake2s_state *S, void *out, size_t outlen); int blake2s_Final(blake2s_state *S, void *out, size_t outlen);
int blake2s(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen); int blake2s(const uint8_t *msg, uint32_t msg_len, void *out, size_t outlen);
int blake2s_Key(const uint8_t *msg, uint32_t msg_len, const void *key, size_t keylen, void *out, size_t outlen); int blake2s_Key(const uint8_t *msg, uint32_t msg_len, const void *key,
size_t keylen, void *out, size_t outlen);
#endif #endif

106
crypto/groestl.c
View File

@ -34,15 +34,14 @@
#include <stddef.h> #include <stddef.h>
#include <string.h> #include <string.h>
#include "groestl_internal.h"
#include "groestl.h" #include "groestl.h"
#include "groestl_internal.h"
#include "memzero.h" #include "memzero.h"
#define C32e(x) \
#define C32e(x) ((SPH_C32(x) >> 24) \ ((SPH_C32(x) >> 24) | ((SPH_C32(x) >> 8) & SPH_C32(0x0000FF00)) | \
| ((SPH_C32(x) >> 8) & SPH_C32(0x0000FF00)) \ ((SPH_C32(x) << 8) & SPH_C32(0x00FF0000)) | \
| ((SPH_C32(x) << 8) & SPH_C32(0x00FF0000)) \ ((SPH_C32(x) << 24) & SPH_C32(0xFF000000)))
| ((SPH_C32(x) << 24) & SPH_C32(0xFF000000)))
#define dec32e_aligned sph_dec32le_aligned #define dec32e_aligned sph_dec32le_aligned
#define enc32e sph_enc32le #define enc32e sph_enc32le
#define B32_0(x) ((x) & 0xFF) #define B32_0(x) ((x) & 0xFF)
@ -58,7 +57,6 @@
#define QC32up(j, r) SPH_C32(0xFFFFFFFF) #define QC32up(j, r) SPH_C32(0xFFFFFFFF)
#define QC32dn(j, r) (((sph_u32)(r) << 24) ^ SPH_T32(~((sph_u32)(j) << 24))) #define QC32dn(j, r) (((sph_u32)(r) << 24) ^ SPH_T32(~((sph_u32)(j) << 24)))
static const sph_u32 T0up[] = { static const sph_u32 T0up[] = {
C32e(0xc632f4a5), C32e(0xf86f9784), C32e(0xee5eb099), C32e(0xf67a8c8d), C32e(0xc632f4a5), C32e(0xf86f9784), C32e(0xee5eb099), C32e(0xf67a8c8d),
C32e(0xffe8170d), C32e(0xd60adcbd), C32e(0xde16c8b1), C32e(0x916dfc54), C32e(0xffe8170d), C32e(0xd60adcbd), C32e(0xde16c8b1), C32e(0x916dfc54),
@ -123,8 +121,7 @@ static const sph_u32 T0up[] = {
C32e(0x03898a8f), C32e(0x594a13f8), C32e(0x09929b80), C32e(0x1a233917), C32e(0x03898a8f), C32e(0x594a13f8), C32e(0x09929b80), C32e(0x1a233917),
C32e(0x651075da), C32e(0xd7845331), C32e(0x84d551c6), C32e(0xd003d3b8), C32e(0x651075da), C32e(0xd7845331), C32e(0x84d551c6), C32e(0xd003d3b8),
C32e(0x82dc5ec3), C32e(0x29e2cbb0), C32e(0x5ac39977), C32e(0x1e2d3311), C32e(0x82dc5ec3), C32e(0x29e2cbb0), C32e(0x5ac39977), C32e(0x1e2d3311),
C32e(0x7b3d46cb), C32e(0xa8b71ffc), C32e(0x6d0c61d6), C32e(0x2c624e3a) C32e(0x7b3d46cb), C32e(0xa8b71ffc), C32e(0x6d0c61d6), C32e(0x2c624e3a)};
};
static const sph_u32 T0dn[] = { static const sph_u32 T0dn[] = {
C32e(0xf497a5c6), C32e(0x97eb84f8), C32e(0xb0c799ee), C32e(0x8cf78df6), C32e(0xf497a5c6), C32e(0x97eb84f8), C32e(0xb0c799ee), C32e(0x8cf78df6),
@ -190,8 +187,7 @@ static const sph_u32 T0dn[] = {
C32e(0x8a068f03), C32e(0x13b2f859), C32e(0x9b128009), C32e(0x3934171a), C32e(0x8a068f03), C32e(0x13b2f859), C32e(0x9b128009), C32e(0x3934171a),
C32e(0x75cada65), C32e(0x53b531d7), C32e(0x5113c684), C32e(0xd3bbb8d0), C32e(0x75cada65), C32e(0x53b531d7), C32e(0x5113c684), C32e(0xd3bbb8d0),
C32e(0x5e1fc382), C32e(0xcb52b029), C32e(0x99b4775a), C32e(0x333c111e), C32e(0x5e1fc382), C32e(0xcb52b029), C32e(0x99b4775a), C32e(0x333c111e),
C32e(0x46f6cb7b), C32e(0x1f4bfca8), C32e(0x61dad66d), C32e(0x4e583a2c) C32e(0x46f6cb7b), C32e(0x1f4bfca8), C32e(0x61dad66d), C32e(0x4e583a2c)};
};
static const sph_u32 T1up[] = { static const sph_u32 T1up[] = {
C32e(0xc6c632f4), C32e(0xf8f86f97), C32e(0xeeee5eb0), C32e(0xf6f67a8c), C32e(0xc6c632f4), C32e(0xf8f86f97), C32e(0xeeee5eb0), C32e(0xf6f67a8c),
@ -257,8 +253,7 @@ static const sph_u32 T1up[] = {
C32e(0x0303898a), C32e(0x59594a13), C32e(0x0909929b), C32e(0x1a1a2339), C32e(0x0303898a), C32e(0x59594a13), C32e(0x0909929b), C32e(0x1a1a2339),
C32e(0x65651075), C32e(0xd7d78453), C32e(0x8484d551), C32e(0xd0d003d3), C32e(0x65651075), C32e(0xd7d78453), C32e(0x8484d551), C32e(0xd0d003d3),
C32e(0x8282dc5e), C32e(0x2929e2cb), C32e(0x5a5ac399), C32e(0x1e1e2d33), C32e(0x8282dc5e), C32e(0x2929e2cb), C32e(0x5a5ac399), C32e(0x1e1e2d33),
C32e(0x7b7b3d46), C32e(0xa8a8b71f), C32e(0x6d6d0c61), C32e(0x2c2c624e) C32e(0x7b7b3d46), C32e(0xa8a8b71f), C32e(0x6d6d0c61), C32e(0x2c2c624e)};
};
static const sph_u32 T1dn[] = { static const sph_u32 T1dn[] = {
C32e(0xa5f497a5), C32e(0x8497eb84), C32e(0x99b0c799), C32e(0x8d8cf78d), C32e(0xa5f497a5), C32e(0x8497eb84), C32e(0x99b0c799), C32e(0x8d8cf78d),
@ -324,22 +319,20 @@ static const sph_u32 T1dn[] = {
C32e(0x8f8a068f), C32e(0xf813b2f8), C32e(0x809b1280), C32e(0x17393417), C32e(0x8f8a068f), C32e(0xf813b2f8), C32e(0x809b1280), C32e(0x17393417),
C32e(0xda75cada), C32e(0x3153b531), C32e(0xc65113c6), C32e(0xb8d3bbb8), C32e(0xda75cada), C32e(0x3153b531), C32e(0xc65113c6), C32e(0xb8d3bbb8),
C32e(0xc35e1fc3), C32e(0xb0cb52b0), C32e(0x7799b477), C32e(0x11333c11), C32e(0xc35e1fc3), C32e(0xb0cb52b0), C32e(0x7799b477), C32e(0x11333c11),
C32e(0xcb46f6cb), C32e(0xfc1f4bfc), C32e(0xd661dad6), C32e(0x3a4e583a) C32e(0xcb46f6cb), C32e(0xfc1f4bfc), C32e(0xd661dad6), C32e(0x3a4e583a)};
};
#define DECL_STATE_BIG \ #define DECL_STATE_BIG sph_u32 H[32] = {0};
sph_u32 H[32] = {0};
#define READ_STATE_BIG(sc) do { \ #define READ_STATE_BIG(sc) \
do { \
memcpy(H, (sc)->state.narrow, sizeof H); \ memcpy(H, (sc)->state.narrow, sizeof H); \
} while (0) } while (0)
#define WRITE_STATE_BIG(sc) do { \ #define WRITE_STATE_BIG(sc) \
do { \
memcpy((sc)->state.narrow, H, sizeof H); \ memcpy((sc)->state.narrow, H, sizeof H); \
} while (0) } while (0)
static void RBTT(size_t d0, size_t d1, sph_u32 *a, size_t b0, size_t b1, static void RBTT(size_t d0, size_t d1, sph_u32 *a, size_t b0, size_t b1,
size_t b2, size_t b3, size_t b4, size_t b5, size_t b6, size_t b2, size_t b3, size_t b4, size_t b5, size_t b6,
size_t b7, sph_u32 *t) { size_t b7, sph_u32 *t) {
@ -407,21 +400,20 @@ static void ROUND_BIG_Q(sph_u32 *a, int r) {
memcpy(a, t, sizeof(t)); memcpy(a, t, sizeof(t));
} }
#define PERM_BIG_P(a) \
#define PERM_BIG_P(a) do { \ do { \
int r; \ int r; \
for (r = 0; r < 14; r ++) \ for (r = 0; r < 14; r++) ROUND_BIG_P(a, r); \
ROUND_BIG_P(a, r); \
} while (0) } while (0)
#define PERM_BIG_Q(a) do { \ #define PERM_BIG_Q(a) \
do { \
int r; \ int r; \
for (r = 0; r < 14; r ++) \ for (r = 0; r < 14; r++) ROUND_BIG_Q(a, r); \
ROUND_BIG_Q(a, r); \
} while (0) } while (0)
#define COMPRESS_BIG \
#define COMPRESS_BIG do { \ do { \
sph_u32 g[32], m[32]; \ sph_u32 g[32], m[32]; \
size_t uu; \ size_t uu; \
for (uu = 0; uu < 32; uu++) { \ for (uu = 0; uu < 32; uu++) { \
@ -430,36 +422,30 @@ static void ROUND_BIG_Q(sph_u32 *a, int r) {
} \ } \
PERM_BIG_P(g); \ PERM_BIG_P(g); \
PERM_BIG_Q(m); \ PERM_BIG_Q(m); \
for (uu = 0; uu < 32; uu ++) \ for (uu = 0; uu < 32; uu++) H[uu] ^= g[uu] ^ m[uu]; \
H[uu] ^= g[uu] ^ m[uu]; \
} while (0) } while (0)
#define FINAL_BIG do { \ #define FINAL_BIG \
do { \
sph_u32 x[32]; \ sph_u32 x[32]; \
size_t uu; \ size_t uu; \
memcpy(x, H, sizeof x); \ memcpy(x, H, sizeof x); \
PERM_BIG_P(x); \ PERM_BIG_P(x); \
for (uu = 0; uu < 32; uu ++) \ for (uu = 0; uu < 32; uu++) H[uu] ^= x[uu]; \
H[uu] ^= x[uu]; \
} while (0) } while (0)
static void groestl_big_init(sph_groestl_big_context *sc, unsigned out_size) {
static void
groestl_big_init(sph_groestl_big_context *sc, unsigned out_size)
{
size_t u = 0; size_t u = 0;
sc->ptr = 0; sc->ptr = 0;
for (u = 0; u < 31; u ++) for (u = 0; u < 31; u++) sc->state.narrow[u] = 0;
sc->state.narrow[u] = 0; sc->state.narrow[31] =
sc->state.narrow[31] = ((sph_u32)(out_size & 0xFF) << 24) ((sph_u32)(out_size & 0xFF) << 24) | ((sph_u32)(out_size & 0xFF00) << 8);
| ((sph_u32)(out_size & 0xFF00) << 8);
sc->count = 0; sc->count = 0;
} }
static void static void groestl_big_core(sph_groestl_big_context *sc, const void *data,
groestl_big_core(sph_groestl_big_context *sc, const void *data, size_t len) size_t len) {
{
if (len == 0) { if (len == 0) {
return; return;
} }
@ -482,8 +468,7 @@ groestl_big_core(sph_groestl_big_context *sc, const void *data, size_t len)
size_t clen = 0; size_t clen = 0;
clen = (sizeof sc->buf) - ptr; clen = (sizeof sc->buf) - ptr;
if (clen > len) if (clen > len) clen = len;
clen = len;
memcpy(buf + ptr, data, clen); memcpy(buf + ptr, data, clen);
ptr += clen; ptr += clen;
data = (const unsigned char *)data + clen; data = (const unsigned char *)data + clen;
@ -498,10 +483,8 @@ groestl_big_core(sph_groestl_big_context *sc, const void *data, size_t len)
sc->ptr = ptr; sc->ptr = ptr;
} }
static void static void groestl_big_close(sph_groestl_big_context *sc, unsigned ub,
groestl_big_close(sph_groestl_big_context *sc, unsigned n, void *dst, size_t out_len) {
unsigned ub, unsigned n, void *dst, size_t out_len)
{
unsigned char pad[136] = {0}; unsigned char pad[136] = {0};
size_t ptr = 0, pad_len = 0, u2 = 0; size_t ptr = 0, pad_len = 0, u2 = 0;
sph_u64 count = 0; sph_u64 count = 0;
@ -523,33 +506,24 @@ groestl_big_close(sph_groestl_big_context *sc,
groestl_big_core(sc, pad, pad_len); groestl_big_core(sc, pad, pad_len);
READ_STATE_BIG(sc); READ_STATE_BIG(sc);
FINAL_BIG; FINAL_BIG;
for (u2 = 0; u2 < 16; u2 ++) for (u2 = 0; u2 < 16; u2++) enc32e(pad + (u2 << 2), H[u2 + 16]);
enc32e(pad + (u2 << 2), H[u2 + 16]);
memcpy(dst, pad + 64 - out_len, out_len); memcpy(dst, pad + 64 - out_len, out_len);
groestl_big_init(sc, (unsigned)out_len << 3); groestl_big_init(sc, (unsigned)out_len << 3);
} }
void void groestl512_Init(void *cc) {
groestl512_Init(void *cc)
{
groestl_big_init((sph_groestl_big_context *)cc, 512); groestl_big_init((sph_groestl_big_context *)cc, 512);
} }
void void groestl512_Update(void *cc, const void *data, size_t len) {
groestl512_Update(void *cc, const void *data, size_t len)
{
groestl_big_core((sph_groestl_big_context *)cc, data, len); groestl_big_core((sph_groestl_big_context *)cc, data, len);
} }
void void groestl512_Final(void *cc, void *dst) {
groestl512_Final(void *cc, void *dst)
{
groestl_big_close((sph_groestl_big_context *)cc, 0, 0, dst, 64); groestl_big_close((sph_groestl_big_context *)cc, 0, 0, dst, 64);
} }
void void groestl512_DoubleTrunc(void *cc, void *dst) {
groestl512_DoubleTrunc(void *cc, void *dst)
{
char buf[64] = {0}; char buf[64] = {0};
groestl512_Final(cc, buf); groestl512_Final(cc, buf);

204
crypto/groestl_internal.h
View File

@ -116,7 +116,6 @@ typedef int64_t sph_s64;
#endif #endif
#if defined SPH_DETECT_LITTLE_ENDIAN && !defined SPH_LITTLE_ENDIAN #if defined SPH_DETECT_LITTLE_ENDIAN && !defined SPH_LITTLE_ENDIAN
#define SPH_LITTLE_ENDIAN SPH_DETECT_LITTLE_ENDIAN #define SPH_LITTLE_ENDIAN SPH_DETECT_LITTLE_ENDIAN
#endif #endif
@ -124,12 +123,9 @@ typedef int64_t sph_s64;
#define SPH_BIG_ENDIAN SPH_DETECT_BIG_ENDIAN #define SPH_BIG_ENDIAN SPH_DETECT_BIG_ENDIAN
#endif #endif
static inline sph_u32 static inline sph_u32 sph_bswap32(sph_u32 x) {
sph_bswap32(sph_u32 x)
{
x = SPH_T32((x << 16) | (x >> 16)); x = SPH_T32((x << 16) | (x >> 16));
x = ((x & SPH_C32(0xFF00FF00)) >> 8) x = ((x & SPH_C32(0xFF00FF00)) >> 8) | ((x & SPH_C32(0x00FF00FF)) << 8);
| ((x & SPH_C32(0x00FF00FF)) << 8);
return x; return x;
} }
@ -139,43 +135,33 @@ sph_bswap32(sph_u32 x)
* @param x the input value * @param x the input value
* @return the byte-swapped value * @return the byte-swapped value
*/ */
static inline sph_u64 static inline sph_u64 sph_bswap64(sph_u64 x) {
sph_bswap64(sph_u64 x)
{
x = SPH_T64((x << 32) | (x >> 32)); x = SPH_T64((x << 32) | (x >> 32));
x = ((x & SPH_C64(0xFFFF0000FFFF0000)) >> 16) x = ((x & SPH_C64(0xFFFF0000FFFF0000)) >> 16) |
| ((x & SPH_C64(0x0000FFFF0000FFFF)) << 16); ((x & SPH_C64(0x0000FFFF0000FFFF)) << 16);
x = ((x & SPH_C64(0xFF00FF00FF00FF00)) >> 8) x = ((x & SPH_C64(0xFF00FF00FF00FF00)) >> 8) |
| ((x & SPH_C64(0x00FF00FF00FF00FF)) << 8); ((x & SPH_C64(0x00FF00FF00FF00FF)) << 8);
return x; return x;
} }
static inline void static inline void sph_enc16be(void *dst, unsigned val) {
sph_enc16be(void *dst, unsigned val)
{
((unsigned char *)dst)[0] = (val >> 8); ((unsigned char *)dst)[0] = (val >> 8);
((unsigned char *)dst)[1] = val; ((unsigned char *)dst)[1] = val;
} }
static inline unsigned static inline unsigned sph_dec16be(const void *src) {
sph_dec16be(const void *src) return ((unsigned)(((const unsigned char *)src)[0]) << 8) |
{ (unsigned)(((const unsigned char *)src)[1]);
return ((unsigned)(((const unsigned char *)src)[0]) << 8)
| (unsigned)(((const unsigned char *)src)[1]);
} }
static inline void static inline void sph_enc16le(void *dst, unsigned val) {
sph_enc16le(void *dst, unsigned val)
{
((unsigned char *)dst)[0] = val; ((unsigned char *)dst)[0] = val;
((unsigned char *)dst)[1] = val >> 8; ((unsigned char *)dst)[1] = val >> 8;
} }
static inline unsigned static inline unsigned sph_dec16le(const void *src) {
sph_dec16le(const void *src) return (unsigned)(((const unsigned char *)src)[0]) |
{ ((unsigned)(((const unsigned char *)src)[1]) << 8);
return (unsigned)(((const unsigned char *)src)[0])
| ((unsigned)(((const unsigned char *)src)[1]) << 8);
} }
/** /**
@ -184,9 +170,7 @@ sph_dec16le(const void *src)
* @param dst the destination buffer * @param dst the destination buffer
* @param val the 32-bit value to encode * @param val the 32-bit value to encode
*/ */
static inline void static inline void sph_enc32be(void *dst, sph_u32 val) {
sph_enc32be(void *dst, sph_u32 val)
{
((unsigned char *)dst)[0] = (val >> 24); ((unsigned char *)dst)[0] = (val >> 24);
((unsigned char *)dst)[1] = (val >> 16); ((unsigned char *)dst)[1] = (val >> 16);
((unsigned char *)dst)[2] = (val >> 8); ((unsigned char *)dst)[2] = (val >> 8);
@ -200,9 +184,7 @@ sph_enc32be(void *dst, sph_u32 val)
* @param dst the destination buffer (32-bit aligned) * @param dst the destination buffer (32-bit aligned)
* @param val the value to encode * @param val the value to encode
*/ */
static inline void static inline void sph_enc32be_aligned(void *dst, sph_u32 val) {
sph_enc32be_aligned(void *dst, sph_u32 val)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
*(sph_u32 *)dst = sph_bswap32(val); *(sph_u32 *)dst = sph_bswap32(val);
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
@ -221,13 +203,11 @@ sph_enc32be_aligned(void *dst, sph_u32 val)
* @param src the source buffer * @param src the source buffer
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u32 static inline sph_u32 sph_dec32be(const void *src) {
sph_dec32be(const void *src) return ((sph_u32)(((const unsigned char *)src)[0]) << 24) |
{ ((sph_u32)(((const unsigned char *)src)[1]) << 16) |
return ((sph_u32)(((const unsigned char *)src)[0]) << 24) ((sph_u32)(((const unsigned char *)src)[2]) << 8) |
| ((sph_u32)(((const unsigned char *)src)[1]) << 16) (sph_u32)(((const unsigned char *)src)[3]);
| ((sph_u32)(((const unsigned char *)src)[2]) << 8)
| (sph_u32)(((const unsigned char *)src)[3]);
} }
/** /**
@ -237,18 +217,16 @@ sph_dec32be(const void *src)
* @param src the source buffer (32-bit aligned) * @param src the source buffer (32-bit aligned)
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u32 static inline sph_u32 sph_dec32be_aligned(const void *src) {
sph_dec32be_aligned(const void *src)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
return sph_bswap32(*(const sph_u32 *)src); return sph_bswap32(*(const sph_u32 *)src);
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
return *(const sph_u32 *)src; return *(const sph_u32 *)src;
#else #else
return ((sph_u32)(((const unsigned char *)src)[0]) << 24) return ((sph_u32)(((const unsigned char *)src)[0]) << 24) |
| ((sph_u32)(((const unsigned char *)src)[1]) << 16) ((sph_u32)(((const unsigned char *)src)[1]) << 16) |
| ((sph_u32)(((const unsigned char *)src)[2]) << 8) ((sph_u32)(((const unsigned char *)src)[2]) << 8) |
| (sph_u32)(((const unsigned char *)src)[3]); (sph_u32)(((const unsigned char *)src)[3]);
#endif #endif
} }
@ -258,9 +236,7 @@ sph_dec32be_aligned(const void *src)
* @param dst the destination buffer * @param dst the destination buffer
* @param val the 32-bit value to encode * @param val the 32-bit value to encode
*/ */
static inline void static inline void sph_enc32le(void *dst, sph_u32 val) {
sph_enc32le(void *dst, sph_u32 val)
{
((unsigned char *)dst)[0] = val; ((unsigned char *)dst)[0] = val;
((unsigned char *)dst)[1] = (val >> 8); ((unsigned char *)dst)[1] = (val >> 8);
((unsigned char *)dst)[2] = (val >> 16); ((unsigned char *)dst)[2] = (val >> 16);
@ -274,9 +250,7 @@ sph_enc32le(void *dst, sph_u32 val)
* @param dst the destination buffer (32-bit aligned) * @param dst the destination buffer (32-bit aligned)
* @param val the value to encode * @param val the value to encode
*/ */
static inline void static inline void sph_enc32le_aligned(void *dst, sph_u32 val) {
sph_enc32le_aligned(void *dst, sph_u32 val)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
*(sph_u32 *)dst = val; *(sph_u32 *)dst = val;
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
@ -295,13 +269,11 @@ sph_enc32le_aligned(void *dst, sph_u32 val)
* @param src the source buffer * @param src the source buffer
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u32 static inline sph_u32 sph_dec32le(const void *src) {
sph_dec32le(const void *src) return (sph_u32)(((const unsigned char *)src)[0]) |
{ ((sph_u32)(((const unsigned char *)src)[1]) << 8) |
return (sph_u32)(((const unsigned char *)src)[0]) ((sph_u32)(((const unsigned char *)src)[2]) << 16) |
| ((sph_u32)(((const unsigned char *)src)[1]) << 8) ((sph_u32)(((const unsigned char *)src)[3]) << 24);
| ((sph_u32)(((const unsigned char *)src)[2]) << 16)
| ((sph_u32)(((const unsigned char *)src)[3]) << 24);
} }
/** /**
@ -311,18 +283,16 @@ sph_dec32le(const void *src)
* @param src the source buffer (32-bit aligned) * @param src the source buffer (32-bit aligned)
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u32 static inline sph_u32 sph_dec32le_aligned(const void *src) {
sph_dec32le_aligned(const void *src)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
return *(const sph_u32 *)src; return *(const sph_u32 *)src;
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
return sph_bswap32(*(const sph_u32 *)src); return sph_bswap32(*(const sph_u32 *)src);
#else #else
return (sph_u32)(((const unsigned char *)src)[0]) return (sph_u32)(((const unsigned char *)src)[0]) |
| ((sph_u32)(((const unsigned char *)src)[1]) << 8) ((sph_u32)(((const unsigned char *)src)[1]) << 8) |
| ((sph_u32)(((const unsigned char *)src)[2]) << 16) ((sph_u32)(((const unsigned char *)src)[2]) << 16) |
| ((sph_u32)(((const unsigned char *)src)[3]) << 24); ((sph_u32)(((const unsigned char *)src)[3]) << 24);
#endif #endif
} }
@ -332,9 +302,7 @@ sph_dec32le_aligned(const void *src)
* @param dst the destination buffer * @param dst the destination buffer
* @param val the 64-bit value to encode * @param val the 64-bit value to encode
*/ */
static inline void static inline void sph_enc64be(void *dst, sph_u64 val) {
sph_enc64be(void *dst, sph_u64 val)
{
((unsigned char *)dst)[0] = (val >> 56); ((unsigned char *)dst)[0] = (val >> 56);
((unsigned char *)dst)[1] = (val >> 48); ((unsigned char *)dst)[1] = (val >> 48);
((unsigned char *)dst)[2] = (val >> 40); ((unsigned char *)dst)[2] = (val >> 40);
@ -352,9 +320,7 @@ sph_enc64be(void *dst, sph_u64 val)
* @param dst the destination buffer (64-bit aligned) * @param dst the destination buffer (64-bit aligned)
* @param val the value to encode * @param val the value to encode
*/ */
static inline void static inline void sph_enc64be_aligned(void *dst, sph_u64 val) {
sph_enc64be_aligned(void *dst, sph_u64 val)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
*(sph_u64 *)dst = sph_bswap64(val); *(sph_u64 *)dst = sph_bswap64(val);
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
@ -377,17 +343,15 @@ sph_enc64be_aligned(void *dst, sph_u64 val)
* @param src the source buffer * @param src the source buffer
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u64 static inline sph_u64 sph_dec64be(const void *src) {
sph_dec64be(const void *src) return ((sph_u64)(((const unsigned char *)src)[0]) << 56) |
{ ((sph_u64)(((const unsigned char *)src)[1]) << 48) |
return ((sph_u64)(((const unsigned char *)src)[0]) << 56) ((sph_u64)(((const unsigned char *)src)[2]) << 40) |
| ((sph_u64)(((const unsigned char *)src)[1]) << 48) ((sph_u64)(((const unsigned char *)src)[3]) << 32) |
| ((sph_u64)(((const unsigned char *)src)[2]) << 40) ((sph_u64)(((const unsigned char *)src)[4]) << 24) |
| ((sph_u64)(((const unsigned char *)src)[3]) << 32) ((sph_u64)(((const unsigned char *)src)[5]) << 16) |
| ((sph_u64)(((const unsigned char *)src)[4]) << 24) ((sph_u64)(((const unsigned char *)src)[6]) << 8) |
| ((sph_u64)(((const unsigned char *)src)[5]) << 16) (sph_u64)(((const unsigned char *)src)[7]);
| ((sph_u64)(((const unsigned char *)src)[6]) << 8)
| (sph_u64)(((const unsigned char *)src)[7]);
} }
/** /**
@ -397,22 +361,20 @@ sph_dec64be(const void *src)
* @param src the source buffer (64-bit aligned) * @param src the source buffer (64-bit aligned)
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u64 static inline sph_u64 sph_dec64be_aligned(const void *src) {
sph_dec64be_aligned(const void *src)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
return sph_bswap64(*(const sph_u64 *)src); return sph_bswap64(*(const sph_u64 *)src);
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
return *(const sph_u64 *)src; return *(const sph_u64 *)src;
#else #else
return ((sph_u64)(((const unsigned char *)src)[0]) << 56) return ((sph_u64)(((const unsigned char *)src)[0]) << 56) |
| ((sph_u64)(((const unsigned char *)src)[1]) << 48) ((sph_u64)(((const unsigned char *)src)[1]) << 48) |
| ((sph_u64)(((const unsigned char *)src)[2]) << 40) ((sph_u64)(((const unsigned char *)src)[2]) << 40) |
| ((sph_u64)(((const unsigned char *)src)[3]) << 32) ((sph_u64)(((const unsigned char *)src)[3]) << 32) |
| ((sph_u64)(((const unsigned char *)src)[4]) << 24) ((sph_u64)(((const unsigned char *)src)[4]) << 24) |
| ((sph_u64)(((const unsigned char *)src)[5]) << 16) ((sph_u64)(((const unsigned char *)src)[5]) << 16) |
| ((sph_u64)(((const unsigned char *)src)[6]) << 8) ((sph_u64)(((const unsigned char *)src)[6]) << 8) |
| (sph_u64)(((const unsigned char *)src)[7]); (sph_u64)(((const unsigned char *)src)[7]);
#endif #endif
} }
@ -422,9 +384,7 @@ sph_dec64be_aligned(const void *src)
* @param dst the destination buffer * @param dst the destination buffer
* @param val the 64-bit value to encode * @param val the 64-bit value to encode
*/ */
static inline void static inline void sph_enc64le(void *dst, sph_u64 val) {
sph_enc64le(void *dst, sph_u64 val)
{
((unsigned char *)dst)[0] = val; ((unsigned char *)dst)[0] = val;
((unsigned char *)dst)[1] = (val >> 8); ((unsigned char *)dst)[1] = (val >> 8);
((unsigned char *)dst)[2] = (val >> 16); ((unsigned char *)dst)[2] = (val >> 16);
@ -442,9 +402,7 @@ sph_enc64le(void *dst, sph_u64 val)
* @param dst the destination buffer (64-bit aligned) * @param dst the destination buffer (64-bit aligned)
* @param val the value to encode * @param val the value to encode
*/ */
static inline void static inline void sph_enc64le_aligned(void *dst, sph_u64 val) {
sph_enc64le_aligned(void *dst, sph_u64 val)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
*(sph_u64 *)dst = val; *(sph_u64 *)dst = val;
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
@ -467,17 +425,15 @@ sph_enc64le_aligned(void *dst, sph_u64 val)
* @param src the source buffer * @param src the source buffer
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u64 static inline sph_u64 sph_dec64le(const void *src) {
sph_dec64le(const void *src) return (sph_u64)(((const unsigned char *)src)[0]) |
{ ((sph_u64)(((const unsigned char *)src)[1]) << 8) |
return (sph_u64)(((const unsigned char *)src)[0]) ((sph_u64)(((const unsigned char *)src)[2]) << 16) |
| ((sph_u64)(((const unsigned char *)src)[1]) << 8) ((sph_u64)(((const unsigned char *)src)[3]) << 24) |
| ((sph_u64)(((const unsigned char *)src)[2]) << 16) ((sph_u64)(((const unsigned char *)src)[4]) << 32) |
| ((sph_u64)(((const unsigned char *)src)[3]) << 24) ((sph_u64)(((const unsigned char *)src)[5]) << 40) |
| ((sph_u64)(((const unsigned char *)src)[4]) << 32) ((sph_u64)(((const unsigned char *)src)[6]) << 48) |
| ((sph_u64)(((const unsigned char *)src)[5]) << 40) ((sph_u64)(((const unsigned char *)src)[7]) << 56);
| ((sph_u64)(((const unsigned char *)src)[6]) << 48)
| ((sph_u64)(((const unsigned char *)src)[7]) << 56);
} }
/** /**
@ -487,22 +443,20 @@ sph_dec64le(const void *src)
* @param src the source buffer (64-bit aligned) * @param src the source buffer (64-bit aligned)
* @return the decoded value * @return the decoded value
*/ */
static inline sph_u64 static inline sph_u64 sph_dec64le_aligned(const void *src) {
sph_dec64le_aligned(const void *src)
{
#if SPH_LITTLE_ENDIAN #if SPH_LITTLE_ENDIAN
return *(const sph_u64 *)src; return *(const sph_u64 *)src;
#elif SPH_BIG_ENDIAN #elif SPH_BIG_ENDIAN
return sph_bswap64(*(const sph_u64 *)src); return sph_bswap64(*(const sph_u64 *)src);
#else #else
return (sph_u64)(((const unsigned char *)src)[0]) return (sph_u64)(((const unsigned char *)src)[0]) |
| ((sph_u64)(((const unsigned char *)src)[1]) << 8) ((sph_u64)(((const unsigned char *)src)[1]) << 8) |
| ((sph_u64)(((const unsigned char *)src)[2]) << 16) ((sph_u64)(((const unsigned char *)src)[2]) << 16) |
| ((sph_u64)(((const unsigned char *)src)[3]) << 24) ((sph_u64)(((const unsigned char *)src)[3]) << 24) |
| ((sph_u64)(((const unsigned char *)src)[4]) << 32) ((sph_u64)(((const unsigned char *)src)[4]) << 32) |
| ((sph_u64)(((const unsigned char *)src)[5]) << 40) ((sph_u64)(((const unsigned char *)src)[5]) << 40) |
| ((sph_u64)(((const unsigned char *)src)[6]) << 48) ((sph_u64)(((const unsigned char *)src)[6]) << 48) |
| ((sph_u64)(((const unsigned char *)src)[7]) << 56); ((sph_u64)(((const unsigned char *)src)[7]) << 56);
#endif #endif
} }

2
tools/style.c.exclude
View File

@ -3,9 +3,7 @@
^\./crypto/chacha20poly1305/ ^\./crypto/chacha20poly1305/
^\./crypto/ed25519-donna/ ^\./crypto/ed25519-donna/
^\./crypto/gui/ ^\./crypto/gui/
^\./crypto/blake2
^\./crypto/check_mem ^\./crypto/check_mem
^\./crypto/groestl
^\./crypto/ripemd160 ^\./crypto/ripemd160
^\./crypto/segwit_addr ^\./crypto/segwit_addr
^\./crypto/sha2 ^\./crypto/sha2