Commit 18a7ebda authored by David Carlier's avatar David Carlier
Browse files

[Sanitizers] intercept md5 and sha* apis on FreeBSD. 

Reviewed By: vitalybuka

Differential Revision: https://reviews.llvm.org/D110989
parent 3129aa5c

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

+2 −2
Original line number Diff line number Diff line
@@ -548,10 +548,10 @@ 
#define SANITIZER_INTERCEPT_SHA1 SI_NETBSD

#define SANITIZER_INTERCEPT_MD4 SI_NETBSD

#define SANITIZER_INTERCEPT_RMD160 SI_NETBSD

#define SANITIZER_INTERCEPT_MD5 SI_NETBSD

#define SANITIZER_INTERCEPT_MD5 (SI_NETBSD || SI_FREEBSD)

#define SANITIZER_INTERCEPT_FSEEK (SI_NETBSD || SI_FREEBSD)

#define SANITIZER_INTERCEPT_MD2 SI_NETBSD

#define SANITIZER_INTERCEPT_SHA2 SI_NETBSD

#define SANITIZER_INTERCEPT_SHA2 (SI_NETBSD || SI_FREEBSD)

#define SANITIZER_INTERCEPT_CDB SI_NETBSD

#define SANITIZER_INTERCEPT_VIS (SI_NETBSD || SI_FREEBSD)

#define SANITIZER_INTERCEPT_POPEN SI_POSIX

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.cpp

+21 −0
Original line number Diff line number Diff line
@@ -69,6 +69,11 @@ 
#include <semaphore.h>

#include <signal.h>

#include <stddef.h>

#include <md5.h>

#include <sha224.h>

#include <sha256.h>

#include <sha384.h>

#include <sha512.h>

#include <stdio.h>

#include <stringlist.h>

#include <term.h>
@@ -361,6 +366,22 @@ const int si_SEGV_MAPERR = SEGV_MAPERR; 
const int si_SEGV_ACCERR = SEGV_ACCERR;

const int unvis_valid = UNVIS_VALID;

const int unvis_validpush = UNVIS_VALIDPUSH;



const unsigned MD5_CTX_sz = sizeof(MD5_CTX);

const unsigned MD5_return_length = MD5_DIGEST_STRING_LENGTH;



#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-rt/lib/sanitizer_common/sanitizer_platform_limits_freebsd.h

+16 −0
Original line number Diff line number Diff line
@@ -647,6 +647,22 @@ extern unsigned IOCTL_KDSKBMODE; 
extern const int si_SEGV_MAPERR;

extern const int si_SEGV_ACCERR;



extern const unsigned MD5_CTX_sz;

extern const unsigned MD5_return_length;



#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



struct __sanitizer_cap_rights {

  u64 cr_rights[2];

};

compiler-rt/test/sanitizer_common/TestCases/FreeBSD/md5.cpp

0 → 100644
+119 −0
Original line number Diff line number Diff line 
// RUN: %clangxx -O0 -g %s -o %t -lmd && %run %t 2>&1 | FileCheck %s



#include <sys/param.h>



#include <assert.h>

#include <md5.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



void test1() {

  MD5_CTX ctx;

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  uint8_t digest[MD5_DIGEST_LENGTH];

  size_t entropysz = sizeof(entropy);

  size_t digestsz = sizeof(digest);



  MD5Init(&ctx);

  MD5Update(&ctx, entropy, entropysz);

  MD5Final(digest, &ctx);



  printf("test1: '");

  for (size_t i = 0; i < digestsz; i++)

    printf("%02x", digest[i]);

  printf("'\n");

}



void test2() {

  MD5_CTX ctx;

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  char digest[MD5_DIGEST_STRING_LENGTH];

  size_t entropysz = sizeof(entropy);



  MD5Init(&ctx);

  MD5Update(&ctx, entropy, entropysz);

  char *p = MD5End(&ctx, digest);

  assert(p);



  printf("test2: '%s'\n", digest);

}



void test3() {

  MD5_CTX ctx;

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  size_t entropysz = sizeof(entropy);



  MD5Init(&ctx);

  MD5Update(&ctx, entropy, entropysz);

  char *p = MD5End(&ctx, NULL);

  assert(strlen(p) == MD5_DIGEST_STRING_LENGTH - 1);



  printf("test3: '%s'\n", p);



  free(p);

}



void test4() {

  char digest[MD5_DIGEST_STRING_LENGTH];



  char *p = MD5File("/etc/fstab", digest);

  assert(p == digest);



  printf("test4: '%s'\n", p);

}



void test5() {

  char *p = MD5File("/etc/fstab", NULL);

  assert(strlen(p) == MD5_DIGEST_STRING_LENGTH - 1);



  printf("test5: '%s'\n", p);



  free(p);

}



void test6() {

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  char digest[MD5_DIGEST_STRING_LENGTH];

  size_t entropysz = sizeof(entropy);



  char *p = MD5Data(entropy, entropysz, digest);

  assert(p == digest);



  printf("test6: '%s'\n", p);

}



void test7() {

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  size_t entropysz = sizeof(entropy);



  char *p = MD5Data(entropy, entropysz, NULL);

  assert(strlen(p) == MD5_DIGEST_STRING_LENGTH - 1);



  printf("test7: '%s'\n", p);



  free(p);

}



int main(void) {

  printf("MD5\n");



  test1();

  test2();

  test3();

  test4();

  test5();

  test6();

  test7();



  // CHECK: MD5

  // CHECK: test1: '86e65b1ef4a830af347ac05ab4f0e999'

  // CHECK: test2: '86e65b1ef4a830af347ac05ab4f0e999'

  // CHECK: test3: '86e65b1ef4a830af347ac05ab4f0e999'

  // CHECK: test4: '{{.*}}'

  // CHECK: test5: '{{.*}}'

  // CHECK: test6: '86e65b1ef4a830af347ac05ab4f0e999'

  // CHECK: test7: '86e65b1ef4a830af347ac05ab4f0e999'



  return 0;

}

compiler-rt/test/sanitizer_common/TestCases/FreeBSD/sha2.cpp

0 → 100644
+214 −0
Original line number Diff line number Diff line 
// RUN: %clangxx -O0 -g %s -DSHASIZE=224 -o %t -lmd && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-224

// RUN: %clangxx -O0 -g %s -DSHASIZE=256 -o %t -lmd && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-256

// RUN: %clangxx -O0 -g %s -DSHASIZE=384 -o %t -lmd && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-384

// RUN: %clangxx -O0 -g %s -DSHASIZE=512 -o %t -lmd && %run %t 2>&1 | FileCheck %s -check-prefix=CHECK-512



#include <sys/param.h>



#include <assert.h>

#include <sha224.h>

#include <sha256.h>

#include <sha384.h>

#include <sha512.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



#ifndef SHASIZE

#error SHASIZE must be defined

#endif



#define _SHA_CTX(x) SHA##x##_CTX

#define SHA_CTX(x) _SHA_CTX(x)



#define _SHA_DIGEST_LENGTH(x) SHA##x##_DIGEST_LENGTH

#define SHA_DIGEST_LENGTH(x) _SHA_DIGEST_LENGTH(x)



#define _SHA_DIGEST_STRING_LENGTH(x) SHA##x##_DIGEST_STRING_LENGTH

#define SHA_DIGEST_STRING_LENGTH(x) _SHA_DIGEST_STRING_LENGTH(x)



#define _SHA_Init(x) SHA##x##_Init

#define SHA_Init(x) _SHA_Init(x)



#define _SHA_Update(x) SHA##x##_Update

#define SHA_Update(x) _SHA_Update(x)



#define _SHA_Final(x) SHA##x##_Final

#define SHA_Final(x) _SHA_Final(x)



#define _SHA_End(x) SHA##x##_End

#define SHA_End(x) _SHA_End(x)



#define _SHA_File(x) SHA##x##_File

#define SHA_File(x) _SHA_File(x)



#define _SHA_FileChunk(x) SHA##x##_FileChunk

#define SHA_FileChunk(x) _SHA_FileChunk(x)



#define _SHA_Data(x) SHA##x##_Data

#define SHA_Data(x) _SHA_Data(x)



void test1() {

  SHA_CTX(SHASIZE) ctx;

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  uint8_t digest[SHA_DIGEST_LENGTH(SHASIZE)];

  size_t entropysz = sizeof(entropy);

  size_t digestsz = sizeof(digest);



  SHA_Init(SHASIZE)(&ctx);

  SHA_Update(SHASIZE)(&ctx, entropy, entropysz);

  SHA_Final(SHASIZE)(digest, &ctx);



  printf("test1: '");

  for (size_t i = 0; i < digestsz; i++)

    printf("%02x", digest[i]);

  printf("'\n");

}



void test2() {

  SHA_CTX(SHASIZE) ctx;

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)];

  size_t entropysz = sizeof(entropy);



  SHA_Init(SHASIZE)(&ctx);

  SHA_Update(SHASIZE)(&ctx, entropy, entropysz);

  char *p = SHA_End(SHASIZE)(&ctx, digest);

  assert(p == digest);



  printf("test2: '%s'\n", digest);

}



void test3() {

  SHA_CTX(SHASIZE) ctx;

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  size_t entropysz = sizeof(entropy);



  SHA_Init(SHASIZE)(&ctx);

  SHA_Update(SHASIZE)(&ctx, entropy, entropysz);

  char *p = SHA_End(SHASIZE)(&ctx, NULL);

  assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1);



  printf("test3: '%s'\n", p);



  free(p);

}



void test4() {

  char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)];



  char *p = SHA_File(SHASIZE)("/etc/fstab", digest);

  assert(p == digest);



  printf("test4: '%s'\n", p);

}



void test5() {

  char *p = SHA_File(SHASIZE)("/etc/fstab", NULL);

  assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1);



  printf("test5: '%s'\n", p);



  free(p);

}



void test6() {

  char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)];



  char *p = SHA_FileChunk(SHASIZE)("/etc/fstab", digest, 10, 20);

  assert(p == digest);



  printf("test6: '%s'\n", p);

}



void test7() {

  char *p = SHA_FileChunk(SHASIZE)("/etc/fstab", NULL, 10, 20);

  assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1);



  printf("test7: '%s'\n", p);



  free(p);

}



void test8() {

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  char digest[SHA_DIGEST_STRING_LENGTH(SHASIZE)];

  size_t entropysz = sizeof(entropy);



  char *p = SHA_Data(SHASIZE)(entropy, entropysz, digest);

  assert(p == digest);



  printf("test8: '%s'\n", p);

}



void test9() {

  uint8_t entropy[] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};

  size_t entropysz = sizeof(entropy);



  char *p = SHA_Data(SHASIZE)(entropy, entropysz, NULL);

  assert(strlen(p) == SHA_DIGEST_STRING_LENGTH(SHASIZE) - 1);



  printf("test9: '%s'\n", p);



  free(p);

}



int main(void) {

  printf("SHA%d\n", SHASIZE);



  test1();

  test2();

  test3();

  test4();

  test5();

  test6();

  test7();

  test8();

  test9();



  // CHECK-224: SHA224

  // CHECK-224: test1: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'

  // CHECK-224: test2: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'

  // CHECK-224: test3: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'

  // CHECK-224: test4: '{{.*}}'

  // CHECK-224: test5: '{{.*}}'

  // CHECK-224: test6: '{{.*}}'

  // CHECK-224: test7: '{{.*}}'

  // CHECK-224: test8: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'

  // CHECK-224: test9: '760dfb93100a6bf5996c90f678e529dc945bb2f74a211eedcf0f3a48'



  // CHECK-256: SHA256

  // CHECK-256: test1: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8'

  // CHECK-256: test2: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8'

  // CHECK-256: test3: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8'

  // CHECK-256: test4: '{{.*}}'

  // CHECK-256: test5: '{{.*}}'

  // CHECK-256: test6: '{{.*}}'

  // CHECK-256: test7: '{{.*}}'

  // CHECK-256: test8: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8'

  // CHECK-256: test9: 'bb000ddd92a0a2a346f0b531f278af06e370f86932ccafccc892d68d350f80f8'



  // CHECK-384: SHA384

  // CHECK-384: test1: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'

  // CHECK-384: test2: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'

  // CHECK-384: test3: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'

  // CHECK-384: test4: '{{.*}}'

  // CHECK-384: test5: '{{.*}}'

  // CHECK-384: test6: '{{.*}}'

  // CHECK-384: test7: '{{.*}}'

  // CHECK-384: test8: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'

  // CHECK-384: test9: 'f450c023b168ebd56ff916ca9b1f1f0010b8c592d28205cc91fa3056f629eed108e8bac864f01ca37a3edee596739e12'



  // CHECK-512: SHA512

  // CHECK-512: test1: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'

  // CHECK-512: test2: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'

  // CHECK-512: test3: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'

  // CHECK-512: test4: '{{.*}}'

  // CHECK-512: test5: '{{.*}}'

  // CHECK-512: test6: '{{.*}}'

  // CHECK-512: test7: '{{.*}}'

  // CHECK-512: test8: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'

  // CHECK-512: test9: '0e3f68731c0e2a6a4eab5d713c9a80dc78086b5fa7d2b5ab127277958e68d1b1dee1882b083b0106cd4319de42c0c8f452871364f5baa8a6379690612c6b844e'



  return 0;

}