FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
blake2-impl.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2020 Doc.ai and/or its affiliates.
3  * Copyright (c) 2012 Samuel Neves <sneves@dei.uc.pt>.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 /*
18  More information about the BLAKE2 hash function can be found at
19  https://blake2.net.
20 */
21 #ifndef __included_crypto_blake2_impl_h__
22 #define __included_crypto_blake2_impl_h__
23 
24 #include <stdint.h>
25 #include <string.h>
26 #include <vppinfra/byte_order.h>
27 
28 #if defined(CLIB_ARCH_IS_LITTLE_ENDIAN)
29 #define NATIVE_LITTLE_ENDIAN
30 #endif
31 
32 #if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L)
33 #if defined(_MSC_VER)
34 #define BLAKE2_INLINE __inline
35 #elif defined(__GNUC__)
36 #define BLAKE2_INLINE __inline__
37 #else
38 #define BLAKE2_INLINE
39 #endif
40 #else
41 #define BLAKE2_INLINE inline
42 #endif
43 
44 static BLAKE2_INLINE uint32_t
45 load32 (const void *src)
46 {
47 #if defined(NATIVE_LITTLE_ENDIAN)
48  uint32_t w;
49  memcpy (&w, src, sizeof w);
50  return w;
51 #else
52  const uint8_t *p = (const uint8_t *) src;
53  return ((uint32_t) (p[0]) << 0) |
54  ((uint32_t) (p[1]) << 8) |
55  ((uint32_t) (p[2]) << 16) | ((uint32_t) (p[3]) << 24);
56 #endif
57 }
58 
59 static BLAKE2_INLINE uint64_t
60 load64 (const void *src)
61 {
62 #if defined(NATIVE_LITTLE_ENDIAN)
63  uint64_t w;
64  memcpy (&w, src, sizeof w);
65  return w;
66 #else
67  const uint8_t *p = (const uint8_t *) src;
68  return ((uint64_t) (p[0]) << 0) |
69  ((uint64_t) (p[1]) << 8) |
70  ((uint64_t) (p[2]) << 16) |
71  ((uint64_t) (p[3]) << 24) |
72  ((uint64_t) (p[4]) << 32) |
73  ((uint64_t) (p[5]) << 40) |
74  ((uint64_t) (p[6]) << 48) | ((uint64_t) (p[7]) << 56);
75 #endif
76 }
77 
78 static BLAKE2_INLINE uint16_t
79 load16 (const void *src)
80 {
81 #if defined(NATIVE_LITTLE_ENDIAN)
82  uint16_t w;
83  memcpy (&w, src, sizeof w);
84  return w;
85 #else
86  const uint8_t *p = (const uint8_t *) src;
87  return (uint16_t) (((uint32_t) (p[0]) << 0) | ((uint32_t) (p[1]) << 8));
88 #endif
89 }
90 
91 static BLAKE2_INLINE void
92 store16 (void *dst, uint16_t w)
93 {
94 #if defined(NATIVE_LITTLE_ENDIAN)
95  memcpy (dst, &w, sizeof w);
96 #else
97  uint8_t *p = (uint8_t *) dst;
98  *p++ = (uint8_t) w;
99  w >>= 8;
100  *p++ = (uint8_t) w;
101 #endif
102 }
103 
104 static BLAKE2_INLINE void
105 store32 (void *dst, uint32_t w)
106 {
107 #if defined(NATIVE_LITTLE_ENDIAN)
108  memcpy (dst, &w, sizeof w);
109 #else
110  uint8_t *p = (uint8_t *) dst;
111  p[0] = (uint8_t) (w >> 0);
112  p[1] = (uint8_t) (w >> 8);
113  p[2] = (uint8_t) (w >> 16);
114  p[3] = (uint8_t) (w >> 24);
115 #endif
116 }
117 
118 static BLAKE2_INLINE void
119 store64 (void *dst, uint64_t w)
120 {
121 #if defined(NATIVE_LITTLE_ENDIAN)
122  memcpy (dst, &w, sizeof w);
123 #else
124  uint8_t *p = (uint8_t *) dst;
125  p[0] = (uint8_t) (w >> 0);
126  p[1] = (uint8_t) (w >> 8);
127  p[2] = (uint8_t) (w >> 16);
128  p[3] = (uint8_t) (w >> 24);
129  p[4] = (uint8_t) (w >> 32);
130  p[5] = (uint8_t) (w >> 40);
131  p[6] = (uint8_t) (w >> 48);
132  p[7] = (uint8_t) (w >> 56);
133 #endif
134 }
135 
136 static BLAKE2_INLINE uint64_t
137 load48 (const void *src)
138 {
139  const uint8_t *p = (const uint8_t *) src;
140  return ((uint64_t) (p[0]) << 0) |
141  ((uint64_t) (p[1]) << 8) |
142  ((uint64_t) (p[2]) << 16) |
143  ((uint64_t) (p[3]) << 24) |
144  ((uint64_t) (p[4]) << 32) | ((uint64_t) (p[5]) << 40);
145 }
146 
147 static BLAKE2_INLINE void
148 store48 (void *dst, uint64_t w)
149 {
150  uint8_t *p = (uint8_t *) dst;
151  p[0] = (uint8_t) (w >> 0);
152  p[1] = (uint8_t) (w >> 8);
153  p[2] = (uint8_t) (w >> 16);
154  p[3] = (uint8_t) (w >> 24);
155  p[4] = (uint8_t) (w >> 32);
156  p[5] = (uint8_t) (w >> 40);
157 }
158 
159 static BLAKE2_INLINE uint32_t
160 rotr32 (const uint32_t w, const unsigned c)
161 {
162  return (w >> c) | (w << (32 - c));
163 }
164 
165 static BLAKE2_INLINE uint64_t
166 rotr64 (const uint64_t w, const unsigned c)
167 {
168  return (w >> c) | (w << (64 - c));
169 }
170 
171 /* prevents compiler optimizing out memset() */
172 static BLAKE2_INLINE void
173 secure_zero_memory (void *v, size_t n)
174 {
175  static void *(*const volatile memset_v) (void *, int, size_t) = &memset;
176  memset_v (v, 0, n);
177 }
178 
179 #endif //__included_crypto_blake2_impl_h__
180 
181 /*
182  * fd.io coding-style-patch-verification: ON
183  *
184  * Local Variables:
185  * eval: (c-set-style "gnu")
186  * End:
187  */
static BLAKE2_INLINE uint64_t rotr64(const uint64_t w, const unsigned c)
Definition: blake2-impl.h:166
Optimized string handling code, including c11-compliant "safe C library" variants.
vl_api_address_t src
Definition: gre.api:54
static BLAKE2_INLINE uint32_t rotr32(const uint32_t w, const unsigned c)
Definition: blake2-impl.h:160
static BLAKE2_INLINE void store48(void *dst, uint64_t w)
Definition: blake2-impl.h:148
static BLAKE2_INLINE uint16_t load16(const void *src)
Definition: blake2-impl.h:79
static BLAKE2_INLINE void store32(void *dst, uint32_t w)
Definition: blake2-impl.h:105
static BLAKE2_INLINE uint32_t load32(const void *src)
Definition: blake2-impl.h:45
static BLAKE2_INLINE void store16(void *dst, uint16_t w)
Definition: blake2-impl.h:92
vl_api_address_t dst
Definition: gre.api:55
#define BLAKE2_INLINE
Definition: blake2-impl.h:38
svmdb_client_t * c
static BLAKE2_INLINE void store64(void *dst, uint64_t w)
Definition: blake2-impl.h:119
static BLAKE2_INLINE uint64_t load48(const void *src)
Definition: blake2-impl.h:137
static BLAKE2_INLINE uint64_t load64(const void *src)
Definition: blake2-impl.h:60
static BLAKE2_INLINE void secure_zero_memory(void *v, size_t n)
Definition: blake2-impl.h:173