Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : Core SMB2 server
4 :
5 : Copyright (C) Stefan Metzmacher 2009
6 :
7 : This program is free software; you can redistribute it and/or modify
8 : it under the terms of the GNU General Public License as published by
9 : the Free Software Foundation; either version 3 of the License, or
10 : (at your option) any later version.
11 :
12 : This program is distributed in the hope that it will be useful,
13 : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : GNU General Public License for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with this program. If not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : #include "includes.h"
22 : #include "smbd/smbd.h"
23 : #include "smbd/globals.h"
24 : #include "../libcli/smb/smb_common.h"
25 : #include "../lib/util/tevent_ntstatus.h"
26 : #include "include/ntioctl.h"
27 : #include "smb2_ioctl_private.h"
28 : #include "librpc/gen_ndr/ioctl.h"
29 :
30 : #undef DBGC_CLASS
31 : #define DBGC_CLASS DBGC_SMB2
32 :
33 : static struct tevent_req *smbd_smb2_ioctl_send(TALLOC_CTX *mem_ctx,
34 : struct tevent_context *ev,
35 : struct smbd_smb2_request *smb2req,
36 : struct files_struct *in_fsp,
37 : uint32_t in_ctl_code,
38 : DATA_BLOB in_input,
39 : uint32_t in_max_output,
40 : uint32_t in_flags);
41 : static NTSTATUS smbd_smb2_ioctl_recv(struct tevent_req *req,
42 : TALLOC_CTX *mem_ctx,
43 : DATA_BLOB *out_output,
44 : uint8_t *body_padding,
45 : bool *disconnect);
46 :
47 : static void smbd_smb2_request_ioctl_done(struct tevent_req *subreq);
48 336096 : NTSTATUS smbd_smb2_request_process_ioctl(struct smbd_smb2_request *req)
49 : {
50 7176 : NTSTATUS status;
51 7176 : const uint8_t *inbody;
52 7176 : uint32_t min_buffer_offset;
53 7176 : uint32_t max_buffer_offset;
54 7176 : uint32_t min_output_offset;
55 7176 : uint32_t allowed_length_in;
56 7176 : uint32_t allowed_length_out;
57 7176 : uint32_t in_ctl_code;
58 7176 : uint64_t in_file_id_persistent;
59 7176 : uint64_t in_file_id_volatile;
60 336096 : struct files_struct *in_fsp = NULL;
61 7176 : uint32_t in_input_offset;
62 7176 : uint32_t in_input_length;
63 336096 : DATA_BLOB in_input_buffer = data_blob_null;
64 7176 : uint32_t in_max_input_length;
65 7176 : uint32_t in_output_offset;
66 7176 : uint32_t in_output_length;
67 336096 : DATA_BLOB in_output_buffer = data_blob_null;
68 7176 : uint32_t in_max_output_length;
69 7176 : uint32_t in_flags;
70 7176 : uint32_t data_length_in;
71 7176 : uint32_t data_length_out;
72 7176 : uint32_t data_length_tmp;
73 7176 : uint32_t data_length_max;
74 7176 : struct tevent_req *subreq;
75 :
76 336096 : status = smbd_smb2_request_verify_sizes(req, 0x39);
77 336096 : if (!NT_STATUS_IS_OK(status)) {
78 0 : return smbd_smb2_request_error(req, status);
79 : }
80 336096 : inbody = SMBD_SMB2_IN_BODY_PTR(req);
81 :
82 336096 : in_ctl_code = IVAL(inbody, 0x04);
83 336096 : in_file_id_persistent = BVAL(inbody, 0x08);
84 336096 : in_file_id_volatile = BVAL(inbody, 0x10);
85 336096 : in_input_offset = IVAL(inbody, 0x18);
86 336096 : in_input_length = IVAL(inbody, 0x1C);
87 336096 : in_max_input_length = IVAL(inbody, 0x20);
88 336096 : in_output_offset = IVAL(inbody, 0x24);
89 336096 : in_output_length = IVAL(inbody, 0x28);
90 336096 : in_max_output_length = IVAL(inbody, 0x2C);
91 336096 : in_flags = IVAL(inbody, 0x30);
92 :
93 336096 : min_buffer_offset = SMB2_HDR_BODY + SMBD_SMB2_IN_BODY_LEN(req);
94 336096 : max_buffer_offset = min_buffer_offset + SMBD_SMB2_IN_DYN_LEN(req);
95 336096 : min_output_offset = min_buffer_offset;
96 :
97 : /*
98 : * InputOffset (4 bytes): The offset, in bytes, from the beginning of
99 : * the SMB2 header to the input data buffer. If no input data is
100 : * required for the FSCTL/IOCTL command being issued, the client SHOULD
101 : * set this value to 0.<49>
102 : * <49> If no input data is required for the FSCTL/IOCTL command being
103 : * issued, Windows-based clients set this field to any value.
104 : */
105 336096 : allowed_length_in = 0;
106 336096 : if ((in_input_offset > 0) && (in_input_length > 0)) {
107 7168 : uint32_t tmp_ofs;
108 :
109 333568 : if (in_input_offset < min_buffer_offset) {
110 0 : return smbd_smb2_request_error(req,
111 : NT_STATUS_INVALID_PARAMETER);
112 : }
113 333568 : if (in_input_offset > max_buffer_offset) {
114 0 : return smbd_smb2_request_error(req,
115 : NT_STATUS_INVALID_PARAMETER);
116 : }
117 333568 : allowed_length_in = max_buffer_offset - in_input_offset;
118 :
119 333568 : tmp_ofs = in_input_offset - min_buffer_offset;
120 333568 : in_input_buffer.data = SMBD_SMB2_IN_DYN_PTR(req);
121 333568 : in_input_buffer.data += tmp_ofs;
122 333568 : in_input_buffer.length = in_input_length;
123 333568 : min_output_offset += tmp_ofs;
124 333568 : min_output_offset += in_input_length;
125 : }
126 :
127 336096 : if (in_input_length > allowed_length_in) {
128 0 : return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
129 : }
130 :
131 336096 : allowed_length_out = 0;
132 336096 : if (in_output_offset > 0) {
133 332730 : if (in_output_offset < min_buffer_offset) {
134 0 : return smbd_smb2_request_error(req,
135 : NT_STATUS_INVALID_PARAMETER);
136 : }
137 332730 : if (in_output_offset > max_buffer_offset) {
138 0 : return smbd_smb2_request_error(req,
139 : NT_STATUS_INVALID_PARAMETER);
140 : }
141 332730 : allowed_length_out = max_buffer_offset - in_output_offset;
142 : }
143 :
144 336096 : if (in_output_length > allowed_length_out) {
145 0 : return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
146 : }
147 :
148 336096 : if (in_output_length > 0) {
149 0 : uint32_t tmp_ofs;
150 :
151 0 : if (in_output_offset < min_output_offset) {
152 0 : return smbd_smb2_request_error(req,
153 : NT_STATUS_INVALID_PARAMETER);
154 : }
155 :
156 0 : tmp_ofs = in_output_offset - min_buffer_offset;
157 0 : in_output_buffer.data = SMBD_SMB2_IN_DYN_PTR(req);
158 0 : in_output_buffer.data += tmp_ofs;
159 0 : in_output_buffer.length = in_output_length;
160 : }
161 :
162 : /*
163 : * verify the credits and avoid overflows
164 : * in_input_buffer.length and in_output_buffer.length
165 : * are already verified.
166 : */
167 336096 : data_length_in = in_input_buffer.length + in_output_buffer.length;
168 :
169 336096 : data_length_out = in_max_input_length;
170 336096 : data_length_tmp = UINT32_MAX - data_length_out;
171 336096 : if (data_length_tmp < in_max_output_length) {
172 0 : return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
173 : }
174 336096 : data_length_out += in_max_output_length;
175 :
176 336096 : data_length_max = MAX(data_length_in, data_length_out);
177 :
178 336096 : status = smbd_smb2_request_verify_creditcharge(req, data_length_max);
179 336096 : if (!NT_STATUS_IS_OK(status)) {
180 0 : return smbd_smb2_request_error(req, status);
181 : }
182 :
183 : /*
184 : * If the Flags field of the request is not SMB2_0_IOCTL_IS_FSCTL the
185 : * server MUST fail the request with STATUS_NOT_SUPPORTED.
186 : */
187 336096 : if (in_flags != SMB2_IOCTL_FLAG_IS_FSCTL) {
188 0 : return smbd_smb2_request_error(req, NT_STATUS_NOT_SUPPORTED);
189 : }
190 :
191 336096 : switch (in_ctl_code) {
192 14335 : case FSCTL_DFS_GET_REFERRALS:
193 : case FSCTL_DFS_GET_REFERRALS_EX:
194 : case FSCTL_PIPE_WAIT:
195 : case FSCTL_VALIDATE_NEGOTIATE_INFO_224:
196 : case FSCTL_VALIDATE_NEGOTIATE_INFO:
197 : case FSCTL_QUERY_NETWORK_INTERFACE_INFO:
198 : case FSCTL_SMBTORTURE_FORCE_UNACKED_TIMEOUT:
199 : case FSCTL_SMBTORTURE_IOCTL_RESPONSE_BODY_PADDING8:
200 : case FSCTL_SMBTORTURE_GLOBAL_READ_RESPONSE_BODY_PADDING8:
201 : /*
202 : * Some SMB2 specific CtlCodes like FSCTL_DFS_GET_REFERRALS or
203 : * FSCTL_PIPE_WAIT does not take a file handle.
204 : *
205 : * If FileId in the SMB2 Header of the request is not
206 : * 0xFFFFFFFFFFFFFFFF, then the server MUST fail the request
207 : * with STATUS_INVALID_PARAMETER.
208 : */
209 14335 : if (in_file_id_persistent != UINT64_MAX ||
210 : in_file_id_volatile != UINT64_MAX) {
211 28 : return smbd_smb2_request_error(req,
212 : NT_STATUS_INVALID_PARAMETER);
213 : }
214 14277 : break;
215 321761 : default:
216 321761 : in_fsp = file_fsp_smb2(req, in_file_id_persistent,
217 : in_file_id_volatile);
218 321761 : if (in_fsp == NULL) {
219 26 : return smbd_smb2_request_error(req, NT_STATUS_FILE_CLOSED);
220 : }
221 314589 : break;
222 : }
223 :
224 336042 : subreq = smbd_smb2_ioctl_send(req, req->sconn->ev_ctx,
225 : req, in_fsp,
226 : in_ctl_code,
227 : in_input_buffer,
228 : in_max_output_length,
229 : in_flags);
230 336042 : if (subreq == NULL) {
231 0 : return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
232 : }
233 :
234 : /*
235 : * If the FSCTL has gone async on a file handle, remember
236 : * to add it to the list of async requests we need to wait
237 : * for on file handle close.
238 : */
239 336042 : if (in_fsp != NULL && tevent_req_is_in_progress(subreq)) {
240 7146 : bool ok;
241 :
242 319131 : ok = aio_add_req_to_fsp(in_fsp, subreq);
243 319131 : if (!ok) {
244 0 : return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
245 : }
246 : }
247 :
248 336042 : tevent_req_set_callback(subreq, smbd_smb2_request_ioctl_done, req);
249 :
250 336042 : return smbd_smb2_request_pending_queue(req, subreq, 1000);
251 : }
252 :
253 : /*
254 : * 3.3.4.4 Sending an Error Response
255 : * An error code other than one of the following indicates a failure:
256 : */
257 336042 : static bool smbd_smb2_ioctl_is_failure(uint32_t ctl_code, NTSTATUS status,
258 : size_t data_size)
259 : {
260 336042 : if (NT_STATUS_IS_OK(status)) {
261 321938 : return false;
262 : }
263 :
264 : /*
265 : * STATUS_BUFFER_OVERFLOW in a FSCTL_PIPE_TRANSCEIVE, FSCTL_PIPE_PEEK or
266 : * FSCTL_DFS_GET_REFERRALS Response specified in section 2.2.32.<153>
267 : */
268 6931 : if (NT_STATUS_EQUAL(status, STATUS_BUFFER_OVERFLOW)
269 0 : && ((ctl_code == FSCTL_PIPE_TRANSCEIVE)
270 0 : || (ctl_code == FSCTL_PIPE_PEEK)
271 0 : || (ctl_code == FSCTL_DFS_GET_REFERRALS))) {
272 0 : return false;
273 : }
274 :
275 : /*
276 : * Any status other than STATUS_SUCCESS in a FSCTL_SRV_COPYCHUNK or
277 : * FSCTL_SRV_COPYCHUNK_WRITE Response, when returning an
278 : * SRV_COPYCHUNK_RESPONSE as described in section 2.2.32.1.
279 : */
280 6931 : if (((ctl_code == FSCTL_SRV_COPYCHUNK)
281 6835 : || (ctl_code == FSCTL_SRV_COPYCHUNK_WRITE))
282 96 : && (data_size == sizeof(struct srv_copychunk_rsp))) {
283 88 : return false;
284 : }
285 :
286 6840 : return true;
287 : }
288 :
289 336042 : static void smbd_smb2_request_ioctl_done(struct tevent_req *subreq)
290 : {
291 336042 : struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
292 : struct smbd_smb2_request);
293 7176 : const uint8_t *inbody;
294 7176 : DATA_BLOB outbody;
295 7176 : DATA_BLOB outdyn;
296 7176 : uint32_t in_ctl_code;
297 7176 : uint64_t in_file_id_persistent;
298 7176 : uint64_t in_file_id_volatile;
299 7176 : uint32_t in_max_output_length;
300 7176 : uint32_t out_input_offset;
301 7176 : uint32_t out_output_offset;
302 336042 : DATA_BLOB out_output_buffer = data_blob_null;
303 7176 : NTSTATUS status;
304 7176 : NTSTATUS error; /* transport error */
305 336042 : bool disconnect = false;
306 7176 : uint16_t body_size;
307 336042 : uint8_t body_padding = 0;
308 :
309 336042 : status = smbd_smb2_ioctl_recv(subreq, req,
310 : &out_output_buffer,
311 : &body_padding,
312 : &disconnect);
313 :
314 336042 : DEBUG(10,("smbd_smb2_request_ioctl_done: smbd_smb2_ioctl_recv returned "
315 : "%u status %s\n",
316 : (unsigned int)out_output_buffer.length,
317 : nt_errstr(status) ));
318 :
319 336042 : TALLOC_FREE(subreq);
320 336042 : if (disconnect) {
321 0 : error = status;
322 0 : smbd_server_connection_terminate(req->xconn,
323 : nt_errstr(error));
324 6843 : return;
325 : }
326 :
327 336042 : inbody = SMBD_SMB2_IN_BODY_PTR(req);
328 :
329 336042 : in_ctl_code = IVAL(inbody, 0x04);
330 336042 : in_file_id_persistent = BVAL(inbody, 0x08);
331 336042 : in_file_id_volatile = BVAL(inbody, 0x10);
332 336042 : in_max_output_length = IVAL(inbody, 0x2C);
333 :
334 336042 : if (out_output_buffer.length > in_max_output_length) {
335 : /*
336 : * Return NT_STATUS_BUFFER_TOO_SMALL by
337 : * default if the provided buffer doesn't
338 : * fit.
339 : *
340 : * If someone wants truncated data
341 : * together with STATUS_BUFFER_OVERFLOW
342 : * it needs to be done explicitly in
343 : * the backends. We currently do that
344 : * in:
345 : * - fsctl_dfs_get_refers()
346 : * - smbd_smb2_ioctl_pipe_read_done()
347 : */
348 14 : status = NT_STATUS_BUFFER_TOO_SMALL;
349 : }
350 :
351 336042 : if (smbd_smb2_ioctl_is_failure(in_ctl_code, status,
352 : out_output_buffer.length)) {
353 6843 : error = smbd_smb2_request_error(req, status);
354 6843 : if (!NT_STATUS_IS_OK(error)) {
355 0 : smbd_server_connection_terminate(req->xconn,
356 : nt_errstr(error));
357 0 : return;
358 : }
359 6840 : return;
360 : }
361 :
362 : /*
363 : * Only FSCTL_SMBTORTURE_IOCTL_RESPONSE_BODY_PADDING8
364 : * sets body_padding to a value different from 0.
365 : */
366 329199 : body_size = 0x30 + body_padding;
367 329199 : out_input_offset = SMB2_HDR_BODY + body_size;
368 329199 : out_output_offset = SMB2_HDR_BODY + body_size;
369 :
370 329199 : outbody = smbd_smb2_generate_outbody(req, body_size);
371 329199 : if (outbody.data == NULL) {
372 0 : error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
373 0 : if (!NT_STATUS_IS_OK(error)) {
374 0 : smbd_server_connection_terminate(req->xconn,
375 : nt_errstr(error));
376 0 : return;
377 : }
378 0 : return;
379 : }
380 :
381 329199 : SSVAL(outbody.data, 0x00, 0x30 + 1); /* struct size */
382 329199 : SSVAL(outbody.data, 0x02, 0); /* reserved */
383 329199 : SIVAL(outbody.data, 0x04,
384 : in_ctl_code); /* ctl code */
385 329199 : SBVAL(outbody.data, 0x08,
386 : in_file_id_persistent); /* file id (persistent) */
387 329199 : SBVAL(outbody.data, 0x10,
388 : in_file_id_volatile); /* file id (volatile) */
389 329199 : SIVAL(outbody.data, 0x18,
390 : out_input_offset); /* input offset */
391 329199 : SIVAL(outbody.data, 0x1C, 0); /* input count */
392 329199 : SIVAL(outbody.data, 0x20,
393 : out_output_offset); /* output offset */
394 329199 : SIVAL(outbody.data, 0x24,
395 : out_output_buffer.length); /* output count */
396 329199 : SIVAL(outbody.data, 0x28, 0); /* flags */
397 329199 : SIVAL(outbody.data, 0x2C, 0); /* reserved */
398 329199 : if (body_padding != 0) {
399 8 : memset(outbody.data + 0x30, 0, body_padding);
400 : }
401 :
402 : /*
403 : * Note: Windows Vista and 2008 send back also the
404 : * input from the request. But it was fixed in
405 : * Windows 7.
406 : */
407 329199 : outdyn = out_output_buffer;
408 :
409 329199 : error = smbd_smb2_request_done_ex(req, status, outbody, &outdyn,
410 : __location__);
411 329199 : if (!NT_STATUS_IS_OK(error)) {
412 0 : smbd_server_connection_terminate(req->xconn,
413 : nt_errstr(error));
414 0 : return;
415 : }
416 : }
417 :
418 336042 : static struct tevent_req *smbd_smb2_ioctl_send(TALLOC_CTX *mem_ctx,
419 : struct tevent_context *ev,
420 : struct smbd_smb2_request *smb2req,
421 : struct files_struct *fsp,
422 : uint32_t in_ctl_code,
423 : DATA_BLOB in_input,
424 : uint32_t in_max_output,
425 : uint32_t in_flags)
426 : {
427 7176 : struct tevent_req *req;
428 7176 : struct smbd_smb2_ioctl_state *state;
429 7176 : struct smb_request *smbreq;
430 :
431 336042 : req = tevent_req_create(mem_ctx, &state,
432 : struct smbd_smb2_ioctl_state);
433 336042 : if (req == NULL) {
434 0 : return NULL;
435 : }
436 336042 : state->smb2req = smb2req;
437 336042 : state->smbreq = NULL;
438 336042 : state->fsp = fsp;
439 336042 : state->in_input = in_input;
440 336042 : state->in_max_output = in_max_output;
441 336042 : state->out_output = data_blob_null;
442 :
443 336042 : DEBUG(10, ("smbd_smb2_ioctl: ctl_code[0x%08x] %s, %s\n",
444 : (unsigned)in_ctl_code,
445 : fsp ? fsp_str_dbg(fsp) : "<no handle>",
446 : fsp_fnum_dbg(fsp)));
447 :
448 336042 : smbreq = smbd_smb2_fake_smb_request(smb2req, fsp);
449 336042 : if (tevent_req_nomem(smbreq, req)) {
450 0 : return tevent_req_post(req, ev);
451 : }
452 336042 : state->smbreq = smbreq;
453 :
454 336042 : switch (in_ctl_code & IOCTL_DEV_TYPE_MASK) {
455 11295 : case FSCTL_DFS:
456 11295 : return smb2_ioctl_dfs(in_ctl_code, ev, req, state);
457 974 : case FSCTL_FILESYSTEM:
458 974 : return smb2_ioctl_filesys(in_ctl_code, ev, req, state);
459 318555 : case FSCTL_NAMED_PIPE:
460 318555 : return smb2_ioctl_named_pipe(in_ctl_code, ev, req, state);
461 4870 : case FSCTL_NETWORK_FILESYSTEM:
462 4870 : return smb2_ioctl_network_fs(in_ctl_code, ev, req, state);
463 348 : case FSCTL_SMBTORTURE:
464 348 : return smb2_ioctl_smbtorture(in_ctl_code, ev, req, state);
465 0 : default:
466 0 : if (IS_IPC(smbreq->conn)) {
467 0 : tevent_req_nterror(req, NT_STATUS_FS_DRIVER_REQUIRED);
468 : } else {
469 0 : tevent_req_nterror(req, NT_STATUS_INVALID_DEVICE_REQUEST);
470 : }
471 :
472 0 : return tevent_req_post(req, ev);
473 : }
474 : }
475 :
476 336042 : static NTSTATUS smbd_smb2_ioctl_recv(struct tevent_req *req,
477 : TALLOC_CTX *mem_ctx,
478 : DATA_BLOB *out_output,
479 : uint8_t *body_padding,
480 : bool *disconnect)
481 : {
482 336042 : NTSTATUS status = NT_STATUS_OK;
483 336042 : struct smbd_smb2_ioctl_state *state = tevent_req_data(req,
484 : struct smbd_smb2_ioctl_state);
485 7176 : enum tevent_req_state req_state;
486 7176 : uint64_t err;
487 :
488 336042 : *body_padding = state->body_padding;
489 336042 : *disconnect = state->disconnect;
490 :
491 336042 : if ((tevent_req_is_error(req, &req_state, &err) == false)
492 6917 : || (req_state == TEVENT_REQ_USER_ERROR)) {
493 : /*
494 : * Return output buffer to caller if the ioctl was successfully
495 : * processed, even if a user error occurred. Some ioctls return
496 : * data on failure.
497 : */
498 336042 : *out_output = state->out_output;
499 336042 : talloc_steal(mem_ctx, out_output->data);
500 : }
501 :
502 336042 : tevent_req_is_nterror(req, &status);
503 336042 : tevent_req_received(req);
504 336042 : return status;
505 : }
|
