Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : LDAP protocol helper functions for SAMBA
4 :
5 : Copyright (C) Simo Sorce 2005
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 :
22 : #include "includes.h"
23 :
24 : #include <ldb.h>
25 :
26 : #include "../lib/util/asn1.h"
27 : #include "libcli/ldap/libcli_ldap.h"
28 : #include "libcli/ldap/ldap_proto.h"
29 : #include "dsdb/samdb/samdb.h"
30 :
31 0 : static bool decode_server_sort_response(void *mem_ctx, DATA_BLOB in, void *_out)
32 : {
33 0 : void **out = _out;
34 0 : DATA_BLOB attr;
35 0 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
36 0 : struct ldb_sort_resp_control *lsrc;
37 :
38 0 : if (!data) return false;
39 :
40 0 : if (!asn1_load(data, in)) {
41 0 : return false;
42 : }
43 :
44 0 : lsrc = talloc(mem_ctx, struct ldb_sort_resp_control);
45 0 : if (!lsrc) {
46 0 : return false;
47 : }
48 :
49 0 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
50 0 : return false;
51 : }
52 :
53 0 : if (!asn1_read_enumerated(data, &(lsrc->result))) {
54 0 : return false;
55 : }
56 :
57 0 : lsrc->attr_desc = NULL;
58 0 : if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
59 0 : if (!asn1_read_OctetString(data, mem_ctx, &attr)) {
60 0 : return false;
61 : }
62 0 : lsrc->attr_desc = talloc_strndup(lsrc, (const char *)attr.data, attr.length);
63 0 : if (!lsrc->attr_desc) {
64 0 : return false;
65 : }
66 : }
67 :
68 0 : if (!asn1_end_tag(data)) {
69 0 : return false;
70 : }
71 :
72 0 : *out = lsrc;
73 :
74 0 : return true;
75 : }
76 :
77 53536 : static bool decode_server_sort_request(void *mem_ctx, DATA_BLOB in, void *_out)
78 : {
79 53536 : void **out = _out;
80 0 : DATA_BLOB attr;
81 0 : DATA_BLOB rule;
82 53536 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
83 0 : struct ldb_server_sort_control **lssc;
84 0 : int num;
85 :
86 53536 : if (!data) return false;
87 :
88 53536 : if (!asn1_load(data, in)) {
89 0 : return false;
90 : }
91 :
92 53536 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
93 0 : return false;
94 : }
95 :
96 53536 : lssc = NULL;
97 :
98 107072 : for (num = 0; asn1_peek_tag(data, ASN1_SEQUENCE(0)); num++) {
99 53536 : lssc = talloc_realloc(mem_ctx, lssc, struct ldb_server_sort_control *, num + 2);
100 53536 : if (!lssc) {
101 0 : return false;
102 : }
103 53536 : lssc[num] = talloc_zero(lssc, struct ldb_server_sort_control);
104 53536 : if (!lssc[num]) {
105 0 : return false;
106 : }
107 :
108 53536 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
109 0 : return false;
110 : }
111 :
112 53536 : if (!asn1_read_OctetString(data, mem_ctx, &attr)) {
113 0 : return false;
114 : }
115 :
116 53536 : lssc[num]->attributeName = talloc_strndup(lssc[num], (const char *)attr.data, attr.length);
117 53536 : if (!lssc [num]->attributeName) {
118 0 : return false;
119 : }
120 :
121 53536 : if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(0))) {
122 15 : if (!asn1_read_ContextSimple(data, mem_ctx, 0, &rule)) {
123 0 : return false;
124 : }
125 15 : lssc[num]->orderingRule = talloc_strndup(lssc[num], (const char *)rule.data, rule.length);
126 15 : if (!lssc[num]->orderingRule) {
127 0 : return false;
128 : }
129 : }
130 :
131 53536 : if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(1))) {
132 0 : bool reverse;
133 59 : if (!asn1_read_BOOLEAN_context(data, &reverse, 1)) {
134 0 : return false;
135 : }
136 59 : lssc[num]->reverse = reverse;
137 : }
138 :
139 53536 : if (!asn1_end_tag(data)) {
140 0 : return false;
141 : }
142 : }
143 :
144 53536 : if (lssc != NULL) {
145 53536 : lssc[num] = NULL;
146 : }
147 :
148 53536 : if (!asn1_end_tag(data)) {
149 0 : return false;
150 : }
151 :
152 53536 : *out = lssc;
153 :
154 53536 : return true;
155 : }
156 :
157 16263 : static bool decode_extended_dn_request(void *mem_ctx, DATA_BLOB in, void *_out)
158 : {
159 16263 : void **out = _out;
160 0 : struct asn1_data *data;
161 0 : struct ldb_extended_dn_control *ledc;
162 :
163 : /* The content of this control is optional */
164 16263 : if (in.length == 0) {
165 136 : *out = NULL;
166 136 : return true;
167 : }
168 :
169 16127 : data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
170 16127 : if (!data) return false;
171 :
172 16127 : if (!asn1_load(data, in)) {
173 0 : return false;
174 : }
175 :
176 16127 : ledc = talloc(mem_ctx, struct ldb_extended_dn_control);
177 16127 : if (!ledc) {
178 0 : return false;
179 : }
180 :
181 16127 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
182 0 : return false;
183 : }
184 :
185 16127 : if (!asn1_read_Integer(data, &(ledc->type))) {
186 0 : return false;
187 : }
188 :
189 16127 : if (!asn1_end_tag(data)) {
190 0 : return false;
191 : }
192 :
193 16127 : *out = ledc;
194 :
195 16127 : return true;
196 : }
197 :
198 16800 : static bool decode_sd_flags_request(void *mem_ctx, DATA_BLOB in, void *_out)
199 : {
200 16800 : void **out = _out;
201 16800 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
202 0 : struct ldb_sd_flags_control *lsdfc;
203 :
204 16800 : if (!data) return false;
205 :
206 16800 : if (!asn1_load(data, in)) {
207 0 : return false;
208 : }
209 :
210 16800 : lsdfc = talloc(mem_ctx, struct ldb_sd_flags_control);
211 16800 : if (!lsdfc) {
212 0 : return false;
213 : }
214 :
215 16800 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
216 0 : return false;
217 : }
218 :
219 16800 : if (!asn1_read_Integer(data, (int *) &(lsdfc->secinfo_flags))) {
220 0 : return false;
221 : }
222 :
223 16800 : if (!asn1_end_tag(data)) {
224 0 : return false;
225 : }
226 :
227 16800 : *out = lsdfc;
228 :
229 16800 : return true;
230 : }
231 :
232 325 : static bool decode_search_options_request(void *mem_ctx, DATA_BLOB in, void *_out)
233 : {
234 325 : void **out = _out;
235 325 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
236 0 : struct ldb_search_options_control *lsoc;
237 :
238 325 : if (!data) return false;
239 :
240 325 : if (!asn1_load(data, in)) {
241 0 : return false;
242 : }
243 :
244 325 : lsoc = talloc(mem_ctx, struct ldb_search_options_control);
245 325 : if (!lsoc) {
246 0 : return false;
247 : }
248 :
249 325 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
250 0 : return false;
251 : }
252 :
253 325 : if (!asn1_read_Integer(data, (int *) &(lsoc->search_options))) {
254 0 : return false;
255 : }
256 :
257 325 : if (!asn1_end_tag(data)) {
258 0 : return false;
259 : }
260 :
261 325 : *out = lsoc;
262 :
263 325 : return true;
264 : }
265 :
266 139201 : static bool decode_paged_results_request(void *mem_ctx, DATA_BLOB in, void *_out)
267 : {
268 139201 : void **out = _out;
269 0 : DATA_BLOB cookie;
270 139201 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
271 0 : struct ldb_paged_control *lprc;
272 :
273 139201 : if (!data) return false;
274 :
275 139201 : if (!asn1_load(data, in)) {
276 0 : return false;
277 : }
278 :
279 139201 : lprc = talloc(mem_ctx, struct ldb_paged_control);
280 139201 : if (!lprc) {
281 0 : return false;
282 : }
283 :
284 139201 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
285 0 : return false;
286 : }
287 :
288 139201 : if (!asn1_read_Integer(data, &(lprc->size))) {
289 0 : return false;
290 : }
291 :
292 139201 : if (!asn1_read_OctetString(data, mem_ctx, &cookie)) {
293 0 : return false;
294 : }
295 139201 : lprc->cookie_len = cookie.length;
296 139201 : if (lprc->cookie_len) {
297 471 : lprc->cookie = talloc_memdup(lprc, cookie.data, cookie.length);
298 :
299 471 : if (!(lprc->cookie)) {
300 0 : return false;
301 : }
302 : } else {
303 138730 : lprc->cookie = NULL;
304 : }
305 :
306 139201 : if (!asn1_end_tag(data)) {
307 0 : return false;
308 : }
309 :
310 139201 : *out = lprc;
311 :
312 139201 : return true;
313 : }
314 :
315 1044 : static bool decode_dirsync_request(void *mem_ctx, DATA_BLOB in, void *_out)
316 : {
317 1044 : void **out = _out;
318 0 : DATA_BLOB cookie;
319 1044 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
320 0 : struct ldb_dirsync_control *ldc;
321 :
322 1044 : if (!data) return false;
323 :
324 1044 : if (!asn1_load(data, in)) {
325 0 : return false;
326 : }
327 :
328 1044 : ldc = talloc(mem_ctx, struct ldb_dirsync_control);
329 1044 : if (!ldc) {
330 0 : return false;
331 : }
332 :
333 1044 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
334 0 : return false;
335 : }
336 :
337 1044 : if (!asn1_read_Integer(data, &(ldc->flags))) {
338 0 : return false;
339 : }
340 :
341 1044 : if (!asn1_read_Integer(data, &(ldc->max_attributes))) {
342 0 : return false;
343 : }
344 :
345 1044 : if (!asn1_read_OctetString(data, mem_ctx, &cookie)) {
346 0 : return false;
347 : }
348 1044 : ldc->cookie_len = cookie.length;
349 1044 : if (ldc->cookie_len) {
350 659 : ldc->cookie = talloc_memdup(ldc, cookie.data, cookie.length);
351 :
352 659 : if (!(ldc->cookie)) {
353 0 : return false;
354 : }
355 : } else {
356 385 : ldc->cookie = NULL;
357 : }
358 :
359 1044 : if (!asn1_end_tag(data)) {
360 0 : return false;
361 : }
362 :
363 1044 : *out = ldc;
364 :
365 1044 : return true;
366 : }
367 :
368 : /* seem that this controls has 2 forms one in case it is used with
369 : * a Search Request and another when used ina Search Response
370 : */
371 29 : static bool decode_asq_control(void *mem_ctx, DATA_BLOB in, void *_out)
372 : {
373 29 : void **out = _out;
374 0 : DATA_BLOB source_attribute;
375 29 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
376 0 : struct ldb_asq_control *lac;
377 :
378 29 : if (!data) return false;
379 :
380 29 : if (!asn1_load(data, in)) {
381 0 : return false;
382 : }
383 :
384 29 : lac = talloc(mem_ctx, struct ldb_asq_control);
385 29 : if (!lac) {
386 0 : return false;
387 : }
388 :
389 29 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
390 0 : return false;
391 : }
392 :
393 29 : if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
394 :
395 15 : if (!asn1_read_OctetString(data, mem_ctx, &source_attribute)) {
396 0 : return false;
397 : }
398 15 : lac->src_attr_len = source_attribute.length;
399 15 : if (lac->src_attr_len) {
400 15 : lac->source_attribute = talloc_strndup(lac, (const char *)source_attribute.data, source_attribute.length);
401 :
402 15 : if (!(lac->source_attribute)) {
403 0 : return false;
404 : }
405 : } else {
406 0 : lac->source_attribute = NULL;
407 : }
408 :
409 15 : lac->request = 1;
410 :
411 14 : } else if (asn1_peek_tag(data, ASN1_ENUMERATED)) {
412 :
413 14 : if (!asn1_read_enumerated(data, &(lac->result))) {
414 0 : return false;
415 : }
416 :
417 14 : lac->request = 0;
418 :
419 : } else {
420 0 : return false;
421 : }
422 :
423 29 : if (!asn1_end_tag(data)) {
424 0 : return false;
425 : }
426 :
427 29 : *out = lac;
428 :
429 29 : return true;
430 : }
431 :
432 0 : static bool decode_verify_name_request(void *mem_ctx, DATA_BLOB in, void *_out)
433 : {
434 0 : void **out = _out;
435 0 : DATA_BLOB name;
436 0 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
437 0 : struct ldb_verify_name_control *lvnc;
438 0 : int len;
439 :
440 0 : if (!data) return false;
441 :
442 0 : if (!asn1_load(data, in)) {
443 0 : return false;
444 : }
445 :
446 0 : lvnc = talloc(mem_ctx, struct ldb_verify_name_control);
447 0 : if (!lvnc) {
448 0 : return false;
449 : }
450 :
451 0 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
452 0 : return false;
453 : }
454 :
455 0 : if (!asn1_read_Integer(data, &(lvnc->flags))) {
456 0 : return false;
457 : }
458 :
459 0 : if (!asn1_read_OctetString(data, mem_ctx, &name)) {
460 0 : return false;
461 : }
462 :
463 0 : if (name.length) {
464 0 : len = utf16_null_terminated_len_n(name.data, name.length);
465 0 : convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
466 0 : name.data, len,
467 0 : &lvnc->gc, &lvnc->gc_len);
468 :
469 0 : if (!(lvnc->gc)) {
470 0 : return false;
471 : }
472 : } else {
473 0 : lvnc->gc_len = 0;
474 0 : lvnc->gc = NULL;
475 : }
476 :
477 0 : if (!asn1_end_tag(data)) {
478 0 : return false;
479 : }
480 :
481 0 : *out = lvnc;
482 0 : return true;
483 : }
484 :
485 0 : static bool encode_verify_name_request(void *mem_ctx, void *in, DATA_BLOB *out)
486 : {
487 0 : struct ldb_verify_name_control *lvnc = talloc_get_type(in, struct ldb_verify_name_control);
488 0 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
489 0 : DATA_BLOB gc_utf16;
490 :
491 0 : if (!data) return false;
492 :
493 0 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
494 0 : return false;
495 : }
496 :
497 0 : if (!asn1_write_Integer(data, lvnc->flags)) {
498 0 : return false;
499 : }
500 :
501 0 : if (lvnc->gc_len) {
502 0 : bool ok;
503 :
504 0 : ok = convert_string_talloc(mem_ctx, CH_UNIX, CH_UTF16,
505 0 : lvnc->gc, lvnc->gc_len,
506 : &gc_utf16.data, &gc_utf16.length);
507 0 : if (!ok) {
508 0 : return false;
509 : }
510 0 : if (!asn1_write_OctetString(data, gc_utf16.data, gc_utf16.length)) {
511 0 : return false;
512 : }
513 : } else {
514 0 : if (!asn1_write_OctetString(data, NULL, 0)) {
515 0 : return false;
516 : }
517 : }
518 :
519 0 : if (!asn1_pop_tag(data)) {
520 0 : return false;
521 : }
522 :
523 0 : if (!asn1_extract_blob(data, mem_ctx, out)) {
524 0 : return false;
525 : }
526 :
527 0 : talloc_free(data);
528 :
529 0 : return true;
530 : }
531 :
532 53033 : static bool decode_vlv_request(void *mem_ctx, DATA_BLOB in, void *_out)
533 : {
534 53033 : void **out = _out;
535 0 : DATA_BLOB assertion_value, context_id;
536 53033 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
537 0 : struct ldb_vlv_req_control *lvrc;
538 :
539 53033 : if (!data) return false;
540 :
541 53033 : if (!asn1_load(data, in)) {
542 0 : return false;
543 : }
544 :
545 53033 : lvrc = talloc(mem_ctx, struct ldb_vlv_req_control);
546 53033 : if (!lvrc) {
547 0 : return false;
548 : }
549 :
550 53033 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
551 0 : return false;
552 : }
553 :
554 53033 : if (!asn1_read_Integer(data, &(lvrc->beforeCount))) {
555 0 : return false;
556 : }
557 :
558 53033 : if (!asn1_read_Integer(data, &(lvrc->afterCount))) {
559 0 : return false;
560 : }
561 :
562 53033 : if (asn1_peek_tag(data, ASN1_CONTEXT(0))) {
563 :
564 30758 : lvrc->type = 0;
565 :
566 30758 : if (!asn1_start_tag(data, ASN1_CONTEXT(0))) {
567 0 : return false;
568 : }
569 :
570 30758 : if (!asn1_read_Integer(data, &(lvrc->match.byOffset.offset))) {
571 0 : return false;
572 : }
573 :
574 30758 : if (!asn1_read_Integer(data, &(lvrc->match.byOffset.contentCount))) {
575 0 : return false;
576 : }
577 :
578 30758 : if (!asn1_end_tag(data)) { /*CONTEXT*/
579 0 : return false;
580 : }
581 :
582 : } else {
583 :
584 22275 : lvrc->type = 1;
585 :
586 22275 : if (!asn1_read_ContextSimple(data, mem_ctx, 1, &assertion_value)){
587 0 : return false;
588 : }
589 :
590 22275 : lvrc->match.gtOrEq.value_len = assertion_value.length;
591 22275 : if (lvrc->match.gtOrEq.value_len) {
592 22275 : lvrc->match.gtOrEq.value = talloc_memdup(lvrc, assertion_value.data, assertion_value.length);
593 :
594 22275 : if (!(lvrc->match.gtOrEq.value)) {
595 0 : return false;
596 : }
597 : } else {
598 0 : lvrc->match.gtOrEq.value = NULL;
599 : }
600 : }
601 :
602 53033 : if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
603 45278 : if (!asn1_read_OctetString(data, mem_ctx, &context_id)) {
604 0 : return false;
605 : }
606 45278 : lvrc->ctxid_len = context_id.length;
607 45278 : if (lvrc->ctxid_len) {
608 45278 : lvrc->contextId = talloc_memdup(lvrc, context_id.data, context_id.length);
609 :
610 45278 : if (!(lvrc->contextId)) {
611 0 : return false;
612 : }
613 : } else {
614 0 : lvrc->contextId = NULL;
615 : }
616 : } else {
617 7755 : lvrc->contextId = NULL;
618 7755 : lvrc->ctxid_len = 0;
619 : }
620 :
621 53033 : if (!asn1_end_tag(data)) {
622 0 : return false;
623 : }
624 :
625 53033 : *out = lvrc;
626 :
627 53033 : return true;
628 : }
629 :
630 53028 : static bool decode_vlv_response(void *mem_ctx, DATA_BLOB in, void *_out)
631 : {
632 53028 : void **out = _out;
633 0 : DATA_BLOB context_id;
634 53028 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
635 0 : struct ldb_vlv_resp_control *lvrc;
636 :
637 53028 : if (!data) return false;
638 :
639 53028 : if (!asn1_load(data, in)) {
640 0 : return false;
641 : }
642 :
643 53028 : lvrc = talloc(mem_ctx, struct ldb_vlv_resp_control);
644 53028 : if (!lvrc) {
645 0 : return false;
646 : }
647 :
648 53028 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
649 0 : return false;
650 : }
651 :
652 53028 : if (!asn1_read_Integer(data, &(lvrc->targetPosition))) {
653 0 : return false;
654 : }
655 :
656 53028 : if (!asn1_read_Integer(data, &(lvrc->contentCount))) {
657 0 : return false;
658 : }
659 :
660 53028 : if (!asn1_read_enumerated(data, &(lvrc->vlv_result))) {
661 0 : return false;
662 : }
663 :
664 53028 : if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
665 53028 : if (!asn1_read_OctetString(data, mem_ctx, &context_id)) {
666 0 : return false;
667 : }
668 53028 : lvrc->contextId = talloc_memdup(lvrc, (const char *)context_id.data, context_id.length);
669 53028 : if (!lvrc->contextId) {
670 0 : return false;
671 : }
672 53028 : lvrc->ctxid_len = context_id.length;
673 : } else {
674 0 : lvrc->contextId = NULL;
675 0 : lvrc->ctxid_len = 0;
676 : }
677 :
678 53028 : if (!asn1_end_tag(data)) {
679 0 : return false;
680 : }
681 :
682 53028 : *out = lvrc;
683 :
684 53028 : return true;
685 : }
686 :
687 0 : static bool encode_server_sort_response(void *mem_ctx, void *in, DATA_BLOB *out)
688 : {
689 0 : struct ldb_sort_resp_control *lsrc = talloc_get_type(in, struct ldb_sort_resp_control);
690 0 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
691 :
692 0 : if (!data) return false;
693 :
694 0 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
695 0 : return false;
696 : }
697 :
698 0 : if (!asn1_write_enumerated(data, lsrc->result)) {
699 0 : return false;
700 : }
701 :
702 0 : if (lsrc->attr_desc) {
703 0 : if (!asn1_write_OctetString(data, lsrc->attr_desc, strlen(lsrc->attr_desc))) {
704 0 : return false;
705 : }
706 : }
707 :
708 0 : if (!asn1_pop_tag(data)) {
709 0 : return false;
710 : }
711 :
712 0 : if (!asn1_extract_blob(data, mem_ctx, out)) {
713 0 : return false;
714 : }
715 :
716 0 : talloc_free(data);
717 :
718 0 : return true;
719 : }
720 :
721 53536 : static bool encode_server_sort_request(void *mem_ctx, void *in, DATA_BLOB *out)
722 : {
723 53536 : struct ldb_server_sort_control **lssc = talloc_get_type(in, struct ldb_server_sort_control *);
724 53536 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
725 0 : int num;
726 :
727 53536 : if (!data) return false;
728 :
729 53536 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
730 0 : return false;
731 : }
732 :
733 : /*
734 : RFC2891 section 1.1:
735 : SortKeyList ::= SEQUENCE OF SEQUENCE {
736 : attributeType AttributeDescription,
737 : orderingRule [0] MatchingRuleId OPTIONAL,
738 : reverseOrder [1] BOOLEAN DEFAULT FALSE }
739 : */
740 107072 : for (num = 0; lssc[num]; num++) {
741 53536 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
742 0 : return false;
743 : }
744 :
745 53536 : if (!asn1_write_OctetString(data, lssc[num]->attributeName, strlen(lssc[num]->attributeName))) {
746 0 : return false;
747 : }
748 :
749 53536 : if (lssc[num]->orderingRule) {
750 15 : DATA_BLOB order = data_blob_string_const(lssc[num]->orderingRule);
751 15 : if (!asn1_write_ContextSimple(data, 0, &order)) {
752 0 : return false;
753 : }
754 : }
755 :
756 53536 : if (lssc[num]->reverse) {
757 59 : if (!asn1_write_BOOLEAN_context(data, lssc[num]->reverse, 1)) {
758 0 : return false;
759 : }
760 : }
761 :
762 53536 : if (!asn1_pop_tag(data)) {
763 0 : return false;
764 : }
765 : }
766 :
767 53536 : if (!asn1_pop_tag(data)) {
768 0 : return false;
769 : }
770 :
771 53536 : if (!asn1_extract_blob(data, mem_ctx, out)) {
772 0 : return false;
773 : }
774 :
775 53536 : talloc_free(data);
776 :
777 53536 : return true;
778 : }
779 :
780 16237 : static bool encode_extended_dn_request(void *mem_ctx, void *in, DATA_BLOB *out)
781 : {
782 16237 : struct ldb_extended_dn_control *ledc = talloc_get_type(in, struct ldb_extended_dn_control);
783 0 : struct asn1_data *data;
784 :
785 16237 : if (!in) {
786 114 : *out = data_blob(NULL, 0);
787 114 : return true;
788 : }
789 :
790 16123 : data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
791 :
792 16123 : if (!data) return false;
793 :
794 16123 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
795 0 : return false;
796 : }
797 :
798 16123 : if (!asn1_write_Integer(data, ledc->type)) {
799 0 : return false;
800 : }
801 :
802 16123 : if (!asn1_pop_tag(data)) {
803 0 : return false;
804 : }
805 :
806 16123 : if (!asn1_extract_blob(data, mem_ctx, out)) {
807 0 : return false;
808 : }
809 :
810 16123 : talloc_free(data);
811 :
812 16123 : return true;
813 : }
814 :
815 16796 : static bool encode_sd_flags_request(void *mem_ctx, void *in, DATA_BLOB *out)
816 : {
817 16796 : struct ldb_sd_flags_control *lsdfc = talloc_get_type(in, struct ldb_sd_flags_control);
818 16796 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
819 :
820 16796 : if (!data) return false;
821 :
822 16796 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
823 0 : return false;
824 : }
825 :
826 16796 : if (!asn1_write_Integer(data, lsdfc->secinfo_flags)) {
827 0 : return false;
828 : }
829 :
830 16796 : if (!asn1_pop_tag(data)) {
831 0 : return false;
832 : }
833 :
834 16796 : if (!asn1_extract_blob(data, mem_ctx, out)) {
835 0 : return false;
836 : }
837 :
838 16796 : talloc_free(data);
839 :
840 16796 : return true;
841 : }
842 :
843 325 : static bool encode_search_options_request(void *mem_ctx, void *in, DATA_BLOB *out)
844 : {
845 325 : struct ldb_search_options_control *lsoc = talloc_get_type(in, struct ldb_search_options_control);
846 325 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
847 :
848 325 : if (!data) return false;
849 :
850 325 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
851 0 : return false;
852 : }
853 :
854 325 : if (!asn1_write_Integer(data, lsoc->search_options)) {
855 0 : return false;
856 : }
857 :
858 325 : if (!asn1_pop_tag(data)) {
859 0 : return false;
860 : }
861 :
862 325 : if (!asn1_extract_blob(data, mem_ctx, out)) {
863 0 : return false;
864 : }
865 :
866 325 : talloc_free(data);
867 :
868 325 : return true;
869 : }
870 :
871 139201 : static bool encode_paged_results_request(void *mem_ctx, void *in, DATA_BLOB *out)
872 : {
873 139201 : struct ldb_paged_control *lprc = talloc_get_type(in, struct ldb_paged_control);
874 139201 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
875 :
876 139201 : if (!data) return false;
877 :
878 139201 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
879 0 : return false;
880 : }
881 :
882 139201 : if (!asn1_write_Integer(data, lprc->size)) {
883 0 : return false;
884 : }
885 :
886 139201 : if (!asn1_write_OctetString(data, lprc->cookie, lprc->cookie_len)) {
887 0 : return false;
888 : }
889 :
890 139201 : if (!asn1_pop_tag(data)) {
891 0 : return false;
892 : }
893 :
894 139201 : if (!asn1_extract_blob(data, mem_ctx, out)) {
895 0 : return false;
896 : }
897 :
898 139201 : talloc_free(data);
899 :
900 139201 : return true;
901 : }
902 :
903 : /* seem that this controls has 2 forms one in case it is used with
904 : * a Search Request and another when used ina Search Response
905 : */
906 29 : static bool encode_asq_control(void *mem_ctx, void *in, DATA_BLOB *out)
907 : {
908 29 : struct ldb_asq_control *lac = talloc_get_type(in, struct ldb_asq_control);
909 29 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
910 :
911 29 : if (!data) return false;
912 :
913 29 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
914 0 : return false;
915 : }
916 :
917 29 : if (lac->request) {
918 :
919 15 : if (!asn1_write_OctetString(data, lac->source_attribute, lac->src_attr_len)) {
920 0 : return false;
921 : }
922 : } else {
923 14 : if (!asn1_write_enumerated(data, lac->result)) {
924 0 : return false;
925 : }
926 : }
927 :
928 29 : if (!asn1_pop_tag(data)) {
929 0 : return false;
930 : }
931 :
932 29 : if (!asn1_extract_blob(data, mem_ctx, out)) {
933 0 : return false;
934 : }
935 :
936 29 : talloc_free(data);
937 :
938 29 : return true;
939 : }
940 :
941 1044 : static bool encode_dirsync_request(void *mem_ctx, void *in, DATA_BLOB *out)
942 : {
943 1044 : struct ldb_dirsync_control *ldc = talloc_get_type(in, struct ldb_dirsync_control);
944 1044 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
945 :
946 1044 : if (!data) return false;
947 :
948 1044 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
949 0 : return false;
950 : }
951 :
952 1044 : if (!asn1_write_Integer(data, ldc->flags)) {
953 0 : return false;
954 : }
955 :
956 1044 : if (!asn1_write_Integer(data, ldc->max_attributes)) {
957 0 : return false;
958 : }
959 :
960 1044 : if (!asn1_write_OctetString(data, ldc->cookie, ldc->cookie_len)) {
961 0 : return false;
962 : }
963 :
964 1044 : if (!asn1_pop_tag(data)) {
965 0 : return false;
966 : }
967 :
968 1044 : if (!asn1_extract_blob(data, mem_ctx, out)) {
969 0 : return false;
970 : }
971 :
972 1044 : talloc_free(data);
973 :
974 1044 : return true;
975 : }
976 :
977 53033 : static bool encode_vlv_request(void *mem_ctx, void *in, DATA_BLOB *out)
978 : {
979 53033 : struct ldb_vlv_req_control *lvrc = talloc_get_type(in, struct ldb_vlv_req_control);
980 53033 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
981 :
982 53033 : if (!data) return false;
983 :
984 53033 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
985 0 : return false;
986 : }
987 :
988 53033 : if (!asn1_write_Integer(data, lvrc->beforeCount)) {
989 0 : return false;
990 : }
991 :
992 53033 : if (!asn1_write_Integer(data, lvrc->afterCount)) {
993 0 : return false;
994 : }
995 :
996 53033 : if (lvrc->type == 0) {
997 30758 : if (!asn1_push_tag(data, ASN1_CONTEXT(0))) {
998 0 : return false;
999 : }
1000 :
1001 30758 : if (!asn1_write_Integer(data, lvrc->match.byOffset.offset)) {
1002 0 : return false;
1003 : }
1004 :
1005 30758 : if (!asn1_write_Integer(data, lvrc->match.byOffset.contentCount)) {
1006 0 : return false;
1007 : }
1008 :
1009 30758 : if (!asn1_pop_tag(data)) { /*CONTEXT*/
1010 0 : return false;
1011 : }
1012 : } else {
1013 22275 : if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(1))) {
1014 0 : return false;
1015 : }
1016 :
1017 22275 : if (!asn1_write(data, lvrc->match.gtOrEq.value, lvrc->match.gtOrEq.value_len)) {
1018 0 : return false;
1019 : }
1020 :
1021 22275 : if (!asn1_pop_tag(data)) { /*CONTEXT*/
1022 0 : return false;
1023 : }
1024 : }
1025 :
1026 53033 : if (lvrc->ctxid_len) {
1027 45278 : if (!asn1_write_OctetString(data, lvrc->contextId, lvrc->ctxid_len)) {
1028 0 : return false;
1029 : }
1030 : }
1031 :
1032 53033 : if (!asn1_pop_tag(data)) {
1033 0 : return false;
1034 : }
1035 :
1036 53033 : if (!asn1_extract_blob(data, mem_ctx, out)) {
1037 0 : return false;
1038 : }
1039 :
1040 53033 : talloc_free(data);
1041 :
1042 53033 : return true;
1043 : }
1044 :
1045 53028 : static bool encode_vlv_response(void *mem_ctx, void *in, DATA_BLOB *out)
1046 : {
1047 53028 : struct ldb_vlv_resp_control *lvrc = talloc_get_type(in, struct ldb_vlv_resp_control);
1048 53028 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
1049 :
1050 53028 : if (!data) return false;
1051 :
1052 53028 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
1053 0 : return false;
1054 : }
1055 :
1056 53028 : if (!asn1_write_Integer(data, lvrc->targetPosition)) {
1057 0 : return false;
1058 : }
1059 :
1060 53028 : if (!asn1_write_Integer(data, lvrc->contentCount)) {
1061 0 : return false;
1062 : }
1063 :
1064 53028 : if (!asn1_write_enumerated(data, lvrc->vlv_result)) {
1065 0 : return false;
1066 : }
1067 :
1068 53028 : if (lvrc->ctxid_len) {
1069 53028 : if (!asn1_write_OctetString(data, lvrc->contextId, lvrc->ctxid_len)) {
1070 0 : return false;
1071 : }
1072 : }
1073 :
1074 53028 : if (!asn1_pop_tag(data)) {
1075 0 : return false;
1076 : }
1077 :
1078 53028 : if (!asn1_extract_blob(data, mem_ctx, out)) {
1079 0 : return false;
1080 : }
1081 :
1082 53028 : talloc_free(data);
1083 :
1084 53028 : return true;
1085 : }
1086 :
1087 0 : static bool encode_openldap_dereference(void *mem_ctx, void *in, DATA_BLOB *out)
1088 : {
1089 0 : struct dsdb_openldap_dereference_control *control = talloc_get_type(in, struct dsdb_openldap_dereference_control);
1090 0 : int i,j;
1091 0 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
1092 :
1093 0 : if (!data) return false;
1094 :
1095 0 : if (!control) return false;
1096 :
1097 0 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
1098 0 : return false;
1099 : }
1100 :
1101 0 : for (i=0; control->dereference && control->dereference[i]; i++) {
1102 0 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
1103 0 : return false;
1104 : }
1105 0 : if (!asn1_write_OctetString(data, control->dereference[i]->source_attribute, strlen(control->dereference[i]->source_attribute))) {
1106 0 : return false;
1107 : }
1108 0 : if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
1109 0 : return false;
1110 : }
1111 0 : for (j=0; control->dereference && control->dereference[i]->dereference_attribute[j]; j++) {
1112 0 : if (!asn1_write_OctetString(data, control->dereference[i]->dereference_attribute[j],
1113 0 : strlen(control->dereference[i]->dereference_attribute[j]))) {
1114 0 : return false;
1115 : }
1116 : }
1117 :
1118 0 : if (!asn1_pop_tag(data)) {
1119 0 : return false;
1120 : }
1121 0 : if (!asn1_pop_tag(data)) {
1122 0 : return false;
1123 : }
1124 : }
1125 0 : if (!asn1_pop_tag(data)) {
1126 0 : return false;
1127 : }
1128 :
1129 0 : if (!asn1_extract_blob(data, mem_ctx, out)) {
1130 0 : return false;
1131 : }
1132 :
1133 0 : talloc_free(data);
1134 0 : return true;
1135 : }
1136 :
1137 0 : static bool decode_openldap_dereference(void *mem_ctx, DATA_BLOB in, void *_out)
1138 : {
1139 0 : void **out = _out;
1140 0 : struct asn1_data *data = asn1_init(mem_ctx, ASN1_MAX_TREE_DEPTH);
1141 0 : struct dsdb_openldap_dereference_result_control *control;
1142 0 : struct dsdb_openldap_dereference_result **r = NULL;
1143 0 : int i = 0;
1144 0 : if (!data) return false;
1145 :
1146 0 : control = talloc(mem_ctx, struct dsdb_openldap_dereference_result_control);
1147 0 : if (!control) return false;
1148 :
1149 0 : if (!asn1_load(data, in)) {
1150 0 : return false;
1151 : }
1152 :
1153 0 : control = talloc(mem_ctx, struct dsdb_openldap_dereference_result_control);
1154 0 : if (!control) {
1155 0 : return false;
1156 : }
1157 :
1158 0 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
1159 0 : return false;
1160 : }
1161 :
1162 0 : while (asn1_tag_remaining(data) > 0) {
1163 0 : r = talloc_realloc(control, r, struct dsdb_openldap_dereference_result *, i + 2);
1164 0 : if (!r) {
1165 0 : return false;
1166 : }
1167 0 : r[i] = talloc_zero(r, struct dsdb_openldap_dereference_result);
1168 0 : if (!r[i]) {
1169 0 : return false;
1170 : }
1171 :
1172 0 : if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
1173 0 : return false;
1174 : }
1175 :
1176 0 : if (!asn1_read_OctetString_talloc(r[i], data, &r[i]->source_attribute)) {
1177 0 : return false;
1178 : }
1179 0 : if (!asn1_read_OctetString_talloc(r[i], data, &r[i]->dereferenced_dn)) {
1180 0 : return false;
1181 : }
1182 0 : if (asn1_peek_tag(data, ASN1_CONTEXT(0))) {
1183 0 : if (!asn1_start_tag(data, ASN1_CONTEXT(0))) {
1184 0 : return false;
1185 : }
1186 0 : if (!ldap_decode_attribs_bare(r, data, &r[i]->attributes,
1187 0 : &r[i]->num_attributes)) {
1188 0 : return false;
1189 : }
1190 0 : if (!asn1_end_tag(data)) {
1191 0 : return false;
1192 : }
1193 : }
1194 0 : if (!asn1_end_tag(data)) {
1195 0 : return false;
1196 : }
1197 0 : i++;
1198 0 : r[i] = NULL;
1199 : }
1200 :
1201 0 : if (!asn1_end_tag(data)) {
1202 0 : return false;
1203 : }
1204 :
1205 0 : control->attributes = r;
1206 0 : *out = control;
1207 :
1208 0 : return true;
1209 : }
1210 :
1211 67818 : static bool encode_flag_request(void *mem_ctx, void *in, DATA_BLOB *out)
1212 : {
1213 67818 : if (in) {
1214 0 : return false;
1215 : }
1216 :
1217 67818 : *out = data_blob(NULL, 0);
1218 67818 : return true;
1219 : }
1220 :
1221 68147 : static bool decode_flag_request(void *mem_ctx, DATA_BLOB in, void *_out)
1222 : {
1223 68147 : if (in.length != 0) {
1224 0 : return false;
1225 : }
1226 :
1227 68147 : return true;
1228 : }
1229 :
1230 : static const struct ldap_control_handler ldap_known_controls[] = {
1231 : { LDB_CONTROL_PAGED_RESULTS_OID, decode_paged_results_request, encode_paged_results_request },
1232 : { LDB_CONTROL_SD_FLAGS_OID, decode_sd_flags_request, encode_sd_flags_request },
1233 : { LDB_CONTROL_DOMAIN_SCOPE_OID, decode_flag_request, encode_flag_request },
1234 : { LDB_CONTROL_SEARCH_OPTIONS_OID, decode_search_options_request, encode_search_options_request },
1235 : { LDB_CONTROL_NOTIFICATION_OID, decode_flag_request, encode_flag_request },
1236 : { LDB_CONTROL_TREE_DELETE_OID, decode_flag_request, encode_flag_request },
1237 : { LDB_CONTROL_SHOW_DELETED_OID, decode_flag_request, encode_flag_request },
1238 : { LDB_CONTROL_SHOW_RECYCLED_OID, decode_flag_request, encode_flag_request },
1239 : { LDB_CONTROL_SHOW_DEACTIVATED_LINK_OID, decode_flag_request, encode_flag_request },
1240 : { LDB_CONTROL_EXTENDED_DN_OID, decode_extended_dn_request, encode_extended_dn_request },
1241 : { LDB_CONTROL_SERVER_SORT_OID, decode_server_sort_request, encode_server_sort_request },
1242 : { LDB_CONTROL_SORT_RESP_OID, decode_server_sort_response, encode_server_sort_response },
1243 : { LDB_CONTROL_ASQ_OID, decode_asq_control, encode_asq_control },
1244 : { LDB_CONTROL_DIRSYNC_OID, decode_dirsync_request, encode_dirsync_request },
1245 : { LDB_CONTROL_DIRSYNC_EX_OID, decode_dirsync_request, encode_dirsync_request },
1246 : { LDB_CONTROL_VLV_REQ_OID, decode_vlv_request, encode_vlv_request },
1247 : { LDB_CONTROL_VLV_RESP_OID, decode_vlv_response, encode_vlv_response },
1248 : { LDB_CONTROL_PERMISSIVE_MODIFY_OID, decode_flag_request, encode_flag_request },
1249 : { LDB_CONTROL_SERVER_LAZY_COMMIT, decode_flag_request, encode_flag_request },
1250 : { LDB_CONTROL_RODC_DCPROMO_OID, decode_flag_request, encode_flag_request },
1251 : { LDB_CONTROL_RELAX_OID, decode_flag_request, encode_flag_request },
1252 : { DSDB_OPENLDAP_DEREFERENCE_CONTROL, decode_openldap_dereference, encode_openldap_dereference },
1253 : { LDB_CONTROL_VERIFY_NAME_OID, decode_verify_name_request, encode_verify_name_request },
1254 :
1255 : /* the following are internal only, with a network
1256 : representation */
1257 : { DSDB_CONTROL_BYPASS_PASSWORD_HASH_OID, decode_flag_request, encode_flag_request },
1258 :
1259 : /* all the ones below are internal only, and have no network
1260 : * representation */
1261 : { DSDB_CONTROL_CURRENT_PARTITION_OID, NULL, NULL },
1262 : { DSDB_CONTROL_REPLICATED_UPDATE_OID, NULL, NULL },
1263 : { DSDB_CONTROL_DN_STORAGE_FORMAT_OID, NULL, NULL },
1264 : { LDB_CONTROL_RECALCULATE_SD_OID, NULL, NULL },
1265 : { LDB_CONTROL_REVEAL_INTERNALS, NULL, NULL },
1266 : { LDB_CONTROL_AS_SYSTEM_OID, NULL, NULL },
1267 : { DSDB_CONTROL_PASSWORD_CHANGE_STATUS_OID, NULL, NULL },
1268 : { DSDB_CONTROL_PASSWORD_HASH_VALUES_OID, NULL, NULL },
1269 : { DSDB_CONTROL_PASSWORD_CHANGE_OLD_PW_CHECKED_OID, NULL, NULL },
1270 : { DSDB_CONTROL_PASSWORD_ACL_VALIDATION_OID, NULL, NULL },
1271 : { DSDB_CONTROL_APPLY_LINKS, NULL, NULL },
1272 : { LDB_CONTROL_BYPASS_OPERATIONAL_OID, NULL, NULL },
1273 : { DSDB_CONTROL_CHANGEREPLMETADATA_OID, NULL, NULL },
1274 : { LDB_CONTROL_PROVISION_OID, NULL, NULL },
1275 : { DSDB_EXTENDED_REPLICATED_OBJECTS_OID, NULL, NULL },
1276 : { DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID, NULL, NULL },
1277 : { DSDB_EXTENDED_ALLOCATE_RID_POOL, NULL, NULL },
1278 : { DSDB_CONTROL_NO_GLOBAL_CATALOG, NULL, NULL },
1279 : { DSDB_EXTENDED_SCHEMA_UPGRADE_IN_PROGRESS_OID, NULL, NULL },
1280 : { DSDB_CONTROL_TRANSACTION_IDENTIFIER_OID, NULL, NULL},
1281 : { DSDB_CONTROL_CALCULATED_DEFAULT_SD_OID, NULL, NULL },
1282 : { NULL, NULL, NULL }
1283 : };
1284 :
1285 4063751 : const struct ldap_control_handler *samba_ldap_control_handlers(void)
1286 : {
1287 4063751 : return ldap_known_controls;
1288 : }
|
