Debian Codegraph @

source4/torture/ntp/ntp_signd.c

raw
1 /*
2 Unix SMB/CIFS implementation.
3
4 Test NTP authentication support
5
6 Copyright (C) Andrew Bartlet <[email protected]> 2008
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "torture/smbtorture.h"
24 #include <tevent.h>
25 #include "lib/stream/packet.h"
26 #include "lib/tsocket/tsocket.h"
27 #include "libcli/util/tstream.h"
28 #include "torture/rpc/torture_rpc.h"
29 #include "libcli/auth/libcli_auth.h"
30 #include "librpc/gen_ndr/ndr_netlogon_c.h"
31 #include "librpc/gen_ndr/ndr_ntp_signd.h"
32 #include "param/param.h"
33 #include "system/network.h"
34 #include "torture/ntp/proto.h"
35
36 #include <gnutls/gnutls.h>
37 #include <gnutls/crypto.h>
38
39 #define TEST_MACHINE_NAME "ntpsigndtest"
40
41 struct signd_client_state {
42 struct tsocket_address *local_address;
43 struct tsocket_address *remote_address;
44
45 struct tstream_context *tstream;
46 struct tevent_queue *send_queue;
47
48 uint8_t request_hdr[4];
49 struct iovec request_iov[2];
50
51 DATA_BLOB reply;
52
53 NTSTATUS status;
54 };
55
56 /*
57 * A torture test to show that the unix domain socket protocol is
58 * operating correctly, and the signatures are as expected
59 */
60 static bool test_ntp_signd(struct torture_context *tctx,
61 struct dcerpc_pipe *p,
62 struct cli_credentials *credentials)
63 {
64 struct netlogon_creds_CredentialState *creds;
65 TALLOC_CTX *mem_ctx = talloc_new(tctx);
66
67 struct netr_ServerReqChallenge r;
68 struct netr_ServerAuthenticate3 a;
69 struct netr_Credential credentials1, credentials2, credentials3;
70 uint32_t rid;
71 const char *machine_name;
72 const struct samr_Password *pwhash = cli_credentials_get_nt_hash(credentials, mem_ctx);
73 uint32_t negotiate_flags = NETLOGON_NEG_AUTH2_ADS_FLAGS | NETLOGON_NEG_SUPPORTS_AES;
74
75 struct sign_request sign_req;
76 struct signed_reply signed_reply;
77 DATA_BLOB sign_req_blob;
78
79 struct signd_client_state *signd_client;
80 struct tevent_req *req;
81 char *unix_address;
82 int sys_errno;
83
84 gnutls_hash_hd_t hash_hnd;
85 uint8_t sig[16];
86 enum ndr_err_code ndr_err;
87 bool ok;
88 int rc;
89
90 machine_name = cli_credentials_get_workstation(credentials);
91
92 torture_comment(tctx, "Testing ServerReqChallenge\n");
93
94 r.in.server_name = NULL;
95 r.in.computer_name = machine_name;
96 r.in.credentials = &credentials1;
97 r.out.return_credentials = &credentials2;
98
99 generate_random_buffer(credentials1.data, sizeof(credentials1.data));
100
101 torture_assert_ntstatus_ok(tctx,
102 dcerpc_netr_ServerReqChallenge_r(p->binding_handle, tctx, &r),
103 "ServerReqChallenge failed");
104 torture_assert_ntstatus_ok(tctx, r.out.result,
105 "ServerReqChallenge failed");
106
107 a.in.server_name = NULL;
108 a.in.account_name = talloc_asprintf(tctx, "%s$", machine_name);
109 a.in.secure_channel_type = SEC_CHAN_WKSTA;
110 a.in.computer_name = machine_name;
111 a.in.negotiate_flags = &negotiate_flags;
112 a.in.credentials = &credentials3;
113 a.out.return_credentials = &credentials3;
114 a.out.negotiate_flags = &negotiate_flags;
115 a.out.rid = &rid;
116
117 creds = netlogon_creds_client_init(tctx, a.in.account_name,
118 a.in.computer_name,
119 a.in.secure_channel_type,
120 &credentials1, &credentials2,
121 pwhash, &credentials3,
122 negotiate_flags,
123 negotiate_flags);
124
125 torture_assert(tctx, creds != NULL, "memory allocation");
126
127 torture_comment(tctx, "Testing ServerAuthenticate3\n");
128
129 torture_assert_ntstatus_ok(tctx,
130 dcerpc_netr_ServerAuthenticate3_r(p->binding_handle, tctx, &a),
131 "ServerAuthenticate3 failed");
132 torture_assert_ntstatus_ok(tctx, a.out.result,
133 "ServerAuthenticate3 failed");
134 torture_assert(tctx,
135 netlogon_creds_client_check(creds, &credentials3),
136 "Credential chaining failed");
137
138 sign_req.op = SIGN_TO_CLIENT;
139 sign_req.packet_id = 1;
140 sign_req.key_id = rid;
141 sign_req.packet_to_sign = data_blob_string_const("I am a tea pot");
142
143 ndr_err = ndr_push_struct_blob(&sign_req_blob,
144 mem_ctx,
145 &sign_req,
146 (ndr_push_flags_fn_t)ndr_push_sign_request);
147 torture_assert(tctx,
148 NDR_ERR_CODE_IS_SUCCESS(ndr_err),
149 "Failed to push sign_req");
150
151 signd_client = talloc(mem_ctx, struct signd_client_state);
152
153 /* Create socket addresses */
154 torture_comment(tctx, "Creating the socket addresses\n");
155 rc = tsocket_address_unix_from_path(signd_client, "",
156 &signd_client->local_address);
157 torture_assert(tctx, rc == 0,
158 "Failed to create local address from unix path.");
159
160 unix_address = talloc_asprintf(signd_client,
161 "%s/socket",
162 lpcfg_ntp_signd_socket_directory(tctx->lp_ctx));
163 rc = tsocket_address_unix_from_path(mem_ctx,
164 unix_address,
165 &signd_client->remote_address);
166 torture_assert(tctx, rc == 0,
167 "Failed to create remote address from unix path.");
168
169 /* Connect to the unix socket */
170 torture_comment(tctx, "Connecting to the unix socket\n");
171 req = tstream_unix_connect_send(signd_client,
172 tctx->ev,
173 signd_client->local_address,
174 signd_client->remote_address);
175 torture_assert(tctx, req != NULL,
176 "Failed to create a tstream unix connect request.");
177
178 ok = tevent_req_poll(req, tctx->ev);
179 torture_assert(tctx, ok == true,
180 "Failed to poll for tstream_unix_connect_send.");
181
182 rc = tstream_unix_connect_recv(req,
183 &sys_errno,
184 signd_client,
185 &signd_client->tstream);
186 TALLOC_FREE(req);
187 torture_assert(tctx, rc == 0, "Failed to connect to signd!");
188
189 /* Allocate the send queue */
190 signd_client->send_queue = tevent_queue_create(signd_client,
191 "signd_client_queue");
192 torture_assert(tctx, signd_client->send_queue != NULL,
193 "Failed to create send queue!");
194
195 /*
196 * Create the request buffer.
197 * First add the length of the request buffer
198 */
199 RSIVAL(signd_client->request_hdr, 0, sign_req_blob.length);
200 signd_client->request_iov[0].iov_base = (char *) signd_client->request_hdr;
201 signd_client->request_iov[0].iov_len = 4;
202
203 signd_client->request_iov[1].iov_base = (char *) sign_req_blob.data;
204 signd_client->request_iov[1].iov_len = sign_req_blob.length;
205
206 /* Fire the request buffer */
207 torture_comment(tctx, "Sending the request\n");
208 req = tstream_writev_queue_send(signd_client,
209 tctx->ev,
210 signd_client->tstream,
211 signd_client->send_queue,
212 signd_client->request_iov, 2);
213 torture_assert(tctx, req != NULL,
214 "Failed to send the signd request.");
215
216 ok = tevent_req_poll(req, tctx->ev);
217 torture_assert(tctx, ok == true,
218 "Failed to poll for tstream_writev_queue_send.");
219
220 rc = tstream_writev_queue_recv(req, &sys_errno);
221 TALLOC_FREE(req);
222 torture_assert(tctx, rc > 0, "Failed to send data");
223
224 /* Wait for a reply */
225 torture_comment(tctx, "Waiting for the reply\n");
226 req = tstream_read_pdu_blob_send(signd_client,
227 tctx->ev,
228 signd_client->tstream,
229 4, /*initial_read_size */
230 tstream_full_request_u32,
231 NULL);
232 torture_assert(tctx, req != NULL,
233 "Failed to setup a read for pdu_blob.");
234
235 ok = tevent_req_poll(req, tctx->ev);
236 torture_assert(tctx, ok == true,
237 "Failed to poll for tstream_read_pdu_blob_send.");
238
239 signd_client->status = tstream_read_pdu_blob_recv(req,
240 signd_client,
241 &signd_client->reply);
242 torture_assert_ntstatus_ok(tctx, signd_client->status,
243 "Error reading signd_client reply packet");
244
245 /* Skip length header */
246 signd_client->reply.data += 4;
247 signd_client->reply.length -= 4;
248
249 /* Check if the reply buffer is valid */
250 torture_comment(tctx, "Validating the reply buffer\n");
251 ndr_err = ndr_pull_struct_blob_all(&signd_client->reply,
252 mem_ctx,
253 &signed_reply,
254 (ndr_pull_flags_fn_t)ndr_pull_signed_reply);
255 torture_assert(tctx, NDR_ERR_CODE_IS_SUCCESS(ndr_err),
256 ndr_map_error2string(ndr_err));
257
258 torture_assert_u64_equal(tctx, signed_reply.version,
259 NTP_SIGND_PROTOCOL_VERSION_0,
260 "Invalid Version");
261 torture_assert_u64_equal(tctx, signed_reply.packet_id,
262 sign_req.packet_id, "Invalid Packet ID");
263 torture_assert_u64_equal(tctx, signed_reply.op,
264 SIGNING_SUCCESS,
265 "Should have replied with signing success");
266 torture_assert_u64_equal(tctx, signed_reply.signed_packet.length,
267 sign_req.packet_to_sign.length + 20,
268 "Invalid reply length from signd");
269 torture_assert_u64_equal(tctx, rid,
270 IVAL(signed_reply.signed_packet.data,
271 sign_req.packet_to_sign.length),
272 "Incorrect RID in reply");
273
274 /* Check computed signature */
275 gnutls_hash_init(&hash_hnd, GNUTLS_DIG_MD5);
276 gnutls_hash(hash_hnd, pwhash->hash, sizeof(pwhash->hash));
277 gnutls_hash(hash_hnd,
278 sign_req.packet_to_sign.data,
279 sign_req.packet_to_sign.length);
280 gnutls_hash_deinit(hash_hnd, sig);
281
282 torture_assert_mem_equal(tctx,
283 &signed_reply.signed_packet.data[sign_req.packet_to_sign.length + 4],
284 sig, 16, "Signature on reply was incorrect!");
285
286 talloc_free(mem_ctx);
287
288 return true;
289 }
290
291 NTSTATUS torture_ntp_init(TALLOC_CTX *ctx)
292 {
293 struct torture_suite *suite = torture_suite_create(ctx, "ntp");
294 struct torture_rpc_tcase *tcase;
295
296 tcase = torture_suite_add_machine_workstation_rpc_iface_tcase(suite,
297 "signd", &ndr_table_netlogon, TEST_MACHINE_NAME);
298
299 torture_rpc_tcase_add_test_creds(tcase, "ntp_signd", test_ntp_signd);
300
301 suite->description = talloc_strdup(suite, "NTP tests");
302
303 torture_register_suite(ctx, suite);
304
305 return NT_STATUS_OK;
306 }
307