Skip to content

Commit 3f47a6f

Browse files
krytarowskikrytarowski
committed
Add interceptors for the sha1(3) from NetBSD
Summary: Add interceptors for: - SHA1Init - SHA1Update - SHA1Final - SHA1Transform - SHA1End - SHA1File - SHA1FileChunk - SHA1Data Add a dedicated regression test for this API. Reviewers: vitalybuka, joerg Reviewed By: vitalybuka Subscribers: mgorny, llvm-commits, kubamracek, #sanitizers Tags: #sanitizers Differential Revision: https://reviews.llvm.org/D54927 llvm-svn: 348676
1 parent 041c9fa commit 3f47a6f

File tree

5 files changed

+272
-0
lines changed

5 files changed

+272
-0
lines changed

‎compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7888,6 +7888,99 @@ INTERCEPTOR(int, cap_ioctls_get, int fd, uptr *cmds, SIZE_T maxcmds) {
78887888
#define INIT_CAPSICUM
78897889
#endif
78907890

7891+
#if SANITIZER_INTERCEPT_SHA1
7892+
INTERCEPTOR(void, SHA1Init, void *context) {
7893+
void *ctx;
7894+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1Init, context);
7895+
REAL(SHA1Init)(context);
7896+
if (context)
7897+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, context, SHA1_CTX_sz);
7898+
}
7899+
INTERCEPTOR(void, SHA1Update, void *context, const u8 *data, unsigned len) {
7900+
void *ctx;
7901+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1Update, context, data, len);
7902+
if (data && len > 0)
7903+
COMMON_INTERCEPTOR_READ_RANGE(ctx, data, len);
7904+
if (context)
7905+
COMMON_INTERCEPTOR_READ_RANGE(ctx, context, SHA1_CTX_sz);
7906+
REAL(SHA1Update)(context, data, len);
7907+
if (context)
7908+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, context, SHA1_CTX_sz);
7909+
}
7910+
INTERCEPTOR(void, SHA1Final, u8 digest[20], void *context) {
7911+
void *ctx;
7912+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1Final, digest, context);
7913+
if (context)
7914+
COMMON_INTERCEPTOR_READ_RANGE(ctx, context, SHA1_CTX_sz);
7915+
REAL(SHA1Final)(digest, context);
7916+
if (digest)
7917+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, digest, sizeof(u8) * 20);
7918+
}
7919+
INTERCEPTOR(void, SHA1Transform, u32 state[5], u8 buffer[64]) {
7920+
void *ctx;
7921+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1Transform, state, buffer);
7922+
if (state)
7923+
COMMON_INTERCEPTOR_READ_RANGE(ctx, state, sizeof(u32) * 5);
7924+
if (buffer)
7925+
COMMON_INTERCEPTOR_READ_RANGE(ctx, buffer, sizeof(u8) * 64);
7926+
REAL(SHA1Transform)(state, buffer);
7927+
if (state)
7928+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, state, sizeof(u32) * 5);
7929+
}
7930+
INTERCEPTOR(char *, SHA1End, void *context, char *buf) {
7931+
void *ctx;
7932+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1End, context, buf);
7933+
if (context)
7934+
COMMON_INTERCEPTOR_READ_RANGE(ctx, context, SHA1_CTX_sz);
7935+
char *ret = REAL(SHA1End)(context, buf);
7936+
if (ret)
7937+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA1_return_length);
7938+
return ret;
7939+
}
7940+
INTERCEPTOR(char *, SHA1File, char *filename, char *buf) {
7941+
void *ctx;
7942+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1File, filename, buf);
7943+
if (filename)
7944+
COMMON_INTERCEPTOR_READ_RANGE(ctx, filename, REAL(strlen)(filename) + 1);
7945+
char *ret = REAL(SHA1File)(filename, buf);
7946+
if (ret)
7947+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA1_return_length);
7948+
return ret;
7949+
}
7950+
INTERCEPTOR(char *, SHA1FileChunk, char *filename, char *buf, OFF_T offset,
7951+
OFF_T length) {
7952+
void *ctx;
7953+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1FileChunk, filename, buf, offset, length);
7954+
if (filename)
7955+
COMMON_INTERCEPTOR_READ_RANGE(ctx, filename, REAL(strlen)(filename) + 1);
7956+
char *ret = REAL(SHA1FileChunk)(filename, buf, offset, length);
7957+
if (ret)
7958+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA1_return_length);
7959+
return ret;
7960+
}
7961+
INTERCEPTOR(char *, SHA1Data, u8 *data, SIZE_T len, char *buf) {
7962+
void *ctx;
7963+
COMMON_INTERCEPTOR_ENTER(ctx, SHA1Data, data, len, buf);
7964+
if (data)
7965+
COMMON_INTERCEPTOR_READ_RANGE(ctx, data, len);
7966+
char *ret = REAL(SHA1Data)(data, len, buf);
7967+
if (ret)
7968+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, SHA1_return_length);
7969+
return ret;
7970+
}
7971+
#define INIT_SHA1 \
7972+
COMMON_INTERCEPT_FUNCTION(SHA1Init); \
7973+
COMMON_INTERCEPT_FUNCTION(SHA1Update); \
7974+
COMMON_INTERCEPT_FUNCTION(SHA1Final); \
7975+
COMMON_INTERCEPT_FUNCTION(SHA1Transform); \
7976+
COMMON_INTERCEPT_FUNCTION(SHA1End); \
7977+
COMMON_INTERCEPT_FUNCTION(SHA1File); \
7978+
COMMON_INTERCEPT_FUNCTION(SHA1FileChunk); \
7979+
COMMON_INTERCEPT_FUNCTION(SHA1Data)
7980+
#else
7981+
#define INIT_SHA1
7982+
#endif
7983+
78917984
static void InitializeCommonInterceptors() {
78927985
static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
78937986
interceptor_metadata_map =
@@ -8158,6 +8251,7 @@ static void InitializeCommonInterceptors() {
81588251
INIT_STATVFS1;
81598252
INIT_STRTOI;
81608253
INIT_CAPSICUM;
8254+
INIT_SHA1;
81618255

81628256
INIT___PRINTF_CHK;
81638257
}

‎compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -535,5 +535,6 @@
535535
#define SANITIZER_INTERCEPT_STATVFS1 SI_NETBSD
536536
#define SANITIZER_INTERCEPT_STRTOI SI_NETBSD
537537
#define SANITIZER_INTERCEPT_CAPSICUM SI_FREEBSD
538+
#define SANITIZER_INTERCEPT_SHA1 SI_NETBSD
538539

539540
#endif // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

‎compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.cc

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2101,6 +2101,9 @@ const int modctl_load = MODCTL_LOAD;
21012101
const int modctl_unload = MODCTL_UNLOAD;
21022102
const int modctl_stat = MODCTL_STAT;
21032103
const int modctl_exists = MODCTL_EXISTS;
2104+
2105+
const unsigned SHA1_CTX_sz = sizeof(SHA1_CTX);
2106+
const unsigned SHA1_return_length = SHA1_DIGEST_STRING_LENGTH;
21042107
} // namespace __sanitizer
21052108

21062109
using namespace __sanitizer;

‎compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2225,6 +2225,9 @@ extern unsigned IOCTL_SNDCTL_DSP_SILENCE;
22252225

22262226
extern const int si_SEGV_MAPERR;
22272227
extern const int si_SEGV_ACCERR;
2228+
2229+
extern const unsigned SHA1_CTX_sz;
2230+
extern const unsigned SHA1_return_length;
22282231
} // namespace __sanitizer
22292232

22302233
#define CHECK_TYPE_SIZE(TYPE) \

‎compiler-rt/test/sanitizer_common/TestCases/NetBSD/sha1.cc

Lines changed: 171 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,171 @@
1+
// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
2+
3+
#include <assert.h>
4+
#include <sha1.h>
5+
#include <stdio.h>
6+
#include <stdlib.h>
7+
#include <string.h>
8+
9+
void test1() {
10+
SHA1_CTX ctx;
11+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
12+
uint8_t digest[SHA1_DIGEST_LENGTH];
13+
14+
SHA1Init(&ctx);
15+
SHA1Update(&ctx, entropy, __arraycount(entropy));
16+
SHA1Final(digest, &ctx);
17+
18+
printf("test1: '");
19+
for (size_t i = 0; i < __arraycount(digest); i++)
20+
printf("%02x", digest[i]);
21+
printf("'\n");
22+
}
23+
24+
void local_SHA1Update(SHA1_CTX *context, const uint8_t *data, unsigned int len)
25+
{
26+
unsigned int a, b;
27+
28+
b = context->count[0];
29+
context->count[0] += len << 3;
30+
if (context->count[0] < b)
31+
context->count[1] += (len >> 29) + 1;
32+
b = (b >> 3) & 63;
33+
if ((b + len) > 63) {
34+
memcpy(&context->buffer[b], data, (a = 64 - b));
35+
SHA1Transform(context->state, context->buffer);
36+
for ( ; a + 63 < len; a += 64)
37+
SHA1Transform(context->state, &data[a]);
38+
b = 0;
39+
} else {
40+
a = 0;
41+
}
42+
memcpy(&context->buffer[b], &data[a], len - a);
43+
}
44+
45+
void test2() {
46+
SHA1_CTX ctx;
47+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
48+
uint8_t digest[SHA1_DIGEST_LENGTH];
49+
50+
SHA1Init(&ctx);
51+
local_SHA1Update(&ctx, entropy, __arraycount(entropy));
52+
SHA1Final(digest, &ctx);
53+
54+
printf("test2: '");
55+
for (size_t i = 0; i < __arraycount(digest); i++)
56+
printf("%02x", digest[i]);
57+
printf("'\n");
58+
}
59+
60+
void test3() {
61+
SHA1_CTX ctx;
62+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
63+
char digest[SHA1_DIGEST_STRING_LENGTH];
64+
65+
SHA1Init(&ctx);
66+
SHA1Update(&ctx, entropy, __arraycount(entropy));
67+
char *p = SHA1End(&ctx, digest);
68+
assert(p == digest);
69+
70+
printf("test3: '%s'\n", digest);
71+
}
72+
73+
void test4() {
74+
SHA1_CTX ctx;
75+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
76+
77+
SHA1Init(&ctx);
78+
SHA1Update(&ctx, entropy, __arraycount(entropy));
79+
char *p = SHA1End(&ctx, NULL);
80+
assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1);
81+
82+
printf("test4: '%s'\n", p);
83+
84+
free(p);
85+
}
86+
87+
void test5() {
88+
char digest[SHA1_DIGEST_STRING_LENGTH];
89+
90+
char *p = SHA1File("/etc/fstab", digest);
91+
assert(p == digest);
92+
93+
printf("test5: '%s'\n", p);
94+
}
95+
96+
void test6() {
97+
char *p = SHA1File("/etc/fstab", NULL);
98+
assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1);
99+
100+
printf("test6: '%s'\n", p);
101+
102+
free(p);
103+
}
104+
105+
void test7() {
106+
char digest[SHA1_DIGEST_STRING_LENGTH];
107+
108+
char *p = SHA1FileChunk("/etc/fstab", digest, 10, 20);
109+
assert(p == digest);
110+
111+
printf("test7: '%s'\n", p);
112+
}
113+
114+
void test8() {
115+
char *p = SHA1FileChunk("/etc/fstab", NULL, 10, 20);
116+
assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1);
117+
118+
printf("test8: '%s'\n", p);
119+
120+
free(p);
121+
}
122+
123+
void test9() {
124+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
125+
char digest[SHA1_DIGEST_STRING_LENGTH];
126+
127+
char *p = SHA1Data(entropy, __arraycount(entropy), digest);
128+
assert(p == digest);
129+
130+
printf("test9: '%s'\n", p);
131+
}
132+
133+
void test10() {
134+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
135+
136+
char *p = SHA1Data(entropy, __arraycount(entropy), NULL);
137+
assert(strlen(p) == SHA1_DIGEST_STRING_LENGTH - 1);
138+
139+
printf("test10: '%s'\n", p);
140+
141+
free(p);
142+
}
143+
144+
int main(void) {
145+
printf("SHA1\n");
146+
147+
test1();
148+
test2();
149+
test3();
150+
test4();
151+
test5();
152+
test6();
153+
test7();
154+
test8();
155+
test9();
156+
test10();
157+
158+
// CHECK: SHA1
159+
// CHECK: test1: '57d1b759bf3d1811135748cb0328c73b51fa6f57'
160+
// CHECK: test2: '57d1b759bf3d1811135748cb0328c73b51fa6f57'
161+
// CHECK: test3: '57d1b759bf3d1811135748cb0328c73b51fa6f57'
162+
// CHECK: test4: '57d1b759bf3d1811135748cb0328c73b51fa6f57'
163+
// CHECK: test5: '{{.*}}'
164+
// CHECK: test6: '{{.*}}'
165+
// CHECK: test7: '{{.*}}'
166+
// CHECK: test8: '{{.*}}'
167+
// CHECK: test9: '57d1b759bf3d1811135748cb0328c73b51fa6f57'
168+
// CHECK: test10: '57d1b759bf3d1811135748cb0328c73b51fa6f57'
169+
170+
return 0;
171+
}

0 commit comments

Comments
 (0)