Lib: Add Blake2s and Blake2b hash functions
The Babel MAC authentication RFC recommends implementing Blake2s as one of the supported algorithms. In order to achieve do this, add the blake2b and blake2s hash functions for MAC authentication. The hashing function implementations are the reference implementations from blake2.net. The Blake2 algorithms allow specifying an arbitrary output size, and the Babel MAC spec says to implement Blake2s with 128-bit output. To satisfy this, we add two different variants of each of the algorithms, one using the default size (256 bits for Blake2s, 512 bits for Blake2b), and one using half the default output size. Update to BIRD coding style done by committer.
This commit is contained in:
Toke Høiland-Jørgensen
Ondrej Zajicek (work)
parent
e5724f71d2
commit
725d9af94a
10 changed files with 975 additions and 8 deletions
|
|
@ -820,7 +820,7 @@ agreement").
|
|||
<tag><label id="proto-pass-to">to "<m/time/"</tag>
|
||||
Shorthand for setting both <cf/generate to/ and <cf/accept to/.
|
||||
|
||||
<tag><label id="proto-pass-algorithm">algorithm ( keyed md5 | keyed sha1 | hmac sha1 | hmac sha256 | hmac sha384 | hmac sha512 )</tag>
|
||||
<tag><label id="proto-pass-algorithm">algorithm ( keyed md5 | keyed sha1 | hmac sha1 | hmac sha256 | hmac sha384 | hmac sha512 | blake2s128 | blake2s256 | blake2b256 | blake2b512 )</tag>
|
||||
The message authentication algorithm for the password when cryptographic
|
||||
authentication is enabled. The default value depends on the protocol.
|
||||
For RIP and OSPFv2 it is Keyed-MD5 (for compatibility), for OSPFv3
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
src := bitmap.c bitops.c checksum.c event.c flowspec.c idm.c ip.c lists.c mac.c md5.c mempool.c net.c patmatch.c printf.c resource.c sha1.c sha256.c sha512.c slab.c slists.c strtoul.c tbf.c timer.c xmalloc.c
|
||||
src := bitmap.c bitops.c blake2s.c blake2b.c checksum.c event.c flowspec.c idm.c ip.c lists.c mac.c md5.c mempool.c net.c patmatch.c printf.c resource.c sha1.c sha256.c sha512.c slab.c slists.c strtoul.c tbf.c timer.c xmalloc.c
|
||||
obj := $(src-o-files)
|
||||
$(all-daemon)
|
||||
|
||||
|
|
|
|||
|
|
@ -74,6 +74,8 @@ static inline int u64_cmp(u64 i1, u64 i2)
|
|||
#define PACKED __attribute__((packed))
|
||||
#define NONNULL(...) __attribute__((nonnull((__VA_ARGS__))))
|
||||
|
||||
#define STATIC_ASSERT(...) _Static_assert(__VA_ARGS__)
|
||||
|
||||
#ifndef HAVE_THREAD_LOCAL
|
||||
#define _Thread_local
|
||||
#endif
|
||||
|
|
|
|||
153
lib/blake2-impl.h
Normal file
153
lib/blake2-impl.h
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
/*
|
||||
* BIRD Library -- BLAKE2 Support Code
|
||||
*
|
||||
* Based on the code from BLAKE2 reference source code package
|
||||
*
|
||||
* 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 : https://creativecommons.org/publicdomain/zero/1.0
|
||||
* - OpenSSL license : https://www.openssl.org/source/license.html
|
||||
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* More information about the BLAKE2 hash function can be found at
|
||||
* https://blake2.net/ web.
|
||||
*/
|
||||
|
||||
#ifndef _BIRD_BLAKE2_IMPL_H_
|
||||
#define _BIRD_BLAKE2_IMPL_H_
|
||||
|
||||
#include "nest/bird.h"
|
||||
|
||||
|
||||
static inline u32 load32(const void *src)
|
||||
{
|
||||
#if !defined(CPU_BIG_ENDIAN)
|
||||
u32 w;
|
||||
memcpy(&w, src, sizeof w);
|
||||
return w;
|
||||
#else
|
||||
const u8 *p = (const u8 *) src;
|
||||
return ((u32) (p[0]) << 0) |
|
||||
((u32) (p[1]) << 8) |
|
||||
((u32) (p[2]) << 16) |
|
||||
((u32) (p[3]) << 24) ;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline u64 load64(const void *src)
|
||||
{
|
||||
#if !defined(CPU_BIG_ENDIAN)
|
||||
u64 w;
|
||||
memcpy(&w, src, sizeof w);
|
||||
return w;
|
||||
#else
|
||||
const u8 *p = (const u8 *) src;
|
||||
return ((u64) (p[0]) << 0) |
|
||||
((u64) (p[1]) << 8) |
|
||||
((u64) (p[2]) << 16) |
|
||||
((u64) (p[3]) << 24) |
|
||||
((u64) (p[4]) << 32) |
|
||||
((u64) (p[5]) << 40) |
|
||||
((u64) (p[6]) << 48) |
|
||||
((u64) (p[7]) << 56) ;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline u16 load16(const void *src)
|
||||
{
|
||||
#if !defined(CPU_BIG_ENDIAN)
|
||||
u16 w;
|
||||
memcpy(&w, src, sizeof w);
|
||||
return w;
|
||||
#else
|
||||
const u8 *p = (const u8 *) src;
|
||||
return (u16) (((u32) (p[0]) << 0) |
|
||||
((u32) (p[1]) << 8));
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void store16(void *dst, u16 w)
|
||||
{
|
||||
#if !defined(CPU_BIG_ENDIAN)
|
||||
memcpy(dst, &w, sizeof w);
|
||||
#else
|
||||
u8 *p = (u8 *) dst;
|
||||
*p++ = (u8)w; w >>= 8;
|
||||
*p++ = (u8)w;
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void store32(void *dst, u32 w)
|
||||
{
|
||||
#if !defined(CPU_BIG_ENDIAN)
|
||||
memcpy(dst, &w, sizeof w);
|
||||
#else
|
||||
u8 *p = (u8 *)dst;
|
||||
p[0] = (u8) (w >> 0);
|
||||
p[1] = (u8) (w >> 8);
|
||||
p[2] = (u8) (w >> 16);
|
||||
p[3] = (u8) (w >> 24);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void store64(void *dst, u64 w)
|
||||
{
|
||||
#if !defined(CPU_BIG_ENDIAN)
|
||||
memcpy(dst, &w, sizeof w);
|
||||
#else
|
||||
u8 *p = (u8 *) dst;
|
||||
p[0] = (u8) (w >> 0);
|
||||
p[1] = (u8) (w >> 8);
|
||||
p[2] = (u8) (w >> 16);
|
||||
p[3] = (u8) (w >> 24);
|
||||
p[4] = (u8) (w >> 32);
|
||||
p[5] = (u8) (w >> 40);
|
||||
p[6] = (u8) (w >> 48);
|
||||
p[7] = (u8) (w >> 56);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline u64 load48(const void *src)
|
||||
{
|
||||
const u8 *p = (const u8 *) src;
|
||||
return ((u64) (p[0]) << 0) |
|
||||
((u64) (p[1]) << 8) |
|
||||
((u64) (p[2]) << 16) |
|
||||
((u64) (p[3]) << 24) |
|
||||
((u64) (p[4]) << 32) |
|
||||
((u64) (p[5]) << 40) ;
|
||||
}
|
||||
|
||||
static inline void store48(void *dst, u64 w)
|
||||
{
|
||||
u8 *p = (u8 *) dst;
|
||||
p[0] = (u8) (w >> 0);
|
||||
p[1] = (u8) (w >> 8);
|
||||
p[2] = (u8) (w >> 16);
|
||||
p[3] = (u8) (w >> 24);
|
||||
p[4] = (u8) (w >> 32);
|
||||
p[5] = (u8) (w >> 40);
|
||||
}
|
||||
|
||||
static inline u32 rotr32(const u32 w, const uint c)
|
||||
{
|
||||
return (w >> c) | (w << (32 - c));
|
||||
}
|
||||
|
||||
static inline u64 rotr64(const u64 w, const uint c)
|
||||
{
|
||||
return (w >> c) | (w << (64 - c));
|
||||
}
|
||||
|
||||
/* prevents compiler optimizing out memset() */
|
||||
static inline void secure_zero_memory(void *v, size_t n)
|
||||
{
|
||||
static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
|
||||
memset_v(v, 0, n);
|
||||
}
|
||||
|
||||
#endif
|
||||
148
lib/blake2.h
Normal file
148
lib/blake2.h
Normal file
|
|
@ -0,0 +1,148 @@
|
|||
/*
|
||||
* BIRD Library -- BLAKE2 Hash Functions
|
||||
*
|
||||
* Based on the code from BLAKE2 reference source code package
|
||||
*
|
||||
* 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 : https://creativecommons.org/publicdomain/zero/1.0
|
||||
* - OpenSSL license : https://www.openssl.org/source/license.html
|
||||
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* More information about the BLAKE2 hash function can be found at
|
||||
* https://blake2.net/ web.
|
||||
*/
|
||||
|
||||
#ifndef _BIRD_BLAKE2_H_
|
||||
#define _BIRD_BLAKE2_H_
|
||||
|
||||
#include "nest/bird.h"
|
||||
|
||||
|
||||
enum blake2s_constant
|
||||
{
|
||||
BLAKE2S_BLOCKBYTES = 64,
|
||||
BLAKE2S_OUTBYTES = 32,
|
||||
BLAKE2S_KEYBYTES = 32,
|
||||
BLAKE2S_SALTBYTES = 8,
|
||||
BLAKE2S_PERSONALBYTES = 8,
|
||||
};
|
||||
|
||||
enum blake2b_constant
|
||||
{
|
||||
BLAKE2B_BLOCKBYTES = 128,
|
||||
BLAKE2B_OUTBYTES = 64,
|
||||
BLAKE2B_KEYBYTES = 64,
|
||||
BLAKE2B_SALTBYTES = 16,
|
||||
BLAKE2B_PERSONALBYTES = 16,
|
||||
};
|
||||
|
||||
#define BLAKE2S_SIZE 32 // BLAKE2S_OUTBYTES
|
||||
#define BLAKE2S_BLOCK_SIZE 64 // BLAKE2S_BLOCKBYTES
|
||||
#define BLAKE2S_256_SIZE 32
|
||||
|
||||
#define BLAKE2B_SIZE 64 // BLAKE2B_OUTBYTES
|
||||
#define BLAKE2B_BLOCK_SIZE 128 // BLAKE2B_BLOCKBYTES
|
||||
#define BLAKE2B_512_SIZE 64
|
||||
|
||||
|
||||
struct blake2s_state
|
||||
{
|
||||
u32 h[8];
|
||||
u32 t[2];
|
||||
u32 f[2];
|
||||
byte buf[BLAKE2S_BLOCK_SIZE];
|
||||
uint buflen;
|
||||
uint outlen;
|
||||
u8 last_node;
|
||||
};
|
||||
|
||||
struct blake2b_state
|
||||
{
|
||||
u64 h[8];
|
||||
u64 t[2];
|
||||
u64 f[2];
|
||||
byte buf[BLAKE2B_BLOCK_SIZE];
|
||||
uint buflen;
|
||||
uint outlen;
|
||||
u8 last_node;
|
||||
};
|
||||
|
||||
struct blake2s_param
|
||||
{
|
||||
u8 digest_length; /* 1 */
|
||||
u8 key_length; /* 2 */
|
||||
u8 fanout; /* 3 */
|
||||
u8 depth; /* 4 */
|
||||
u32 leaf_length; /* 8 */
|
||||
u32 node_offset; /* 12 */
|
||||
u16 xof_length; /* 14 */
|
||||
u8 node_depth; /* 15 */
|
||||
u8 inner_length; /* 16 */
|
||||
/* byte reserved[0]; */
|
||||
byte salt[BLAKE2S_SALTBYTES]; /* 24 */
|
||||
byte personal[BLAKE2S_PERSONALBYTES]; /* 32 */
|
||||
} PACKED;
|
||||
|
||||
struct blake2b_param
|
||||
{
|
||||
u8 digest_length; /* 1 */
|
||||
u8 key_length; /* 2 */
|
||||
u8 fanout; /* 3 */
|
||||
u8 depth; /* 4 */
|
||||
u32 leaf_length; /* 8 */
|
||||
u32 node_offset; /* 12 */
|
||||
u32 xof_length; /* 16 */
|
||||
u8 node_depth; /* 17 */
|
||||
u8 inner_length; /* 18 */
|
||||
byte reserved[14]; /* 32 */
|
||||
byte salt[BLAKE2B_SALTBYTES]; /* 48 */
|
||||
byte personal[BLAKE2B_PERSONALBYTES]; /* 64 */
|
||||
} PACKED;
|
||||
|
||||
|
||||
/* Streaming API */
|
||||
int blake2s_init(struct blake2s_state *s, size_t outlen);
|
||||
int blake2s_init_key(struct blake2s_state *s, size_t outlen, const void *key, size_t keylen);
|
||||
int blake2s_init_param(struct blake2s_state *s, const struct blake2s_param *p);
|
||||
int blake2s_update(struct blake2s_state *s, const void *in, size_t inlen);
|
||||
int blake2s_final(struct blake2s_state *s, void *out, size_t outlen);
|
||||
|
||||
int blake2b_init(struct blake2b_state *s, size_t outlen);
|
||||
int blake2b_init_key(struct blake2b_state *s, size_t outlen, const void *key, size_t keylen);
|
||||
int blake2b_init_param(struct blake2b_state *s, const struct blake2b_param *p);
|
||||
int blake2b_update(struct blake2b_state *s, const void *in, size_t inlen);
|
||||
int blake2b_final(struct blake2b_state *s, void *out, size_t outlen);
|
||||
|
||||
|
||||
/* Wrapper functions for MAC class */
|
||||
|
||||
struct mac_desc;
|
||||
struct mac_context;
|
||||
|
||||
struct blake2s_context {
|
||||
const struct mac_desc *type;
|
||||
struct blake2s_state state;
|
||||
byte buf[BLAKE2S_SIZE];
|
||||
};
|
||||
|
||||
struct blake2b_context {
|
||||
const struct mac_desc *type;
|
||||
struct blake2b_state state;
|
||||
byte buf[BLAKE2B_SIZE];
|
||||
};
|
||||
|
||||
|
||||
void blake2s_mac_init(struct mac_context *ctx, const byte *key, uint keylen);
|
||||
void blake2s_mac_update(struct mac_context *ctx, const byte *data, uint datalen);
|
||||
byte *blake2s_mac_final(struct mac_context *ctx);
|
||||
|
||||
void blake2b_mac_init(struct mac_context *ctx, const byte *key, uint keylen);
|
||||
void blake2b_mac_update(struct mac_context *ctx, const byte *data, uint datalen);
|
||||
byte *blake2b_mac_final(struct mac_context *ctx);
|
||||
|
||||
#endif /* _BIRD_BLAKE2_H_ */
|
||||
322
lib/blake2b.c
Normal file
322
lib/blake2b.c
Normal file
|
|
@ -0,0 +1,322 @@
|
|||
/*
|
||||
* BIRD Library -- BLAKE2b Hash Function
|
||||
*
|
||||
* Based on the code from BLAKE2 reference source code package
|
||||
*
|
||||
* 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 : https://creativecommons.org/publicdomain/zero/1.0
|
||||
* - OpenSSL license : https://www.openssl.org/source/license.html
|
||||
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* More information about the BLAKE2 hash function can be found at
|
||||
* https://blake2.net/ web.
|
||||
*/
|
||||
|
||||
#include "lib/mac.h"
|
||||
#include "lib/blake2.h"
|
||||
#include "lib/blake2-impl.h"
|
||||
|
||||
|
||||
static const u64 blake2b_IV[8] =
|
||||
{
|
||||
U64(0x6a09e667f3bcc908),
|
||||
U64(0xbb67ae8584caa73b),
|
||||
U64(0x3c6ef372fe94f82b),
|
||||
U64(0xa54ff53a5f1d36f1),
|
||||
U64(0x510e527fade682d1),
|
||||
U64(0x9b05688c2b3e6c1f),
|
||||
U64(0x1f83d9abfb41bd6b),
|
||||
U64(0x5be0cd19137e2179)
|
||||
};
|
||||
|
||||
static const u8 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 },
|
||||
{ 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 },
|
||||
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
{ 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 },
|
||||
};
|
||||
|
||||
STATIC_ASSERT(sizeof(struct blake2b_param) == BLAKE2B_OUTBYTES);
|
||||
|
||||
|
||||
static inline void
|
||||
blake2b_set_lastnode(struct blake2b_state *s)
|
||||
{
|
||||
s->f[1] = (u64) -1;
|
||||
}
|
||||
|
||||
/* Some helper functions, not necessarily useful */
|
||||
static inline int
|
||||
blake2b_is_lastblock(const struct blake2b_state *s)
|
||||
{
|
||||
return s->f[0] != 0;
|
||||
}
|
||||
|
||||
static inline void
|
||||
blake2b_set_lastblock(struct blake2b_state *s)
|
||||
{
|
||||
if (s->last_node)
|
||||
blake2b_set_lastnode(s);
|
||||
|
||||
s->f[0] = (u64) -1;
|
||||
}
|
||||
|
||||
static inline void
|
||||
blake2b_increment_counter(struct blake2b_state *s, const u64 inc)
|
||||
{
|
||||
s->t[0] += inc;
|
||||
s->t[1] += (s->t[0] < inc);
|
||||
}
|
||||
|
||||
static void
|
||||
blake2b_init0(struct blake2b_state *s)
|
||||
{
|
||||
memset(s, 0, sizeof(struct blake2b_state));
|
||||
|
||||
for (uint i = 0; i < 8; ++i)
|
||||
s->h[i] = blake2b_IV[i];
|
||||
}
|
||||
|
||||
/* init xors IV with input parameter block */
|
||||
int
|
||||
blake2b_init_param(struct blake2b_state *s, const struct blake2b_param *p)
|
||||
{
|
||||
const byte *pb = (const void *) p;
|
||||
|
||||
blake2b_init0(s);
|
||||
|
||||
/* IV XOR ParamBlock */
|
||||
for (uint i = 0; i < 8; ++i)
|
||||
s->h[i] ^= load64(pb + sizeof(s->h[i]) * i);
|
||||
|
||||
s->outlen = p->digest_length;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
blake2b_init(struct blake2b_state *s, size_t outlen)
|
||||
{
|
||||
struct blake2b_param p[1];
|
||||
|
||||
if (!outlen || (outlen > BLAKE2B_OUTBYTES))
|
||||
return -1;
|
||||
|
||||
p->digest_length = (uint8_t) outlen;
|
||||
p->key_length = 0;
|
||||
p->fanout = 1;
|
||||
p->depth = 1;
|
||||
store32(&p->leaf_length, 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));
|
||||
memset(p->salt, 0, sizeof(p->salt));
|
||||
memset(p->personal, 0, sizeof(p->personal));
|
||||
|
||||
return blake2b_init_param(s, p);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
blake2b_init_key(struct blake2b_state *s, size_t outlen, const void *key, size_t keylen)
|
||||
{
|
||||
struct blake2b_param p[1];
|
||||
|
||||
if (!outlen || (outlen > BLAKE2B_OUTBYTES))
|
||||
return -1;
|
||||
|
||||
if (!key || !keylen || (keylen > BLAKE2B_KEYBYTES))
|
||||
return -1;
|
||||
|
||||
p->digest_length = (uint8_t) outlen;
|
||||
p->key_length = (uint8_t) keylen;
|
||||
p->fanout = 1;
|
||||
p->depth = 1;
|
||||
store32(&p->leaf_length, 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));
|
||||
memset(p->salt, 0, sizeof(p->salt));
|
||||
memset(p->personal, 0, sizeof(p->personal));
|
||||
|
||||
if (blake2b_init_param(s, p) < 0)
|
||||
return -1;
|
||||
|
||||
{
|
||||
byte block[BLAKE2B_BLOCKBYTES];
|
||||
memset(block, 0, BLAKE2B_BLOCKBYTES);
|
||||
memcpy(block, key, keylen);
|
||||
blake2b_update(s, block, BLAKE2B_BLOCKBYTES);
|
||||
secure_zero_memory(block, BLAKE2B_BLOCKBYTES); /* Burn the key from stack */
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#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); \
|
||||
a = a + b + m[blake2b_sigma[r][2*i+1]]; \
|
||||
d = rotr64(d ^ a, 16); \
|
||||
c = c + d; \
|
||||
b = rotr64(b ^ c, 63); \
|
||||
} while(0)
|
||||
|
||||
#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]); \
|
||||
G(r,3,v[ 3],v[ 7],v[11],v[15]); \
|
||||
G(r,4,v[ 0],v[ 5],v[10],v[15]); \
|
||||
G(r,5,v[ 1],v[ 6],v[11],v[12]); \
|
||||
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(struct blake2b_state *s, const byte block[BLAKE2B_BLOCKBYTES])
|
||||
{
|
||||
u64 m[16];
|
||||
u64 v[16];
|
||||
uint 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);
|
||||
ROUND(3);
|
||||
ROUND(4);
|
||||
ROUND(5);
|
||||
ROUND(6);
|
||||
ROUND(7);
|
||||
ROUND(8);
|
||||
ROUND(9);
|
||||
ROUND(10);
|
||||
ROUND(11);
|
||||
|
||||
for (i = 0; i < 8; ++i)
|
||||
s->h[i] = s->h[i] ^ v[i] ^ v[i + 8];
|
||||
}
|
||||
|
||||
#undef G
|
||||
#undef ROUND
|
||||
|
||||
int
|
||||
blake2b_update(struct blake2b_state *s, const void *pin, size_t inlen)
|
||||
{
|
||||
const byte *in = pin;
|
||||
|
||||
if (inlen > 0)
|
||||
{
|
||||
size_t left = s->buflen;
|
||||
size_t fill = BLAKE2B_BLOCKBYTES - left;
|
||||
|
||||
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;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
int
|
||||
blake2b_final(struct blake2b_state *s, void *out, size_t outlen)
|
||||
{
|
||||
byte buffer[BLAKE2B_OUTBYTES] = {0};
|
||||
|
||||
if (!out || (outlen < s->outlen))
|
||||
return -1;
|
||||
|
||||
if (blake2b_is_lastblock(s))
|
||||
return -1;
|
||||
|
||||
blake2b_increment_counter(s, s->buflen);
|
||||
blake2b_set_lastblock(s);
|
||||
memset(s->buf + s->buflen, 0, BLAKE2B_BLOCKBYTES - s->buflen); /* Padding */
|
||||
blake2b_compress(s, s->buf);
|
||||
|
||||
/* Output full hash to temp buffer */
|
||||
for (uint i = 0; i < 8; ++i)
|
||||
store64(buffer + sizeof(s->h[i]) * i, s->h[i]);
|
||||
|
||||
memcpy(out, buffer, s->outlen);
|
||||
secure_zero_memory(buffer, sizeof(buffer));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
blake2b_mac_init(struct mac_context *mac, const byte *key, uint keylen)
|
||||
{
|
||||
struct blake2b_context *ctx = (void *) mac;
|
||||
blake2b_init_key(&ctx->state, mac_get_length(mac), key, keylen);
|
||||
}
|
||||
|
||||
void
|
||||
blake2b_mac_update(struct mac_context *mac, const byte *buf, uint len)
|
||||
{
|
||||
struct blake2b_context *ctx = (void *) mac;
|
||||
blake2b_update(&ctx->state, buf, len);
|
||||
}
|
||||
|
||||
byte *
|
||||
blake2b_mac_final(struct mac_context *mac)
|
||||
{
|
||||
struct blake2b_context *ctx = (void *) mac;
|
||||
blake2b_final(&ctx->state, ctx->buf, mac_get_length(mac));
|
||||
return ctx->buf;
|
||||
}
|
||||
313
lib/blake2s.c
Normal file
313
lib/blake2s.c
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
/*
|
||||
* BIRD Library -- BLAKE2s Hash Function
|
||||
*
|
||||
* Based on the code from BLAKE2 reference source code package
|
||||
*
|
||||
* 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 : https://creativecommons.org/publicdomain/zero/1.0
|
||||
* - OpenSSL license : https://www.openssl.org/source/license.html
|
||||
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* More information about the BLAKE2 hash function can be found at
|
||||
* https://blake2.net/ web.
|
||||
*/
|
||||
|
||||
#include "lib/mac.h"
|
||||
#include "lib/blake2.h"
|
||||
#include "lib/blake2-impl.h"
|
||||
|
||||
|
||||
static const u32 blake2s_IV[8] =
|
||||
{
|
||||
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
|
||||
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
|
||||
};
|
||||
|
||||
static const u8 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 },
|
||||
{ 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 },
|
||||
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
|
||||
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
|
||||
{ 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 },
|
||||
};
|
||||
|
||||
STATIC_ASSERT(sizeof(struct blake2s_param) == BLAKE2S_OUTBYTES);
|
||||
|
||||
|
||||
static inline void
|
||||
blake2s_set_lastnode(struct blake2s_state *s)
|
||||
{
|
||||
s->f[1] = (u32) -1;
|
||||
}
|
||||
|
||||
/* Some helper functions, not necessarily useful */
|
||||
static inline int
|
||||
blake2s_is_lastblock(const struct blake2s_state *s)
|
||||
{
|
||||
return s->f[0] != 0;
|
||||
}
|
||||
|
||||
static inline void
|
||||
blake2s_set_lastblock(struct blake2s_state *s)
|
||||
{
|
||||
if (s->last_node)
|
||||
blake2s_set_lastnode(s);
|
||||
|
||||
s->f[0] = (u32) -1;
|
||||
}
|
||||
|
||||
static inline void
|
||||
blake2s_increment_counter(struct blake2s_state *s, const u32 inc)
|
||||
{
|
||||
s->t[0] += inc;
|
||||
s->t[1] += (s->t[0] < inc);
|
||||
}
|
||||
|
||||
static void
|
||||
blake2s_init0(struct blake2s_state *s)
|
||||
{
|
||||
memset(s, 0, sizeof(struct blake2s_state));
|
||||
|
||||
for (uint i = 0; i < 8; ++i)
|
||||
s->h[i] = blake2s_IV[i];
|
||||
}
|
||||
|
||||
/* init2 xors IV with input parameter block */
|
||||
int
|
||||
blake2s_init_param(struct blake2s_state *s, const struct blake2s_param *p)
|
||||
{
|
||||
const byte *pb = (const void *) p;
|
||||
|
||||
blake2s_init0(s);
|
||||
|
||||
/* IV XOR ParamBlock */
|
||||
for (uint i = 0; i < 8; ++i)
|
||||
s->h[i] ^= load32(&pb[i * 4]);
|
||||
|
||||
s->outlen = p->digest_length;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Sequential blake2s initialization */
|
||||
int
|
||||
blake2s_init(struct blake2s_state *s, size_t outlen)
|
||||
{
|
||||
struct blake2s_param p[1];
|
||||
|
||||
/* Move interval verification here? */
|
||||
if (!outlen || (outlen > BLAKE2S_OUTBYTES))
|
||||
return -1;
|
||||
|
||||
p->digest_length = (uint8_t) outlen;
|
||||
p->key_length = 0;
|
||||
p->fanout = 1;
|
||||
p->depth = 1;
|
||||
store32(&p->leaf_length, 0);
|
||||
store32(&p->node_offset, 0);
|
||||
store16(&p->xof_length, 0);
|
||||
p->node_depth = 0;
|
||||
p->inner_length = 0;
|
||||
/* memset(p->reserved, 0, sizeof(p->reserved)); */
|
||||
memset(p->salt, 0, sizeof(p->salt));
|
||||
memset(p->personal, 0, sizeof(p->personal));
|
||||
|
||||
return blake2s_init_param(s, p);
|
||||
}
|
||||
|
||||
int
|
||||
blake2s_init_key(struct blake2s_state *s, size_t outlen, const void *key, size_t keylen)
|
||||
{
|
||||
struct blake2s_param p[1];
|
||||
|
||||
if (!outlen || (outlen > BLAKE2S_OUTBYTES))
|
||||
return -1;
|
||||
|
||||
if (!key || !keylen || (keylen > BLAKE2S_KEYBYTES))
|
||||
return -1;
|
||||
|
||||
p->digest_length = (uint8_t) outlen;
|
||||
p->key_length = (uint8_t) keylen;
|
||||
p->fanout = 1;
|
||||
p->depth = 1;
|
||||
store32(&p->leaf_length, 0);
|
||||
store32(&p->node_offset, 0);
|
||||
store16(&p->xof_length, 0);
|
||||
p->node_depth = 0;
|
||||
p->inner_length = 0;
|
||||
/* memset(p->reserved, 0, sizeof(p->reserved)); */
|
||||
memset(p->salt, 0, sizeof(p->salt));
|
||||
memset(p->personal, 0, sizeof(p->personal));
|
||||
|
||||
if (blake2s_init_param(s, p) < 0)
|
||||
return -1;
|
||||
|
||||
{
|
||||
byte block[BLAKE2S_BLOCKBYTES];
|
||||
memset(block, 0, BLAKE2S_BLOCKBYTES);
|
||||
memcpy(block, key, keylen);
|
||||
blake2s_update(s, block, BLAKE2S_BLOCKBYTES);
|
||||
secure_zero_memory(block, BLAKE2S_BLOCKBYTES); /* Burn the key from stack */
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define G(r,i,a,b,c,d) \
|
||||
do { \
|
||||
a = a + b + m[blake2s_sigma[r][2*i+0]]; \
|
||||
d = rotr32(d ^ a, 16); \
|
||||
c = c + d; \
|
||||
b = rotr32(b ^ c, 12); \
|
||||
a = a + b + m[blake2s_sigma[r][2*i+1]]; \
|
||||
d = rotr32(d ^ a, 8); \
|
||||
c = c + d; \
|
||||
b = rotr32(b ^ c, 7); \
|
||||
} while(0)
|
||||
|
||||
#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]); \
|
||||
G(r,3,v[ 3],v[ 7],v[11],v[15]); \
|
||||
G(r,4,v[ 0],v[ 5],v[10],v[15]); \
|
||||
G(r,5,v[ 1],v[ 6],v[11],v[12]); \
|
||||
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
|
||||
blake2s_compress(struct blake2s_state *s, const byte in[BLAKE2S_BLOCKBYTES])
|
||||
{
|
||||
u32 m[16];
|
||||
u32 v[16];
|
||||
uint i;
|
||||
|
||||
for (i = 0; i < 16; ++i)
|
||||
m[i] = load32(in + i * sizeof(m[i]));
|
||||
|
||||
for (i = 0; i < 8; ++i)
|
||||
v[i] = s->h[i];
|
||||
|
||||
v[ 8] = blake2s_IV[0];
|
||||
v[ 9] = blake2s_IV[1];
|
||||
v[10] = blake2s_IV[2];
|
||||
v[11] = blake2s_IV[3];
|
||||
v[12] = s->t[0] ^ blake2s_IV[4];
|
||||
v[13] = s->t[1] ^ blake2s_IV[5];
|
||||
v[14] = s->f[0] ^ blake2s_IV[6];
|
||||
v[15] = s->f[1] ^ blake2s_IV[7];
|
||||
|
||||
ROUND(0);
|
||||
ROUND(1);
|
||||
ROUND(2);
|
||||
ROUND(3);
|
||||
ROUND(4);
|
||||
ROUND(5);
|
||||
ROUND(6);
|
||||
ROUND(7);
|
||||
ROUND(8);
|
||||
ROUND(9);
|
||||
|
||||
for (i = 0; i < 8; ++i)
|
||||
s->h[i] = s->h[i] ^ v[i] ^ v[i + 8];
|
||||
}
|
||||
|
||||
#undef G
|
||||
#undef ROUND
|
||||
|
||||
int
|
||||
blake2s_update(struct blake2s_state *s, const void *pin, size_t inlen)
|
||||
{
|
||||
const byte *in = pin;
|
||||
|
||||
if (inlen > 0)
|
||||
{
|
||||
size_t left = s->buflen;
|
||||
size_t fill = BLAKE2S_BLOCKBYTES - left;
|
||||
|
||||
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;
|
||||
|
||||
while (inlen > BLAKE2S_BLOCKBYTES)
|
||||
{
|
||||
blake2s_increment_counter(s, BLAKE2S_BLOCKBYTES);
|
||||
blake2s_compress(s, in);
|
||||
in += BLAKE2S_BLOCKBYTES;
|
||||
inlen -= BLAKE2S_BLOCKBYTES;
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(s->buf + s->buflen, in, inlen);
|
||||
s->buflen += inlen;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
blake2s_final(struct blake2s_state *s, void *out, size_t outlen)
|
||||
{
|
||||
byte buffer[BLAKE2S_OUTBYTES] = {0};
|
||||
|
||||
if (!out || (outlen < s->outlen))
|
||||
return -1;
|
||||
|
||||
if (blake2s_is_lastblock(s))
|
||||
return -1;
|
||||
|
||||
blake2s_increment_counter(s, s->buflen);
|
||||
blake2s_set_lastblock(s);
|
||||
memset(s->buf + s->buflen, 0, BLAKE2S_BLOCKBYTES - s->buflen); /* Padding */
|
||||
blake2s_compress(s, s->buf);
|
||||
|
||||
/* Output full hash to temp buffer */
|
||||
for (uint i = 0; i < 8; ++i)
|
||||
store32(buffer + sizeof(s->h[i]) * i, s->h[i]);
|
||||
|
||||
memcpy(out, buffer, outlen);
|
||||
secure_zero_memory(buffer, sizeof(buffer));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
blake2s_mac_init(struct mac_context *mac, const byte *key, uint keylen)
|
||||
{
|
||||
struct blake2s_context *ctx = (void *) mac;
|
||||
blake2s_init_key(&ctx->state, mac_get_length(mac), key, keylen);
|
||||
}
|
||||
|
||||
void
|
||||
blake2s_mac_update(struct mac_context *mac, const byte *data, uint datalen)
|
||||
{
|
||||
struct blake2s_context *ctx = (void *) mac;
|
||||
blake2s_update(&ctx->state, data, datalen);
|
||||
}
|
||||
|
||||
byte *
|
||||
blake2s_mac_final(struct mac_context *mac)
|
||||
{
|
||||
struct blake2s_context *ctx = (void *) mac;
|
||||
blake2s_final(&ctx->state, ctx->buf, mac_get_length(mac));
|
||||
return ctx->buf;
|
||||
}
|
||||
28
lib/mac.c
28
lib/mac.c
|
|
@ -32,6 +32,7 @@
|
|||
#include "lib/sha1.h"
|
||||
#include "lib/sha256.h"
|
||||
#include "lib/sha512.h"
|
||||
#include "lib/blake2.h"
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -154,13 +155,26 @@ hmac_final(struct mac_context *ctx)
|
|||
* Common code
|
||||
*/
|
||||
|
||||
#define HASH_DESC(name, px, PX) \
|
||||
{ name, PX##_SIZE, sizeof(struct nrmh_context), nrmh_init, nrmh_update, nrmh_final, \
|
||||
PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final }
|
||||
#define HASH_DESC(name, px, PX) \
|
||||
{ \
|
||||
name, PX##_SIZE, sizeof(struct nrmh_context), \
|
||||
nrmh_init, nrmh_update, nrmh_final, \
|
||||
PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final \
|
||||
}
|
||||
|
||||
#define HMAC_DESC(name, px, PX) \
|
||||
{ name, PX##_SIZE, sizeof(struct hmac_context), hmac_init, hmac_update, hmac_final, \
|
||||
PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final }
|
||||
{ \
|
||||
name, PX##_SIZE, sizeof(struct hmac_context), \
|
||||
hmac_init, hmac_update, hmac_final, \
|
||||
PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final \
|
||||
}
|
||||
|
||||
#define BLAKE_DESC(name, vx, VX, size) \
|
||||
{ \
|
||||
name, size/8, sizeof(struct vx##_context), \
|
||||
vx##_mac_init, vx##_mac_update, vx##_mac_final, \
|
||||
size/8, VX##_BLOCK_SIZE, NULL, NULL, NULL \
|
||||
}
|
||||
|
||||
const struct mac_desc mac_table[ALG_MAX] = {
|
||||
[ALG_MD5] = HASH_DESC("Keyed MD5", md5, MD5),
|
||||
|
|
@ -169,6 +183,10 @@ const struct mac_desc mac_table[ALG_MAX] = {
|
|||
[ALG_SHA256] = HASH_DESC("Keyed SHA-256", sha256, SHA256),
|
||||
[ALG_SHA384] = HASH_DESC("Keyed SHA-384", sha384, SHA384),
|
||||
[ALG_SHA512] = HASH_DESC("Keyed SHA-512", sha512, SHA512),
|
||||
[ALG_BLAKE2S_128] = BLAKE_DESC("Blake2s-128", blake2s, BLAKE2S, 128),
|
||||
[ALG_BLAKE2S_256] = BLAKE_DESC("Blake2s-256", blake2s, BLAKE2S, 256),
|
||||
[ALG_BLAKE2B_256] = BLAKE_DESC("Blake2b-256", blake2b, BLAKE2B, 256),
|
||||
[ALG_BLAKE2B_512] = BLAKE_DESC("Blake2b-512", blake2b, BLAKE2B, 512),
|
||||
[ALG_HMAC_MD5] = HMAC_DESC("HMAC-MD5", md5, MD5),
|
||||
[ALG_HMAC_SHA1] = HMAC_DESC("HMAC-SHA-1", sha1, SHA1),
|
||||
[ALG_HMAC_SHA224] = HMAC_DESC("HMAC-SHA-224", sha224, SHA224),
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
|
||||
#include "nest/bird.h"
|
||||
#include "lib/sha512.h"
|
||||
#include "lib/blake2.h"
|
||||
|
||||
|
||||
#define ALG_UNDEFINED 0
|
||||
|
|
@ -21,6 +22,10 @@
|
|||
#define ALG_SHA256 0x04
|
||||
#define ALG_SHA384 0x05
|
||||
#define ALG_SHA512 0x06
|
||||
#define ALG_BLAKE2S_128 0x07
|
||||
#define ALG_BLAKE2S_256 0x08
|
||||
#define ALG_BLAKE2B_256 0x09
|
||||
#define ALG_BLAKE2B_512 0x0A
|
||||
#define ALG_HMAC 0x10
|
||||
#define ALG_HMAC_MD5 0x11
|
||||
#define ALG_HMAC_SHA1 0x12
|
||||
|
|
@ -71,6 +76,8 @@ union mac_context_union {
|
|||
struct mac_context mac;
|
||||
struct nrmh_context nrmh;
|
||||
struct hmac_context hmac;
|
||||
struct blake2s_context blake2s;
|
||||
struct blake2b_context blake2b;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ CF_KEYWORDS(INTERFACE, IMPORT, EXPORT, FILTER, NONE, VRF, DEFAULT, TABLE, STATES
|
|||
CF_KEYWORDS(IPV4, IPV6, VPN4, VPN6, ROA4, ROA6, FLOW4, FLOW6, SADR, MPLS)
|
||||
CF_KEYWORDS(RECEIVE, LIMIT, ACTION, WARN, BLOCK, RESTART, DISABLE, KEEP, FILTERED, RPKI)
|
||||
CF_KEYWORDS(PASSWORD, FROM, PASSIVE, TO, ID, EVENTS, PACKETS, PROTOCOLS, CHANNELS, INTERFACES)
|
||||
CF_KEYWORDS(ALGORITHM, KEYED, HMAC, MD5, SHA1, SHA256, SHA384, SHA512)
|
||||
CF_KEYWORDS(ALGORITHM, KEYED, HMAC, MD5, SHA1, SHA256, SHA384, SHA512, BLAKE2S128, BLAKE2S256, BLAKE2B256, BLAKE2B512)
|
||||
CF_KEYWORDS(PRIMARY, STATS, COUNT, BY, FOR, COMMANDS, PREEXPORT, NOEXPORT, EXPORTED, GENERATE)
|
||||
CF_KEYWORDS(BGP, PASSWORDS, DESCRIPTION, SORTED)
|
||||
CF_KEYWORDS(RELOAD, IN, OUT, MRTDUMP, MESSAGES, RESTRICT, MEMORY, IGP_METRIC, CLASS, DSCP)
|
||||
|
|
@ -532,6 +532,10 @@ password_algorithm:
|
|||
| HMAC SHA256 { $$ = ALG_HMAC_SHA256; }
|
||||
| HMAC SHA384 { $$ = ALG_HMAC_SHA384; }
|
||||
| HMAC SHA512 { $$ = ALG_HMAC_SHA512; }
|
||||
| BLAKE2S128 { $$ = ALG_BLAKE2S_128; }
|
||||
| BLAKE2S256 { $$ = ALG_BLAKE2S_256; }
|
||||
| BLAKE2B256 { $$ = ALG_BLAKE2B_256; }
|
||||
| BLAKE2B512 { $$ = ALG_BLAKE2B_512; }
|
||||
;
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue