digest_test.cc
Go to the documentation of this file.
1 /* Copyright (c) 2014, Google Inc.
2  *
3  * Permission to use, copy, modify, and/or distribute this software for any
4  * purpose with or without fee is hereby granted, provided that the above
5  * copyright notice and this permission notice appear in all copies.
6  *
7  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
10  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
12  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
13  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
14 
15 #include <stdint.h>
16 #include <stdio.h>
17 #include <string.h>
18 
19 #include <memory>
20 #include <vector>
21 
22 #include <gtest/gtest.h>
23 
24 #include <openssl/asn1.h>
25 #include <openssl/bytestring.h>
26 #include <openssl/crypto.h>
27 #include <openssl/digest.h>
28 #include <openssl/err.h>
29 #include <openssl/md4.h>
30 #include <openssl/md5.h>
31 #include <openssl/nid.h>
32 #include <openssl/obj.h>
33 #include <openssl/sha.h>
34 
35 #include "../internal.h"
36 #include "../test/test_util.h"
37 
38 
39 struct MD {
40  // name is the name of the digest.
41  const char* name;
42  // md_func is the digest to test.
43  const EVP_MD *(*func)(void);
44  // one_shot_func is the convenience one-shot version of the
45  // digest.
46  uint8_t *(*one_shot_func)(const uint8_t *, size_t, uint8_t *);
47 };
48 
49 static const MD md4 = { "MD4", &EVP_md4, nullptr };
50 static const MD md5 = { "MD5", &EVP_md5, &MD5 };
51 static const MD sha1 = { "SHA1", &EVP_sha1, &SHA1 };
52 static const MD sha224 = { "SHA224", &EVP_sha224, &SHA224 };
53 static const MD sha256 = { "SHA256", &EVP_sha256, &SHA256 };
54 static const MD sha384 = { "SHA384", &EVP_sha384, &SHA384 };
55 static const MD sha512 = { "SHA512", &EVP_sha512, &SHA512 };
56 static const MD sha512_256 = { "SHA512-256", &EVP_sha512_256, &SHA512_256 };
57 static const MD md5_sha1 = { "MD5-SHA1", &EVP_md5_sha1, nullptr };
58 static const MD blake2b256 = { "BLAKE2b-256", &EVP_blake2b256, nullptr };
59 
60 struct DigestTestVector {
61  // md is the digest to test.
62  const MD &md;
63  // input is a NUL-terminated string to hash.
64  const char *input;
65  // repeat is the number of times to repeat input.
66  size_t repeat;
67  // expected_hex is the expected digest in hexadecimal.
68  const char *expected_hex;
69 };
70 
71 static const DigestTestVector kTestVectors[] = {
72  // MD4 tests, from RFC 1320. (crypto/md4 does not provide a
73  // one-shot MD4 function.)
74  {md4, "", 1, "31d6cfe0d16ae931b73c59d7e0c089c0"},
75  {md4, "a", 1, "bde52cb31de33e46245e05fbdbd6fb24"},
76  {md4, "abc", 1, "a448017aaf21d8525fc10ae87aa6729d"},
77  {md4, "message digest", 1, "d9130a8164549fe818874806e1c7014b"},
78  {md4, "abcdefghijklmnopqrstuvwxyz", 1, "d79e1c308aa5bbcdeea8ed63df412da9"},
79  {md4, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 1,
80  "043f8582f241db351ce627e153e7f0e4"},
81  {md4, "1234567890", 8, "e33b4ddc9c38f2199c3e7b164fcc0536"},
82 
83  // MD5 tests, from RFC 1321.
84  {md5, "", 1, "d41d8cd98f00b204e9800998ecf8427e"},
85  {md5, "a", 1, "0cc175b9c0f1b6a831c399e269772661"},
86  {md5, "abc", 1, "900150983cd24fb0d6963f7d28e17f72"},
87  {md5, "message digest", 1, "f96b697d7cb7938d525a2f31aaf161d0"},
88  {md5, "abcdefghijklmnopqrstuvwxyz", 1, "c3fcd3d76192e4007dfb496cca67e13b"},
89  {md5, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 1,
90  "d174ab98d277d9f5a5611c2c9f419d9f"},
91  {md5, "1234567890", 8, "57edf4a22be3c955ac49da2e2107b67a"},
92 
93  // SHA-1 tests, from RFC 3174.
94  {sha1, "abc", 1, "a9993e364706816aba3e25717850c26c9cd0d89d"},
95  {sha1, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1,
96  "84983e441c3bd26ebaae4aa1f95129e5e54670f1"},
97  {sha1, "a", 1000000, "34aa973cd4c4daa4f61eeb2bdbad27316534016f"},
98  {sha1, "0123456701234567012345670123456701234567012345670123456701234567",
99  10, "dea356a2cddd90c7a7ecedc5ebb563934f460452"},
100 
101  // SHA-224 tests, from RFC 3874.
102  {sha224, "abc", 1,
103  "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7"},
104  {sha224, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1,
105  "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525"},
106  {sha224, "a", 1000000,
107  "20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67"},
108 
109  // SHA-256 tests, from NIST.
110  {sha256, "abc", 1,
111  "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"},
112  {sha256, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1,
113  "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"},
114 
115  // SHA-384 tests, from NIST.
116  {sha384, "abc", 1,
117  "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed"
118  "8086072ba1e7cc2358baeca134c825a7"},
119  {sha384,
120  "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
121  "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
122  1,
123  "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712"
124  "fcc7c71a557e2db966c3e9fa91746039"},
125 
126  // SHA-512 tests, from NIST.
127  {sha512, "abc", 1,
128  "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a"
129  "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f"},
130  {sha512,
131  "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
132  "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
133  1,
134  "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018"
135  "501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909"},
136 
137  // SHA-512-256 tests, from
138  // https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha512_256.pdf
139  {sha512_256, "abc", 1,
140  "53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23"},
141  {sha512_256,
142  "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopj"
143  "klmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
144  1, "3928e184fb8690f840da3988121d31be65cb9d3ef83ee6146feac861e19b563a"},
145 
146  // MD5-SHA1 tests.
147  {md5_sha1, "abc", 1,
148  "900150983cd24fb0d6963f7d28e17f72a9993e364706816aba3e25717850c26c9cd0d89d"},
149 
150  // BLAKE2b-256 tests.
151  {blake2b256, "abc", 1,
152  "bddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319"},
153 };
154 
155 static void CompareDigest(const DigestTestVector *test,
156  const uint8_t *digest,
157  size_t digest_len) {
158  EXPECT_EQ(test->expected_hex,
159  EncodeHex(bssl::MakeConstSpan(digest, digest_len)));
160 }
161 
162 static void TestDigest(const DigestTestVector *test) {
163  bssl::ScopedEVP_MD_CTX ctx;
164 
165  // Test the input provided.
166  ASSERT_TRUE(EVP_DigestInit_ex(ctx.get(), test->md.func(), nullptr));
167  for (size_t i = 0; i < test->repeat; i++) {
168  ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), test->input, strlen(test->input)));
169  }
170  std::unique_ptr<uint8_t[]> digest(new uint8_t[EVP_MD_size(test->md.func())]);
171  unsigned digest_len;
172  ASSERT_TRUE(EVP_DigestFinal_ex(ctx.get(), digest.get(), &digest_len));
173  CompareDigest(test, digest.get(), digest_len);
174 
175  // Test the input one character at a time.
176  ASSERT_TRUE(EVP_DigestInit_ex(ctx.get(), test->md.func(), nullptr));
177  ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), nullptr, 0));
178  for (size_t i = 0; i < test->repeat; i++) {
179  for (const char *p = test->input; *p; p++) {
180  ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), p, 1));
181  }
182  }
183  ASSERT_TRUE(EVP_DigestFinal_ex(ctx.get(), digest.get(), &digest_len));
184  EXPECT_EQ(EVP_MD_size(test->md.func()), digest_len);
185  CompareDigest(test, digest.get(), digest_len);
186 
187  // Test with unaligned input.
188  ASSERT_TRUE(EVP_DigestInit_ex(ctx.get(), test->md.func(), nullptr));
189  std::vector<char> unaligned(strlen(test->input) + 1);
190  char *ptr = unaligned.data();
191  if ((reinterpret_cast<uintptr_t>(ptr) & 1) == 0) {
192  ptr++;
193  }
194  OPENSSL_memcpy(ptr, test->input, strlen(test->input));
195  for (size_t i = 0; i < test->repeat; i++) {
196  ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), ptr, strlen(test->input)));
197  }
198  ASSERT_TRUE(EVP_DigestFinal_ex(ctx.get(), digest.get(), &digest_len));
199  CompareDigest(test, digest.get(), digest_len);
200 
201  // Make a copy of the digest in the initial state.
202  ASSERT_TRUE(EVP_DigestInit_ex(ctx.get(), test->md.func(), nullptr));
203  bssl::ScopedEVP_MD_CTX copy;
204  ASSERT_TRUE(EVP_MD_CTX_copy_ex(copy.get(), ctx.get()));
205  for (size_t i = 0; i < test->repeat; i++) {
206  ASSERT_TRUE(EVP_DigestUpdate(copy.get(), test->input, strlen(test->input)));
207  }
208  ASSERT_TRUE(EVP_DigestFinal_ex(copy.get(), digest.get(), &digest_len));
209  CompareDigest(test, digest.get(), digest_len);
210 
211  // Make a copy of the digest with half the input provided.
212  size_t half = strlen(test->input) / 2;
213  ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), test->input, half));
214  ASSERT_TRUE(EVP_MD_CTX_copy_ex(copy.get(), ctx.get()));
215  ASSERT_TRUE(EVP_DigestUpdate(copy.get(), test->input + half,
216  strlen(test->input) - half));
217  for (size_t i = 1; i < test->repeat; i++) {
218  ASSERT_TRUE(EVP_DigestUpdate(copy.get(), test->input, strlen(test->input)));
219  }
220  ASSERT_TRUE(EVP_DigestFinal_ex(copy.get(), digest.get(), &digest_len));
221  CompareDigest(test, digest.get(), digest_len);
222 
223  // Move the digest from the initial state.
224  ASSERT_TRUE(EVP_DigestInit_ex(ctx.get(), test->md.func(), nullptr));
225  copy = std::move(ctx);
226  for (size_t i = 0; i < test->repeat; i++) {
227  ASSERT_TRUE(EVP_DigestUpdate(copy.get(), test->input, strlen(test->input)));
228  }
229  ASSERT_TRUE(EVP_DigestFinal_ex(copy.get(), digest.get(), &digest_len));
230  CompareDigest(test, digest.get(), digest_len);
231 
232  // Move the digest with half the input provided.
233  ASSERT_TRUE(EVP_DigestInit_ex(ctx.get(), test->md.func(), nullptr));
234  ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), test->input, half));
235  copy = std::move(ctx);
236  ASSERT_TRUE(EVP_DigestUpdate(copy.get(), test->input + half,
237  strlen(test->input) - half));
238  for (size_t i = 1; i < test->repeat; i++) {
239  ASSERT_TRUE(EVP_DigestUpdate(copy.get(), test->input, strlen(test->input)));
240  }
241  ASSERT_TRUE(EVP_DigestFinal_ex(copy.get(), digest.get(), &digest_len));
242  CompareDigest(test, digest.get(), digest_len);
243 
244  // Test the one-shot function.
245  if (test->md.one_shot_func && test->repeat == 1) {
246  uint8_t *out = test->md.one_shot_func((const uint8_t *)test->input,
247  strlen(test->input), digest.get());
248  // One-shot functions return their supplied buffers.
249  EXPECT_EQ(digest.get(), out);
250  CompareDigest(test, digest.get(), EVP_MD_size(test->md.func()));
251  }
252 }
253 
254 TEST(DigestTest, TestVectors) {
255  for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kTestVectors); i++) {
256  SCOPED_TRACE(i);
257  TestDigest(&kTestVectors[i]);
258  }
259 }
260 
261 TEST(DigestTest, Getters) {
262  EXPECT_EQ(EVP_sha512(), EVP_get_digestbyname("RSA-SHA512"));
263  EXPECT_EQ(EVP_sha512(), EVP_get_digestbyname("sha512WithRSAEncryption"));
264  EXPECT_EQ(nullptr, EVP_get_digestbyname("nonsense"));
265  EXPECT_EQ(EVP_sha512(), EVP_get_digestbyname("SHA512"));
266  EXPECT_EQ(EVP_sha512(), EVP_get_digestbyname("sha512"));
267 
268  EXPECT_EQ(EVP_sha512(), EVP_get_digestbynid(NID_sha512));
269  EXPECT_EQ(nullptr, EVP_get_digestbynid(NID_sha512WithRSAEncryption));
270  EXPECT_EQ(nullptr, EVP_get_digestbynid(NID_undef));
271 
272  bssl::UniquePtr<ASN1_OBJECT> obj(OBJ_txt2obj("1.3.14.3.2.26", 0));
273  ASSERT_TRUE(obj);
274  EXPECT_EQ(EVP_sha1(), EVP_get_digestbyobj(obj.get()));
275  EXPECT_EQ(EVP_md5_sha1(), EVP_get_digestbyobj(OBJ_nid2obj(NID_md5_sha1)));
276  EXPECT_EQ(EVP_sha1(), EVP_get_digestbyobj(OBJ_nid2obj(NID_sha1)));
277 }
278 
279 TEST(DigestTest, ASN1) {
280  bssl::ScopedCBB cbb;
281  ASSERT_TRUE(CBB_init(cbb.get(), 0));
282  EXPECT_FALSE(EVP_marshal_digest_algorithm(cbb.get(), EVP_md5_sha1()));
283 
284  static const uint8_t kSHA256[] = {0x30, 0x0d, 0x06, 0x09, 0x60,
285  0x86, 0x48, 0x01, 0x65, 0x03,
286  0x04, 0x02, 0x01, 0x05, 0x00};
287  static const uint8_t kSHA256NoParam[] = {0x30, 0x0b, 0x06, 0x09, 0x60,
288  0x86, 0x48, 0x01, 0x65, 0x03,
289  0x04, 0x02, 0x01};
290  static const uint8_t kSHA256GarbageParam[] = {
291  0x30, 0x0e, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
292  0x65, 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x2a};
293 
294  // Serialize SHA-256.
295  cbb.Reset();
296  ASSERT_TRUE(CBB_init(cbb.get(), 0));
297  ASSERT_TRUE(EVP_marshal_digest_algorithm(cbb.get(), EVP_sha256()));
298  uint8_t *der;
299  size_t der_len;
300  ASSERT_TRUE(CBB_finish(cbb.get(), &der, &der_len));
301  bssl::UniquePtr<uint8_t> free_der(der);
302  EXPECT_EQ(Bytes(kSHA256), Bytes(der, der_len));
303 
304  // Parse SHA-256.
305  CBS cbs;
306  CBS_init(&cbs, kSHA256, sizeof(kSHA256));
307  EXPECT_EQ(EVP_sha256(), EVP_parse_digest_algorithm(&cbs));
308  EXPECT_EQ(0u, CBS_len(&cbs));
309 
310  // Missing parameters are tolerated for compatibility.
311  CBS_init(&cbs, kSHA256NoParam, sizeof(kSHA256NoParam));
312  EXPECT_EQ(EVP_sha256(), EVP_parse_digest_algorithm(&cbs));
313  EXPECT_EQ(0u, CBS_len(&cbs));
314 
315  // Garbage parameters are not.
316  CBS_init(&cbs, kSHA256GarbageParam, sizeof(kSHA256GarbageParam));
317  EXPECT_FALSE(EVP_parse_digest_algorithm(&cbs));
318 }
319 
320 TEST(DigestTest, TransformBlocks) {
321  uint8_t blocks[SHA256_CBLOCK * 10];
322  for (size_t i = 0; i < sizeof(blocks); i++) {
323  blocks[i] = i*3;
324  }
325 
326  SHA256_CTX ctx1;
327  SHA256_Init(&ctx1);
328  SHA256_Update(&ctx1, blocks, sizeof(blocks));
329 
330  SHA256_CTX ctx2;
331  SHA256_Init(&ctx2);
332  SHA256_TransformBlocks(ctx2.h, blocks, sizeof(blocks) / SHA256_CBLOCK);
333 
334  EXPECT_TRUE(0 == OPENSSL_memcmp(ctx1.h, ctx2.h, sizeof(ctx1.h)));
335 }
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1970
ptr
char * ptr
Definition: abseil-cpp/absl/base/internal/low_level_alloc_test.cc:45
DigestTestVector::expected_hex
const char * expected_hex
Definition: digest_test.cc:68
obj
OPENSSL_EXPORT const ASN1_OBJECT * obj
Definition: x509.h:1671
NID_md5_sha1
#define NID_md5_sha1
Definition: nid.h:603
kTestVectors
static const DigestTestVector kTestVectors[]
Definition: digest_test.cc:71
EVP_md5_sha1
const OPENSSL_EXPORT EVP_MD * EVP_md5_sha1(void)
DigestTestVector::md
const MD & md
Definition: digest_test.cc:62
CBB_init
#define CBB_init
Definition: boringssl_prefix_symbols.h:1047
gen_build_yaml.out
dictionary out
Definition: src/benchmark/gen_build_yaml.py:24
EVP_sha512
const OPENSSL_EXPORT EVP_MD * EVP_sha512(void)
Bytes
Definition: boringssl-with-bazel/src/crypto/test/test_util.h:38
cbs_st
Definition: bytestring.h:39
OPENSSL_memcmp
static int OPENSSL_memcmp(const void *s1, const void *s2, size_t n)
Definition: third_party/boringssl-with-bazel/src/crypto/internal.h:811
DigestTestVector
Definition: digest_test.cc:60
DigestTestVector::repeat
size_t repeat
Definition: digest_test.cc:66
ctx
Definition: benchmark-async.c:30
EVP_get_digestbyname
#define EVP_get_digestbyname
Definition: boringssl_prefix_symbols.h:1726
sha224
static const MD sha224
Definition: digest_test.cc:52
SHA512_256
#define SHA512_256
Definition: boringssl_prefix_symbols.h:2165
env_md_st
Definition: third_party/boringssl-with-bazel/src/crypto/fipsmodule/digest/internal.h:67
MD::name
const char * name
Definition: digest_test.cc:41
EVP_sha384
const OPENSSL_EXPORT EVP_MD * EVP_sha384(void)
test
Definition: spinlock_test.cc:36
SHA256_CBLOCK
#define SHA256_CBLOCK
Definition: sha.h:152
EVP_get_digestbynid
#define EVP_get_digestbynid
Definition: boringssl_prefix_symbols.h:1727
string.h
copy
static int copy(grpc_slice_buffer *input, grpc_slice_buffer *output)
Definition: message_compress.cc:145
OPENSSL_ARRAY_SIZE
#define OPENSSL_ARRAY_SIZE(array)
Definition: third_party/boringssl-with-bazel/src/crypto/internal.h:179
SHA384
#define SHA384
Definition: boringssl_prefix_symbols.h:2160
CBS_len
#define CBS_len
Definition: boringssl_prefix_symbols.h:1089
u
OPENSSL_EXPORT pem_password_cb void * u
Definition: pem.h:351
EVP_DigestUpdate
#define EVP_DigestUpdate
Definition: boringssl_prefix_symbols.h:1516
ctx
static struct test_ctx ctx
Definition: test-ipc-send-recv.c:65
TestDigest
static void TestDigest(const DigestTestVector *test)
Definition: digest_test.cc:162
cbs
const CBS * cbs
Definition: third_party/boringssl-with-bazel/src/crypto/trust_token/internal.h:107
xds_manager.p
p
Definition: xds_manager.py:60
EVP_DigestInit_ex
#define EVP_DigestInit_ex
Definition: boringssl_prefix_symbols.h:1511
CBS_init
#define CBS_init
Definition: boringssl_prefix_symbols.h:1085
EVP_sha256
const OPENSSL_EXPORT EVP_MD * EVP_sha256(void)
uint8_t
unsigned char uint8_t
Definition: stdint-msvc2008.h:78
SHA512
#define SHA512
Definition: boringssl_prefix_symbols.h:2164
EVP_MD_CTX_copy_ex
#define EVP_MD_CTX_copy_ex
Definition: boringssl_prefix_symbols.h:1563
MD5
#define MD5
Definition: boringssl_prefix_symbols.h:1811
EXPECT_EQ
#define EXPECT_EQ(a, b)
Definition: iomgr/time_averaged_stats_test.cc:27
EVP_blake2b256
#define EVP_blake2b256
Definition: boringssl_prefix_symbols.h:1714
md4
static const MD md4
Definition: digest_test.cc:49
OBJ_nid2obj
#define OBJ_nid2obj
Definition: boringssl_prefix_symbols.h:1855
bytestring.h
sha256_state_st::h
uint32_t h[8]
Definition: sha.h:190
SCOPED_TRACE
#define SCOPED_TRACE(message)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2264
absl::move
constexpr absl::remove_reference_t< T > && move(T &&t) noexcept
Definition: abseil-cpp/absl/utility/utility.h:221
CBB_finish
#define CBB_finish
Definition: boringssl_prefix_symbols.h:1043
EVP_MD_size
#define EVP_MD_size
Definition: boringssl_prefix_symbols.h:1579
CompareDigest
static void CompareDigest(const DigestTestVector *test, const uint8_t *digest, size_t digest_len)
Definition: digest_test.cc:155
sha.h
OBJ_txt2obj
#define OBJ_txt2obj
Definition: boringssl_prefix_symbols.h:1861
EncodeHex
std::string EncodeHex(bssl::Span< const uint8_t > in)
Definition: boringssl-with-bazel/src/crypto/test/test_util.cc:75
OPENSSL_memcpy
static void * OPENSSL_memcpy(void *dst, const void *src, size_t n)
Definition: third_party/boringssl-with-bazel/src/crypto/internal.h:819
half
Definition: passthru_endpoint.cc:53
err.h
crypto.h
sha256
static const MD sha256
Definition: digest_test.cc:53
NID_undef
#define NID_undef
Definition: nid.h:85
EVP_marshal_digest_algorithm
#define EVP_marshal_digest_algorithm
Definition: boringssl_prefix_symbols.h:1735
SHA1
#define SHA1
Definition: boringssl_prefix_symbols.h:2145
uintptr_t
_W64 unsigned int uintptr_t
Definition: stdint-msvc2008.h:119
NID_sha1
#define NID_sha1
Definition: nid.h:372
sha512
static const MD sha512
Definition: digest_test.cc:55
stdint.h
NID_sha512
#define NID_sha512
Definition: nid.h:3003
ctx2
static struct echo_ctx ctx2
Definition: test-ipc-send-recv.c:66
md5_sha1
static const MD md5_sha1
Definition: digest_test.cc:57
SHA256
#define SHA256
Definition: boringssl_prefix_symbols.h:2154
sha256_state_st
Definition: sha.h:189
nid.h
digest.h
EVP_DigestFinal_ex
#define EVP_DigestFinal_ex
Definition: boringssl_prefix_symbols.h:1509
md4.h
md5.h
sha1
static const MD sha1
Definition: digest_test.cc:51
SHA224
#define SHA224
Definition: boringssl_prefix_symbols.h:2150
SHA256_Init
#define SHA256_Init
Definition: boringssl_prefix_symbols.h:2156
NID_sha512WithRSAEncryption
#define NID_sha512WithRSAEncryption
Definition: nid.h:2983
sha384
static const MD sha384
Definition: digest_test.cc:54
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1973
blake2b256
static const MD blake2b256
Definition: digest_test.cc:58
DigestTestVector::input
const char * input
Definition: digest_test.cc:64
MD
Definition: digest_test.cc:39
EVP_sha1
const OPENSSL_EXPORT EVP_MD * EVP_sha1(void)
google::protobuf::python::descriptor::Getters
static PyGetSetDef Getters[]
Definition: bloaty/third_party/protobuf/python/google/protobuf/pyext/descriptor.cc:417
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1967
obj.h
EVP_get_digestbyobj
#define EVP_get_digestbyobj
Definition: boringssl_prefix_symbols.h:1728
EVP_md4
const OPENSSL_EXPORT EVP_MD * EVP_md4(void)
EVP_md5
const OPENSSL_EXPORT EVP_MD * EVP_md5(void)
SHA256_TransformBlocks
#define SHA256_TransformBlocks
Definition: boringssl_prefix_symbols.h:2158
md5
static const MD md5
Definition: digest_test.cc:50
sha512_256
static const MD sha512_256
Definition: digest_test.cc:56
EVP_sha512_256
const OPENSSL_EXPORT EVP_MD * EVP_sha512_256(void)
TEST
TEST(DigestTest, TestVectors)
Definition: digest_test.cc:254
EVP_sha224
const OPENSSL_EXPORT EVP_MD * EVP_sha224(void)
i
uint64_t i
Definition: abseil-cpp/absl/container/btree_benchmark.cc:230
asn1.h
EVP_parse_digest_algorithm
#define EVP_parse_digest_algorithm
Definition: boringssl_prefix_symbols.h:1741
absl::MakeConstSpan
constexpr Span< const T > MakeConstSpan(T *ptr, size_t size) noexcept
Definition: abseil-cpp/absl/types/span.h:707
SHA256_Update
#define SHA256_Update
Definition: boringssl_prefix_symbols.h:2159

grpc
Author(s):
autogenerated on Thu Mar 13 2025 02:59:12