Add interceptors for the sha2(3) from NetBSD

[krytarowski]

Summary

SHA224_Init, SHA224_Update, SHA224_Final, SHA224_End, SHA224_File,
SHA224_FileChunk, SHA224_Data, SHA256_Init, SHA256_Update, SHA256_Final,
SHA256_End, SHA256_File, SHA256_FileChunk, SHA256_Data, SHA384_Init,
SHA384_Update, SHA384_Final, SHA384_End, SHA384_File, SHA384_FileChunk,
SHA384_Data, SHA512_Init, SHA512_Update, SHA512_Final, SHA512_End,
SHA512_File, SHA512_FileChunk, SHA512_Data – calculates the NIST Secure
Hash Standard (version 2)

Add tests for new interceptors.

[vitalybuka]

lib/sanitizer_common/sanitizer_common_interceptors.inc

7420

#define INIT_SHA2_INTECEPTORS(LEN) \
 COMMON_INTERCEPT_FUNCTION(SHA##LEN##_Init); \
...
 COMMON_INTERCEPT_FUNCTION(SHA##LEN##_Data); \


#define INIT_SHA2 \
   INIT_SHA2_INTECEPTORS(224); \
   INIT_SHA2_INTECEPTORS(256); \
   INIT_SHA2_INTECEPTORS(384); \
   INIT_SHA2_INTECEPTORS(512);

test/sanitizer_common/TestCases/NetBSD/sha224.cc

1

tests are very similar. can you just use multiple:

RUN: .. -DSSH_SIZE=224..
RUN: .. -DSSH_SIZE=256..
RUN: .. -DSSH_SIZE=384..

test/sanitizer_common/TestCases/NetBSD/sha256.cc

144

tests are broken by clang-format
please protect such lines with
clang-format off
clang-format on

[krytarowski]

• apply enhancements
• align style

[vitalybuka]

test/sanitizer_common/TestCases/NetBSD/sha2.cc

161 ↗

(On Diff #177360)

actually I've recently updated clang-format config, similar to llvm and clang
it will not brake long lines in tests, so off/on is not needed

lib/sanitizer_common/sanitizer_common_interceptors.inc

 #define INIT_SETVBUF COMMON_INTERCEPT_FUNCTION(setvbuf); \
     COMMON_INTERCEPT_FUNCTION(setbuf); \
     COMMON_INTERCEPT_FUNCTION(setbuffer); \
     COMMON_INTERCEPT_FUNCTION(setlinebuf)
 #else
 #define INIT_SETVBUF
 #endif
 
+#if SANITIZER_INTERCEPT_SHA2
+#define SHA2_INTERCEPTORS(LEN, SHA2_STATE_T) \
+  INTERCEPTOR(void, SHA##LEN##_Init, void *context) { \
+    void *ctx; \
+    COMMON_INTERCEPTOR_ENTER(ctx, SHA##LEN##_Init, context); \
+    REAL(SHA##LEN##_Init)(context); \
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, context, SHA##LEN##_CTX_sz); \
+  } \
+  INTERCEPTOR(void, SHA##LEN##_Update, void *context, \
+              const u8 *data, SIZE_T len) { \
+    void *ctx; \
+    COMMON_INTERCEPTOR_ENTER(ctx, SHA##LEN##_Update, context, data, len); \
+    if (data) \
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, data, len); \
+    if (context) \
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, context, SHA##LEN##_CTX_sz); \
+    REAL(SHA##LEN##_Update)(context, data, len); \
+  } \
+  INTERCEPTOR(void, SHA##LEN##_Final, u8 digest[SHA##LEN##_digest_length], \
+  void *context) { \
+    void *ctx; \
+    COMMON_INTERCEPTOR_ENTER(ctx, SHA##LEN##_Final, digest, context); \
+    REAL(SHA##LEN##_Final)(digest, context); \
+    if (digest) \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, digest, \
+                                     sizeof(digest[0]) * \
+  SHA##LEN##_digest_length); \
+  } \
+  INTERCEPTOR(char *, SHA##LEN##_End, void *context, char *buf) { \
+    void *ctx; \
+    COMMON_INTERCEPTOR_ENTER(ctx, SHA##LEN##_End, context, buf); \
+    if (context) \
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, context, SHA##LEN##_CTX_sz); \
+    char *ret = REAL(SHA##LEN##_End)(context, buf); \
+    if (ret) \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA##LEN##_return_length); \
+    return ret; \
+  } \
+  INTERCEPTOR(char *, SHA##LEN##_File, const char *filename, char *buf) { \
+    void *ctx; \
+    COMMON_INTERCEPTOR_ENTER(ctx, SHA##LEN##_File, filename, buf); \
+    if (filename) \
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, filename, REAL(strlen)(filename) + 1);\
+    char *ret = REAL(SHA##LEN##_File)(filename, buf); \
+    if (ret) \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA##LEN##_return_length); \
+    return ret; \
+  } \
+  INTERCEPTOR(char *, SHA##LEN##_FileChunk, const char *filename, char *buf, \
+              OFF_T offset, OFF_T length) { \
+    void *ctx; \
+    COMMON_INTERCEPTOR_ENTER(ctx, SHA##LEN##_FileChunk, filename, buf, offset, \
+  length); \
+    if (filename) \
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, filename, REAL(strlen)(filename) + 1);\
+    char *ret = REAL(SHA##LEN##_FileChunk)(filename, buf, offset, length); \
+    if (ret) \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA##LEN##_return_length); \
+    return ret; \
+  } \
+  INTERCEPTOR(char *, SHA##LEN##_Data, u8 *data, SIZE_T len, char *buf) { \
+    void *ctx; \
+    COMMON_INTERCEPTOR_ENTER(ctx, SHA##LEN##_Data, data, len, buf); \
+    if (data) \
+      COMMON_INTERCEPTOR_READ_RANGE(ctx, data, len); \
+    char *ret = REAL(SHA##LEN##_Data)(data, len, buf); \
+    if (ret) \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA##LEN##_return_length); \
+    return ret; \
+  }
+
+SHA2_INTERCEPTORS(224, u32);
+SHA2_INTERCEPTORS(256, u32);
+SHA2_INTERCEPTORS(384, u64);
+SHA2_INTERCEPTORS(512, u64);
+
+
+#define INIT_SHA2 \
+  COMMON_INTERCEPT_FUNCTION(SHA224_Init); \
+  COMMON_INTERCEPT_FUNCTION(SHA224_Update); \
+  COMMON_INTERCEPT_FUNCTION(SHA224_Final); \
+  COMMON_INTERCEPT_FUNCTION(SHA224_End); \
+  COMMON_INTERCEPT_FUNCTION(SHA224_File); \
+  COMMON_INTERCEPT_FUNCTION(SHA224_FileChunk); \
+  COMMON_INTERCEPT_FUNCTION(SHA224_Data); \
+  COMMON_INTERCEPT_FUNCTION(SHA256_Init); \
+  COMMON_INTERCEPT_FUNCTION(SHA256_Update); \
+  COMMON_INTERCEPT_FUNCTION(SHA256_Final); \
+  COMMON_INTERCEPT_FUNCTION(SHA256_End); \
+  COMMON_INTERCEPT_FUNCTION(SHA256_File); \
+  COMMON_INTERCEPT_FUNCTION(SHA256_FileChunk); \
+  COMMON_INTERCEPT_FUNCTION(SHA256_Data); \
+  COMMON_INTERCEPT_FUNCTION(SHA384_Init); \
+  COMMON_INTERCEPT_FUNCTION(SHA384_Update); \
+  COMMON_INTERCEPT_FUNCTION(SHA384_Final); \
+  COMMON_INTERCEPT_FUNCTION(SHA384_End); \
+  COMMON_INTERCEPT_FUNCTION(SHA384_File); \
+  COMMON_INTERCEPT_FUNCTION(SHA384_FileChunk); \
+  COMMON_INTERCEPT_FUNCTION(SHA384_Data); \
+  COMMON_INTERCEPT_FUNCTION(SHA512_Init); \
+  COMMON_INTERCEPT_FUNCTION(SHA512_Update); \
+  COMMON_INTERCEPT_FUNCTION(SHA512_Final); \
+  COMMON_INTERCEPT_FUNCTION(SHA512_End); \
+  COMMON_INTERCEPT_FUNCTION(SHA512_File); \
+  COMMON_INTERCEPT_FUNCTION(SHA512_FileChunk); \
+  COMMON_INTERCEPT_FUNCTION(SHA512_Data)
+#undef SHA2_INTERCEPTORS
+#else
+#define INIT_SHA2
+#endif
+
 static void InitializeCommonInterceptors() {
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map = new((void *)&metadata_mem) MetadataHashMap();
 
   INIT_MMAP;
   INIT_MMAP64;
   INIT_TEXTDOMAIN;
   INIT_STRLEN;
static void InitializeCommonInterceptors() {
   INIT_FGETLN;
   INIT_STRMODE;
   INIT_TTYENT;
   INIT_PROTOENT;
   INIT_NETENT;
   INIT_GETMNTINFO;
   INIT_MI_VECTOR_HASH;
   INIT_SETVBUF;
+  INIT_SHA2;
 
   INIT___PRINTF_CHK;
 }

lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_STRMODE (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_TTYENT SI_NETBSD
 #define SANITIZER_INTERCEPT_PROTOENT SI_NETBSD
 #define SANITIZER_INTERCEPT_NETENT SI_NETBSD
 #define SANITIZER_INTERCEPT_SETVBUF (SI_NETBSD || SI_FREEBSD || \
   SI_LINUX || SI_MAC)
 #define SANITIZER_INTERCEPT_GETMNTINFO SI_NETBSD
 #define SANITIZER_INTERCEPT_MI_VECTOR_HASH SI_NETBSD
+#define SANITIZER_INTERCEPT_SHA2 SI_NETBSD
 
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

 extern unsigned IOCTL_SNDCTL_DSP_SETPLAYVOL;
 extern unsigned IOCTL_SNDCTL_DSP_GETRECVOL;
 extern unsigned IOCTL_SNDCTL_DSP_SETRECVOL;
 extern unsigned IOCTL_SNDCTL_DSP_SKIP;
 extern unsigned IOCTL_SNDCTL_DSP_SILENCE;
 
 extern const int si_SEGV_MAPERR;
 extern const int si_SEGV_ACCERR;
+
+#define SHA2_EXTERN(LEN)                          \
+  extern const unsigned SHA##LEN##_CTX_sz;        \
+  extern const unsigned SHA##LEN##_return_length; \
+  extern const unsigned SHA##LEN##_block_length;  \
+  extern const unsigned SHA##LEN##_digest_length
+
+SHA2_EXTERN(224);
+SHA2_EXTERN(256);
+SHA2_EXTERN(384);
+SHA2_EXTERN(512);
+
+#undef SHA2_EXTERN
 }  // namespace __sanitizer
 
 #define CHECK_TYPE_SIZE(TYPE) \
   COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
 
 #define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER)                      \
   COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \
                  sizeof(((CLASS *)NULL)->MEMBER));                \

lib/sanitizer_common/sanitizer_platform_limits_netbsd.cc

 unsigned IOCTL_SNDCTL_DSP_SETPLAYVOL = SNDCTL_DSP_SETPLAYVOL;
 unsigned IOCTL_SNDCTL_DSP_GETRECVOL = SNDCTL_DSP_GETRECVOL;
 unsigned IOCTL_SNDCTL_DSP_SETRECVOL = SNDCTL_DSP_SETRECVOL;
 unsigned IOCTL_SNDCTL_DSP_SKIP = SNDCTL_DSP_SKIP;
 unsigned IOCTL_SNDCTL_DSP_SILENCE = SNDCTL_DSP_SILENCE;
 
 const int si_SEGV_MAPERR = SEGV_MAPERR;
 const int si_SEGV_ACCERR = SEGV_ACCERR;
+
+#define SHA2_CONST(LEN)                                                      \
+  const unsigned SHA##LEN##_CTX_sz = sizeof(SHA##LEN##_CTX);                 \
+  const unsigned SHA##LEN##_return_length = SHA##LEN##_DIGEST_STRING_LENGTH; \
+  const unsigned SHA##LEN##_block_length = SHA##LEN##_BLOCK_LENGTH;          \
+  const unsigned SHA##LEN##_digest_length = SHA##LEN##_DIGEST_LENGTH
+
+SHA2_CONST(224);
+SHA2_CONST(256);
+SHA2_CONST(384);
+SHA2_CONST(512);
+
+#undef SHA2_CONST
 }  // namespace __sanitizer
 
 using namespace __sanitizer;
 
 COMPILER_CHECK(sizeof(__sanitizer_pthread_attr_t) >= sizeof(pthread_attr_t));
 
 COMPILER_CHECK(sizeof(socklen_t) == sizeof(unsigned));
 CHECK_TYPE_SIZE(pthread_key_t);

test/sanitizer_common/TestCases/NetBSD/sha224.cc

+// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <sys/param.h>
+
+#include <endian.h>
+#include <sha2.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1() {
+  SHA224_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  uint8_t digest[SHA224_DIGEST_LENGTH];
+  size_t i;
+
+  SHA224_Init(&ctx);
+  SHA224_Update(&ctx, entropy, __arraycount(entropy));
+  SHA224_Final(digest, &ctx);
+
+  printf("test1: '");
+  for (i = 0; i < __arraycount(digest); i++)
+    printf("%02x", digest[i]);
+  printf("'\n");
+}
+
+void test2() {
+  SHA224_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA224_DIGEST_STRING_LENGTH];
+  char *p;
+
+  SHA224_Init(&ctx);
+  SHA224_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA224_End(&ctx, digest);
+  if (p != digest)
+    abort();
+
+  printf("test2: '%s'\n", digest);
+}
+
+void test3() {
+  SHA224_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  SHA224_Init(&ctx);
+  SHA224_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA224_End(&ctx, NULL);
+  if (strlen(p) != SHA224_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test3: '%s'\n", p);
+
+  free(p);
+}
+
+void test4() {
+  char digest[SHA224_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA224_File("/etc/fstab", digest);
+  if (p != digest)
+    abort();
+
+  printf("test4: '%s'\n", p);
+}
+
+void test5() {
+  char *p;
+
+  p = SHA224_File("/etc/fstab", NULL);
+  if (strlen(p) != SHA224_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test5: '%s'\n", p);
+
+  free(p);
+}
+
+void test6() {
+  char digest[SHA224_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA224_FileChunk("/etc/fstab", digest, 10, 20);
+  if (p != digest)
+    abort();
+
+  printf("test6: '%s'\n", p);
+}
+
+void test7() {
+  char *p;
+
+  p = SHA224_FileChunk("/etc/fstab", NULL, 10, 20);
+  if (strlen(p) != SHA224_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test7: '%s'\n", p);
+
+  free(p);
+}
+
+void test8() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA224_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA224_Data(entropy, __arraycount(entropy), digest);
+  if (p != digest)
+    abort();
+
+  printf("test8: '%s'\n", p);
+}
+
+void test9() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  p = SHA224_Data(entropy, __arraycount(entropy), NULL);
+  if (strlen(p) != SHA224_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test9: '%s'\n", p);
+
+  free(p);
+}
+
+int main(void) {
+  printf("SHA224\n");
+
+  test1();
+  test2();
+  test3();
+  test4();
+  test5();
+  test6();
+  test7();
+  test8();
+  test9();
+
+  // CHECK: SHA224
+  // CHECK: test1: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'
+  // CHECK: test2: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'
+  // CHECK: test3: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'
+  // CHECK: test4: '{{.*}}'
+  // CHECK: test5: '{{.*}}'
+  // CHECK: test6: '{{.*}}'
+  // CHECK: test7: '{{.*}}'
+  // CHECK: test8: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'
+  // CHECK: test9: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'
+
+  return 0;
+}

test/sanitizer_common/TestCases/NetBSD/sha256.cc

+// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <sys/param.h>
+
+#include <endian.h>
+#include <sha2.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1() {
+  SHA256_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  uint8_t digest[SHA256_DIGEST_LENGTH];
+  size_t i;
+
+  SHA256_Init(&ctx);
+  SHA256_Update(&ctx, entropy, __arraycount(entropy));
+  SHA256_Final(digest, &ctx);
+
+  printf("test1: '");
+  for (i = 0; i < __arraycount(digest); i++)
+    printf("%02x", digest[i]);
+  printf("'\n");
+}
+
+void test2() {
+  SHA256_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA256_DIGEST_STRING_LENGTH];
+  char *p;
+
+  SHA256_Init(&ctx);
+  SHA256_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA256_End(&ctx, digest);
+  if (p != digest)
+    abort();
+
+  printf("test2: '%s'\n", digest);
+}
+
+void test3() {
+  SHA256_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  SHA256_Init(&ctx);
+  SHA256_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA256_End(&ctx, NULL);
+  if (strlen(p) != SHA256_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test3: '%s'\n", p);
+
+  free(p);
+}
+
+void test4() {
+  char digest[SHA256_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA256_File("/etc/fstab", digest);
+  if (p != digest)
+    abort();
+
+  printf("test4: '%s'\n", p);
+}
+
+void test5() {
+  char *p;
+
+  p = SHA256_File("/etc/fstab", NULL);
+  if (strlen(p) != SHA256_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test5: '%s'\n", p);
+
+  free(p);
+}
+
+void test6() {
+  char digest[SHA256_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA256_FileChunk("/etc/fstab", digest, 10, 20);
+  if (p != digest)
+    abort();
+
+  printf("test6: '%s'\n", p);
+}
+
+void test7() {
+  char *p;
+
+  p = SHA256_FileChunk("/etc/fstab", NULL, 10, 20);
+  if (strlen(p) != SHA256_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test7: '%s'\n", p);
+
+  free(p);
+}
+
+void test8() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA256_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA256_Data(entropy, __arraycount(entropy), digest);
+  if (p != digest)
+    abort();
+
+  printf("test8: '%s'\n", p);
+}
+
+void test9() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  p = SHA256_Data(entropy, __arraycount(entropy), NULL);
+  if (strlen(p) != SHA256_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test9: '%s'\n", p);
+
+  free(p);
+}
+
+int main(void) {
+  printf("SHA256\n");
+
+  test1();
+  test2();
+  test3();
+  test4();
+  test5();
+  test6();
+  test7();
+  test8();
+  test9();
+
+  // CHECK: SHA256
+  // CHECK: test1:
+  // 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' CHECK:
+  // test2: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8'
+  // CHECK: test3:
+  // 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' CHECK:
+  // test4: '{{.*}}' CHECK: test5: '{{.*}}' CHECK: test6: '{{.*}}' CHECK: test7:
+  // '{{.*}}' CHECK: test8:
+  // 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8' CHECK:
+  // test9: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8'
+
+  return 0;
+}

test/sanitizer_common/TestCases/NetBSD/sha384.cc

+// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <sys/param.h>
+
+#include <endian.h>
+#include <sha2.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1() {
+  SHA384_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  uint8_t digest[SHA384_DIGEST_LENGTH];
+  size_t i;
+
+  SHA384_Init(&ctx);
+  SHA384_Update(&ctx, entropy, __arraycount(entropy));
+  SHA384_Final(digest, &ctx);
+
+  printf("test1: '");
+  for (i = 0; i < __arraycount(digest); i++)
+    printf("%02x", digest[i]);
+  printf("'\n");
+}
+
+void test2() {
+  SHA384_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA384_DIGEST_STRING_LENGTH];
+  char *p;
+
+  SHA384_Init(&ctx);
+  SHA384_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA384_End(&ctx, digest);
+  if (p != digest)
+    abort();
+
+  printf("test2: '%s'\n", digest);
+}
+
+void test3() {
+  SHA384_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  SHA384_Init(&ctx);
+  SHA384_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA384_End(&ctx, NULL);
+  if (strlen(p) != SHA384_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test3: '%s'\n", p);
+
+  free(p);
+}
+
+void test4() {
+  char digest[SHA384_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA384_File("/etc/fstab", digest);
+  if (p != digest)
+    abort();
+
+  printf("test4: '%s'\n", p);
+}
+
+void test5() {
+  char *p;
+
+  p = SHA384_File("/etc/fstab", NULL);
+  if (strlen(p) != SHA384_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test5: '%s'\n", p);
+
+  free(p);
+}
+
+void test6() {
+  char digest[SHA384_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA384_FileChunk("/etc/fstab", digest, 10, 20);
+  if (p != digest)
+    abort();
+
+  printf("test6: '%s'\n", p);
+}
+
+void test7() {
+  char *p;
+
+  p = SHA384_FileChunk("/etc/fstab", NULL, 10, 20);
+  if (strlen(p) != SHA384_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test7: '%s'\n", p);
+
+  free(p);
+}
+
+void test8() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA384_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA384_Data(entropy, __arraycount(entropy), digest);
+  if (p != digest)
+    abort();
+
+  printf("test8: '%s'\n", p);
+}
+
+void test9() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  p = SHA384_Data(entropy, __arraycount(entropy), NULL);
+  if (strlen(p) != SHA384_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test9: '%s'\n", p);
+
+  free(p);
+}
+
+int main(void) {
+  printf("SHA384\n");
+
+  test1();
+  test2();
+  test3();
+  test4();
+  test5();
+  test6();
+  test7();
+  test8();
+  test9();
+
+  // CHECK: SHA384
+  // CHECK: test1:
+  // 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'
+  // CHECK: test2:
+  // 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'
+  // CHECK: test3:
+  // 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'
+  // CHECK: test4: '{{.*}}'
+  // CHECK: test5: '{{.*}}'
+  // CHECK: test6: '{{.*}}'
+  // CHECK: test7: '{{.*}}'
+  // CHECK: test8:
+  // 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'
+  // CHECK: test9:
+  // 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'
+
+  return 0;
+}

test/sanitizer_common/TestCases/NetBSD/sha512.cc

+// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <sys/param.h>
+
+#include <endian.h>
+#include <sha2.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test1() {
+  SHA512_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  uint8_t digest[SHA512_DIGEST_LENGTH];
+  size_t i;
+
+  SHA512_Init(&ctx);
+  SHA512_Update(&ctx, entropy, __arraycount(entropy));
+  SHA512_Final(digest, &ctx);
+
+  printf("test1: '");
+  for (i = 0; i < __arraycount(digest); i++)
+    printf("%02x", digest[i]);
+  printf("'\n");
+}
+
+void test2() {
+  SHA512_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA512_DIGEST_STRING_LENGTH];
+  char *p;
+
+  SHA512_Init(&ctx);
+  SHA512_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA512_End(&ctx, digest);
+  if (p != digest)
+    abort();
+
+  printf("test2: '%s'\n", digest);
+}
+
+void test3() {
+  SHA512_CTX ctx;
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  SHA512_Init(&ctx);
+  SHA512_Update(&ctx, entropy, __arraycount(entropy));
+  p = SHA512_End(&ctx, NULL);
+  if (strlen(p) != SHA512_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test3: '%s'\n", p);
+
+  free(p);
+}
+
+void test4() {
+  char digest[SHA512_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA512_File("/etc/fstab", digest);
+  if (p != digest)
+    abort();
+
+  printf("test4: '%s'\n", p);
+}
+
+void test5() {
+  char *p;
+
+  p = SHA512_File("/etc/fstab", NULL);
+  if (strlen(p) != SHA512_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test5: '%s'\n", p);
+
+  free(p);
+}
+
+void test6() {
+  char digest[SHA512_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA512_FileChunk("/etc/fstab", digest, 10, 20);
+  if (p != digest)
+    abort();
+
+  printf("test6: '%s'\n", p);
+}
+
+void test7() {
+  char *p;
+
+  p = SHA512_FileChunk("/etc/fstab", NULL, 10, 20);
+  if (strlen(p) != SHA512_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test7: '%s'\n", p);
+
+  free(p);
+}
+
+void test8() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char digest[SHA512_DIGEST_STRING_LENGTH];
+  char *p;
+
+  p = SHA512_Data(entropy, __arraycount(entropy), digest);
+  if (p != digest)
+    abort();
+
+  printf("test8: '%s'\n", p);
+}
+
+void test9() {
+  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
+  char *p;
+
+  p = SHA512_Data(entropy, __arraycount(entropy), NULL);
+  if (strlen(p) != SHA512_DIGEST_STRING_LENGTH - 1)
+    abort();
+
+  printf("test9: '%s'\n", p);
+
+  free(p);
+}
+
+int main(void) {
+  printf("SHA512\n");
+
+  test1();
+  test2();
+  test3();
+  test4();
+  test5();
+  test6();
+  test7();
+  test8();
+  test9();
+
+  // CHECK: SHA512
+  // CHECK: test1:
+  // '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'
+  // CHECK: test2:
+  // '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'
+  // CHECK: test3:
+  // '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'
+  // CHECK: test4: '{{.*}}'
+  // CHECK: test5: '{{.*}}'
+  // CHECK: test6: '{{.*}}'
+  // CHECK: test7: '{{.*}}'
+  // CHECK: test8:
+  // '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'
+  // CHECK: test9:
+  // '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'
+
+  return 0;
+}