arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-01-03 12:00:59 +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
worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
You should have received a copy of the CC0 Public Domain Dedication along
with this software. If not, see
<http://creativecommons.org/publicdomain/zero/1.0/>.
*/
#include "blake256.h"
@ -19,11 +20,12 @@
((uint32_t)((p)[2]) << 8) | ((uint32_t)((p)[3])))
#define U32TO8_BIG(p, v) \
(p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
(p)[2] = (uint8_t)((v) >> 8); (p)[3] = (uint8_t)((v) );
(p)[0] = (uint8_t)((v) >> 24); \
(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},
{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},
@ -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},
{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},
{ 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] =
{
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917
};
static const uint32_t u256[16] = {
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917};
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, 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 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,
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;
#define ROT(x, n) (((x) << (32 - n)) | ((x) >> (n)))
#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];
/* don't xor t when the block is only padding */
if ( !S->nullt )
{
if (!S->nullt) {
v[12] ^= S->t[0];
v[13] ^= S->t[0];
v[14] ^= S->t[1];
v[15] ^= S->t[1];
}
for( i = 0; i < 14; ++i )
{
for (i = 0; i < 14; ++i) {
/* column step */
G(0, 4, 8, 12, 0);
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];
}
void blake256_Init( BLAKE256_CTX *S )
{
void blake256_Init(BLAKE256_CTX *S) {
S->h[0] = 0x6a09e667;
S->h[1] = 0xbb67ae85;
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;
}
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 fill = 64 - left;
/* data left and data received fill a block */
if( left && ( inlen >= fill ) )
{
if (left && (inlen >= fill)) {
memcpy((void *)(S->buf + left), (void *)in, fill);
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 */
while( inlen >= 64 )
{
while (inlen >= 64) {
S->t[0] += 512;
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 */
if( inlen > 0 )
{
memcpy( ( void * ) ( S->buf + left ), \
( void * ) in, ( size_t ) inlen );
if (inlen > 0) {
memcpy((void *)(S->buf + left), (void *)in, (size_t)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;
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;
blake256_Update(S, &oo, 1);
}
else
{
} else {
if (S->buflen < 55) /* enough space to fill the block */
{
if (!S->buflen) S->nullt = 1;
S->t[0] -= 440 - (S->buflen << 3);
blake256_Update(S, padding, 55 - S->buflen);
}
else /* need 2 compressions */
} else /* need 2 compressions */
{
S->t[0] -= 512 - (S->buflen << 3);
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]);
}
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_Init(&S);
blake256_Update(&S, in, inlen);

46
crypto/blake256.h
View File

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

93
crypto/blake2b.c
View File

@ -15,13 +15,12 @@
#include <string.h>
#include "blake2b.h"
#include "blake2_common.h"
#include "blake2b.h"
#include "memzero.h"
#include "options.h"
typedef struct blake2b_param__
{
typedef struct blake2b_param__ {
uint8_t digest_length; /* 1 */
uint8_t key_length; /* 2 */
uint8_t fanout; /* 3 */
@ -36,16 +35,12 @@ typedef struct blake2b_param__
uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */
} __attribute__((packed)) blake2b_param;
static const uint64_t blake2b_IV[8] =
{
0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL,
0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL,
0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
};
static const uint64_t blake2b_IV[8] = {
0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL,
0xa54ff53a5f1d36f1ULL, 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},
{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},
@ -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},
{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},
{ 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 */
static int blake2b_is_lastblock( const blake2b_state *S )
{
return S->f[0] != 0;
}
static int blake2b_is_lastblock(const blake2b_state *S) { 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);
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[1] += (S->t[0] < inc);
}
static void blake2b_init0( blake2b_state *S )
{
static void blake2b_init0(blake2b_state *S) {
size_t i = 0;
memzero(S, sizeof(blake2b_state));
@ -94,25 +78,21 @@ static void blake2b_init0( blake2b_state *S )
}
/* 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);
size_t i = 0;
blake2b_init0(S);
/* IV XOR ParamBlock */
for( i = 0; i < 8; ++i )
S->h[i] ^= load64( p + sizeof( S->h[i] ) * i );
for (i = 0; i < 8; ++i) S->h[i] ^= load64(p + sizeof(S->h[i]) * i);
S->outlen = P->digest_length;
return 0;
}
/* 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};
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);
}
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};
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);
}
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};
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); \
} 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 v[16] = {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[15] = blake2b_IV[7] ^ S->f[1];
#if OPTIMIZE_SIZE_BLAKE2B
for (int r = 0; r < 12; 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 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;
if( inlen > 0 )
{
if (inlen > 0) {
size_t left = S->buflen;
size_t fill = BLAKE2B_BLOCKBYTES - left;
if( inlen > fill )
{
if (inlen > fill) {
S->buflen = 0;
memcpy(S->buf + left, in, fill); /* Fill buffer */
blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
blake2b_compress(S, S->buf); /* Compress */
in += fill; inlen -= fill;
in += fill;
inlen -= fill;
while (inlen > BLAKE2B_BLOCKBYTES) {
blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
blake2b_compress(S, in);
@ -298,16 +275,13 @@ int blake2b_Update( blake2b_state *S, const void *pin, size_t inlen )
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};
size_t i = 0;
if( out == NULL || outlen < S->outlen )
return -1;
if (out == NULL || outlen < S->outlen) return -1;
if( blake2b_is_lastblock( S ) )
return -1;
if (blake2b_is_lastblock(S)) return -1;
blake2b_increment_counter(S, S->buflen);
blake2b_set_lastblock(S);
@ -322,8 +296,7 @@ int blake2b_Final( blake2b_state *S, void *out, size_t outlen )
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;
if (0 != blake2b_Init(&ctx, outlen)) 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;
}
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;
if (0 != blake2b_InitKey(&ctx, outlen, key, keylen)) 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__
#define __BLAKE2B_H__
#include <stdint.h>
#include <stddef.h>
#include <stdint.h>
enum blake2b_constant
{
enum blake2b_constant {
BLAKE2B_BLOCKBYTES = 128,
BLAKE2B_OUTBYTES = 64,
BLAKE2B_KEYBYTES = 64,
@ -13,8 +12,7 @@ enum blake2b_constant
BLAKE2B_PERSONALBYTES = 16
};
typedef struct __blake2b_state
{
typedef struct __blake2b_state {
uint64_t h[8];
uint64_t t[2];
uint64_t f[2];
@ -30,12 +28,15 @@ typedef struct __blake2b_state
#define BLAKE2B_KEY_LENGTH BLAKE2B_KEYBYTES
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_InitPersonal(blake2b_state *S, size_t outlen, const void *personal, size_t personal_len);
int blake2b_InitKey(blake2b_state *S, size_t outlen, const void *key,
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_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_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

86
crypto/blake2s.c
View File

@ -15,13 +15,12 @@
#include <string.h>
#include "blake2s.h"
#include "blake2_common.h"
#include "blake2s.h"
#include "memzero.h"
#include "options.h"
typedef struct blake2s_param__
{
typedef struct blake2s_param__ {
uint8_t digest_length; /* 1 */
uint8_t key_length; /* 2 */
uint8_t fanout; /* 3 */
@ -36,14 +35,11 @@ typedef struct blake2s_param__
uint8_t personal[BLAKE2S_PERSONALBYTES]; /* 32 */
} __attribute__((packed)) blake2s_param;
static const uint32_t blake2s_IV[8] =
{
0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
};
static const uint32_t blake2s_IV[8] = {0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL,
0xA54FF53AUL, 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},
{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},
@ -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},
};
static void blake2s_set_lastnode( blake2s_state *S )
{
S->f[1] = (uint32_t)-1;
}
static void blake2s_set_lastnode(blake2s_state *S) { S->f[1] = (uint32_t)-1; }
/* Some helper functions, not necessarily useful */
static int blake2s_is_lastblock( const blake2s_state *S )
{
return S->f[0] != 0;
}
static int blake2s_is_lastblock(const blake2s_state *S) { 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);
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[1] += (S->t[0] < inc);
}
static void blake2s_init0( blake2s_state *S )
{
static void blake2s_init0(blake2s_state *S) {
size_t i = 0;
memzero(S, sizeof(blake2s_state));
@ -89,25 +76,21 @@ static void blake2s_init0( blake2s_state *S )
}
/* 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);
size_t i = 0;
blake2s_init0(S);
/* IV XOR ParamBlock */
for( i = 0; i < 8; ++i )
S->h[i] ^= load32( &p[i * 4] );
for (i = 0; i < 8; ++i) S->h[i] ^= load32(&p[i * 4]);
S->outlen = P->digest_length;
return 0;
}
/* 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};
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);
}
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};
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);
}
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,
size_t keylen) {
blake2s_param P[1] = {0};
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); \
} 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 v[16] = {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 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;
if( inlen > 0 )
{
if (inlen > 0) {
size_t left = S->buflen;
size_t fill = BLAKE2S_BLOCKBYTES - left;
if( inlen > fill )
{
if (inlen > fill) {
S->buflen = 0;
memcpy(S->buf + left, in, fill); /* Fill buffer */
blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
blake2s_compress(S, S->buf); /* Compress */
in += fill; inlen -= fill;
in += fill;
inlen -= fill;
while (inlen > BLAKE2S_BLOCKBYTES) {
blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
blake2s_compress(S, in);
@ -291,16 +271,13 @@ int blake2s_Update( blake2s_state *S, const void *pin, size_t inlen )
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};
size_t i = 0;
if( out == NULL || outlen < S->outlen )
return -1;
if (out == NULL || outlen < S->outlen) return -1;
if( blake2s_is_lastblock( S ) )
return -1;
if (blake2s_is_lastblock(S)) return -1;
blake2s_increment_counter(S, (uint32_t)S->buflen);
blake2s_set_lastblock(S);
@ -315,8 +292,7 @@ int blake2s_Final( blake2s_state *S, void *out, size_t outlen )
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;
if (0 != blake2s_Init(&ctx, outlen)) 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;
}
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;
if (0 != blake2s_InitKey(&ctx, outlen, key, keylen)) 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__
#define __BLAKE2S_H__
#include <stdint.h>
#include <stddef.h>
#include <stdint.h>
enum blake2s_constant
{
enum blake2s_constant {
BLAKE2S_BLOCKBYTES = 64,
BLAKE2S_OUTBYTES = 32,
BLAKE2S_KEYBYTES = 32,
@ -13,8 +12,7 @@ enum blake2s_constant
BLAKE2S_PERSONALBYTES = 8
};
typedef struct __blake2s_state
{
typedef struct __blake2s_state {
uint32_t h[8];
uint32_t t[2];
uint32_t f[2];
@ -30,12 +28,15 @@ typedef struct __blake2s_state
#define BLAKE2S_KEY_LENGTH BLAKE2S_KEYBYTES
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_InitPersonal(blake2s_state *S, size_t outlen, const void *personal, size_t personal_len);
int blake2s_InitKey(blake2s_state *S, size_t outlen, const void *key,
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_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_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

106
crypto/groestl.c
View File

@ -34,15 +34,14 @@
#include <stddef.h>
#include <string.h>
#include "groestl_internal.h"
#include "groestl.h"
#include "groestl_internal.h"
#include "memzero.h"
#define C32e(x) ((SPH_C32(x) >> 24) \
| ((SPH_C32(x) >> 8) & SPH_C32(0x0000FF00)) \
| ((SPH_C32(x) << 8) & SPH_C32(0x00FF0000)) \
| ((SPH_C32(x) << 24) & SPH_C32(0xFF000000)))
#define C32e(x) \
((SPH_C32(x) >> 24) | ((SPH_C32(x) >> 8) & SPH_C32(0x0000FF00)) | \
((SPH_C32(x) << 8) & SPH_C32(0x00FF0000)) | \
((SPH_C32(x) << 24) & SPH_C32(0xFF000000)))
#define dec32e_aligned sph_dec32le_aligned
#define enc32e sph_enc32le
#define B32_0(x) ((x) & 0xFF)
@ -58,7 +57,6 @@
#define QC32up(j, r) SPH_C32(0xFFFFFFFF)
#define QC32dn(j, r) (((sph_u32)(r) << 24) ^ SPH_T32(~((sph_u32)(j) << 24)))
static const sph_u32 T0up[] = {
C32e(0xc632f4a5), C32e(0xf86f9784), C32e(0xee5eb099), C32e(0xf67a8c8d),
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(0x651075da), C32e(0xd7845331), C32e(0x84d551c6), C32e(0xd003d3b8),
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[] = {
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(0x75cada65), C32e(0x53b531d7), C32e(0x5113c684), C32e(0xd3bbb8d0),
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[] = {
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(0x65651075), C32e(0xd7d78453), C32e(0x8484d551), C32e(0xd0d003d3),
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[] = {
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(0xda75cada), C32e(0x3153b531), C32e(0xc65113c6), C32e(0xb8d3bbb8),
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 \
sph_u32 H[32] = {0};
#define DECL_STATE_BIG sph_u32 H[32] = {0};
#define READ_STATE_BIG(sc) do { \
#define READ_STATE_BIG(sc) \
do { \
memcpy(H, (sc)->state.narrow, sizeof H); \
} while (0)
#define WRITE_STATE_BIG(sc) do { \
#define WRITE_STATE_BIG(sc) \
do { \
memcpy((sc)->state.narrow, H, sizeof H); \
} while (0)
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 b7, sph_u32 *t) {
@ -407,21 +400,20 @@ static void ROUND_BIG_Q(sph_u32 *a, int r) {
memcpy(a, t, sizeof(t));
}
#define PERM_BIG_P(a) do { \
#define PERM_BIG_P(a) \
do { \
int r; \
for (r = 0; r < 14; r ++) \
ROUND_BIG_P(a, r); \
for (r = 0; r < 14; r++) ROUND_BIG_P(a, r); \
} while (0)
#define PERM_BIG_Q(a) do { \
#define PERM_BIG_Q(a) \
do { \
int r; \
for (r = 0; r < 14; r ++) \
ROUND_BIG_Q(a, r); \
for (r = 0; r < 14; r++) ROUND_BIG_Q(a, r); \
} while (0)
#define COMPRESS_BIG do { \
#define COMPRESS_BIG \
do { \
sph_u32 g[32], m[32]; \
size_t 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_Q(m); \
for (uu = 0; uu < 32; uu ++) \
H[uu] ^= g[uu] ^ m[uu]; \
for (uu = 0; uu < 32; uu++) H[uu] ^= g[uu] ^ m[uu]; \
} while (0)
#define FINAL_BIG do { \
#define FINAL_BIG \
do { \
sph_u32 x[32]; \
size_t uu; \
memcpy(x, H, sizeof x); \
PERM_BIG_P(x); \
for (uu = 0; uu < 32; uu ++) \
H[uu] ^= x[uu]; \
for (uu = 0; uu < 32; uu++) H[uu] ^= x[uu]; \
} 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;
sc->ptr = 0;
for (u = 0; u < 31; u ++)
sc->state.narrow[u] = 0;
sc->state.narrow[31] = ((sph_u32)(out_size & 0xFF) << 24)
| ((sph_u32)(out_size & 0xFF00) << 8);
for (u = 0; u < 31; u++) sc->state.narrow[u] = 0;
sc->state.narrow[31] =
((sph_u32)(out_size & 0xFF) << 24) | ((sph_u32)(out_size & 0xFF00) << 8);
sc->count = 0;
}
static void
groestl_big_core(sph_groestl_big_context *sc, const void *data, size_t len)
{
static void groestl_big_core(sph_groestl_big_context *sc, const void *data,
size_t len) {
if (len == 0) {
return;
}
@ -482,8 +468,7 @@ groestl_big_core(sph_groestl_big_context *sc, const void *data, size_t len)
size_t clen = 0;
clen = (sizeof sc->buf) - ptr;
if (clen > len)
clen = len;
if (clen > len) clen = len;
memcpy(buf + ptr, data, clen);
ptr += 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;
}
static void
groestl_big_close(sph_groestl_big_context *sc,
unsigned ub, unsigned n, void *dst, size_t out_len)
{
static void groestl_big_close(sph_groestl_big_context *sc, unsigned ub,
unsigned n, void *dst, size_t out_len) {
unsigned char pad[136] = {0};
size_t ptr = 0, pad_len = 0, u2 = 0;
sph_u64 count = 0;
@ -523,33 +506,24 @@ groestl_big_close(sph_groestl_big_context *sc,
groestl_big_core(sc, pad, pad_len);
READ_STATE_BIG(sc);
FINAL_BIG;
for (u2 = 0; u2 < 16; u2 ++)
enc32e(pad + (u2 << 2), H[u2 + 16]);
for (u2 = 0; u2 < 16; u2++) enc32e(pad + (u2 << 2), H[u2 + 16]);
memcpy(dst, pad + 64 - out_len, out_len);
groestl_big_init(sc, (unsigned)out_len << 3);
}
void
groestl512_Init(void *cc)
{
void groestl512_Init(void *cc) {
groestl_big_init((sph_groestl_big_context *)cc, 512);
}
void
groestl512_Update(void *cc, const void *data, size_t len)
{
void groestl512_Update(void *cc, const void *data, size_t len) {
groestl_big_core((sph_groestl_big_context *)cc, data, len);
}
void
groestl512_Final(void *cc, void *dst)
{
void groestl512_Final(void *cc, void *dst) {
groestl_big_close((sph_groestl_big_context *)cc, 0, 0, dst, 64);
}
void
groestl512_DoubleTrunc(void *cc, void *dst)
{
void groestl512_DoubleTrunc(void *cc, void *dst) {
char buf[64] = {0};
groestl512_Final(cc, buf);

204
crypto/groestl_internal.h
View File

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

2
tools/style.c.exclude
View File

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