1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
#include <config.h>
#include "crypto.h"
#include <ctype.h>
#include "isc/string.h"
#include "libssl_compat.h"
struct key *key_ptr;
size_t key_cnt = 0;
int
make_mac(
const void *pkt_data,
int pkt_size,
int mac_size,
const struct key *cmp_key,
void * digest
)
{
u_int len = mac_size;
int key_type;
EVP_MD_CTX * ctx;
if (cmp_key->key_len > 64)
return 0;
if (pkt_size % 4 != 0)
return 0;
INIT_SSL();
key_type = keytype_from_text(cmp_key->type, NULL);
ctx = EVP_MD_CTX_new();
EVP_DigestInit(ctx, EVP_get_digestbynid(key_type));
EVP_DigestUpdate(ctx, (const u_char *)cmp_key->key_seq, (u_int)cmp_key->key_len);
EVP_DigestUpdate(ctx, pkt_data, (u_int)pkt_size);
EVP_DigestFinal(ctx, digest, &len);
EVP_MD_CTX_free(ctx);
return (int)len;
}
/* Generates a md5 digest of the key specified in keyid concatenated with the
* ntp packet (exluding the MAC) and compares this digest to the digest in
* the packet's MAC. If they're equal this function returns 1 (packet is
* authentic) or else 0 (not authentic).
*/
int
auth_md5(
const void *pkt_data,
int pkt_size,
int mac_size,
const struct key *cmp_key
)
{
int hash_len;
int authentic;
char digest[20];
const u_char *pkt_ptr;
if (mac_size > (int)sizeof(digest))
return 0;
pkt_ptr = pkt_data;
hash_len = make_mac(pkt_ptr, pkt_size, sizeof(digest), cmp_key,
digest);
if (!hash_len) {
authentic = FALSE;
} else {
/* isc_tsmemcmp will be better when its easy to link
* with. sntp is a 1-shot program, so snooping for
* timing attacks is Harder.
*/
authentic = !memcmp(digest, (const char*)pkt_data + pkt_size + 4,
hash_len);
}
return authentic;
}
static int
hex_val(
unsigned char x
)
{
int val;
if ('0' <= x && x <= '9')
val = x - '0';
else if ('a' <= x && x <= 'f')
val = x - 'a' + 0xa;
else if ('A' <= x && x <= 'F')
val = x - 'A' + 0xA;
else
val = -1;
return val;
}
/* Load keys from the specified keyfile into the key structures.
* Returns -1 if the reading failed, otherwise it returns the
* number of keys it read
*/
int
auth_init(
const char *keyfile,
struct key **keys
)
{
FILE *keyf = fopen(keyfile, "r");
struct key *prev = NULL;
int scan_cnt, line_cnt = 0;
char kbuf[200];
char keystring[129];
if (keyf == NULL) {
if (debug)
printf("sntp auth_init: Couldn't open key file %s for reading!\n", keyfile);
return -1;
}
if (feof(keyf)) {
if (debug)
printf("sntp auth_init: Key file %s is empty!\n", keyfile);
fclose(keyf);
return -1;
}
key_cnt = 0;
while (!feof(keyf)) {
char * octothorpe;
struct key *act;
int goodline = 0;
if (NULL == fgets(kbuf, sizeof(kbuf), keyf))
continue;
kbuf[sizeof(kbuf) - 1] = '\0';
octothorpe = strchr(kbuf, '#');
if (octothorpe)
*octothorpe = '\0';
act = emalloc(sizeof(*act));
scan_cnt = sscanf(kbuf, "%d %9s %128s", &act->key_id, act->type, keystring);
if (scan_cnt == 3) {
int len = strlen(keystring);
if (len <= 20) {
act->key_len = len;
memcpy(act->key_seq, keystring, len + 1);
goodline = 1;
} else if ((len & 1) != 0) {
goodline = 0; /* it's bad */
} else {
int j;
goodline = 1;
act->key_len = len >> 1;
for (j = 0; j < len; j+=2) {
int val;
val = (hex_val(keystring[j]) << 4) |
hex_val(keystring[j+1]);
if (val < 0) {
goodline = 0; /* it's bad */
break;
}
act->key_seq[j>>1] = (char)val;
}
}
}
if (goodline) {
act->next = NULL;
if (NULL == prev)
*keys = act;
else
prev->next = act;
prev = act;
key_cnt++;
} else {
msyslog(LOG_DEBUG, "auth_init: scanf %d items, skipping line %d.",
scan_cnt, line_cnt);
free(act);
}
line_cnt++;
}
fclose(keyf);
key_ptr = *keys;
return key_cnt;
}
/* Looks for the key with keyid key_id and sets the d_key pointer to the
* address of the key. If no matching key is found the pointer is not touched.
*/
void
get_key(
int key_id,
struct key **d_key
)
{
struct key *itr_key;
if (key_cnt == 0)
return;
for (itr_key = key_ptr; itr_key; itr_key = itr_key->next) {
if (itr_key->key_id == key_id) {
*d_key = itr_key;
break;
}
}
return;
}
|
