c554a02e90ee4d7cbf96ae04f31eacb27c8b0c97
[bbaumbach/samba-autobuild/.git] / source3 / libads / authdata.c
1 /* 
2    Unix SMB/CIFS implementation.
3    kerberos authorization data (PAC) utility library
4    Copyright (C) Jim McDonough 2003   
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22
23 #ifdef HAVE_KRB5
24
25 static DATA_BLOB unwrap_pac(DATA_BLOB *auth_data)
26 {
27         DATA_BLOB pac_contents;
28         ASN1_DATA data;
29         int data_type;
30
31         asn1_load(&data, *auth_data);
32         asn1_start_tag(&data, ASN1_SEQUENCE(0));
33         asn1_start_tag(&data, ASN1_SEQUENCE(0));
34         asn1_start_tag(&data, ASN1_CONTEXT(0));
35         asn1_read_Integer(&data, &data_type);
36         asn1_end_tag(&data);
37         asn1_start_tag(&data, ASN1_CONTEXT(1));
38         asn1_read_OctetString(&data, &pac_contents);
39         asn1_end_tag(&data);
40         asn1_end_tag(&data);
41         asn1_end_tag(&data);
42         return pac_contents;
43 }
44
45 static BOOL pac_io_unknown_type_10(const char *desc, UNKNOWN_TYPE_10 *type_10,
46                                    prs_struct *ps, int depth)
47 {
48         if (NULL == type_10)
49                 return False;
50
51         prs_debug(ps, depth, desc, "pac_io_unknown_type_10");
52         depth++;
53
54         if (!smb_io_time("unknown_time", &type_10->unknown_time, ps, depth))
55                 return False;
56
57         if (!prs_uint16("len", ps, depth, &type_10->len))
58                 return False;
59
60         if (UNMARSHALLING(ps) && type_10->len) {
61                 type_10->username = (uint16 *) prs_alloc_mem(ps, type_10->len);
62                 if (!type_10->username) {
63                         DEBUG(3, ("No memory available\n"));
64                         return False;
65                 }
66         }
67
68         if (!prs_uint16s(True, "name", ps, depth, type_10->username, 
69                          (type_10->len / sizeof(uint16))))
70                 return False;
71
72         return True;
73
74 }
75
76
77 static BOOL pac_io_krb_sids(const char *desc, KRB_SID_AND_ATTRS *sid_and_attr,
78                             prs_struct *ps, int depth)
79 {
80         if (NULL == sid_and_attr)
81                 return False;
82
83         prs_debug(ps, depth, desc, "pac_io_krb_sids");
84         depth++;
85
86         if (UNMARSHALLING(ps)) {
87                 sid_and_attr->sid = 
88                         (DOM_SID2 * ) prs_alloc_mem(ps, sizeof(DOM_SID2));
89                 if (!sid_and_attr->sid) {
90                         DEBUG(3, ("No memory available\n"));
91                         return False;
92                 }
93         }
94
95         if(!smb_io_dom_sid2("sid", sid_and_attr->sid, ps, depth))
96                 return False;
97
98         return True;
99 }
100
101
102 static BOOL pac_io_krb_attrs(const char *desc, KRB_SID_AND_ATTRS *sid_and_attr,
103                              prs_struct *ps, int depth)
104 {
105         if (NULL == sid_and_attr)
106                 return False;
107
108         prs_debug(ps, depth, desc, "pac_io_krb_attrs");
109         depth++;
110
111         if (!prs_uint32("sid_ptr", ps, depth, &sid_and_attr->sid_ptr))
112                 return False;
113         if (!prs_uint32("attrs", ps, depth, &sid_and_attr->attrs))
114                 return False;
115
116         return True;
117 }
118
119 static BOOL pac_io_krb_sid_and_attr_array(const char *desc, 
120                                           KRB_SID_AND_ATTR_ARRAY *array,
121                                           uint32 num,
122                                           prs_struct *ps, int depth)
123 {
124         int i;
125
126         if (NULL == array)
127                 return False;
128
129         prs_debug(ps, depth, desc, "pac_io_krb_sid_and_attr_array");
130         depth++;
131
132
133         if (!prs_uint32("count", ps, depth, &array->count))
134                 return False;
135
136         if (UNMARSHALLING(ps)) {
137                 array->krb_sid_and_attrs = (KRB_SID_AND_ATTRS *)
138                         prs_alloc_mem(ps, sizeof(KRB_SID_AND_ATTRS) * num);
139                 if (!array->krb_sid_and_attrs) {
140                         DEBUG(3, ("No memory available\n"));
141                         return False;
142                 }
143         }
144
145         for (i=0; i<num; i++) {
146                 if (!pac_io_krb_attrs(desc, 
147                                       &array->krb_sid_and_attrs[i],
148                                       ps, depth))
149                         return False;
150
151         }
152         for (i=0; i<num; i++) {
153                 if (!pac_io_krb_sids(desc, 
154                                      &array->krb_sid_and_attrs[i],
155                                      ps, depth))
156                         return False;
157
158         }
159
160         return True;
161
162 }
163
164 static BOOL pac_io_group_membership(const char *desc, 
165                                     GROUP_MEMBERSHIP *membership,
166                                     prs_struct *ps, int depth)
167 {
168         if (NULL == membership)
169                 return False;
170
171         prs_debug(ps, depth, desc, "pac_io_group_membership");
172         depth++;
173
174         if (!prs_uint32("rid", ps, depth, &membership->rid))
175                 return False;
176         if (!prs_uint32("attrs", ps, depth, &membership->attrs))
177                 return False;
178
179         return True;
180 }
181
182
183 static BOOL pac_io_group_membership_array(const char *desc, 
184                                           GROUP_MEMBERSHIP_ARRAY *array,
185                                           uint32 num,
186                                           prs_struct *ps, int depth)
187 {
188         int i;
189
190         if (NULL == array)
191                 return False;
192
193         prs_debug(ps, depth, desc, "pac_io_group_membership_array");
194         depth++;
195
196
197         if (!prs_uint32("count", ps, depth, &array->count))
198                 return False;
199
200         if (UNMARSHALLING(ps)) {
201                 array->group_membership = (GROUP_MEMBERSHIP *)
202                         prs_alloc_mem(ps, sizeof(GROUP_MEMBERSHIP) * num);
203                 if (!array->group_membership) {
204                         DEBUG(3, ("No memory available\n"));
205                         return False;
206                 }
207         }
208
209         for (i=0; i<num; i++) {
210                 if (!pac_io_group_membership(desc, 
211                                              &array->group_membership[i],
212                                              ps, depth))
213                         return False;
214
215         }
216
217         return True;
218
219 }
220
221 static BOOL pac_io_pac_logon_info(const char *desc, PAC_LOGON_INFO *info, 
222                                   prs_struct *ps, int depth)
223 {
224         uint32 garbage;
225         if (NULL == info)
226                 return False;
227
228         prs_debug(ps, depth, desc, "pac_io_pac_logon_info");
229         depth++;
230
231         if (!prs_uint32("unknown", ps, depth, &garbage))
232                 return False;
233         if (!prs_uint32("unknown", ps, depth, &garbage))
234                 return False;
235         if (!prs_uint32("bufferlen", ps, depth, &garbage))
236                 return False;
237         if (!prs_uint32("bufferlenhi", ps, depth, &garbage))
238                 return False;
239         if (!prs_uint32("pointer", ps, depth, &garbage))
240                 return False;
241
242         if (!smb_io_time("logon_time", &info->logon_time, ps, depth))
243                 return False;
244         if (!smb_io_time("logoff_time", &info->logoff_time, ps, depth))
245                 return False;
246         if (!smb_io_time("kickoff_time", &info->kickoff_time, ps, depth))
247                 return False;
248         if (!smb_io_time("pass_last_set_time", &info->pass_last_set_time, 
249                          ps, depth))
250                 return False;
251         if (!smb_io_time("pass_can_change_time", &info->pass_can_change_time, 
252                          ps, depth))
253                 return False;
254         if (!smb_io_time("pass_must_change_time", &info->pass_must_change_time,
255                          ps, depth))
256                 return False;
257
258         if (!smb_io_unihdr("hdr_user_name", &info->hdr_user_name, ps, depth))
259                 return False;
260         if (!smb_io_unihdr("hdr_full_name", &info->hdr_full_name, ps, depth))
261                 return False;
262         if (!smb_io_unihdr("hdr_logon_script", &info->hdr_logon_script, 
263                            ps, depth))
264                 return False;
265         if (!smb_io_unihdr("hdr_profile_path", &info->hdr_profile_path, 
266                            ps, depth))
267                 return False;
268         if (!smb_io_unihdr("hdr_home_dir", &info->hdr_home_dir, ps, depth))
269                 return False;
270         if (!smb_io_unihdr("hdr_dir_drive", &info->hdr_dir_drive, ps, depth))
271                 return False;
272
273         if (!prs_uint16("logon_count", ps, depth, &info->logon_count))
274                 return False;
275         if (!prs_uint16("reserved12", ps, depth, &info->reserved12))
276                 return False;
277         if (!prs_uint32("user_rid", ps, depth, &info->user_rid))
278                 return False;
279         if (!prs_uint32("group_rid", ps, depth, &info->group_rid))
280                 return False;
281         if (!prs_uint32("group_count", ps, depth, &info->group_count))
282                 return False;
283         /* I haven't seen this contain anything yet, but when it does
284            we will have to make sure we decode the contents in the middle
285            all the unistr2s ... */
286         if (!prs_uint32("group_mem_ptr", ps, depth, 
287                         &info->group_membership_ptr))
288                 return False;
289         if (!prs_uint32("user_flags", ps, depth, &info->user_flags))
290                 return False;
291
292         if (!prs_uint32("reserved13.0", ps, depth, &info->reserved13[0]))
293                 return False;
294         if (!prs_uint32("reserved13.1", ps, depth, &info->reserved13[1]))
295                 return False;
296         if (!prs_uint32("reserved13.2", ps, depth, &info->reserved13[2]))
297                 return False;
298         if (!prs_uint32("reserved13.3", ps, depth, &info->reserved13[3]))
299                 return False;
300         
301         if (!smb_io_unihdr("hdr_dom_controller", 
302                            &info->hdr_dom_controller, ps, depth))
303                 return False;
304         if (!smb_io_unihdr("hdr_dom_name", &info->hdr_dom_name, ps, depth))
305                 return False;
306
307         /* this should be followed, but just get ptr for now */
308         if (!prs_uint32("ptr_dom_sid", ps, depth, &info->ptr_dom_sid))
309                 return False;
310
311         if (!prs_uint32("reserved16.0", ps, depth, &info->reserved16[0]))
312                 return False;
313         if (!prs_uint32("reserved16.1", ps, depth, &info->reserved16[1]))
314                 return False;
315
316         /* might be acb_info */
317         if (!prs_uint32("reserved17", ps, depth, &info->reserved17))
318                 return False;
319
320
321         if (!prs_uint32("reserved18.0", ps, depth, &info->reserved18[0]))
322                 return False;
323         if (!prs_uint32("reserved18.1", ps, depth, &info->reserved18[1]))
324                 return False;
325         if (!prs_uint32("reserved18.2", ps, depth, &info->reserved18[2]))
326                 return False;
327         if (!prs_uint32("reserved18.3", ps, depth, &info->reserved18[3]))
328                 return False;
329         if (!prs_uint32("reserved18.4", ps, depth, &info->reserved18[4]))
330                 return False;
331         if (!prs_uint32("reserved18.5", ps, depth, &info->reserved18[5]))
332                 return False;
333         if (!prs_uint32("reserved18.6", ps, depth, &info->reserved18[6]))
334                 return False;
335
336         if (!prs_uint32("sid_count", ps, depth, &info->sid_count))
337                 return False;
338         if (!prs_uint32("ptr_extra_sids", ps, depth, &info->ptr_extra_sids))
339                 return False;
340         if (!prs_uint32("ptr_res_group_dom_sid", ps, depth, 
341                         &info->ptr_res_group_dom_sid))
342                 return False;
343         if (!prs_uint32("res_group_count", ps, depth, &info->res_group_count))
344                 return False;
345         if (!prs_uint32("ptr_res_groups", ps, depth, &info->ptr_res_groups))
346                 return False;
347
348         if(!smb_io_unistr2("uni_user_name", &info->uni_user_name, 
349                            info->hdr_user_name.buffer, ps, depth))
350                 return False;
351         if(!smb_io_unistr2("uni_full_name", &info->uni_full_name, 
352                            info->hdr_full_name.buffer, ps, depth))
353                 return False;
354         if(!smb_io_unistr2("uni_logon_script", &info->uni_logon_script, 
355                            info->hdr_logon_script.buffer, ps, depth))
356                 return False;
357         if(!smb_io_unistr2("uni_profile_path", &info->uni_profile_path,
358                            info->hdr_profile_path.buffer, ps, depth))
359                 return False;
360         if(!smb_io_unistr2("uni_home_dir", &info->uni_home_dir,
361                            info->hdr_home_dir.buffer, ps, depth))
362                 return False;
363         if(!smb_io_unistr2("uni_dir_drive", &info->uni_dir_drive,
364                            info->hdr_dir_drive.buffer, ps, depth))
365                 return False;
366
367         if (info->group_membership_ptr) {
368                 if (!pac_io_group_membership_array("group membership",
369                                                    &info->groups,
370                                                    info->group_count,
371                                                    ps, depth))
372                         return False;
373         }
374
375
376         if(!smb_io_unistr2("uni_dom_controller", &info->uni_dom_controller,
377                            info->hdr_dom_controller.buffer, ps, depth))
378                 return False;
379         if(!smb_io_unistr2("uni_dom_name", &info->uni_dom_name, 
380                            info->hdr_dom_name.buffer, ps, depth))
381                 return False;
382
383         if(info->ptr_dom_sid)
384                 if(!smb_io_dom_sid2("dom_sid", &info->dom_sid, ps, depth))
385                         return False;
386
387         
388         if (info->sid_count && info->ptr_extra_sids)
389                 if (!pac_io_krb_sid_and_attr_array("extra_sids", 
390                                                    &info->extra_sids,
391                                                    info->sid_count,
392                                                    ps, depth))
393                         return False;
394
395         if (info->ptr_res_group_dom_sid)
396                 if (!smb_io_dom_sid2("res_group_dom_sid", 
397                                      &info->res_group_dom_sid, ps, depth))
398                         return False;
399
400         if (info->ptr_res_groups)
401                 if (!pac_io_group_membership_array("res group membership",
402                                                    &info->res_groups,
403                                                    info->res_group_count,
404                                                    ps, depth))
405                         return False;
406
407         return True;
408 }
409
410
411 static BOOL pac_io_pac_signature_data(const char *desc, 
412                                       PAC_SIGNATURE_DATA *data, uint32 length,
413                                       prs_struct *ps, int depth)
414 {
415         uint32 siglen = length - sizeof(uint32);
416         if (NULL == data)
417                 return False;
418
419         prs_debug(ps, depth, desc, "pac_io_pac_signature_data");
420         depth++;
421
422         if (!prs_uint32("type", ps, depth, &data->type))
423                 return False;
424         if (UNMARSHALLING(ps)) {
425                 data->signature = prs_alloc_mem(ps, siglen);
426                 if (!data->signature) {
427                         DEBUG(3, ("No memory available\n"));
428                         return False;
429                 }
430         }
431         if (!prs_uint8s(False, "signature", ps, depth, data->signature,siglen))
432                 return False;
433
434         return True;
435 }
436
437 static BOOL pac_io_pac_info_hdr_ctr(const char *desc, PAC_INFO_HDR *hdr,
438                                     prs_struct *ps, int depth)
439 {
440         if (NULL == hdr)
441                 return False;
442
443         prs_debug(ps, depth, desc, "pac_io_pac_info_hdr_ctr");
444         depth++;
445
446         if (!prs_align(ps))
447                 return False;
448
449         if (hdr->offset != prs_offset(ps)) {
450                 DEBUG(5, ("offset in header(x%x) and data(x%x) do not match\n",
451                           hdr->offset, prs_offset(ps)));
452                 prs_set_offset(ps, hdr->offset);
453         }
454
455         if (UNMARSHALLING(ps) && hdr->size > 0) {
456                 hdr->ctr = (PAC_INFO_CTR *) 
457                         prs_alloc_mem(ps, sizeof(PAC_INFO_CTR));
458                 if (!hdr->ctr) {
459                         DEBUG(3, ("No memory available\n"));
460                         return False;
461                 }
462         }
463
464         switch(hdr->type) {
465         case PAC_TYPE_LOGON_INFO:
466                 DEBUG(5, ("PAC_TYPE_LOGON_INFO\n"));
467                 if (UNMARSHALLING(ps))
468                         hdr->ctr->pac.logon_info = (PAC_LOGON_INFO *)
469                                 prs_alloc_mem(ps, sizeof(PAC_LOGON_INFO));
470                 if (!hdr->ctr->pac.logon_info) {
471                         DEBUG(3, ("No memory available\n"));
472                         return False;
473                 }
474                 if (!pac_io_pac_logon_info(desc, hdr->ctr->pac.logon_info,
475                                            ps, depth))
476                         return False;
477                 break;
478
479         case PAC_TYPE_SERVER_CHECKSUM:
480                 DEBUG(5, ("PAC_TYPE_SERVER_CHECKSUM\n"));
481                 if (UNMARSHALLING(ps))
482                         hdr->ctr->pac.srv_cksum = (PAC_SIGNATURE_DATA *)
483                                 prs_alloc_mem(ps, sizeof(PAC_SIGNATURE_DATA));
484                 if (!hdr->ctr->pac.srv_cksum) {
485                         DEBUG(3, ("No memory available\n"));
486                         return False;
487                 }
488                 if (!pac_io_pac_signature_data(desc, hdr->ctr->pac.srv_cksum,
489                                                hdr->size, ps, depth))
490                         return False;
491                 break;
492
493         case PAC_TYPE_PRIVSVR_CHECKSUM:
494                 DEBUG(5, ("PAC_TYPE_PRIVSVR_CHECKSUM\n"));
495                 if (UNMARSHALLING(ps))
496                         hdr->ctr->pac.privsrv_cksum = (PAC_SIGNATURE_DATA *)
497                                 prs_alloc_mem(ps, sizeof(PAC_SIGNATURE_DATA));
498                 if (!hdr->ctr->pac.privsrv_cksum) {
499                         DEBUG(3, ("No memory available\n"));
500                         return False;
501                 }
502                 if (!pac_io_pac_signature_data(desc, 
503                                                hdr->ctr->pac.privsrv_cksum,
504                                                hdr->size, ps, depth))
505                         return False;
506                 break;
507
508         case PAC_TYPE_UNKNOWN_10:
509                 DEBUG(5, ("PAC_TYPE_UNKNOWN_10\n"));
510                 if (UNMARSHALLING(ps))
511                         hdr->ctr->pac.type_10 = (UNKNOWN_TYPE_10 *)
512                                 prs_alloc_mem(ps, sizeof(UNKNOWN_TYPE_10));
513                 if (!hdr->ctr->pac.type_10) {
514                         DEBUG(3, ("No memory available\n"));
515                         return False;
516                 }
517                 if (!pac_io_unknown_type_10(desc, hdr->ctr->pac.type_10,
518                                             ps, depth))
519                         return False;
520                 break;
521
522         default:
523                 /* dont' know, so we need to skip it */
524                 DEBUG(3, ("unknown PAC type %d\n", hdr->type));
525                 prs_set_offset(ps, prs_offset(ps) + hdr->size);
526         }
527
528         return True;
529 }
530
531 static BOOL pac_io_pac_info_hdr(const char *desc, PAC_INFO_HDR *hdr, 
532                                 prs_struct *ps, int depth)
533 {
534         if (NULL == hdr)
535                 return False;
536
537         prs_debug(ps, depth, desc, "pac_io_pac_info_hdr");
538         depth++;
539
540         if (!prs_align(ps))
541                 return False;
542         if (!prs_uint32("type", ps, depth, &hdr->type))
543                 return False;
544         if (!prs_uint32("size", ps, depth, &hdr->size))
545                 return False;
546         if (!prs_uint32("offset", ps, depth, &hdr->offset))
547                 return False;
548         if (!prs_uint32("offsethi", ps, depth, &hdr->offsethi))
549                 return False;
550
551         return True;
552 }
553
554 static BOOL pac_io_pac_data(const char *desc, PAC_DATA *data, 
555                             prs_struct *ps, int depth)
556 {
557         int i;
558
559         if (NULL == data)
560                 return False;
561
562         prs_debug(ps, depth, desc, "pac_io_pac_data");
563         depth++;
564
565         if (!prs_align(ps))
566                 return False;
567         if (!prs_uint32("num_buffers", ps, depth, &data->num_buffers))
568                 return False;
569         if (!prs_uint32("version", ps, depth, &data->version))
570                 return False;
571
572         if (UNMARSHALLING(ps) && data->num_buffers > 0) {
573                 if ((data->pac_info_hdr_ptr = (PAC_INFO_HDR *) 
574                      prs_alloc_mem(ps, sizeof(PAC_INFO_HDR) * 
575                                    data->num_buffers)) == NULL) {
576                         return False;
577                 }
578         }
579
580         for (i=0; i<data->num_buffers; i++) {
581                 if (!pac_io_pac_info_hdr(desc, &data->pac_info_hdr_ptr[i], ps, 
582                                          depth))
583                         return False;
584         }
585
586         for (i=0; i<data->num_buffers; i++) {
587                 if (!pac_io_pac_info_hdr_ctr(desc, &data->pac_info_hdr_ptr[i],
588                                              ps, depth))
589                         return False;
590         }
591
592         return True;
593 }
594
595 PAC_DATA *decode_pac_data(DATA_BLOB *auth_data, TALLOC_CTX *ctx)
596 {
597         DATA_BLOB pac_data_blob = unwrap_pac(auth_data);
598         prs_struct ps;
599         PAC_DATA *pac_data;
600
601         DEBUG(5,("dump_pac_data\n"));
602         prs_init(&ps, pac_data_blob.length, ctx, UNMARSHALL);
603         prs_copy_data_in(&ps, pac_data_blob.data, pac_data_blob.length);
604         prs_set_offset(&ps, 0);
605
606         pac_data = (PAC_DATA *) talloc_zero(ctx, sizeof(PAC_DATA));
607         pac_io_pac_data("pac data", pac_data, &ps, 0);
608
609         prs_mem_free(&ps);
610
611         return pac_data;
612 }
613
614 #endif