Skip to content

Commit f9b8569

Browse files
krytarowskikrytarowski
committed
Add interceptors for the rmd160(3) from NetBSD
Summary: RMD160Init, RMD160Update, RMD160Final, RMD160Transform, RMD160End, RMD160File, RMD160Data - calculates the ``RIPEMD-160'' message digest. Add a dedicated test for this API. Reviewers: vitalybuka, joerg Reviewed By: vitalybuka Subscribers: kubamracek, llvm-commits, mgorny, #sanitizers Tags: #sanitizers Differential Revision: https://reviews.llvm.org/D54991 llvm-svn: 348678
1 parent e9bf12f commit f9b8569

File tree

5 files changed

+234
-0
lines changed

5 files changed

+234
-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
@@ -8058,6 +8058,99 @@ INTERCEPTOR(char *, MD4Data, const unsigned char *data, unsigned int len,
80588058
#define INIT_MD4
80598059
#endif
80608060

8061+
#if SANITIZER_INTERCEPT_RMD160
8062+
INTERCEPTOR(void, RMD160Init, void *context) {
8063+
void *ctx;
8064+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160Init, context);
8065+
REAL(RMD160Init)(context);
8066+
if (context)
8067+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, context, RMD160_CTX_sz);
8068+
}
8069+
INTERCEPTOR(void, RMD160Update, void *context, const u8 *data, unsigned len) {
8070+
void *ctx;
8071+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160Update, context, data, len);
8072+
if (data && len > 0)
8073+
COMMON_INTERCEPTOR_READ_RANGE(ctx, data, len);
8074+
if (context)
8075+
COMMON_INTERCEPTOR_READ_RANGE(ctx, context, RMD160_CTX_sz);
8076+
REAL(RMD160Update)(context, data, len);
8077+
if (context)
8078+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, context, RMD160_CTX_sz);
8079+
}
8080+
INTERCEPTOR(void, RMD160Final, u8 digest[20], void *context) {
8081+
void *ctx;
8082+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160Final, digest, context);
8083+
if (context)
8084+
COMMON_INTERCEPTOR_READ_RANGE(ctx, context, RMD160_CTX_sz);
8085+
REAL(RMD160Final)(digest, context);
8086+
if (digest)
8087+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, digest, sizeof(u8) * 20);
8088+
}
8089+
INTERCEPTOR(void, RMD160Transform, u32 state[5], u16 buffer[16]) {
8090+
void *ctx;
8091+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160Transform, state, buffer);
8092+
if (state)
8093+
COMMON_INTERCEPTOR_READ_RANGE(ctx, state, sizeof(u32) * 5);
8094+
if (buffer)
8095+
COMMON_INTERCEPTOR_READ_RANGE(ctx, buffer, sizeof(u32) * 16);
8096+
REAL(RMD160Transform)(state, buffer);
8097+
if (state)
8098+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, state, sizeof(u32) * 5);
8099+
}
8100+
INTERCEPTOR(char *, RMD160End, void *context, char *buf) {
8101+
void *ctx;
8102+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160End, context, buf);
8103+
if (context)
8104+
COMMON_INTERCEPTOR_READ_RANGE(ctx, context, RMD160_CTX_sz);
8105+
char *ret = REAL(RMD160End)(context, buf);
8106+
if (ret)
8107+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, RMD160_return_length);
8108+
return ret;
8109+
}
8110+
INTERCEPTOR(char *, RMD160File, char *filename, char *buf) {
8111+
void *ctx;
8112+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160File, filename, buf);
8113+
if (filename)
8114+
COMMON_INTERCEPTOR_READ_RANGE(ctx, filename, REAL(strlen)(filename) + 1);
8115+
char *ret = REAL(RMD160File)(filename, buf);
8116+
if (ret)
8117+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, RMD160_return_length);
8118+
return ret;
8119+
}
8120+
INTERCEPTOR(char *, RMD160FileChunk, char *filename, char *buf, OFF_T offset,
8121+
OFF_T length) {
8122+
void *ctx;
8123+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160FileChunk, filename, buf, offset, length);
8124+
if (filename)
8125+
COMMON_INTERCEPTOR_READ_RANGE(ctx, filename, REAL(strlen)(filename) + 1);
8126+
char *ret = REAL(RMD160FileChunk)(filename, buf, offset, length);
8127+
if (ret)
8128+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, RMD160_return_length);
8129+
return ret;
8130+
}
8131+
INTERCEPTOR(char *, RMD160Data, u8 *data, SIZE_T len, char *buf) {
8132+
void *ctx;
8133+
COMMON_INTERCEPTOR_ENTER(ctx, RMD160Data, data, len, buf);
8134+
if (data && len > 0)
8135+
COMMON_INTERCEPTOR_READ_RANGE(ctx, data, len);
8136+
char *ret = REAL(RMD160Data)(data, len, buf);
8137+
if (ret)
8138+
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ret, RMD160_return_length);
8139+
return ret;
8140+
}
8141+
#define INIT_RMD160 \
8142+
COMMON_INTERCEPT_FUNCTION(RMD160Init); \
8143+
COMMON_INTERCEPT_FUNCTION(RMD160Update); \
8144+
COMMON_INTERCEPT_FUNCTION(RMD160Final); \
8145+
COMMON_INTERCEPT_FUNCTION(RMD160Transform); \
8146+
COMMON_INTERCEPT_FUNCTION(RMD160End); \
8147+
COMMON_INTERCEPT_FUNCTION(RMD160File); \
8148+
COMMON_INTERCEPT_FUNCTION(RMD160FileChunk); \
8149+
COMMON_INTERCEPT_FUNCTION(RMD160Data)
8150+
#else
8151+
#define INIT_RMD160
8152+
#endif
8153+
80618154
static void InitializeCommonInterceptors() {
80628155
static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
80638156
interceptor_metadata_map =
@@ -8330,6 +8423,7 @@ static void InitializeCommonInterceptors() {
83308423
INIT_CAPSICUM;
83318424
INIT_SHA1;
83328425
INIT_MD4;
8426+
INIT_RMD160;
83338427

83348428
INIT___PRINTF_CHK;
83358429
}

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -537,5 +537,6 @@
537537
#define SANITIZER_INTERCEPT_CAPSICUM SI_FREEBSD
538538
#define SANITIZER_INTERCEPT_SHA1 SI_NETBSD
539539
#define SANITIZER_INTERCEPT_MD4 SI_NETBSD
540+
#define SANITIZER_INTERCEPT_RMD160 SI_NETBSD
540541

541542
#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
@@ -2107,6 +2107,9 @@ const unsigned SHA1_return_length = SHA1_DIGEST_STRING_LENGTH;
21072107

21082108
const unsigned MD4_CTX_sz = sizeof(MD4_CTX);
21092109
const unsigned MD4_return_length = MD4_DIGEST_STRING_LENGTH;
2110+
2111+
const unsigned RMD160_CTX_sz = sizeof(RMD160_CTX);
2112+
const unsigned RMD160_return_length = RMD160_DIGEST_STRING_LENGTH;
21102113
} // namespace __sanitizer
21112114

21122115
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
@@ -2231,6 +2231,9 @@ extern const unsigned SHA1_return_length;
22312231

22322232
extern const unsigned MD4_CTX_sz;
22332233
extern const unsigned MD4_return_length;
2234+
2235+
extern const unsigned RMD160_CTX_sz;
2236+
extern const unsigned RMD160_return_length;
22342237
} // namespace __sanitizer
22352238

22362239
#define CHECK_TYPE_SIZE(TYPE) \

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

Lines changed: 133 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,133 @@
1+
// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
2+
3+
#include <assert.h>
4+
#include <rmd160.h>
5+
#include <stdio.h>
6+
#include <stdlib.h>
7+
#include <string.h>
8+
9+
void test1() {
10+
RMD160_CTX ctx;
11+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
12+
uint8_t digest[RMD160_DIGEST_LENGTH];
13+
14+
RMD160Init(&ctx);
15+
RMD160Update(&ctx, entropy, __arraycount(entropy));
16+
RMD160Final(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 test2() {
25+
RMD160_CTX ctx;
26+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
27+
char digest[RMD160_DIGEST_STRING_LENGTH];
28+
29+
RMD160Init(&ctx);
30+
RMD160Update(&ctx, entropy, __arraycount(entropy));
31+
char *p = RMD160End(&ctx, digest);
32+
assert(p == digest);
33+
34+
printf("test2: '%s'\n", digest);
35+
}
36+
37+
void test3() {
38+
RMD160_CTX ctx;
39+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
40+
41+
RMD160Init(&ctx);
42+
RMD160Update(&ctx, entropy, __arraycount(entropy));
43+
char *p = RMD160End(&ctx, NULL);
44+
assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1);
45+
46+
printf("test3: '%s'\n", p);
47+
48+
free(p);
49+
}
50+
51+
void test4() {
52+
char digest[RMD160_DIGEST_STRING_LENGTH];
53+
54+
char *p = RMD160File("/etc/fstab", digest);
55+
assert(p == digest);
56+
57+
printf("test4: '%s'\n", p);
58+
}
59+
60+
void test5() {
61+
char *p = RMD160File("/etc/fstab", NULL);
62+
assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1);
63+
64+
printf("test5: '%s'\n", p);
65+
66+
free(p);
67+
}
68+
69+
void test6() {
70+
char digest[RMD160_DIGEST_STRING_LENGTH];
71+
72+
char *p = RMD160FileChunk("/etc/fstab", digest, 10, 20);
73+
assert(p == digest);
74+
75+
printf("test6: '%s'\n", p);
76+
}
77+
78+
void test7() {
79+
char *p = RMD160FileChunk("/etc/fstab", NULL, 10, 20);
80+
assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1);
81+
82+
printf("test7: '%s'\n", p);
83+
84+
free(p);
85+
}
86+
87+
void test8() {
88+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
89+
char digest[RMD160_DIGEST_STRING_LENGTH];
90+
91+
char *p = RMD160Data(entropy, __arraycount(entropy), digest);
92+
assert(p == digest);
93+
94+
printf("test8: '%s'\n", p);
95+
}
96+
97+
void test9() {
98+
uint8_t entropy[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
99+
100+
char *p = RMD160Data(entropy, __arraycount(entropy), NULL);
101+
assert(strlen(p) == RMD160_DIGEST_STRING_LENGTH - 1);
102+
103+
printf("test9: '%s'\n", p);
104+
105+
free(p);
106+
}
107+
108+
int main(void) {
109+
printf("RMD160\n");
110+
111+
test1();
112+
test2();
113+
test3();
114+
test4();
115+
test5();
116+
test6();
117+
test7();
118+
test8();
119+
test9();
120+
121+
// CHECK: RMD160
122+
// CHECK: test1: '2787e5a006365df6e8e799315b669dc34866783c'
123+
// CHECK: test2: '2787e5a006365df6e8e799315b669dc34866783c'
124+
// CHECK: test3: '2787e5a006365df6e8e799315b669dc34866783c'
125+
// CHECK: test4: '{{.*}}'
126+
// CHECK: test5: '{{.*}}'
127+
// CHECK: test6: '{{.*}}'
128+
// CHECK: test7: '{{.*}}'
129+
// CHECK: test8: '2787e5a006365df6e8e799315b669dc34866783c'
130+
// CHECK: test9: '2787e5a006365df6e8e799315b669dc34866783c'
131+
132+
return 0;
133+
}

0 commit comments

Comments
 (0)