mount.cifs: make local versions of strlcat and strlcpy static
[Samba/gebeck_regimport.git] / source3 / rpc_parse / parse_prs.c
blob5eb6c31ee6d0db6c89462e3edc289b1e89178c0d
1 /*
2 Unix SMB/CIFS implementation.
3 Samba memory buffer functions
4 Copyright (C) Andrew Tridgell 1992-1997
5 Copyright (C) Luke Kenneth Casson Leighton 1996-1997
6 Copyright (C) Jeremy Allison 1999
7 Copyright (C) Andrew Bartlett 2003.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "includes.h"
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_RPC_PARSE
28 /**
29 * Dump a prs to a file: from the current location through to the end.
30 **/
31 void prs_dump(const char *name, int v, prs_struct *ps)
33 prs_dump_region(name, v, ps, ps->data_offset, ps->buffer_size);
36 /**
37 * Dump from the start of the prs to the current location.
38 **/
39 void prs_dump_before(const char *name, int v, prs_struct *ps)
41 prs_dump_region(name, v, ps, 0, ps->data_offset);
44 /**
45 * Dump everything from the start of the prs up to the current location.
46 **/
47 void prs_dump_region(const char *name, int v, prs_struct *ps,
48 int from_off, int to_off)
50 int fd, i;
51 char *fname = NULL;
52 ssize_t sz;
53 if (DEBUGLEVEL < 50) return;
54 for (i=1;i<100;i++) {
55 if (v != -1) {
56 if (asprintf(&fname,"/tmp/%s_%d.%d.prs", name, v, i) < 0) {
57 return;
59 } else {
60 if (asprintf(&fname,"/tmp/%s.%d.prs", name, i) < 0) {
61 return;
64 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
65 if (fd != -1 || errno != EEXIST) break;
67 if (fd != -1) {
68 sz = write(fd, ps->data_p + from_off, to_off - from_off);
69 i = close(fd);
70 if ( (sz != to_off-from_off) || (i != 0) ) {
71 DEBUG(0,("Error writing/closing %s: %ld!=%ld %d\n", fname, (unsigned long)sz, (unsigned long)to_off-from_off, i ));
72 } else {
73 DEBUG(0,("created %s\n", fname));
76 SAFE_FREE(fname);
79 /*******************************************************************
80 Debug output for parsing info
82 XXXX side-effect of this function is to increase the debug depth XXXX.
84 ********************************************************************/
86 void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
88 DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(5+depth,depth), ps->data_offset, fn_name, desc));
91 /**
92 * Initialise an expandable parse structure.
94 * @param size Initial buffer size. If >0, a new buffer will be
95 * created with malloc().
97 * @return False if allocation fails, otherwise True.
98 **/
100 bool prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, bool io)
102 ZERO_STRUCTP(ps);
103 ps->io = io;
104 ps->bigendian_data = RPC_LITTLE_ENDIAN;
105 ps->align = RPC_PARSE_ALIGN;
106 ps->is_dynamic = False;
107 ps->data_offset = 0;
108 ps->buffer_size = 0;
109 ps->data_p = NULL;
110 ps->mem_ctx = ctx;
112 if (size != 0) {
113 ps->buffer_size = size;
114 if((ps->data_p = (char *)SMB_MALLOC((size_t)size)) == NULL) {
115 DEBUG(0,("prs_init: malloc fail for %u bytes.\n", (unsigned int)size));
116 return False;
118 memset(ps->data_p, '\0', (size_t)size);
119 ps->is_dynamic = True; /* We own this memory. */
120 } else if (MARSHALLING(ps)) {
121 /* If size is zero and we're marshalling we should allocate memory on demand. */
122 ps->is_dynamic = True;
125 return True;
128 /*******************************************************************
129 Delete the memory in a parse structure - if we own it.
131 NOTE: Contrary to the somewhat confusing naming, this function is not
132 intended for freeing memory allocated by prs_alloc_mem(). That memory
133 is attached to the talloc context given by ps->mem_ctx.
134 ********************************************************************/
136 void prs_mem_free(prs_struct *ps)
138 if(ps->is_dynamic)
139 SAFE_FREE(ps->data_p);
140 ps->is_dynamic = False;
141 ps->buffer_size = 0;
142 ps->data_offset = 0;
145 /*******************************************************************
146 Clear the memory in a parse structure.
147 ********************************************************************/
149 void prs_mem_clear(prs_struct *ps)
151 if (ps->buffer_size)
152 memset(ps->data_p, '\0', (size_t)ps->buffer_size);
155 /*******************************************************************
156 Allocate memory when unmarshalling... Always zero clears.
157 ********************************************************************/
159 #if defined(PARANOID_MALLOC_CHECKER)
160 char *prs_alloc_mem_(prs_struct *ps, size_t size, unsigned int count)
161 #else
162 char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
163 #endif
165 char *ret = NULL;
167 if (size && count) {
168 /* We can't call the type-safe version here. */
169 ret = (char *)_talloc_zero_array(ps->mem_ctx, size, count,
170 "parse_prs");
172 return ret;
175 /*******************************************************************
176 Return the current talloc context we're using.
177 ********************************************************************/
179 TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
181 return ps->mem_ctx;
184 /*******************************************************************
185 Hand some already allocated memory to a prs_struct.
186 ********************************************************************/
188 void prs_give_memory(prs_struct *ps, char *buf, uint32 size, bool is_dynamic)
190 ps->is_dynamic = is_dynamic;
191 ps->data_p = buf;
192 ps->buffer_size = size;
195 /*******************************************************************
196 Take some memory back from a prs_struct.
197 ********************************************************************/
199 char *prs_take_memory(prs_struct *ps, uint32 *psize)
201 char *ret = ps->data_p;
202 if(psize)
203 *psize = ps->buffer_size;
204 ps->is_dynamic = False;
205 prs_mem_free(ps);
206 return ret;
209 /*******************************************************************
210 Set a prs_struct to exactly a given size. Will grow or tuncate if neccessary.
211 ********************************************************************/
213 bool prs_set_buffer_size(prs_struct *ps, uint32 newsize)
215 if (newsize > ps->buffer_size)
216 return prs_force_grow(ps, newsize - ps->buffer_size);
218 if (newsize < ps->buffer_size) {
219 ps->buffer_size = newsize;
221 /* newsize == 0 acts as a free and set pointer to NULL */
222 if (newsize == 0) {
223 SAFE_FREE(ps->data_p);
224 } else {
225 ps->data_p = (char *)SMB_REALLOC(ps->data_p, newsize);
227 if (ps->data_p == NULL) {
228 DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
229 (unsigned int)newsize));
230 DEBUG(0,("prs_set_buffer_size: Reason %s\n",strerror(errno)));
231 return False;
236 return True;
239 /*******************************************************************
240 Attempt, if needed, to grow a data buffer.
241 Also depends on the data stream mode (io).
242 ********************************************************************/
244 bool prs_grow(prs_struct *ps, uint32 extra_space)
246 uint32 new_size;
248 ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
250 if(ps->data_offset + extra_space <= ps->buffer_size)
251 return True;
254 * We cannot grow the buffer if we're not reading
255 * into the prs_struct, or if we don't own the memory.
258 if(UNMARSHALLING(ps) || !ps->is_dynamic) {
259 DEBUG(0,("prs_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
260 (unsigned int)extra_space));
261 return False;
265 * Decide how much extra space we really need.
268 extra_space -= (ps->buffer_size - ps->data_offset);
269 if(ps->buffer_size == 0) {
271 * Ensure we have at least a PDU's length, or extra_space, whichever
272 * is greater.
275 new_size = MAX(RPC_MAX_PDU_FRAG_LEN,extra_space);
277 if((ps->data_p = (char *)SMB_MALLOC(new_size)) == NULL) {
278 DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
279 return False;
281 memset(ps->data_p, '\0', (size_t)new_size );
282 } else {
284 * If the current buffer size is bigger than the space needed, just
285 * double it, else add extra_space.
287 new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);
289 if ((ps->data_p = (char *)SMB_REALLOC(ps->data_p, new_size)) == NULL) {
290 DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
291 (unsigned int)new_size));
292 return False;
295 memset(&ps->data_p[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
297 ps->buffer_size = new_size;
299 return True;
302 /*******************************************************************
303 Attempt to force a data buffer to grow by len bytes.
304 This is only used when appending more data onto a prs_struct
305 when reading an rpc reply, before unmarshalling it.
306 ********************************************************************/
308 bool prs_force_grow(prs_struct *ps, uint32 extra_space)
310 uint32 new_size = ps->buffer_size + extra_space;
312 if(!UNMARSHALLING(ps) || !ps->is_dynamic) {
313 DEBUG(0,("prs_force_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
314 (unsigned int)extra_space));
315 return False;
318 if((ps->data_p = (char *)SMB_REALLOC(ps->data_p, new_size)) == NULL) {
319 DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
320 (unsigned int)new_size));
321 return False;
324 memset(&ps->data_p[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
326 ps->buffer_size = new_size;
328 return True;
331 /*******************************************************************
332 Get the data pointer (external interface).
333 ********************************************************************/
335 char *prs_data_p(prs_struct *ps)
337 return ps->data_p;
340 /*******************************************************************
341 Get the current data size (external interface).
342 ********************************************************************/
344 uint32 prs_data_size(prs_struct *ps)
346 return ps->buffer_size;
349 /*******************************************************************
350 Fetch the current offset (external interface).
351 ********************************************************************/
353 uint32 prs_offset(prs_struct *ps)
355 return ps->data_offset;
358 /*******************************************************************
359 Set the current offset (external interface).
360 ********************************************************************/
362 bool prs_set_offset(prs_struct *ps, uint32 offset)
364 if(offset <= ps->data_offset) {
365 ps->data_offset = offset;
366 return True;
369 if(!prs_grow(ps, offset - ps->data_offset))
370 return False;
372 ps->data_offset = offset;
373 return True;
376 /*******************************************************************
377 Append the data from one parse_struct into another.
378 ********************************************************************/
380 bool prs_append_prs_data(prs_struct *dst, prs_struct *src)
382 if (prs_offset(src) == 0)
383 return True;
385 if(!prs_grow(dst, prs_offset(src)))
386 return False;
388 memcpy(&dst->data_p[dst->data_offset], src->data_p, (size_t)prs_offset(src));
389 dst->data_offset += prs_offset(src);
391 return True;
394 /*******************************************************************
395 Append some data from one parse_struct into another.
396 ********************************************************************/
398 bool prs_append_some_data(prs_struct *dst, void *src_base, uint32_t start,
399 uint32_t len)
401 if (len == 0) {
402 return true;
405 if(!prs_grow(dst, len)) {
406 return false;
409 memcpy(&dst->data_p[dst->data_offset], ((char *)src_base) + start, (size_t)len);
410 dst->data_offset += len;
411 return true;
414 bool prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start,
415 uint32 len)
417 return prs_append_some_data(dst, src->data_p, start, len);
420 /*******************************************************************
421 Append the data from a buffer into a parse_struct.
422 ********************************************************************/
424 bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
426 if (len == 0)
427 return True;
429 if(!prs_grow(dst, len))
430 return False;
432 memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
433 dst->data_offset += len;
435 return True;
438 /*******************************************************************
439 Copy some data from a parse_struct into a buffer.
440 ********************************************************************/
442 bool prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
444 if (len == 0)
445 return True;
447 if(!prs_mem_get(src, len))
448 return False;
450 memcpy(dst, &src->data_p[src->data_offset], (size_t)len);
451 src->data_offset += len;
453 return True;
456 /*******************************************************************
457 Copy all the data from a parse_struct into a buffer.
458 ********************************************************************/
460 bool prs_copy_all_data_out(char *dst, prs_struct *src)
462 uint32 len = prs_offset(src);
464 if (!len)
465 return True;
467 prs_set_offset(src, 0);
468 return prs_copy_data_out(dst, src, len);
471 /*******************************************************************
472 Set the data as X-endian (external interface).
473 ********************************************************************/
475 void prs_set_endian_data(prs_struct *ps, bool endian)
477 ps->bigendian_data = endian;
480 /*******************************************************************
481 Align a the data_len to a multiple of align bytes - filling with
482 zeros.
483 ********************************************************************/
485 bool prs_align(prs_struct *ps)
487 uint32 mod = ps->data_offset & (ps->align-1);
489 if (ps->align != 0 && mod != 0) {
490 uint32 extra_space = (ps->align - mod);
491 if(!prs_grow(ps, extra_space))
492 return False;
493 memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
494 ps->data_offset += extra_space;
497 return True;
500 /******************************************************************
501 Align on a 2 byte boundary
502 *****************************************************************/
504 bool prs_align_uint16(prs_struct *ps)
506 bool ret;
507 uint8 old_align = ps->align;
509 ps->align = 2;
510 ret = prs_align(ps);
511 ps->align = old_align;
513 return ret;
516 /******************************************************************
517 Align on a 8 byte boundary
518 *****************************************************************/
520 bool prs_align_uint64(prs_struct *ps)
522 bool ret;
523 uint8 old_align = ps->align;
525 ps->align = 8;
526 ret = prs_align(ps);
527 ps->align = old_align;
529 return ret;
532 /******************************************************************
533 Align on a specific byte boundary
534 *****************************************************************/
536 bool prs_align_custom(prs_struct *ps, uint8 boundary)
538 bool ret;
539 uint8 old_align = ps->align;
541 ps->align = boundary;
542 ret = prs_align(ps);
543 ps->align = old_align;
545 return ret;
550 /*******************************************************************
551 Align only if required (for the unistr2 string mainly)
552 ********************************************************************/
554 bool prs_align_needed(prs_struct *ps, uint32 needed)
556 if (needed==0)
557 return True;
558 else
559 return prs_align(ps);
562 /*******************************************************************
563 Ensure we can read/write to a given offset.
564 ********************************************************************/
566 char *prs_mem_get(prs_struct *ps, uint32 extra_size)
568 if(UNMARSHALLING(ps)) {
570 * If reading, ensure that we can read the requested size item.
572 if (ps->data_offset + extra_size > ps->buffer_size) {
573 DEBUG(0,("prs_mem_get: reading data of size %u would overrun "
574 "buffer by %u bytes.\n",
575 (unsigned int)extra_size,
576 (unsigned int)(ps->data_offset + extra_size - ps->buffer_size) ));
577 return NULL;
579 } else {
581 * Writing - grow the buffer if needed.
583 if(!prs_grow(ps, extra_size))
584 return NULL;
586 return &ps->data_p[ps->data_offset];
589 /*******************************************************************
590 Change the struct type.
591 ********************************************************************/
593 void prs_switch_type(prs_struct *ps, bool io)
595 if ((ps->io ^ io) == True)
596 ps->io=io;
599 /*******************************************************************
600 Force a prs_struct to be dynamic even when it's size is 0.
601 ********************************************************************/
603 void prs_force_dynamic(prs_struct *ps)
605 ps->is_dynamic=True;
608 /*******************************************************************
609 Associate a session key with a parse struct.
610 ********************************************************************/
612 void prs_set_session_key(prs_struct *ps, const char sess_key[16])
614 ps->sess_key = sess_key;
617 /*******************************************************************
618 Stream a uint8.
619 ********************************************************************/
621 bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
623 char *q = prs_mem_get(ps, 1);
624 if (q == NULL)
625 return False;
627 if (UNMARSHALLING(ps))
628 *data8 = CVAL(q,0);
629 else
630 SCVAL(q,0,*data8);
632 DEBUG(5,("%s%04x %s: %02x\n", tab_depth(5,depth), ps->data_offset, name, *data8));
634 ps->data_offset += 1;
636 return True;
639 /*******************************************************************
640 Stream a uint16* (allocate memory if unmarshalling)
641 ********************************************************************/
643 bool prs_pointer( const char *name, prs_struct *ps, int depth,
644 void *dta, size_t data_size,
645 bool (*prs_fn)(const char*, prs_struct*, int, void*) )
647 void ** data = (void **)dta;
648 uint32 data_p;
650 /* output f000baaa to stream if the pointer is non-zero. */
652 data_p = *data ? 0xf000baaa : 0;
654 if ( !prs_uint32("ptr", ps, depth, &data_p ))
655 return False;
657 /* we're done if there is no data */
659 if ( !data_p )
660 return True;
662 if (UNMARSHALLING(ps)) {
663 if (data_size) {
664 if ( !(*data = PRS_ALLOC_MEM(ps, char, data_size)) )
665 return False;
666 } else {
667 *data = NULL;
671 return prs_fn(name, ps, depth, *data);
675 /*******************************************************************
676 Stream a uint16.
677 ********************************************************************/
679 bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
681 char *q = prs_mem_get(ps, sizeof(uint16));
682 if (q == NULL)
683 return False;
685 if (UNMARSHALLING(ps)) {
686 if (ps->bigendian_data)
687 *data16 = RSVAL(q,0);
688 else
689 *data16 = SVAL(q,0);
690 } else {
691 if (ps->bigendian_data)
692 RSSVAL(q,0,*data16);
693 else
694 SSVAL(q,0,*data16);
697 DEBUG(5,("%s%04x %s: %04x\n", tab_depth(5,depth), ps->data_offset, name, *data16));
699 ps->data_offset += sizeof(uint16);
701 return True;
704 /*******************************************************************
705 Stream a uint32.
706 ********************************************************************/
708 bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
710 char *q = prs_mem_get(ps, sizeof(uint32));
711 if (q == NULL)
712 return False;
714 if (UNMARSHALLING(ps)) {
715 if (ps->bigendian_data)
716 *data32 = RIVAL(q,0);
717 else
718 *data32 = IVAL(q,0);
719 } else {
720 if (ps->bigendian_data)
721 RSIVAL(q,0,*data32);
722 else
723 SIVAL(q,0,*data32);
726 DEBUG(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
728 ps->data_offset += sizeof(uint32);
730 return True;
733 /*******************************************************************
734 Stream an int32.
735 ********************************************************************/
737 bool prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
739 char *q = prs_mem_get(ps, sizeof(int32));
740 if (q == NULL)
741 return False;
743 if (UNMARSHALLING(ps)) {
744 if (ps->bigendian_data)
745 *data32 = RIVALS(q,0);
746 else
747 *data32 = IVALS(q,0);
748 } else {
749 if (ps->bigendian_data)
750 RSIVALS(q,0,*data32);
751 else
752 SIVALS(q,0,*data32);
755 DEBUG(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
757 ps->data_offset += sizeof(int32);
759 return True;
762 /*******************************************************************
763 Stream a NTSTATUS
764 ********************************************************************/
766 bool prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
768 char *q = prs_mem_get(ps, sizeof(uint32));
769 if (q == NULL)
770 return False;
772 if (UNMARSHALLING(ps)) {
773 if (ps->bigendian_data)
774 *status = NT_STATUS(RIVAL(q,0));
775 else
776 *status = NT_STATUS(IVAL(q,0));
777 } else {
778 if (ps->bigendian_data)
779 RSIVAL(q,0,NT_STATUS_V(*status));
780 else
781 SIVAL(q,0,NT_STATUS_V(*status));
784 DEBUG(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name,
785 nt_errstr(*status)));
787 ps->data_offset += sizeof(uint32);
789 return True;
792 /*******************************************************************
793 Stream a DCE error code
794 ********************************************************************/
796 bool prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
798 char *q = prs_mem_get(ps, sizeof(uint32));
799 if (q == NULL)
800 return False;
802 if (UNMARSHALLING(ps)) {
803 if (ps->bigendian_data)
804 *status = NT_STATUS(RIVAL(q,0));
805 else
806 *status = NT_STATUS(IVAL(q,0));
807 } else {
808 if (ps->bigendian_data)
809 RSIVAL(q,0,NT_STATUS_V(*status));
810 else
811 SIVAL(q,0,NT_STATUS_V(*status));
814 DEBUG(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name,
815 dcerpc_errstr(NT_STATUS_V(*status))));
817 ps->data_offset += sizeof(uint32);
819 return True;
823 /*******************************************************************
824 Stream a WERROR
825 ********************************************************************/
827 bool prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
829 char *q = prs_mem_get(ps, sizeof(uint32));
830 if (q == NULL)
831 return False;
833 if (UNMARSHALLING(ps)) {
834 if (ps->bigendian_data)
835 *status = W_ERROR(RIVAL(q,0));
836 else
837 *status = W_ERROR(IVAL(q,0));
838 } else {
839 if (ps->bigendian_data)
840 RSIVAL(q,0,W_ERROR_V(*status));
841 else
842 SIVAL(q,0,W_ERROR_V(*status));
845 DEBUG(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name,
846 dos_errstr(*status)));
848 ps->data_offset += sizeof(uint32);
850 return True;
854 /******************************************************************
855 Stream an array of uint8s. Length is number of uint8s.
856 ********************************************************************/
858 bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
860 int i;
861 char *q = prs_mem_get(ps, len);
862 if (q == NULL)
863 return False;
865 if (UNMARSHALLING(ps)) {
866 for (i = 0; i < len; i++)
867 data8s[i] = CVAL(q,i);
868 } else {
869 for (i = 0; i < len; i++)
870 SCVAL(q, i, data8s[i]);
873 DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset ,name));
874 if (charmode)
875 print_asc(5, (unsigned char*)data8s, len);
876 else {
877 for (i = 0; i < len; i++)
878 DEBUG(5,("%02x ", data8s[i]));
880 DEBUG(5,("\n"));
882 ps->data_offset += len;
884 return True;
887 /******************************************************************
888 Stream an array of uint16s. Length is number of uint16s.
889 ********************************************************************/
891 bool prs_uint16s(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
893 int i;
894 char *q = prs_mem_get(ps, len * sizeof(uint16));
895 if (q == NULL)
896 return False;
898 if (UNMARSHALLING(ps)) {
899 if (ps->bigendian_data) {
900 for (i = 0; i < len; i++)
901 data16s[i] = RSVAL(q, 2*i);
902 } else {
903 for (i = 0; i < len; i++)
904 data16s[i] = SVAL(q, 2*i);
906 } else {
907 if (ps->bigendian_data) {
908 for (i = 0; i < len; i++)
909 RSSVAL(q, 2*i, data16s[i]);
910 } else {
911 for (i = 0; i < len; i++)
912 SSVAL(q, 2*i, data16s[i]);
916 DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
917 if (charmode)
918 print_asc(5, (unsigned char*)data16s, 2*len);
919 else {
920 for (i = 0; i < len; i++)
921 DEBUG(5,("%04x ", data16s[i]));
923 DEBUG(5,("\n"));
925 ps->data_offset += (len * sizeof(uint16));
927 return True;
930 /******************************************************************
931 Start using a function for streaming unicode chars. If unmarshalling,
932 output must be little-endian, if marshalling, input must be little-endian.
933 ********************************************************************/
935 static void dbg_rw_punival(bool charmode, const char *name, int depth, prs_struct *ps,
936 char *in_buf, char *out_buf, int len)
938 int i;
940 if (UNMARSHALLING(ps)) {
941 if (ps->bigendian_data) {
942 for (i = 0; i < len; i++)
943 SSVAL(out_buf,2*i,RSVAL(in_buf, 2*i));
944 } else {
945 for (i = 0; i < len; i++)
946 SSVAL(out_buf, 2*i, SVAL(in_buf, 2*i));
948 } else {
949 if (ps->bigendian_data) {
950 for (i = 0; i < len; i++)
951 RSSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
952 } else {
953 for (i = 0; i < len; i++)
954 SSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
958 DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
959 if (charmode)
960 print_asc(5, (unsigned char*)out_buf, 2*len);
961 else {
962 for (i = 0; i < len; i++)
963 DEBUG(5,("%04x ", out_buf[i]));
965 DEBUG(5,("\n"));
968 /******************************************************************
969 Stream a unistr. Always little endian.
970 ********************************************************************/
972 bool prs_uint16uni(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
974 char *q = prs_mem_get(ps, len * sizeof(uint16));
975 if (q == NULL)
976 return False;
978 dbg_rw_punival(charmode, name, depth, ps, q, (char *)data16s, len);
979 ps->data_offset += (len * sizeof(uint16));
981 return True;
984 /******************************************************************
985 Stream an array of uint32s. Length is number of uint32s.
986 ********************************************************************/
988 bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
990 int i;
991 char *q = prs_mem_get(ps, len * sizeof(uint32));
992 if (q == NULL)
993 return False;
995 if (UNMARSHALLING(ps)) {
996 if (ps->bigendian_data) {
997 for (i = 0; i < len; i++)
998 data32s[i] = RIVAL(q, 4*i);
999 } else {
1000 for (i = 0; i < len; i++)
1001 data32s[i] = IVAL(q, 4*i);
1003 } else {
1004 if (ps->bigendian_data) {
1005 for (i = 0; i < len; i++)
1006 RSIVAL(q, 4*i, data32s[i]);
1007 } else {
1008 for (i = 0; i < len; i++)
1009 SIVAL(q, 4*i, data32s[i]);
1013 DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
1014 if (charmode)
1015 print_asc(5, (unsigned char*)data32s, 4*len);
1016 else {
1017 for (i = 0; i < len; i++)
1018 DEBUG(5,("%08x ", data32s[i]));
1020 DEBUG(5,("\n"));
1022 ps->data_offset += (len * sizeof(uint32));
1024 return True;
1027 /******************************************************************
1028 Stream an array of unicode string, length/buffer specified separately,
1029 in uint16 chars. The unicode string is already in little-endian format.
1030 ********************************************************************/
1032 bool prs_buffer5(bool charmode, const char *name, prs_struct *ps, int depth, BUFFER5 *str)
1034 char *p;
1035 char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
1036 if (q == NULL)
1037 return False;
1039 /* If the string is empty, we don't have anything to stream */
1040 if (str->buf_len==0)
1041 return True;
1043 if (UNMARSHALLING(ps)) {
1044 str->buffer = PRS_ALLOC_MEM(ps,uint16,str->buf_len);
1045 if (str->buffer == NULL)
1046 return False;
1049 p = (char *)str->buffer;
1051 dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len);
1053 ps->data_offset += (str->buf_len * sizeof(uint16));
1055 return True;
1058 /******************************************************************
1059 Stream a "not" unicode string, length/buffer specified separately,
1060 in byte chars. String is in little-endian format.
1061 ********************************************************************/
1063 bool prs_regval_buffer(bool charmode, const char *name, prs_struct *ps, int depth, REGVAL_BUFFER *buf)
1065 char *p;
1066 char *q = prs_mem_get(ps, buf->buf_len);
1067 if (q == NULL)
1068 return False;
1070 if (UNMARSHALLING(ps)) {
1071 if (buf->buf_len > buf->buf_max_len) {
1072 return False;
1074 if ( buf->buf_max_len ) {
1075 buf->buffer = PRS_ALLOC_MEM(ps, uint16, buf->buf_max_len);
1076 if ( buf->buffer == NULL )
1077 return False;
1078 } else {
1079 buf->buffer = NULL;
1083 p = (char *)buf->buffer;
1085 dbg_rw_punival(charmode, name, depth, ps, q, p, buf->buf_len/2);
1086 ps->data_offset += buf->buf_len;
1088 return True;
1091 /******************************************************************
1092 Stream a string, length/buffer specified separately,
1093 in uint8 chars.
1094 ********************************************************************/
1096 bool prs_string2(bool charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
1098 unsigned int i;
1099 char *q = prs_mem_get(ps, str->str_str_len);
1100 if (q == NULL)
1101 return False;
1103 if (UNMARSHALLING(ps)) {
1104 if (str->str_str_len > str->str_max_len) {
1105 return False;
1107 if (str->str_max_len) {
1108 str->buffer = PRS_ALLOC_MEM(ps,unsigned char, str->str_max_len);
1109 if (str->buffer == NULL)
1110 return False;
1111 } else {
1112 str->buffer = NULL;
1113 /* Return early to ensure Coverity isn't confused. */
1114 DEBUG(5,("%s%04x %s: \n", tab_depth(5,depth), ps->data_offset, name));
1115 return True;
1119 if (UNMARSHALLING(ps)) {
1120 for (i = 0; i < str->str_str_len; i++)
1121 str->buffer[i] = CVAL(q,i);
1122 } else {
1123 for (i = 0; i < str->str_str_len; i++)
1124 SCVAL(q, i, str->buffer[i]);
1127 DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
1128 if (charmode)
1129 print_asc(5, (unsigned char*)str->buffer, str->str_str_len);
1130 else {
1131 for (i = 0; i < str->str_str_len; i++)
1132 DEBUG(5,("%02x ", str->buffer[i]));
1134 DEBUG(5,("\n"));
1136 ps->data_offset += str->str_str_len;
1138 return True;
1141 /******************************************************************
1142 Stream a unicode string, length/buffer specified separately,
1143 in uint16 chars. The unicode string is already in little-endian format.
1144 ********************************************************************/
1146 bool prs_unistr2(bool charmode, const char *name, prs_struct *ps, int depth, UNISTR2 *str)
1148 char *p;
1149 char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
1150 if (q == NULL)
1151 return False;
1153 /* If the string is empty, we don't have anything to stream */
1154 if (str->uni_str_len==0)
1155 return True;
1157 if (UNMARSHALLING(ps)) {
1158 if (str->uni_str_len > str->uni_max_len) {
1159 return False;
1161 if (str->uni_max_len) {
1162 str->buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_max_len);
1163 if (str->buffer == NULL)
1164 return False;
1165 } else {
1166 str->buffer = NULL;
1170 p = (char *)str->buffer;
1172 dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
1174 ps->data_offset += (str->uni_str_len * sizeof(uint16));
1176 return True;
1179 /******************************************************************
1180 Stream a unicode string, length/buffer specified separately,
1181 in uint16 chars. The unicode string is already in little-endian format.
1182 ********************************************************************/
1184 bool prs_unistr3(bool charmode, const char *name, UNISTR3 *str, prs_struct *ps, int depth)
1186 char *p;
1187 char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
1188 if (q == NULL)
1189 return False;
1191 if (UNMARSHALLING(ps)) {
1192 if (str->uni_str_len) {
1193 str->str.buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_str_len);
1194 if (str->str.buffer == NULL)
1195 return False;
1196 } else {
1197 str->str.buffer = NULL;
1201 p = (char *)str->str.buffer;
1203 dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
1204 ps->data_offset += (str->uni_str_len * sizeof(uint16));
1206 return True;
1209 /*******************************************************************
1210 Stream a unicode null-terminated string. As the string is already
1211 in little-endian format then do it as a stream of bytes.
1212 ********************************************************************/
1214 bool prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
1216 unsigned int len = 0;
1217 unsigned char *p = (unsigned char *)str->buffer;
1218 uint8 *start;
1219 char *q;
1220 uint32 max_len;
1221 uint16* ptr;
1223 if (MARSHALLING(ps)) {
1225 for(len = 0; str->buffer[len] != 0; len++)
1228 q = prs_mem_get(ps, (len+1)*2);
1229 if (q == NULL)
1230 return False;
1232 start = (uint8*)q;
1234 for(len = 0; str->buffer[len] != 0; len++) {
1235 if(ps->bigendian_data) {
1236 /* swap bytes - p is little endian, q is big endian. */
1237 q[0] = (char)p[1];
1238 q[1] = (char)p[0];
1239 p += 2;
1240 q += 2;
1242 else
1244 q[0] = (char)p[0];
1245 q[1] = (char)p[1];
1246 p += 2;
1247 q += 2;
1252 * even if the string is 'empty' (only an \0 char)
1253 * at this point the leading \0 hasn't been parsed.
1254 * so parse it now
1257 q[0] = 0;
1258 q[1] = 0;
1259 q += 2;
1261 len++;
1263 DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
1264 print_asc(5, (unsigned char*)start, 2*len);
1265 DEBUG(5, ("\n"));
1267 else { /* unmarshalling */
1269 uint32 alloc_len = 0;
1270 q = ps->data_p + prs_offset(ps);
1273 * Work out how much space we need and talloc it.
1275 max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
1277 /* the test of the value of *ptr helps to catch the circumstance
1278 where we have an emtpty (non-existent) string in the buffer */
1279 for ( ptr = (uint16 *)q; *ptr++ && (alloc_len <= max_len); alloc_len++)
1280 /* do nothing */
1283 if (alloc_len < max_len)
1284 alloc_len += 1;
1286 /* should we allocate anything at all? */
1287 str->buffer = PRS_ALLOC_MEM(ps,uint16,alloc_len);
1288 if ((str->buffer == NULL) && (alloc_len > 0))
1289 return False;
1291 p = (unsigned char *)str->buffer;
1293 len = 0;
1294 /* the (len < alloc_len) test is to prevent us from overwriting
1295 memory that is not ours...if we get that far, we have a non-null
1296 terminated string in the buffer and have messed up somewhere */
1297 while ((len < alloc_len) && (*(uint16 *)q != 0)) {
1298 if(ps->bigendian_data)
1300 /* swap bytes - q is big endian, p is little endian. */
1301 p[0] = (unsigned char)q[1];
1302 p[1] = (unsigned char)q[0];
1303 p += 2;
1304 q += 2;
1305 } else {
1307 p[0] = (unsigned char)q[0];
1308 p[1] = (unsigned char)q[1];
1309 p += 2;
1310 q += 2;
1313 len++;
1315 if (len < alloc_len) {
1316 /* NULL terminate the UNISTR */
1317 str->buffer[len++] = '\0';
1320 DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
1321 print_asc(5, (unsigned char*)str->buffer, 2*len);
1322 DEBUG(5, ("\n"));
1325 /* set the offset in the prs_struct; 'len' points to the
1326 terminiating NULL in the UNISTR so we need to go one more
1327 uint16 */
1328 ps->data_offset += (len)*2;
1330 return True;
1334 /*******************************************************************
1335 Stream a null-terminated string. len is strlen, and therefore does
1336 not include the null-termination character.
1337 ********************************************************************/
1339 bool prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size)
1341 char *q;
1342 int i;
1343 int len;
1345 if (UNMARSHALLING(ps))
1346 len = strlen(&ps->data_p[ps->data_offset]);
1347 else
1348 len = strlen(str);
1350 len = MIN(len, (max_buf_size-1));
1352 q = prs_mem_get(ps, len+1);
1353 if (q == NULL)
1354 return False;
1356 for(i = 0; i < len; i++) {
1357 if (UNMARSHALLING(ps))
1358 str[i] = q[i];
1359 else
1360 q[i] = str[i];
1363 /* The terminating null. */
1364 str[i] = '\0';
1366 if (MARSHALLING(ps)) {
1367 q[i] = '\0';
1370 ps->data_offset += len+1;
1372 dump_data(5+depth, (uint8 *)q, len);
1374 return True;
1377 bool prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **str)
1379 size_t len;
1380 char *tmp_str;
1382 if (UNMARSHALLING(ps)) {
1383 len = strlen(&ps->data_p[ps->data_offset]);
1384 } else {
1385 len = strlen(*str);
1388 tmp_str = PRS_ALLOC_MEM(ps, char, len+1);
1390 if (tmp_str == NULL) {
1391 return False;
1394 if (MARSHALLING(ps)) {
1395 strncpy(tmp_str, *str, len);
1398 if (!prs_string(name, ps, depth, tmp_str, len+1)) {
1399 return False;
1402 *str = tmp_str;
1403 return True;
1406 /*******************************************************************
1407 prs_uint16 wrapper. Call this and it sets up a pointer to where the
1408 uint16 should be stored, or gets the size if reading.
1409 ********************************************************************/
1411 bool prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
1413 *offset = ps->data_offset;
1414 if (UNMARSHALLING(ps)) {
1415 /* reading. */
1416 return prs_uint16(name, ps, depth, data16);
1417 } else {
1418 char *q = prs_mem_get(ps, sizeof(uint16));
1419 if(q ==NULL)
1420 return False;
1421 ps->data_offset += sizeof(uint16);
1423 return True;
1426 /*******************************************************************
1427 prs_uint16 wrapper. call this and it retrospectively stores the size.
1428 does nothing on reading, as that is already handled by ...._pre()
1429 ********************************************************************/
1431 bool prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16,
1432 uint32 ptr_uint16, uint32 start_offset)
1434 if (MARSHALLING(ps)) {
1436 * Writing - temporarily move the offset pointer.
1438 uint16 data_size = ps->data_offset - start_offset;
1439 uint32 old_offset = ps->data_offset;
1441 ps->data_offset = ptr_uint16;
1442 if(!prs_uint16(name, ps, depth, &data_size)) {
1443 ps->data_offset = old_offset;
1444 return False;
1446 ps->data_offset = old_offset;
1447 } else {
1448 ps->data_offset = start_offset + (uint32)(*data16);
1450 return True;
1453 /*******************************************************************
1454 prs_uint32 wrapper. Call this and it sets up a pointer to where the
1455 uint32 should be stored, or gets the size if reading.
1456 ********************************************************************/
1458 bool prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
1460 *offset = ps->data_offset;
1461 if (UNMARSHALLING(ps) && (data32 != NULL)) {
1462 /* reading. */
1463 return prs_uint32(name, ps, depth, data32);
1464 } else {
1465 ps->data_offset += sizeof(uint32);
1467 return True;
1470 /*******************************************************************
1471 prs_uint32 wrapper. call this and it retrospectively stores the size.
1472 does nothing on reading, as that is already handled by ...._pre()
1473 ********************************************************************/
1475 bool prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32,
1476 uint32 ptr_uint32, uint32 data_size)
1478 if (MARSHALLING(ps)) {
1480 * Writing - temporarily move the offset pointer.
1482 uint32 old_offset = ps->data_offset;
1483 ps->data_offset = ptr_uint32;
1484 if(!prs_uint32(name, ps, depth, &data_size)) {
1485 ps->data_offset = old_offset;
1486 return False;
1488 ps->data_offset = old_offset;
1490 return True;
1493 /* useful function to store a structure in rpc wire format */
1494 int tdb_prs_store(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps)
1496 TDB_DATA dbuf;
1497 dbuf.dptr = (uint8 *)ps->data_p;
1498 dbuf.dsize = prs_offset(ps);
1499 return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
1502 /* useful function to fetch a structure into rpc wire format */
1503 int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *mem_ctx)
1505 TDB_DATA dbuf;
1507 prs_init_empty(ps, mem_ctx, UNMARSHALL);
1509 dbuf = tdb_fetch(tdb, kbuf);
1510 if (!dbuf.dptr)
1511 return -1;
1513 prs_give_memory(ps, (char *)dbuf.dptr, dbuf.dsize, True);
1515 return 0;
1518 /*******************************************************************
1519 hash a stream.
1520 ********************************************************************/
1522 bool prs_hash1(prs_struct *ps, uint32 offset, int len)
1524 char *q;
1526 q = ps->data_p;
1527 q = &q[offset];
1529 #ifdef DEBUG_PASSWORD
1530 DEBUG(100, ("prs_hash1\n"));
1531 dump_data(100, (uint8 *)ps->sess_key, 16);
1532 dump_data(100, (uint8 *)q, len);
1533 #endif
1534 SamOEMhash((uchar *) q, (const unsigned char *)ps->sess_key, len);
1536 #ifdef DEBUG_PASSWORD
1537 dump_data(100, (uint8 *)q, len);
1538 #endif
1540 return True;
1543 /*******************************************************************
1544 Create a digest over the entire packet (including the data), and
1545 MD5 it with the session key.
1546 ********************************************************************/
1548 static void schannel_digest(struct schannel_auth_struct *a,
1549 enum pipe_auth_level auth_level,
1550 RPC_AUTH_SCHANNEL_CHK * verf,
1551 char *data, size_t data_len,
1552 uchar digest_final[16])
1554 uchar whole_packet_digest[16];
1555 uchar zeros[4];
1556 struct MD5Context ctx3;
1558 ZERO_STRUCT(zeros);
1560 /* verfiy the signature on the packet by MD5 over various bits */
1561 MD5Init(&ctx3);
1562 /* use our sequence number, which ensures the packet is not
1563 out of order */
1564 MD5Update(&ctx3, zeros, sizeof(zeros));
1565 MD5Update(&ctx3, verf->sig, sizeof(verf->sig));
1566 if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
1567 MD5Update(&ctx3, verf->confounder, sizeof(verf->confounder));
1569 MD5Update(&ctx3, (const unsigned char *)data, data_len);
1570 MD5Final(whole_packet_digest, &ctx3);
1571 dump_data_pw("whole_packet_digest:\n", whole_packet_digest, sizeof(whole_packet_digest));
1573 /* MD5 this result and the session key, to prove that
1574 only a valid client could had produced this */
1575 hmac_md5(a->sess_key, whole_packet_digest, sizeof(whole_packet_digest), digest_final);
1578 /*******************************************************************
1579 Calculate the key with which to encode the data payload
1580 ********************************************************************/
1582 static void schannel_get_sealing_key(struct schannel_auth_struct *a,
1583 RPC_AUTH_SCHANNEL_CHK *verf,
1584 uchar sealing_key[16])
1586 uchar zeros[4];
1587 uchar digest2[16];
1588 uchar sess_kf0[16];
1589 int i;
1591 ZERO_STRUCT(zeros);
1593 for (i = 0; i < sizeof(sess_kf0); i++) {
1594 sess_kf0[i] = a->sess_key[i] ^ 0xf0;
1597 dump_data_pw("sess_kf0:\n", sess_kf0, sizeof(sess_kf0));
1599 /* MD5 of sess_kf0 and 4 zero bytes */
1600 hmac_md5(sess_kf0, zeros, 0x4, digest2);
1601 dump_data_pw("digest2:\n", digest2, sizeof(digest2));
1603 /* MD5 of the above result, plus 8 bytes of sequence number */
1604 hmac_md5(digest2, verf->seq_num, sizeof(verf->seq_num), sealing_key);
1605 dump_data_pw("sealing_key:\n", sealing_key, 16);
1608 /*******************************************************************
1609 Encode or Decode the sequence number (which is symmetric)
1610 ********************************************************************/
1612 static void schannel_deal_with_seq_num(struct schannel_auth_struct *a,
1613 RPC_AUTH_SCHANNEL_CHK *verf)
1615 uchar zeros[4];
1616 uchar sequence_key[16];
1617 uchar digest1[16];
1619 ZERO_STRUCT(zeros);
1621 hmac_md5(a->sess_key, zeros, sizeof(zeros), digest1);
1622 dump_data_pw("(sequence key) digest1:\n", digest1, sizeof(digest1));
1624 hmac_md5(digest1, verf->packet_digest, 8, sequence_key);
1626 dump_data_pw("sequence_key:\n", sequence_key, sizeof(sequence_key));
1628 dump_data_pw("seq_num (before):\n", verf->seq_num, sizeof(verf->seq_num));
1629 SamOEMhash(verf->seq_num, sequence_key, 8);
1630 dump_data_pw("seq_num (after):\n", verf->seq_num, sizeof(verf->seq_num));
1633 /*******************************************************************
1634 creates an RPC_AUTH_SCHANNEL_CHK structure.
1635 ********************************************************************/
1637 static bool init_rpc_auth_schannel_chk(RPC_AUTH_SCHANNEL_CHK * chk,
1638 const uchar sig[8],
1639 const uchar packet_digest[8],
1640 const uchar seq_num[8], const uchar confounder[8])
1642 if (chk == NULL)
1643 return False;
1645 memcpy(chk->sig, sig, sizeof(chk->sig));
1646 memcpy(chk->packet_digest, packet_digest, sizeof(chk->packet_digest));
1647 memcpy(chk->seq_num, seq_num, sizeof(chk->seq_num));
1648 memcpy(chk->confounder, confounder, sizeof(chk->confounder));
1650 return True;
1653 /*******************************************************************
1654 Encode a blob of data using the schannel alogrithm, also produceing
1655 a checksum over the original data. We currently only support
1656 signing and sealing togeather - the signing-only code is close, but not
1657 quite compatible with what MS does.
1658 ********************************************************************/
1660 void schannel_encode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
1661 enum schannel_direction direction,
1662 RPC_AUTH_SCHANNEL_CHK * verf,
1663 char *data, size_t data_len)
1665 uchar digest_final[16];
1666 uchar confounder[8];
1667 uchar seq_num[8];
1668 static const uchar nullbytes[8] = { 0, };
1670 static const uchar schannel_seal_sig[8] = SCHANNEL_SEAL_SIGNATURE;
1671 static const uchar schannel_sign_sig[8] = SCHANNEL_SIGN_SIGNATURE;
1672 const uchar *schannel_sig = NULL;
1674 DEBUG(10,("SCHANNEL: schannel_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
1676 if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
1677 schannel_sig = schannel_seal_sig;
1678 } else {
1679 schannel_sig = schannel_sign_sig;
1682 /* fill the 'confounder' with random data */
1683 generate_random_buffer(confounder, sizeof(confounder));
1685 dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
1687 RSIVAL(seq_num, 0, a->seq_num);
1689 switch (direction) {
1690 case SENDER_IS_INITIATOR:
1691 SIVAL(seq_num, 4, 0x80);
1692 break;
1693 case SENDER_IS_ACCEPTOR:
1694 SIVAL(seq_num, 4, 0x0);
1695 break;
1698 dump_data_pw("verf->seq_num:\n", seq_num, sizeof(verf->seq_num));
1700 init_rpc_auth_schannel_chk(verf, schannel_sig, nullbytes,
1701 seq_num, confounder);
1703 /* produce a digest of the packet to prove it's legit (before we seal it) */
1704 schannel_digest(a, auth_level, verf, data, data_len, digest_final);
1705 memcpy(verf->packet_digest, digest_final, sizeof(verf->packet_digest));
1707 if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
1708 uchar sealing_key[16];
1710 /* get the key to encode the data with */
1711 schannel_get_sealing_key(a, verf, sealing_key);
1713 /* encode the verification data */
1714 dump_data_pw("verf->confounder:\n", verf->confounder, sizeof(verf->confounder));
1715 SamOEMhash(verf->confounder, sealing_key, 8);
1717 dump_data_pw("verf->confounder_enc:\n", verf->confounder, sizeof(verf->confounder));
1719 /* encode the packet payload */
1720 dump_data_pw("data:\n", (const unsigned char *)data, data_len);
1721 SamOEMhash((unsigned char *)data, sealing_key, data_len);
1722 dump_data_pw("data_enc:\n", (const unsigned char *)data, data_len);
1725 /* encode the sequence number (key based on packet digest) */
1726 /* needs to be done after the sealing, as the original version
1727 is used in the sealing stuff... */
1728 schannel_deal_with_seq_num(a, verf);
1730 return;
1733 /*******************************************************************
1734 Decode a blob of data using the schannel alogrithm, also verifiying
1735 a checksum over the original data. We currently can verify signed messages,
1736 as well as decode sealed messages
1737 ********************************************************************/
1739 bool schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
1740 enum schannel_direction direction,
1741 RPC_AUTH_SCHANNEL_CHK * verf, char *data, size_t data_len)
1743 uchar digest_final[16];
1745 static const uchar schannel_seal_sig[8] = SCHANNEL_SEAL_SIGNATURE;
1746 static const uchar schannel_sign_sig[8] = SCHANNEL_SIGN_SIGNATURE;
1747 const uchar *schannel_sig = NULL;
1749 uchar seq_num[8];
1751 DEBUG(10,("SCHANNEL: schannel_decode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
1753 if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
1754 schannel_sig = schannel_seal_sig;
1755 } else {
1756 schannel_sig = schannel_sign_sig;
1759 /* Create the expected sequence number for comparison */
1760 RSIVAL(seq_num, 0, a->seq_num);
1762 switch (direction) {
1763 case SENDER_IS_INITIATOR:
1764 SIVAL(seq_num, 4, 0x80);
1765 break;
1766 case SENDER_IS_ACCEPTOR:
1767 SIVAL(seq_num, 4, 0x0);
1768 break;
1771 DEBUG(10,("SCHANNEL: schannel_decode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
1772 dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
1774 dump_data_pw("seq_num:\n", seq_num, sizeof(seq_num));
1776 /* extract the sequence number (key based on supplied packet digest) */
1777 /* needs to be done before the sealing, as the original version
1778 is used in the sealing stuff... */
1779 schannel_deal_with_seq_num(a, verf);
1781 if (memcmp(verf->seq_num, seq_num, sizeof(seq_num))) {
1782 /* don't even bother with the below if the sequence number is out */
1783 /* The sequence number is MD5'ed with a key based on the whole-packet
1784 digest, as supplied by the client. We check that it's a valid
1785 checksum after the decode, below
1787 DEBUG(2, ("schannel_decode: FAILED: packet sequence number:\n"));
1788 dump_data(2, verf->seq_num, sizeof(verf->seq_num));
1789 DEBUG(2, ("should be:\n"));
1790 dump_data(2, seq_num, sizeof(seq_num));
1792 return False;
1795 if (memcmp(verf->sig, schannel_sig, sizeof(verf->sig))) {
1796 /* Validate that the other end sent the expected header */
1797 DEBUG(2, ("schannel_decode: FAILED: packet header:\n"));
1798 dump_data(2, verf->sig, sizeof(verf->sig));
1799 DEBUG(2, ("should be:\n"));
1800 dump_data(2, schannel_sig, sizeof(schannel_sig));
1801 return False;
1804 if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
1805 uchar sealing_key[16];
1807 /* get the key to extract the data with */
1808 schannel_get_sealing_key(a, verf, sealing_key);
1810 /* extract the verification data */
1811 dump_data_pw("verf->confounder:\n", verf->confounder,
1812 sizeof(verf->confounder));
1813 SamOEMhash(verf->confounder, sealing_key, 8);
1815 dump_data_pw("verf->confounder_dec:\n", verf->confounder,
1816 sizeof(verf->confounder));
1818 /* extract the packet payload */
1819 dump_data_pw("data :\n", (const unsigned char *)data, data_len);
1820 SamOEMhash((unsigned char *)data, sealing_key, data_len);
1821 dump_data_pw("datadec:\n", (const unsigned char *)data, data_len);
1824 /* digest includes 'data' after unsealing */
1825 schannel_digest(a, auth_level, verf, data, data_len, digest_final);
1827 dump_data_pw("Calculated digest:\n", digest_final,
1828 sizeof(digest_final));
1829 dump_data_pw("verf->packet_digest:\n", verf->packet_digest,
1830 sizeof(verf->packet_digest));
1832 /* compare - if the client got the same result as us, then
1833 it must know the session key */
1834 return (memcmp(digest_final, verf->packet_digest,
1835 sizeof(verf->packet_digest)) == 0);
1838 /*******************************************************************
1839 creates a new prs_struct containing a DATA_BLOB
1840 ********************************************************************/
1841 bool prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
1843 if (!prs_init( prs, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL ))
1844 return False;
1847 if (!prs_copy_data_in(prs, (char *)blob->data, blob->length))
1848 return False;
1850 return True;
1853 /*******************************************************************
1854 return the contents of a prs_struct in a DATA_BLOB
1855 ********************************************************************/
1856 bool prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
1858 blob->length = prs_data_size(prs);
1859 blob->data = (uint8 *)TALLOC_ZERO_SIZE(mem_ctx, blob->length);
1861 /* set the pointer at the end of the buffer */
1862 prs_set_offset( prs, prs_data_size(prs) );
1864 if (!prs_copy_all_data_out((char *)blob->data, prs))
1865 return False;
1867 return True;