2 Unix SMB/CIFS implementation.
3 simple kerberos5/SPNEGO routines
4 Copyright (C) Andrew Tridgell 2001
5 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002
6 Copyright (C) Andrew Bartlett 2002-2003
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "libcli/auth/msrpc_parse.h"
26 this is a tiny msrpc packet generator. I am only using this to
27 avoid tying this code to a particular varient of our rpc code. This
28 generator is not general enough for all our rpc needs, its just
29 enough for the spnego/ntlmssp code
31 format specifiers are:
33 U = unicode string (input is unix string)
34 a = address (input is char *unix_string)
35 (1 byte type, 1 byte length, unicode/ASCII string, all inline)
36 A = ASCII string (input is unix string)
37 B = data blob (pointer + length)
38 b = data blob in header (pointer + length)
41 C = constant ascii string
43 bool msrpc_gen(TALLOC_CTX
*mem_ctx
,
45 const char *format
, ...)
52 int head_size
=0, data_size
=0;
53 int head_ofs
, data_ofs
;
59 pointers
= talloc_array(mem_ctx
, DATA_BLOB
, strlen(format
));
60 intargs
= talloc_array(pointers
, int, strlen(format
));
62 /* first scan the format to work out the header and body size */
64 for (i
=0; format
[i
]; i
++) {
67 s
= va_arg(ap
, char *);
69 ret
= push_ucs2_talloc(
71 (smb_ucs2_t
**)(void *)&pointers
[i
].data
,
76 pointers
[i
].length
= n
;
77 pointers
[i
].length
-= 2;
78 data_size
+= pointers
[i
].length
;
81 s
= va_arg(ap
, char *);
83 ret
= push_ascii_talloc(
84 pointers
, (char **)(void *)&pointers
[i
].data
,
89 pointers
[i
].length
= n
;
90 pointers
[i
].length
-= 1;
91 data_size
+= pointers
[i
].length
;
96 s
= va_arg(ap
, char *);
97 ret
= push_ucs2_talloc(
99 (smb_ucs2_t
**)(void *)&pointers
[i
].data
,
104 pointers
[i
].length
= n
;
105 pointers
[i
].length
-= 2;
106 data_size
+= pointers
[i
].length
+ 4;
109 b
= va_arg(ap
, uint8_t *);
111 pointers
[i
].data
= b
;
112 pointers
[i
].length
= va_arg(ap
, int);
113 data_size
+= pointers
[i
].length
;
116 b
= va_arg(ap
, uint8_t *);
117 pointers
[i
].data
= b
;
118 pointers
[i
].length
= va_arg(ap
, int);
119 head_size
+= pointers
[i
].length
;
127 s
= va_arg(ap
, char *);
128 pointers
[i
].data
= (uint8_t *)s
;
129 pointers
[i
].length
= strlen(s
)+1;
130 head_size
+= pointers
[i
].length
;
136 /* allocate the space, then scan the format again to fill in the values */
137 *blob
= data_blob_talloc(mem_ctx
, NULL
, head_size
+ data_size
);
140 data_ofs
= head_size
;
142 va_start(ap
, format
);
143 for (i
=0; format
[i
]; i
++) {
148 n
= pointers
[i
].length
;
149 SSVAL(blob
->data
, head_ofs
, n
); head_ofs
+= 2;
150 SSVAL(blob
->data
, head_ofs
, n
); head_ofs
+= 2;
151 SIVAL(blob
->data
, head_ofs
, data_ofs
); head_ofs
+= 4;
152 if (pointers
[i
].data
&& n
) /* don't follow null pointers... */
153 memcpy(blob
->data
+data_ofs
, pointers
[i
].data
, n
);
158 SSVAL(blob
->data
, data_ofs
, j
); data_ofs
+= 2;
160 n
= pointers
[i
].length
;
161 SSVAL(blob
->data
, data_ofs
, n
); data_ofs
+= 2;
163 memcpy(blob
->data
+data_ofs
, pointers
[i
].data
, n
);
169 SIVAL(blob
->data
, head_ofs
, j
);
173 n
= pointers
[i
].length
;
174 memcpy(blob
->data
+ head_ofs
, pointers
[i
].data
, n
);
178 n
= pointers
[i
].length
;
179 memcpy(blob
->data
+ head_ofs
, pointers
[i
].data
, n
);
186 talloc_free(pointers
);
192 /* a helpful macro to avoid running over the end of our blob */
193 #define NEED_DATA(amount) \
194 if ((head_ofs + amount) > blob->length) { \
199 this is a tiny msrpc packet parser. This the the partner of msrpc_gen
201 format specifiers are:
203 U = unicode string (output is unix string)
206 b = data blob in header
208 C = constant ascii string
211 bool msrpc_parse(TALLOC_CTX
*mem_ctx
,
212 const DATA_BLOB
*blob
,
213 const char *format
, ...)
224 char *p
= talloc_array(mem_ctx
, char, p_len
);
227 va_start(ap
, format
);
228 for (i
=0; format
[i
]; i
++) {
232 len1
= SVAL(blob
->data
, head_ofs
); head_ofs
+= 2;
233 len2
= SVAL(blob
->data
, head_ofs
); head_ofs
+= 2;
234 ptr
= IVAL(blob
->data
, head_ofs
); head_ofs
+= 4;
236 ps
= va_arg(ap
, char **);
237 if (len1
== 0 && len2
== 0) {
238 *ps
= (char *)discard_const("");
240 /* make sure its in the right format - be strict */
241 if ((len1
!= len2
) || (ptr
+ len1
< ptr
) || (ptr
+ len1
< len1
) || (ptr
+ len1
> blob
->length
)) {
246 /* if odd length and unicode */
250 if (blob
->data
+ ptr
< (uint8_t *)(uintptr_t)ptr
||
251 blob
->data
+ ptr
< blob
->data
) {
258 if (!convert_string_talloc(mem_ctx
, CH_UTF16
, CH_UNIX
,
259 blob
->data
+ ptr
, len1
,
260 ps
, &pull_len
, false)) {
265 (*ps
) = (char *)discard_const("");
271 len1
= SVAL(blob
->data
, head_ofs
); head_ofs
+= 2;
272 len2
= SVAL(blob
->data
, head_ofs
); head_ofs
+= 2;
273 ptr
= IVAL(blob
->data
, head_ofs
); head_ofs
+= 4;
275 ps
= (char **)va_arg(ap
, char **);
276 /* make sure its in the right format - be strict */
277 if (len1
== 0 && len2
== 0) {
278 *ps
= (char *)discard_const("");
280 if ((len1
!= len2
) || (ptr
+ len1
< ptr
) || (ptr
+ len1
< len1
) || (ptr
+ len1
> blob
->length
)) {
285 if (blob
->data
+ ptr
< (uint8_t *)(uintptr_t)ptr
||
286 blob
->data
+ ptr
< blob
->data
) {
294 if (!convert_string_talloc(mem_ctx
, CH_DOS
, CH_UNIX
,
295 blob
->data
+ ptr
, len1
,
296 ps
, &pull_len
, false)) {
301 (*ps
) = (char *)discard_const("");
307 len1
= SVAL(blob
->data
, head_ofs
); head_ofs
+= 2;
308 len2
= SVAL(blob
->data
, head_ofs
); head_ofs
+= 2;
309 ptr
= IVAL(blob
->data
, head_ofs
); head_ofs
+= 4;
311 b
= (DATA_BLOB
*)va_arg(ap
, void *);
312 if (len1
== 0 && len2
== 0) {
313 *b
= data_blob_talloc(mem_ctx
, NULL
, 0);
315 /* make sure its in the right format - be strict */
316 if ((len1
!= len2
) || (ptr
+ len1
< ptr
) || (ptr
+ len1
< len1
) || (ptr
+ len1
> blob
->length
)) {
321 if (blob
->data
+ ptr
< (uint8_t *)(uintptr_t)ptr
||
322 blob
->data
+ ptr
< blob
->data
) {
327 *b
= data_blob_talloc(mem_ctx
, blob
->data
+ ptr
, len1
);
331 b
= (DATA_BLOB
*)va_arg(ap
, void *);
332 len1
= va_arg(ap
, uint_t
);
333 /* make sure its in the right format - be strict */
335 if (blob
->data
+ head_ofs
< (uint8_t *)head_ofs
||
336 blob
->data
+ head_ofs
< blob
->data
) {
341 *b
= data_blob_talloc(mem_ctx
, blob
->data
+ head_ofs
, len1
);
345 v
= va_arg(ap
, uint32_t *);
347 *v
= IVAL(blob
->data
, head_ofs
); head_ofs
+= 4;
350 s
= va_arg(ap
, char *);
352 if (blob
->data
+ head_ofs
< (uint8_t *)head_ofs
||
353 blob
->data
+ head_ofs
< blob
->data
||
354 (head_ofs
+ (strlen(s
) + 1)) > blob
->length
) {
359 if (memcmp(blob
->data
+ head_ofs
, s
, strlen(s
)+1) != 0) {
363 head_ofs
+= (strlen(s
) + 1);