rippled
sha2_context.h
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of Beast: https://github.com/vinniefalco/Beast
4  Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #ifndef BEAST_CRYPTO_SHA512_CONTEXT_H_INCLUDED
21 #define BEAST_CRYPTO_SHA512_CONTEXT_H_INCLUDED
22 
23 #include <cstdint>
24 #include <cstring>
25 
26 namespace beast {
27 namespace detail {
28 
29 // Based on https://github.com/ogay/sha2
30 // This implementation has been modified from the
31 // original. It has been updated for C++11.
32 
33 /*
34  * Updated to C++, zedwood.com 2012
35  * Based on Olivier Gay's version
36  * See Modified BSD License below:
37  *
38  * FIPS 180-2 SHA-224/256/384/512 implementation
39  * Issue date: 04/30/2005
40  * http://www.ouah.org/ogay/sha2/
41  *
42  * Copyright (C) 2005, 2007 Olivier Gay <olivier.gay@a3.epfl.ch>
43  * All rights reserved.
44  *
45  * Redistribution and use in source and binary forms, with or without
46  * modification, are permitted provided that the following conditions
47  * are met:
48  * 1. Redistributions of source code must retain the above copyright
49  * notice, this list of conditions and the following disclaimer.
50  * 2. Redistributions in binary form must reproduce the above copyright
51  * notice, this list of conditions and the following disclaimer in the
52  * documentation and/or other materials provided with the distribution.
53  * 3. Neither the name of the project nor the names of its contributors
54  * may be used to endorse or promote products derived from this software
55  * without specific prior written permission.
56  *
57  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
58  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
59  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
60  * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
61  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
62  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
63  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
64  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
65  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
66  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
67  * SUCH DAMAGE.
68  */
69 
70 struct sha256_context
71 {
72  explicit sha256_context() = default;
73 
74  static unsigned int const block_size = 64;
75  static unsigned int const digest_size = 32;
76 
77  unsigned int tot_len;
78  unsigned int len;
79  unsigned char block[2 * block_size];
80  std::uint32_t h[8];
81 };
82 
83 struct sha512_context
84 {
85  explicit sha512_context() = default;
86 
87  static unsigned int const block_size = 128;
88  static unsigned int const digest_size = 64;
89 
90  unsigned int tot_len;
91  unsigned int len;
92  unsigned char block[2 * block_size];
93  std::uint64_t h[8];
94 };
95 
96 #define BEAST_SHA2_SHFR(x, n) (x >> n)
97 #define BEAST_SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n)))
98 #define BEAST_SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n)))
99 #define BEAST_SHA2_CH(x, y, z) ((x & y) ^ (~x & z))
100 #define BEAST_SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
101 #define BEAST_SHA256_F1(x) (BEAST_SHA2_ROTR(x, 2) ^ BEAST_SHA2_ROTR(x, 13) ^ BEAST_SHA2_ROTR(x, 22))
102 #define BEAST_SHA256_F2(x) (BEAST_SHA2_ROTR(x, 6) ^ BEAST_SHA2_ROTR(x, 11) ^ BEAST_SHA2_ROTR(x, 25))
103 #define BEAST_SHA256_F3(x) (BEAST_SHA2_ROTR(x, 7) ^ BEAST_SHA2_ROTR(x, 18) ^ BEAST_SHA2_SHFR(x, 3))
104 #define BEAST_SHA256_F4(x) (BEAST_SHA2_ROTR(x, 17) ^ BEAST_SHA2_ROTR(x, 19) ^ BEAST_SHA2_SHFR(x, 10))
105 #define BEAST_SHA512_F1(x) (BEAST_SHA2_ROTR(x, 28) ^ BEAST_SHA2_ROTR(x, 34) ^ BEAST_SHA2_ROTR(x, 39))
106 #define BEAST_SHA512_F2(x) (BEAST_SHA2_ROTR(x, 14) ^ BEAST_SHA2_ROTR(x, 18) ^ BEAST_SHA2_ROTR(x, 41))
107 #define BEAST_SHA512_F3(x) (BEAST_SHA2_ROTR(x, 1) ^ BEAST_SHA2_ROTR(x, 8) ^ BEAST_SHA2_SHFR(x, 7))
108 #define BEAST_SHA512_F4(x) (BEAST_SHA2_ROTR(x, 19) ^ BEAST_SHA2_ROTR(x, 61) ^ BEAST_SHA2_SHFR(x, 6))
109 #define BEAST_SHA2_PACK32(str, x) \
110 { \
111  *(x) = \
112  ((std::uint32_t) *((str) + 3) ) \
113  | ((std::uint32_t) *((str) + 2) << 8) \
114  | ((std::uint32_t) *((str) + 1) << 16) \
115  | ((std::uint32_t) *((str) + 0) << 24); \
116 }
117 #define BEAST_SHA2_UNPACK32(x, str) \
118 { \
119  *((str) + 3) = (std::uint8_t) ((x) ); \
120  *((str) + 2) = (std::uint8_t) ((x) >> 8); \
121  *((str) + 1) = (std::uint8_t) ((x) >> 16); \
122  *((str) + 0) = (std::uint8_t) ((x) >> 24); \
123 }
124 #define BEAST_SHA2_PACK64(str, x) \
125 { \
126  *(x) = \
127  ((std::uint64_t) *((str) + 7) ) \
128  | ((std::uint64_t) *((str) + 6) << 8) \
129  | ((std::uint64_t) *((str) + 5) << 16) \
130  | ((std::uint64_t) *((str) + 4) << 24) \
131  | ((std::uint64_t) *((str) + 3) << 32) \
132  | ((std::uint64_t) *((str) + 2) << 40) \
133  | ((std::uint64_t) *((str) + 1) << 48) \
134  | ((std::uint64_t) *((str) + 0) << 56); \
135 }
136 #define BEAST_SHA2_UNPACK64(x, str) \
137 { \
138  *((str) + 7) = (std::uint8_t) ((x) ); \
139  *((str) + 6) = (std::uint8_t) ((x) >> 8); \
140  *((str) + 5) = (std::uint8_t) ((x) >> 16); \
141  *((str) + 4) = (std::uint8_t) ((x) >> 24); \
142  *((str) + 3) = (std::uint8_t) ((x) >> 32); \
143  *((str) + 2) = (std::uint8_t) ((x) >> 40); \
144  *((str) + 1) = (std::uint8_t) ((x) >> 48); \
145  *((str) + 0) = (std::uint8_t) ((x) >> 56); \
146 }
147 
148 //------------------------------------------------------------------------------
149 
150 // SHA256
151 
152 template <class = void>
153 void sha256_transform (sha256_context& ctx,
154  unsigned char const* message,
155  unsigned int block_nb) noexcept
156 {
157  static unsigned long long const K[64] = {
158  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
159  0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
160  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
161  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
162  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
163  0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
164  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
165  0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
166  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
167  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
168  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
169  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
170  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
171  0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
172  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
173  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
174  };
175  std::uint32_t w[64];
176  std::uint32_t wv[8];
177  std::uint32_t t1, t2;
178  unsigned char const* sub_block;
179  int i, j;
180  for (i = 0; i < (int) block_nb; i++) {
181  sub_block = message + (i << 6);
182  for (j = 0; j < 16; j++)
183  BEAST_SHA2_PACK32(&sub_block[j << 2], &w[j]);
184  for (j = 16; j < 64; j++)
185  w[j] = BEAST_SHA256_F4(
186  w[j - 2]) + w[j - 7] +
187  BEAST_SHA256_F3(w[j - 15]) +
188  w[j - 16];
189  for (j = 0; j < 8; j++)
190  wv[j] = ctx.h[j];
191  for (j = 0; j < 64; j++) {
192  t1 = wv[7] + BEAST_SHA256_F2(wv[4]) +
193  BEAST_SHA2_CH(wv[4], wv[5], wv[6]) +
194  K[j] + w[j];
195  t2 = BEAST_SHA256_F1(wv[0]) +
196  BEAST_SHA2_MAJ(wv[0], wv[1], wv[2]);
197  wv[7] = wv[6];
198  wv[6] = wv[5];
199  wv[5] = wv[4];
200  wv[4] = wv[3] + t1;
201  wv[3] = wv[2];
202  wv[2] = wv[1];
203  wv[1] = wv[0];
204  wv[0] = t1 + t2;
205  }
206  for (j = 0; j < 8; j++)
207  ctx.h[j] += wv[j];
208  }
209 }
210 
211 template <class = void>
212 void init (sha256_context& ctx) noexcept
213 {
214  ctx.len = 0;
215  ctx.tot_len = 0;
216  ctx.h[0] = 0x6a09e667;
217  ctx.h[1] = 0xbb67ae85;
218  ctx.h[2] = 0x3c6ef372;
219  ctx.h[3] = 0xa54ff53a;
220  ctx.h[4] = 0x510e527f;
221  ctx.h[5] = 0x9b05688c;
222  ctx.h[6] = 0x1f83d9ab;
223  ctx.h[7] = 0x5be0cd19;
224 }
225 
226 template <class = void>
227 void update (sha256_context& ctx,
228  void const* message, std::size_t size) noexcept
229 {
230  auto const pm = reinterpret_cast<
231  unsigned char const*>(message);
232  unsigned int block_nb;
233  unsigned int new_len, rem_len, tmp_len;
234  const unsigned char *shifted_message;
235  tmp_len = sha256_context::block_size - ctx.len;
236  rem_len = size < tmp_len ? size : tmp_len;
237  std::memcpy(&ctx.block[ctx.len], pm, rem_len);
238  if (ctx.len + size < sha256_context::block_size) {
239  ctx.len += size;
240  return;
241  }
242  new_len = size - rem_len;
243  block_nb = new_len / sha256_context::block_size;
244  shifted_message = pm + rem_len;
245  sha256_transform(ctx, ctx.block, 1);
246  sha256_transform(ctx, shifted_message, block_nb);
247  rem_len = new_len % sha256_context::block_size;
248  std::memcpy(ctx.block, &shifted_message[
249  block_nb << 6], rem_len);
250  ctx.len = rem_len;
251  ctx.tot_len += (block_nb + 1) << 6;
252 }
253 
254 template <class = void>
255 void finish (sha256_context& ctx,
256  void* digest) noexcept
257 {
258  auto const pd = reinterpret_cast<
259  unsigned char*>(digest);
260  unsigned int block_nb;
261  unsigned int pm_len;
262  unsigned int len_b;
263  int i;
264  block_nb = (1 + ((sha256_context::block_size - 9) <
265  (ctx.len % sha256_context::block_size)));
266  len_b = (ctx.tot_len + ctx.len) << 3;
267  pm_len = block_nb << 6;
268  std::memset(ctx.block + ctx.len, 0, pm_len - ctx.len);
269  ctx.block[ctx.len] = 0x80;
270  BEAST_SHA2_UNPACK32(len_b, ctx.block + pm_len - 4);
271  sha256_transform(ctx, ctx.block, block_nb);
272  for (i = 0 ; i < 8; i++)
273  BEAST_SHA2_UNPACK32(ctx.h[i], &pd[i << 2]);
274 }
275 
276 //------------------------------------------------------------------------------
277 
278 // SHA512
279 
280 template <class = void>
281 void sha512_transform (sha512_context& ctx,
282  unsigned char const* message,
283  unsigned int block_nb) noexcept
284 {
285  static unsigned long long const K[80] = {
286  0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
287  0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
288  0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
289  0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
290  0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
291  0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
292  0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
293  0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
294  0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
295  0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
296  0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
297  0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
298  0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
299  0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
300  0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
301  0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
302  0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
303  0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
304  0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
305  0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
306  0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
307  0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
308  0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
309  0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
310  0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
311  0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
312  0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
313  0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
314  0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
315  0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
316  0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
317  0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
318  0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
319  0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
320  0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
321  0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
322  0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
323  0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
324  0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
325  0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL};
326 
327  std::uint64_t w[80];
328  std::uint64_t wv[8];
329  std::uint64_t t1, t2;
330  unsigned char const* sub_block;
331  int i, j;
332  for (i = 0; i < (int) block_nb; i++)
333  {
334  sub_block = message + (i << 7);
335  for (j = 0; j < 16; j++)
336  BEAST_SHA2_PACK64(&sub_block[j << 3], &w[j]);
337  for (j = 16; j < 80; j++)
338  w[j] = BEAST_SHA512_F4(
339  w[j - 2]) + w[j - 7] +
340  BEAST_SHA512_F3(w[j - 15]) +
341  w[j - 16];
342  for (j = 0; j < 8; j++)
343  wv[j] = ctx.h[j];
344  for (j = 0; j < 80; j++) {
345  t1 = wv[7] + BEAST_SHA512_F2(wv[4]) +
346  BEAST_SHA2_CH(wv[4], wv[5], wv[6]) +
347  K[j] + w[j];
348  t2 = BEAST_SHA512_F1(wv[0]) +
349  BEAST_SHA2_MAJ(wv[0], wv[1], wv[2]);
350  wv[7] = wv[6];
351  wv[6] = wv[5];
352  wv[5] = wv[4];
353  wv[4] = wv[3] + t1;
354  wv[3] = wv[2];
355  wv[2] = wv[1];
356  wv[1] = wv[0];
357  wv[0] = t1 + t2;
358  }
359  for (j = 0; j < 8; j++)
360  ctx.h[j] += wv[j];
361  }
362 }
363 
364 template <class = void>
365 void init (sha512_context& ctx) noexcept
366 {
367  ctx.len = 0;
368  ctx.tot_len = 0;
369  ctx.h[0] = 0x6a09e667f3bcc908ULL;
370  ctx.h[1] = 0xbb67ae8584caa73bULL;
371  ctx.h[2] = 0x3c6ef372fe94f82bULL;
372  ctx.h[3] = 0xa54ff53a5f1d36f1ULL;
373  ctx.h[4] = 0x510e527fade682d1ULL;
374  ctx.h[5] = 0x9b05688c2b3e6c1fULL;
375  ctx.h[6] = 0x1f83d9abfb41bd6bULL;
376  ctx.h[7] = 0x5be0cd19137e2179ULL;
377 }
378 
379 template <class = void>
380 void update (sha512_context& ctx,
381  void const* message, std::size_t size) noexcept
382 {
383  auto const pm = reinterpret_cast<
384  unsigned char const*>(message);
385  unsigned int block_nb;
386  unsigned int new_len, rem_len, tmp_len;
387  const unsigned char *shifted_message;
388  tmp_len = sha512_context::block_size - ctx.len;
389  rem_len = size < tmp_len ? size : tmp_len;
390  std::memcpy(&ctx.block[ctx.len], pm, rem_len);
391  if (ctx.len + size < sha512_context::block_size) {
392  ctx.len += size;
393  return;
394  }
395  new_len = size - rem_len;
396  block_nb = new_len / sha512_context::block_size;
397  shifted_message = pm + rem_len;
398  sha512_transform(ctx, ctx.block, 1);
399  sha512_transform(ctx, shifted_message, block_nb);
400  rem_len = new_len % sha512_context::block_size;
401  std::memcpy(ctx.block, &shifted_message[
402  block_nb << 7], rem_len);
403  ctx.len = rem_len;
404  ctx.tot_len += (block_nb + 1) << 7;
405 }
406 
407 template <class = void>
408 void finish (sha512_context& ctx,
409  void* digest) noexcept
410 {
411  auto const pd = reinterpret_cast<
412  unsigned char*>(digest);
413  unsigned int block_nb;
414  unsigned int pm_len;
415  unsigned int len_b;
416  int i;
417  block_nb = 1 + ((sha512_context::block_size - 17) <
418  (ctx.len % sha512_context::block_size));
419  len_b = (ctx.tot_len + ctx.len) << 3;
420  pm_len = block_nb << 7;
421  std::memset(ctx.block + ctx.len, 0, pm_len - ctx.len);
422  ctx.block[ctx.len] = 0x80;
423  BEAST_SHA2_UNPACK32(len_b, ctx.block + pm_len - 4);
424  sha512_transform(ctx, ctx.block, block_nb);
425  for (i = 0 ; i < 8; i++)
426  BEAST_SHA2_UNPACK64(ctx.h[i], &pd[i << 3]);
427 }
428 
429 } // detail
430 } // beast
431 
432 #endif
beast::detail::sha512_context::len
unsigned int len
Definition: sha2_context.h:91
beast::detail::update
void update(ripemd160_context &ctx, void const *message, std::size_t size) noexcept
Definition: ripemd_context.h:355
cstring
beast::detail::sha256_context::block
unsigned char block[2 *block_size]
Definition: sha2_context.h:79
beast::detail::sha512_context::sha512_context
sha512_context()=default
beast::detail::sha512_context::h
std::uint64_t h[8]
Definition: sha2_context.h:93
beast::detail::sha512_context::block_size
static unsigned const int block_size
Definition: sha2_context.h:87
beast::detail::sha256_context::len
unsigned int len
Definition: sha2_context.h:78
beast::detail::sha256_context::block_size
static unsigned const int block_size
Definition: sha2_context.h:74
beast::detail::sha512_transform
void sha512_transform(sha512_context &ctx, unsigned char const *message, unsigned int block_nb) noexcept
Definition: sha2_context.h:281
beast::detail::sha256_context::tot_len
unsigned int tot_len
Definition: sha2_context.h:77
beast::detail::sha512_context::tot_len
unsigned int tot_len
Definition: sha2_context.h:90
beast::detail::sha256_context::sha256_context
sha256_context()=default
cstdint
beast::detail::init
void init(ripemd160_context &ctx) noexcept
Definition: ripemd_context.h:343
std::uint32_t
beast::detail::finish
void finish(ripemd160_context &ctx, void *digest) noexcept
Definition: ripemd_context.h:392
beast::detail::sha256_transform
void sha256_transform(sha256_context &ctx, unsigned char const *message, unsigned int block_nb) noexcept
Definition: sha2_context.h:153
beast::detail::sha512_context
Definition: sha2_context.h:83
std::size_t
std::memcpy
T memcpy(T... args)
beast::detail::sha256_context::h
std::uint32_t h[8]
Definition: sha2_context.h:80
beast::detail::sha512_context::block
unsigned char block[2 *block_size]
Definition: sha2_context.h:92
std::memset
T memset(T... args)
beast::detail::sha256_context::digest_size
static unsigned const int digest_size
Definition: sha2_context.h:75
beast::detail::sha512_context::digest_size
static unsigned const int digest_size
Definition: sha2_context.h:88
beast
Definition: base_uint.h:582
beast::detail::sha256_context
Definition: sha2_context.h:70
Generated by   doxygen 1.8.17