Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › 255b373
Update blake2b to latest version
Baptiste Daroussin committed 9 years ago
commit 255b3732fda325ff125c68207a6b1912f3f9dafb
parent e768714
4 files changed +404 -301
modified external/blake2/blake2-impl.h
@@ -1,37 +1,36 @@
/*

   BLAKE2 reference source code package - reference C implementations
-
- 
   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
-
- 
   To the extent possible under law, the author(s) have dedicated all copyright
- 
   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/>.
+
+ 
   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+ 
   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+ 
   your option.  The terms of these licenses can be found at:
+
+ 
   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ 
   - OpenSSL license   : https://www.openssl.org/source/license.html
+ 
   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+
+ 
   More information about the BLAKE2 hash function can be found at
+ 
   https://blake2.net.

*/
- 
#pragma once
- 
#ifndef __BLAKE2_IMPL_H__
- 
#define __BLAKE2_IMPL_H__
+ 
#ifndef BLAKE2_IMPL_H
+ 
#define BLAKE2_IMPL_H
- 
#include <pkg_config.h>

#include <stdint.h>
-
- 
#ifdef HAVE_SYS_ENDIAN_H
- 
#include <sys/endian.h>
- 
#elif HAVE_ENDIAN_H
- 
#include <endian.h>
- 
#elif HAVE_MACHINE_ENDIAN_H
- 
#include <machine/endian.h>
- 
#endif
-
- 
#ifdef __BYTE_ORDER
- 
# if __BYTE_ORDER == __LITTLE_ENDIAN
- 
#  define NATIVE_LITTLE_ENDIAN
- 
# endif
+ 
#include <string.h>
+
+ 
#if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L)
+ 
  #if   defined(_MSC_VER)
+ 
    #define BLAKE2_INLINE __inline
+ 
  #elif defined(__GNUC__)
+ 
    #define BLAKE2_INLINE __inline__
+ 
  #else
+ 
    #define BLAKE2_INLINE
+ 
  #endif
+ 
#else
+ 
  #define BLAKE2_INLINE inline

#endif
- 
static inline uint32_t load32( const void *src )
+ 
static BLAKE2_INLINE uint32_t load32( const void *src )

{

#if defined(NATIVE_LITTLE_ENDIAN)

  uint32_t w;
@@ -39,15 +38,14 @@ static inline uint32_t load32( const void *src )
  return w;

#else

  const uint8_t *p = ( const uint8_t * )src;
- 
  uint32_t w = *p++;
- 
  w |= ( uint32_t )( *p++ ) <<  8;
- 
  w |= ( uint32_t )( *p++ ) << 16;
- 
  w |= ( uint32_t )( *p++ ) << 24;
- 
  return w;
+ 
  return (( uint32_t )( p[0] ) <<  0) |
+ 
         (( uint32_t )( p[1] ) <<  8) |
+ 
         (( uint32_t )( p[2] ) << 16) |
+ 
         (( uint32_t )( p[3] ) << 24) ;

#endif

}
- 
static inline uint64_t load64( const void *src )
+ 
static BLAKE2_INLINE uint64_t load64( const void *src )

{

#if defined(NATIVE_LITTLE_ENDIAN)

  uint64_t w;
@@ -55,96 +53,108 @@ static inline uint64_t load64( const void *src )
  return w;

#else

  const uint8_t *p = ( const uint8_t * )src;
- 
  uint64_t w = *p++;
- 
  w |= ( uint64_t )( *p++ ) <<  8;
- 
  w |= ( uint64_t )( *p++ ) << 16;
- 
  w |= ( uint64_t )( *p++ ) << 24;
- 
  w |= ( uint64_t )( *p++ ) << 32;
- 
  w |= ( uint64_t )( *p++ ) << 40;
- 
  w |= ( uint64_t )( *p++ ) << 48;
- 
  w |= ( uint64_t )( *p++ ) << 56;
- 
  return w;
+ 
  return (( uint64_t )( p[0] ) <<  0) |
+ 
         (( uint64_t )( p[1] ) <<  8) |
+ 
         (( uint64_t )( p[2] ) << 16) |
+ 
         (( uint64_t )( p[3] ) << 24) |
+ 
         (( uint64_t )( p[4] ) << 32) |
+ 
         (( uint64_t )( p[5] ) << 40) |
+ 
         (( uint64_t )( p[6] ) << 48) |
+ 
         (( uint64_t )( p[7] ) << 56) ;

#endif

}
- 
static inline void store32( void *dst, uint32_t w )
+ 
static BLAKE2_INLINE uint16_t load16( const void *src )

{

#if defined(NATIVE_LITTLE_ENDIAN)
- 
  memcpy(dst, &w, sizeof w);
+ 
  uint16_t w;
+ 
  memcpy(&w, src, sizeof w);
+ 
  return w;

#else
- 
  uint8_t *p = ( uint8_t * )dst;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w;
+ 
  const uint8_t *p = ( const uint8_t * )src;
+ 
  return (( uint16_t )( p[0] ) <<  0) |
+ 
         (( uint16_t )( p[1] ) <<  8) ;

#endif

}
- 
static inline void store64( void *dst, uint64_t w )
+ 
static BLAKE2_INLINE void store16( void *dst, uint16_t w )

{

#if defined(NATIVE_LITTLE_ENDIAN)

  memcpy(dst, &w, sizeof w);

#else

  uint8_t *p = ( uint8_t * )dst;

  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;

  *p++ = ( uint8_t )w;

#endif

}
- 
static inline uint64_t load48( const void *src )
+ 
static BLAKE2_INLINE void store32( void *dst, uint32_t w )

{
- 
  const uint8_t *p = ( const uint8_t * )src;
- 
  uint64_t w = *p++;
- 
  w |= ( uint64_t )( *p++ ) <<  8;
- 
  w |= ( uint64_t )( *p++ ) << 16;
- 
  w |= ( uint64_t )( *p++ ) << 24;
- 
  w |= ( uint64_t )( *p++ ) << 32;
- 
  w |= ( uint64_t )( *p++ ) << 40;
- 
  return w;
+ 
#if defined(NATIVE_LITTLE_ENDIAN)
+ 
  memcpy(dst, &w, sizeof w);
+ 
#else
+ 
  uint8_t *p = ( uint8_t * )dst;
+ 
  p[0] = (uint8_t)(w >>  0);
+ 
  p[1] = (uint8_t)(w >>  8);
+ 
  p[2] = (uint8_t)(w >> 16);
+ 
  p[3] = (uint8_t)(w >> 24);
+ 
#endif

}
- 
static inline void store48( void *dst, uint64_t w )
+ 
static BLAKE2_INLINE void store64( void *dst, uint64_t w )

{
+ 
#if defined(NATIVE_LITTLE_ENDIAN)
+ 
  memcpy(dst, &w, sizeof w);
+ 
#else

  uint8_t *p = ( uint8_t * )dst;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w; w >>= 8;
- 
  *p++ = ( uint8_t )w;
+ 
  p[0] = (uint8_t)(w >>  0);
+ 
  p[1] = (uint8_t)(w >>  8);
+ 
  p[2] = (uint8_t)(w >> 16);
+ 
  p[3] = (uint8_t)(w >> 24);
+ 
  p[4] = (uint8_t)(w >> 32);
+ 
  p[5] = (uint8_t)(w >> 40);
+ 
  p[6] = (uint8_t)(w >> 48);
+ 
  p[7] = (uint8_t)(w >> 56);
+ 
#endif

}
- 
static inline uint32_t rotl32( const uint32_t w, const unsigned c )
+ 
static BLAKE2_INLINE uint64_t load48( const void *src )

{
- 
  return ( w << c ) | ( w >> ( 32 - c ) );
+ 
  const uint8_t *p = ( const uint8_t * )src;
+ 
  return (( uint64_t )( p[0] ) <<  0) |
+ 
         (( uint64_t )( p[1] ) <<  8) |
+ 
         (( uint64_t )( p[2] ) << 16) |
+ 
         (( uint64_t )( p[3] ) << 24) |
+ 
         (( uint64_t )( p[4] ) << 32) |
+ 
         (( uint64_t )( p[5] ) << 40) ;

}
- 
static inline uint64_t rotl64( const uint64_t w, const unsigned c )
+ 
static BLAKE2_INLINE void store48( void *dst, uint64_t w )

{
- 
  return ( w << c ) | ( w >> ( 64 - c ) );
+ 
  uint8_t *p = ( uint8_t * )dst;
+ 
  p[0] = (uint8_t)(w >>  0);
+ 
  p[1] = (uint8_t)(w >>  8);
+ 
  p[2] = (uint8_t)(w >> 16);
+ 
  p[3] = (uint8_t)(w >> 24);
+ 
  p[4] = (uint8_t)(w >> 32);
+ 
  p[5] = (uint8_t)(w >> 40);

}
- 
static inline uint32_t rotr32( const uint32_t w, const unsigned c )
+ 
static BLAKE2_INLINE uint32_t rotr32( const uint32_t w, const unsigned c )

{

  return ( w >> c ) | ( w << ( 32 - c ) );

}
- 
static inline uint64_t rotr64( const uint64_t w, const unsigned c )
+ 
static BLAKE2_INLINE uint64_t rotr64( const uint64_t w, const unsigned c )

{

  return ( w >> c ) | ( w << ( 64 - c ) );

}



/* prevents compiler optimizing out memset() */
- 
static inline void secure_zero_memory( void *v, size_t n )
+ 
static BLAKE2_INLINE void secure_zero_memory(void *v, size_t n)

{
- 
  volatile uint8_t *p = ( volatile uint8_t * )v;
- 
  while( n-- ) *p++ = 0;
+ 
  static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
+ 
  memset_v(v, 0, n);

}



#endif
modified external/blake2/blake2.h
@@ -1,34 +1,41 @@
/*

   BLAKE2 reference source code package - reference C implementations
- 
   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
+ 
   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+ 
   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+ 
   your option.  The terms of these licenses can be found at:
- 
   To the extent possible under law, the author(s) have dedicated all copyright
- 
   and related and neighboring rights to this software to the public domain
- 
   worldwide. This software is distributed without any warranty.
+ 
   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ 
   - OpenSSL license   : https://www.openssl.org/source/license.html
+ 
   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.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/>.
+ 
   More information about the BLAKE2 hash function can be found at
+ 
   https://blake2.net.

*/
- 
#pragma once
- 
#ifndef __BLAKE2_H__
- 
#define __BLAKE2_H__
+ 
#ifndef BLAKE2_H
+ 
#define BLAKE2_H



#include <stddef.h>

#include <stdint.h>
- 
#ifndef BLAKE_ALIGN
- 
# if defined(_MSC_VER)
- 
#  define BLAKE_ALIGN(x) __declspec(align(x))
- 
# else
- 
#  define BLAKE_ALIGN(x) __attribute__((aligned(x)))
- 
# endif
+ 
#if defined(_MSC_VER)
+ 
#define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop))
+ 
#else
+ 
#define BLAKE2_PACKED(x) x __attribute__((packed))

#endif



#if defined(__cplusplus)

extern "C" {

#endif
+ 
  enum blake2s_constant
+ 
  {
+ 
    BLAKE2S_BLOCKBYTES = 64,
+ 
    BLAKE2S_OUTBYTES   = 32,
+ 
    BLAKE2S_KEYBYTES   = 32,
+ 
    BLAKE2S_SALTBYTES  = 8,
+ 
    BLAKE2S_PERSONALBYTES = 8
+ 
  };



  enum blake2b_constant

  {
@@ -39,47 +46,147 @@ extern "C" {
    BLAKE2B_PERSONALBYTES = 16

  };
- 
#pragma pack(push, 1)
-
- 
  typedef struct __blake2b_param
+ 
  typedef struct blake2s_state__

  {
- 
    uint8_t  digest_length; // 1
- 
    uint8_t  key_length;    // 2
- 
    uint8_t  fanout;        // 3
- 
    uint8_t  depth;         // 4
- 
    uint32_t leaf_length;   // 8
- 
    uint64_t node_offset;   // 16
- 
    uint8_t  node_depth;    // 17
- 
    uint8_t  inner_length;  // 18
- 
    uint8_t  reserved[14];  // 32
- 
    uint8_t  salt[BLAKE2B_SALTBYTES]; // 48
- 
    uint8_t  personal[BLAKE2B_PERSONALBYTES];  // 64
- 
  } blake2b_param;
-
- 
  BLAKE_ALIGN( 64 ) typedef struct __blake2b_state
+ 
    uint32_t h[8];
+ 
    uint32_t t[2];
+ 
    uint32_t f[2];
+ 
    uint8_t  buf[BLAKE2S_BLOCKBYTES];
+ 
    size_t   buflen;
+ 
    size_t   outlen;
+ 
    uint8_t  last_node;
+ 
  } blake2s_state;
+
+ 
  typedef struct blake2b_state__

  {

    uint64_t h[8];

    uint64_t t[2];

    uint64_t f[2];
- 
    uint8_t  buf[2 * BLAKE2B_BLOCKBYTES];
+ 
    uint8_t  buf[BLAKE2B_BLOCKBYTES];

    size_t   buflen;
+ 
    size_t   outlen;

    uint8_t  last_node;

  } blake2b_state;
- 
#pragma pack(pop)
+ 
  typedef struct blake2sp_state__
+ 
  {
+ 
    blake2s_state S[8][1];
+ 
    blake2s_state R[1];
+ 
    uint8_t       buf[8 * BLAKE2S_BLOCKBYTES];
+ 
    size_t        buflen;
+ 
    size_t        outlen;
+ 
  } blake2sp_state;
+
+ 
  typedef struct blake2bp_state__
+ 
  {
+ 
    blake2b_state S[4][1];
+ 
    blake2b_state R[1];
+ 
    uint8_t       buf[4 * BLAKE2B_BLOCKBYTES];
+ 
    size_t        buflen;
+ 
    size_t        outlen;
+ 
  } blake2bp_state;
- 
  int blake2b_init( blake2b_state *S, const uint8_t outlen );
- 
  int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen );
- 
  int blake2b_init_param( blake2b_state *S, const blake2b_param *P );
- 
  int blake2b_update( blake2b_state *S, const uint8_t *in, uint64_t inlen );
- 
  int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen );
- 
  int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
+ 
  BLAKE2_PACKED(struct blake2s_param__
+ 
  {
+ 
    uint8_t  digest_length; /* 1 */
+ 
    uint8_t  key_length;    /* 2 */
+ 
    uint8_t  fanout;        /* 3 */
+ 
    uint8_t  depth;         /* 4 */
+ 
    uint32_t leaf_length;   /* 8 */
+ 
    uint32_t node_offset;  /* 12 */
+ 
    uint16_t xof_length;    /* 14 */
+ 
    uint8_t  node_depth;    /* 15 */
+ 
    uint8_t  inner_length;  /* 16 */
+ 
    /* uint8_t  reserved[0]; */
+ 
    uint8_t  salt[BLAKE2S_SALTBYTES]; /* 24 */
+ 
    uint8_t  personal[BLAKE2S_PERSONALBYTES];  /* 32 */
+ 
  });
+
+ 
  typedef struct blake2s_param__ blake2s_param;
+
+ 
  BLAKE2_PACKED(struct blake2b_param__
+ 
  {
+ 
    uint8_t  digest_length; /* 1 */
+ 
    uint8_t  key_length;    /* 2 */
+ 
    uint8_t  fanout;        /* 3 */
+ 
    uint8_t  depth;         /* 4 */
+ 
    uint32_t leaf_length;   /* 8 */
+ 
    uint32_t node_offset;   /* 12 */
+ 
    uint32_t xof_length;    /* 16 */
+ 
    uint8_t  node_depth;    /* 17 */
+ 
    uint8_t  inner_length;  /* 18 */
+ 
    uint8_t  reserved[14];  /* 32 */
+ 
    uint8_t  salt[BLAKE2B_SALTBYTES]; /* 48 */
+ 
    uint8_t  personal[BLAKE2B_PERSONALBYTES];  /* 64 */
+ 
  });
+
+ 
  typedef struct blake2b_param__ blake2b_param;
+
+ 
  typedef struct blake2xs_state__
+ 
  {
+ 
    blake2s_state S[1];
+ 
    blake2s_param P[1];
+ 
  } blake2xs_state;
- 
  static inline int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
+ 
  typedef struct blake2xb_state__

  {
- 
    return blake2b( out, in, key, outlen, inlen, keylen );
- 
  }
+ 
    blake2b_state S[1];
+ 
    blake2b_param P[1];
+ 
  } blake2xb_state;
+
+ 
  /* Padded structs result in a compile-time error */
+ 
  enum {
+ 
    BLAKE2_DUMMY_1 = 1/(sizeof(blake2s_param) == BLAKE2S_OUTBYTES),
+ 
    BLAKE2_DUMMY_2 = 1/(sizeof(blake2b_param) == BLAKE2B_OUTBYTES)
+ 
  };
+
+ 
  /* Streaming API */
+ 
  int blake2s_init( blake2s_state *S, size_t outlen );
+ 
  int blake2s_init_key( blake2s_state *S, size_t outlen, const void *key, size_t keylen );
+ 
  int blake2s_init_param( blake2s_state *S, const blake2s_param *P );
+ 
  int blake2s_update( blake2s_state *S, const void *in, size_t inlen );
+ 
  int blake2s_final( blake2s_state *S, void *out, size_t outlen );
+
+ 
  int blake2b_init( blake2b_state *S, size_t outlen );
+ 
  int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen );
+ 
  int blake2b_init_param( blake2b_state *S, const blake2b_param *P );
+ 
  int blake2b_update( blake2b_state *S, const void *in, size_t inlen );
+ 
  int blake2b_final( blake2b_state *S, void *out, size_t outlen );
+
+ 
  int blake2sp_init( blake2sp_state *S, size_t outlen );
+ 
  int blake2sp_init_key( blake2sp_state *S, size_t outlen, const void *key, size_t keylen );
+ 
  int blake2sp_update( blake2sp_state *S, const void *in, size_t inlen );
+ 
  int blake2sp_final( blake2sp_state *S, void *out, size_t outlen );
+
+ 
  int blake2bp_init( blake2bp_state *S, size_t outlen );
+ 
  int blake2bp_init_key( blake2bp_state *S, size_t outlen, const void *key, size_t keylen );
+ 
  int blake2bp_update( blake2bp_state *S, const void *in, size_t inlen );
+ 
  int blake2bp_final( blake2bp_state *S, void *out, size_t outlen );
+
+ 
  /* Variable output length API */
+ 
  int blake2xs_init( blake2xs_state *S, const size_t outlen );
+ 
  int blake2xs_init_key( blake2xs_state *S, const size_t outlen, const void *key, size_t keylen );
+ 
  int blake2xs_update( blake2xs_state *S, const void *in, size_t inlen );
+ 
  int blake2xs_final(blake2xs_state *S, void *out, size_t outlen);
+
+ 
  int blake2xb_init( blake2xb_state *S, const size_t outlen );
+ 
  int blake2xb_init_key( blake2xb_state *S, const size_t outlen, const void *key, size_t keylen );
+ 
  int blake2xb_update( blake2xb_state *S, const void *in, size_t inlen );
+ 
  int blake2xb_final(blake2xb_state *S, void *out, size_t outlen);
+
+ 
  /* Simple API */
+ 
  int blake2s( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+ 
  int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+
+ 
  int blake2sp( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+ 
  int blake2bp( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+
+ 
  int blake2xs( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+ 
  int blake2xb( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+
+ 
  /* This is simply an alias for blake2b */
+ 
  int blake2( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );



#if defined(__cplusplus)

}
modified external/blake2/blake2b-ref.c
@@ -1,14 +1,16 @@
/*

   BLAKE2 reference source code package - reference C implementations
-
- 
   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
-
- 
   To the extent possible under law, the author(s) have dedicated all copyright
- 
   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/>.
+
+ 
   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+ 
   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+ 
   your option.  The terms of these licenses can be found at:
+
+ 
   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ 
   - OpenSSL license   : https://www.openssl.org/source/license.html
+ 
   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+
+ 
   More information about the BLAKE2 hash function can be found at
+ 
   https://blake2.net.

*/



#include <stdint.h>
@@ -43,135 +45,69 @@ static const uint8_t blake2b_sigma[12][16] =
};
- 
static inline int blake2b_set_lastnode( blake2b_state *S )
- 
{
- 
  S->f[1] = ~0ULL;
- 
  return 0;
- 
}
-
- 
static inline int blake2b_clear_lastnode( blake2b_state *S )
+ 
static void blake2b_set_lastnode( blake2b_state *S )

{
- 
  S->f[1] = 0ULL;
- 
  return 0;
+ 
  S->f[1] = (uint64_t)-1;

}



/* Some helper functions, not necessarily useful */
- 
static inline int blake2b_set_lastblock( blake2b_state *S )
+ 
static int blake2b_is_lastblock( const blake2b_state *S )

{
- 
  if( S->last_node ) blake2b_set_lastnode( S );
-
- 
  S->f[0] = ~0ULL;
- 
  return 0;
+ 
  return S->f[0] != 0;

}
- 
static inline int blake2b_clear_lastblock( blake2b_state *S )
+ 
static void blake2b_set_lastblock( blake2b_state *S )

{
- 
  if( S->last_node ) blake2b_clear_lastnode( S );
+ 
  if( S->last_node ) blake2b_set_lastnode( S );
- 
  S->f[0] = 0ULL;
- 
  return 0;
+ 
  S->f[0] = (uint64_t)-1;

}
- 
static inline int 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 );
- 
  return 0;
- 
}
-
-
-
- 
// Parameter-related functions
- 
static inline int blake2b_param_set_digest_length( blake2b_param *P, const uint8_t digest_length )
- 
{
- 
  P->digest_length = digest_length;
- 
  return 0;
- 
}
-
- 
static inline int blake2b_param_set_fanout( blake2b_param *P, const uint8_t fanout )
- 
{
- 
  P->fanout = fanout;
- 
  return 0;
- 
}
-
- 
static inline int blake2b_param_set_max_depth( blake2b_param *P, const uint8_t depth )
- 
{
- 
  P->depth = depth;
- 
  return 0;

}
- 
static inline int blake2b_param_set_leaf_length( blake2b_param *P, const uint32_t leaf_length )
- 
{
- 
  store32( &P->leaf_length, leaf_length );
- 
  return 0;
- 
}
-
- 
static inline int blake2b_param_set_node_offset( blake2b_param *P, const uint64_t node_offset )
- 
{
- 
  store64( &P->node_offset, node_offset );
- 
  return 0;
- 
}
-
- 
static inline int blake2b_param_set_node_depth( blake2b_param *P, const uint8_t node_depth )
- 
{
- 
  P->node_depth = node_depth;
- 
  return 0;
- 
}
-
- 
static inline int blake2b_param_set_inner_length( blake2b_param *P, const uint8_t inner_length )
- 
{
- 
  P->inner_length = inner_length;
- 
  return 0;
- 
}
-
- 
static inline int blake2b_param_set_salt( blake2b_param *P, const uint8_t salt[BLAKE2B_SALTBYTES] )
- 
{
- 
  memcpy( P->salt, salt, BLAKE2B_SALTBYTES );
- 
  return 0;
- 
}
-
- 
static inline int blake2b_param_set_personal( blake2b_param *P, const uint8_t personal[BLAKE2B_PERSONALBYTES] )
- 
{
- 
  memcpy( P->personal, personal, BLAKE2B_PERSONALBYTES );
- 
  return 0;
- 
}
-
- 
static inline int blake2b_init0( blake2b_state *S )
+ 
static void blake2b_init0( blake2b_state *S )

{
+ 
  size_t i;

  memset( S, 0, sizeof( blake2b_state ) );
- 
  for( int i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i];
-
- 
  return 0;
+ 
  for( i = 0; i < 8; ++i ) S->h[i] = blake2b_IV[i];

}



/* init xors IV with input parameter block */

int blake2b_init_param( blake2b_state *S, const blake2b_param *P )

{
- 
  blake2b_init0( S );

  const uint8_t *p = ( const uint8_t * )( P );
+ 
  size_t i;
+
+ 
  blake2b_init0( S );



  /* IV XOR ParamBlock */
- 
  for( size_t i = 0; i < 8; ++i )
+ 
  for( i = 0; i < 8; ++i )

    S->h[i] ^= load64( p + sizeof( S->h[i] ) * i );
+ 
  S->outlen = P->digest_length;

  return 0;

}
- 
int blake2b_init( blake2b_state *S, const uint8_t outlen )
+ 
int blake2b_init( blake2b_state *S, size_t outlen )

{

  blake2b_param P[1];



  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;
- 
  P->digest_length = outlen;
+ 
  P->digest_length = (uint8_t)outlen;

  P->key_length    = 0;

  P->fanout        = 1;

  P->depth         = 1;

  store32( &P->leaf_length, 0 );
- 
  store64( &P->node_offset, 0 );
+ 
  store32( &P->node_offset, 0 );
+ 
  store32( &P->xof_length, 0 );

  P->node_depth    = 0;

  P->inner_length  = 0;

  memset( P->reserved, 0, sizeof( P->reserved ) );
@@ -181,7 +117,7 @@ int blake2b_init( blake2b_state *S, const uint8_t outlen )
}
- 
int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen )
+ 
int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen )

{

  blake2b_param P[1];
@@ -189,12 +125,13 @@ int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, c


  if ( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1;
- 
  P->digest_length = outlen;
- 
  P->key_length    = keylen;
+ 
  P->digest_length = (uint8_t)outlen;
+ 
  P->key_length    = (uint8_t)keylen;

  P->fanout        = 1;

  P->depth         = 1;

  store32( &P->leaf_length, 0 );
- 
  store64( &P->node_offset, 0 );
+ 
  store32( &P->node_offset, 0 );
+ 
  store32( &P->xof_length, 0 );

  P->node_depth    = 0;

  P->inner_length  = 0;

  memset( P->reserved, 0, sizeof( P->reserved ) );
@@ -213,39 +150,20 @@ int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, c
  return 0;

}
- 
static int blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOCKBYTES] )
- 
{
- 
  uint64_t m[16];
- 
  uint64_t v[16];
- 
  int i;
-
- 
  for( i = 0; i < 16; ++i )
- 
    m[i] = load64( block + i * sizeof( m[i] ) );
-
- 
  for( i = 0; i < 8; ++i )
- 
    v[i] = S->h[i];
-
- 
  v[ 8] = blake2b_IV[0];
- 
  v[ 9] = blake2b_IV[1];
- 
  v[10] = blake2b_IV[2];
- 
  v[11] = blake2b_IV[3];
- 
  v[12] = S->t[0] ^ blake2b_IV[4];
- 
  v[13] = S->t[1] ^ blake2b_IV[5];
- 
  v[14] = S->f[0] ^ blake2b_IV[6];
- 
  v[15] = S->f[1] ^ blake2b_IV[7];
- 
#define G(r,i,a,b,c,d) \
- 
  do { \
+ 
#define G(r,i,a,b,c,d)                      \
+ 
  do {                                      \

    a = a + b + m[blake2b_sigma[r][2*i+0]]; \
- 
    d = rotr64(d ^ a, 32); \
- 
    c = c + d; \
- 
    b = rotr64(b ^ c, 24); \
+ 
    d = rotr64(d ^ a, 32);                  \
+ 
    c = c + d;                              \
+ 
    b = rotr64(b ^ c, 24);                  \

    a = a + b + m[blake2b_sigma[r][2*i+1]]; \
- 
    d = rotr64(d ^ a, 16); \
- 
    c = c + d; \
- 
    b = rotr64(b ^ c, 63); \
+ 
    d = rotr64(d ^ a, 16);                  \
+ 
    c = c + d;                              \
+ 
    b = rotr64(b ^ c, 63);                  \

  } while(0)
- 
#define ROUND(r)  \
- 
  do { \
+
+ 
#define ROUND(r)                    \
+ 
  do {                              \

    G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \

    G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \

    G(r,2,v[ 2],v[ 6],v[10],v[14]); \
@@ -255,6 +173,30 @@ static int blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOCK
    G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \

    G(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] )
+ 
{
+ 
  uint64_t m[16];
+ 
  uint64_t v[16];
+ 
  size_t i;
+
+ 
  for( i = 0; i < 16; ++i ) {
+ 
    m[i] = load64( block + i * sizeof( m[i] ) );
+ 
  }
+
+ 
  for( i = 0; i < 8; ++i ) {
+ 
    v[i] = S->h[i];
+ 
  }
+
+ 
  v[ 8] = blake2b_IV[0];
+ 
  v[ 9] = blake2b_IV[1];
+ 
  v[10] = blake2b_IV[2];
+ 
  v[11] = blake2b_IV[3];
+ 
  v[12] = blake2b_IV[4] ^ S->t[0];
+ 
  v[13] = blake2b_IV[5] ^ S->t[1];
+ 
  v[14] = blake2b_IV[6] ^ S->f[0];
+ 
  v[15] = blake2b_IV[7] ^ S->f[1];
+ 


  ROUND( 0 );

  ROUND( 1 );

  ROUND( 2 );
@@ -268,84 +210,80 @@ static int blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOCK
  ROUND( 10 );

  ROUND( 11 );
- 
  for( i = 0; i < 8; ++i )
+ 
  for( i = 0; i < 8; ++i ) {

    S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
+ 
  }
+ 
}



#undef G

#undef ROUND
- 
  return 0;
- 
}
- 
/* inlen now in bytes */
- 
int blake2b_update( blake2b_state *S, const uint8_t *in, uint64_t inlen )
+ 
int blake2b_update( blake2b_state *S, const void *pin, size_t inlen )

{
- 
  while( inlen > 0 )
+ 
  const unsigned char * in = (const unsigned char *)pin;
+ 
  if( inlen > 0 )

  {

    size_t left = S->buflen;
- 
    size_t fill = 2 * BLAKE2B_BLOCKBYTES - left;
-
+ 
    size_t fill = BLAKE2B_BLOCKBYTES - left;

    if( inlen > fill )

    {
- 
      memcpy( S->buf + left, in, fill ); // Fill buffer
- 
      S->buflen += fill;
+ 
      S->buflen = 0;
+ 
      memcpy( S->buf + left, in, fill ); /* Fill buffer */

      blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
- 
      blake2b_compress( S, S->buf ); // Compress
- 
      memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); // Shift buffer left
- 
      S->buflen -= BLAKE2B_BLOCKBYTES;
- 
      in += fill;
- 
      inlen -= fill;
- 
    }
- 
    else // inlen <= fill
- 
    {
- 
      memcpy( S->buf + left, in, inlen );
- 
      S->buflen += inlen; // Be lazy, do not compress
- 
      in += inlen;
- 
      inlen -= inlen;
+ 
      blake2b_compress( S, S->buf ); /* Compress */
+ 
      in += fill; inlen -= fill;
+ 
      while(inlen > BLAKE2B_BLOCKBYTES) {
+ 
        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
+ 
        blake2b_compress( S, in );
+ 
        in += BLAKE2B_BLOCKBYTES;
+ 
        inlen -= BLAKE2B_BLOCKBYTES;
+ 
      }

    }
+ 
    memcpy( S->buf + S->buflen, in, inlen );
+ 
    S->buflen += inlen;

  }
- 


  return 0;

}
- 
/* Is this correct? */
- 
int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen )
+ 
int blake2b_final( blake2b_state *S, void *out, size_t outlen )

{

  uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
+ 
  size_t i;
- 
  if( outlen > BLAKE2B_OUTBYTES )
+ 
  if( out == NULL || outlen < S->outlen )

    return -1;
- 
  if( S->buflen > BLAKE2B_BLOCKBYTES )
- 
  {
- 
    blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
- 
    blake2b_compress( S, S->buf );
- 
    S->buflen -= BLAKE2B_BLOCKBYTES;
- 
    memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, S->buflen );
- 
  }
+ 
  if( blake2b_is_lastblock( S ) )
+ 
    return -1;



  blake2b_increment_counter( S, S->buflen );

  blake2b_set_lastblock( S );
- 
  memset( S->buf + S->buflen, 0, 2 * BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
+ 
  memset( S->buf + S->buflen, 0, BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */

  blake2b_compress( S, S->buf );
- 
  for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
+ 
  for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */

    store64( buffer + sizeof( S->h[i] ) * i, S->h[i] );
- 
  memcpy( out, buffer, outlen );
+ 
  memcpy( out, buffer, S->outlen );
+ 
  secure_zero_memory(buffer, sizeof(buffer));

  return 0;

}



/* inlen, at least, should be uint64_t. Others can be size_t. */
- 
int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
+ 
int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen )

{

  blake2b_state S[1];



  /* Verify parameters */
- 
  if ( NULL == in ) return -1;
+ 
  if ( NULL == in && inlen > 0 ) return -1;



  if ( NULL == out ) return -1;
- 
  if( NULL == key ) keylen = 0;
+ 
  if( NULL == key && keylen > 0 ) return -1;
+
+ 
  if( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1;
+
+ 
  if( keylen > BLAKE2B_KEYBYTES ) return -1;



  if( keylen > 0 )

  {
@@ -361,34 +299,82 @@ int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen
  return 0;

}
+ 
int blake2( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ) {
+ 
  return blake2b(out, outlen, in, inlen, key, keylen);
+ 
}
+
+ 
#if defined(SUPERCOP)
+ 
int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen )
+ 
{
+ 
  return blake2b( out, BLAKE2B_OUTBYTES, in, inlen, NULL, 0 );
+ 
}
+ 
#endif
+ 


#if defined(BLAKE2B_SELFTEST)

#include <string.h>

#include "blake2-kat.h"
- 
int main( int argc, char **argv )
+ 
int main( void )

{

  uint8_t key[BLAKE2B_KEYBYTES];
- 
  uint8_t buf[KAT_LENGTH];
+ 
  uint8_t buf[BLAKE2_KAT_LENGTH];
+ 
  size_t i, step;
- 
  for( size_t i = 0; i < BLAKE2B_KEYBYTES; ++i )
+ 
  for( i = 0; i < BLAKE2B_KEYBYTES; ++i )

    key[i] = ( uint8_t )i;
- 
  for( size_t i = 0; i < KAT_LENGTH; ++i )
+ 
  for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )

    buf[i] = ( uint8_t )i;
- 
  for( size_t i = 0; i < KAT_LENGTH; ++i )
+ 
  /* Test simple API */
+ 
  for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )

  {

    uint8_t hash[BLAKE2B_OUTBYTES];
- 
    blake2b( hash, buf, key, BLAKE2B_OUTBYTES, i, BLAKE2B_KEYBYTES );
+ 
    blake2b( hash, BLAKE2B_OUTBYTES, buf, i, key, BLAKE2B_KEYBYTES );



    if( 0 != memcmp( hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES ) )

    {
- 
      puts( "error" );
- 
      return -1;
+ 
      goto fail;
+ 
    }
+ 
  }
+
+ 
  /* Test streaming API */
+ 
  for(step = 1; step < BLAKE2B_BLOCKBYTES; ++step) {
+ 
    for (i = 0; i < BLAKE2_KAT_LENGTH; ++i) {
+ 
      uint8_t hash[BLAKE2B_OUTBYTES];
+ 
      blake2b_state S;
+ 
      uint8_t * p = buf;
+ 
      size_t mlen = i;
+ 
      int err = 0;
+
+ 
      if( (err = blake2b_init_key(&S, BLAKE2B_OUTBYTES, key, BLAKE2B_KEYBYTES)) < 0 ) {
+ 
        goto fail;
+ 
      }
+
+ 
      while (mlen >= step) {
+ 
        if ( (err = blake2b_update(&S, p, step)) < 0 ) {
+ 
          goto fail;
+ 
        }
+ 
        mlen -= step;
+ 
        p += step;
+ 
      }
+ 
      if ( (err = blake2b_update(&S, p, mlen)) < 0) {
+ 
        goto fail;
+ 
      }
+ 
      if ( (err = blake2b_final(&S, hash, BLAKE2B_OUTBYTES)) < 0) {
+ 
        goto fail;
+ 
      }
+
+ 
      if (0 != memcmp(hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES)) {
+ 
        goto fail;
+ 
      }

    }

  }



  puts( "ok" );

  return 0;
+ 
fail:
+ 
  puts("error");
+ 
  return -1;

}

#endif
modified libpkg/pkg_checksum.c
@@ -424,7 +424,7 @@ pkg_checksum_hash_blake2_bulk(const unsigned char *in, size_t inlen,
				unsigned char **out, size_t *outlen)

{

	*out = malloc(BLAKE2B_OUTBYTES);
- 
	blake2b(*out, in, NULL, BLAKE2B_OUTBYTES, inlen, 0);
+ 
	blake2b(*out, BLAKE2B_OUTBYTES,  in, inlen, NULL, 0);

	*outlen = BLAKE2B_OUTBYTES;

}