source3/rpc_parse/parse_sec.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-1998,
   6  *  Copyright (C) Jeremy R. Allison            1995-1998
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
   8  *  Copyright (C) Paul Ashton                  1997-1998.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25
  26 #include "includes.h"
  27
  28 extern int DEBUGLEVEL;
  29
  30 #define SD_HEADER_SIZE 0x14
  31
  32 /*******************************************************************
  33  Sets up a SEC_ACCESS structure.
  34 ********************************************************************/
  35
  36 void init_sec_access(SEC_ACCESS *t, uint32 mask)
  37 {
  38         t->mask = mask;
  39 }
  40
  41 /*******************************************************************
  42  Reads or writes a SEC_ACCESS structure.
  43 ********************************************************************/
  44
  45 BOOL sec_io_access(char *desc, SEC_ACCESS *t, prs_struct *ps, int depth)
  46 {
  47         if (t == NULL)
  48                 return False;
  49
  50         prs_debug(ps, depth, desc, "sec_io_access");
  51         depth++;
  52
  53         if(!prs_align(ps))
  54                 return False;
  55
  56         if(!prs_uint32("mask", ps, depth, &(t->mask)))
  57                 return False;
  58
  59         return True;
  60 }
  61
  62
  63 /*******************************************************************
  64  Sets up a SEC_ACE structure.
  65 ********************************************************************/
  66
  67 void init_sec_ace(SEC_ACE *t, DOM_SID *sid, uint8 type, SEC_ACCESS mask, uint8 flag)
  68 {
  69         t->type = type;
  70         t->flags = flag;
  71         t->size = sid_size(sid) + 8;
  72         t->info = mask;
  73
  74         ZERO_STRUCTP(&t->sid);
  75         sid_copy(&t->sid, sid);
  76 }
  77
  78 /*******************************************************************
  79  Reads or writes a SEC_ACE structure.
  80 ********************************************************************/
  81
  82 BOOL sec_io_ace(char *desc, SEC_ACE *psa, prs_struct *ps, int depth)
  83 {
  84         uint32 old_offset;
  85         uint32 offset_ace_size;
  86
  87         if (psa == NULL)
  88                 return False;
  89
  90         prs_debug(ps, depth, desc, "sec_io_ace");
  91         depth++;
  92
  93         if(!prs_align(ps))
  94                 return False;
  95
  96         old_offset = prs_offset(ps);
  97
  98         if(!prs_uint8("type ", ps, depth, &psa->type))
  99                 return False;
 100
 101         if(!prs_uint8("flags", ps, depth, &psa->flags))
 102                 return False;
 103
 104         if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size))
 105                 return False;
 106
 107         if(!sec_io_access("info ", &psa->info, ps, depth))
 108                 return False;
 109
 110         if(!prs_align(ps))
 111                 return False;
 112
 113         if(!smb_io_dom_sid("sid  ", &psa->sid , ps, depth))
 114                 return False;
 115
 116         if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset))
 117                 return False;
 118
 119         return True;
 120 }
 121
 122 /*******************************************************************
 123  Create a SEC_ACL structure.
 124 ********************************************************************/
 125
 126 SEC_ACL *make_sec_acl(uint16 revision, int num_aces, SEC_ACE *ace_list)
 127 {
 128         SEC_ACL *dst;
 129         int i;
 130
 131         if((dst = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL)
 132                 return NULL;
 133
 134         ZERO_STRUCTP(dst);
 135
 136         dst->revision = revision;
 137         dst->num_aces = num_aces;
 138         dst->size = 8;
 139
 140         if((dst->ace = (SEC_ACE *)malloc( sizeof(SEC_ACE) * num_aces )) == NULL) {
 141                 free_sec_acl(&dst);
 142                 return NULL;
 143         }
 144
 145         for (i = 0; i < num_aces; i++) {
 146                 dst->ace[i] = ace_list[i]; /* Structure copy. */
 147                 dst->size += ace_list[i].size;
 148         }
 149
 150         return dst;
 151 }
 152
 153 /*******************************************************************
 154  Duplicate a SEC_ACL structure.
 155 ********************************************************************/
 156
 157 SEC_ACL *dup_sec_acl( SEC_ACL *src)
 158 {
 159         if(src == NULL)
 160                 return NULL;
 161
 162         return make_sec_acl( src->revision, src->num_aces, src->ace);
 163 }
 164
 165 /*******************************************************************
 166  Delete a SEC_ACL structure.
 167 ********************************************************************/
 168
 169 void free_sec_acl(SEC_ACL **ppsa)
 170 {
 171         SEC_ACL *psa;
 172
 173         if(ppsa == NULL || *ppsa == NULL)
 174                 return;
 175
 176         psa = *ppsa;
 177         if (psa->ace != NULL)
 178                 free(psa->ace);
 179
 180         free(psa);
 181         *ppsa = NULL;
 182 }
 183
 184 /*******************************************************************
 185  Reads or writes a SEC_ACL structure.
 186
 187  First of the xx_io_xx functions that allocates its data structures
 188  for you as it reads them.
 189 ********************************************************************/
 190
 191 BOOL sec_io_acl(char *desc, SEC_ACL **ppsa, prs_struct *ps, int depth)
 192 {
 193         int i;
 194         uint32 old_offset;
 195         uint32 offset_acl_size;
 196         SEC_ACL *psa;
 197
 198         if (ppsa == NULL)
 199                 return False;
 200
 201         psa = *ppsa;
 202
 203         if(UNMARSHALLING(ps) && psa == NULL) {
 204                 /*
 205                  * This is a read and we must allocate the stuct to read into.
 206                  */
 207                 if((psa = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL)
 208                         return False;
 209                 ZERO_STRUCTP(psa);
 210                 *ppsa = psa;
 211         }
 212
 213         prs_debug(ps, depth, desc, "sec_io_acl");
 214         depth++;
 215
 216         if(!prs_align(ps))
 217                 return False;
 218
 219         old_offset = prs_offset(ps);
 220
 221         if(!prs_uint16("revision", ps, depth, &psa->revision))
 222                 return False;
 223
 224         if(!prs_uint16_pre("size     ", ps, depth, &psa->size, &offset_acl_size))
 225                 return False;
 226
 227         if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces))
 228                 return False;
 229
 230         if (UNMARSHALLING(ps) && psa->num_aces != 0) {
 231                 /* reading */
 232                 if((psa->ace = malloc(sizeof(psa->ace[0]) * psa->num_aces)) == NULL)
 233                         return False;
 234                 ZERO_STRUCTP(psa->ace);
 235         }
 236
 237         for (i = 0; i < psa->num_aces; i++) {
 238                 fstring tmp;
 239                 slprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i);
 240                 if(!sec_io_ace(tmp, &psa->ace[i], ps, depth))
 241                         return False;
 242         }
 243
 244         if(!prs_align(ps))
 245                 return False;
 246
 247         if(!prs_uint16_post("size     ", ps, depth, &psa->size, offset_acl_size, old_offset))
 248                 return False;
 249
 250         return True;
 251 }
 252
 253 /*******************************************************************
 254  Works out the linearization size of a SEC_DESC.
 255 ********************************************************************/
 256
 257 size_t sec_desc_size(SEC_DESC *psd)
 258 {
 259         size_t offset;
 260
 261         if (!psd) return 0;
 262
 263         offset = SD_HEADER_SIZE;
 264
 265         if (psd->owner_sid != NULL)
 266                 offset += ((sid_size(psd->owner_sid) + 3) & ~3);
 267
 268         if (psd->grp_sid != NULL)
 269                 offset += ((sid_size(psd->grp_sid) + 3) & ~3);
 270
 271         if (psd->sacl != NULL)
 272                 offset += ((psd->sacl->size + 3) & ~3);
 273
 274         if (psd->dacl != NULL)
 275                 offset += ((psd->dacl->size + 3) & ~3);
 276
 277         return offset;
 278 }
 279
 280 /*******************************************************************
 281  Creates a SEC_DESC structure
 282 ********************************************************************/
 283
 284 SEC_DESC *make_sec_desc(uint16 revision, uint16 type,
 285                         DOM_SID *owner_sid, DOM_SID *grp_sid,
 286                         SEC_ACL *sacl, SEC_ACL *dacl, size_t *sd_size)
 287 {
 288         SEC_DESC *dst;
 289         uint32 offset;
 290
 291         *sd_size = 0;
 292
 293         if(( dst = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
 294                 return NULL;
 295
 296         ZERO_STRUCTP(dst);
 297
 298         dst->revision = revision;
 299         dst->type     = type;
 300
 301         dst->off_owner_sid = 0;
 302         dst->off_grp_sid   = 0;
 303         dst->off_sacl      = 0;
 304         dst->off_dacl      = 0;
 305
 306         if(owner_sid && ((dst->owner_sid = sid_dup(owner_sid)) == NULL))
 307                 goto error_exit;
 308
 309         if(grp_sid && ((dst->grp_sid = sid_dup(grp_sid)) == NULL))
 310                 goto error_exit;
 311
 312         if(sacl && ((dst->sacl = dup_sec_acl(sacl)) == NULL))
 313                 goto error_exit;
 314
 315         if(dacl && ((dst->dacl = dup_sec_acl(dacl)) == NULL))
 316                 goto error_exit;
 317
 318         offset = 0;
 319
 320         /*
 321          * Work out the linearization sizes.
 322          */
 323
 324         if (dst->owner_sid != NULL) {
 325
 326                 if (offset == 0)
 327                         offset = SD_HEADER_SIZE;
 328
 329                 dst->off_owner_sid = offset;
 330                 offset += ((sid_size(dst->owner_sid) + 3) & ~3);
 331         }
 332
 333         if (dst->grp_sid != NULL) {
 334
 335                 if (offset == 0)
 336                         offset = SD_HEADER_SIZE;
 337
 338                 dst->off_grp_sid = offset;
 339                 offset += ((sid_size(dst->grp_sid) + 3) & ~3);
 340         }
 341
 342         if (dst->sacl != NULL) {
 343
 344                 if (offset == 0)
 345                         offset = SD_HEADER_SIZE;
 346
 347                 dst->off_sacl = offset;
 348                 offset += ((sacl->size + 3) & ~3);
 349         }
 350
 351         if (dst->dacl != NULL) {
 352
 353                 if (offset == 0)
 354                         offset = SD_HEADER_SIZE;
 355
 356                 dst->off_dacl = offset;
 357                 offset += ((dacl->size + 3) & ~3);
 358         }
 359
 360         *sd_size = (size_t)((offset == 0) ? SD_HEADER_SIZE : offset);
 361         return dst;
 362
 363 error_exit:
 364
 365         *sd_size = 0;
 366         free_sec_desc(&dst);
 367         return NULL;
 368 }
 369
 370 /*******************************************************************
 371  Duplicate a SEC_DESC structure.
 372 ********************************************************************/
 373
 374 SEC_DESC *dup_sec_desc( SEC_DESC *src)
 375 {
 376         size_t dummy;
 377
 378         if(src == NULL)
 379                 return NULL;
 380
 381         return make_sec_desc( src->revision, src->type,
 382                                 src->owner_sid, src->grp_sid, src->sacl,
 383                                 src->dacl, &dummy);
 384 }
 385
 386 /*******************************************************************
 387  Deletes a SEC_DESC structure
 388 ********************************************************************/
 389
 390 void free_sec_desc(SEC_DESC **ppsd)
 391 {
 392         SEC_DESC *psd;
 393
 394         if(ppsd == NULL || *ppsd == NULL)
 395                 return;
 396
 397         psd = *ppsd;
 398
 399         free_sec_acl(&psd->dacl);
 400         free_sec_acl(&psd->dacl);
 401         free(psd->owner_sid);
 402         free(psd->grp_sid);
 403         free(psd);
 404         *ppsd = NULL;
 405 }
 406
 407 /*******************************************************************
 408  Creates a SEC_DESC structure with typical defaults.
 409 ********************************************************************/
 410
 411 SEC_DESC *make_standard_sec_desc(DOM_SID *owner_sid, DOM_SID *grp_sid,
 412                                  SEC_ACL *dacl, size_t *sd_size)
 413 {
 414         return make_sec_desc(SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT,
 415                              owner_sid, grp_sid, NULL, dacl, sd_size);
 416 }
 417
 418 /*******************************************************************
 419  Reads or writes a SEC_DESC structure.
 420  If reading and the *ppsd = NULL, allocates the structure.
 421 ********************************************************************/
 422
 423 BOOL sec_io_desc(char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
 424 {
 425         uint32 old_offset;
 426         uint32 max_offset = 0; /* after we're done, move offset to end */
 427         SEC_DESC *psd;
 428
 429         if (ppsd == NULL)
 430                 return False;
 431
 432         psd = *ppsd;
 433
 434         if (psd == NULL) {
 435                 if(UNMARSHALLING(ps)) {
 436                         if((psd = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
 437                                 return False;
 438                         ZERO_STRUCTP(psd);
 439                         *ppsd = psd;
 440                 } else {
 441                         /* Marshalling - just ignore. */
 442                         return True;
 443                 }
 444         }
 445
 446         prs_debug(ps, depth, desc, "sec_io_desc");
 447         depth++;
 448
 449         if(!prs_align(ps))
 450                 return False;
 451
 452         /* start of security descriptor stored for back-calc offset purposes */
 453         old_offset = prs_offset(ps);
 454
 455         if(!prs_uint16("revision ", ps, depth, &psd->revision))
 456                 return False;
 457
 458         if(!prs_uint16("type     ", ps, depth, &psd->type))
 459                 return False;
 460
 461         if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid))
 462                 return False;
 463
 464         if(!prs_uint32("off_grp_sid  ", ps, depth, &psd->off_grp_sid))
 465                 return False;
 466
 467         if(!prs_uint32("off_sacl     ", ps, depth, &psd->off_sacl))
 468                 return False;
 469
 470         if(!prs_uint32("off_dacl     ", ps, depth, &psd->off_dacl))
 471                 return False;
 472
 473         max_offset = MAX(max_offset, prs_offset(ps));
 474
 475         if (psd->off_owner_sid != 0) {
 476
 477                 if (UNMARSHALLING(ps)) {
 478                         if(!prs_set_offset(ps, old_offset + psd->off_owner_sid))
 479                                 return False;
 480                         /* reading */
 481                         if((psd->owner_sid = malloc(sizeof(*psd->owner_sid))) == NULL)
 482                                 return False;
 483                         ZERO_STRUCTP(psd->owner_sid);
 484                 }
 485
 486                 if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
 487                         return False;
 488                 if(!prs_align(ps))
 489                         return False;
 490         }
 491
 492         max_offset = MAX(max_offset, prs_offset(ps));
 493
 494         if (psd->off_grp_sid != 0) {
 495
 496                 if (UNMARSHALLING(ps)) {
 497                         /* reading */
 498                         if(!prs_set_offset(ps, old_offset + psd->off_grp_sid))
 499                                 return False;
 500                         if((psd->grp_sid = malloc(sizeof(*psd->grp_sid))) == NULL)
 501                                 return False;
 502                         ZERO_STRUCTP(psd->grp_sid);
 503                 }
 504
 505                 if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth))
 506                         return False;
 507                 if(!prs_align(ps))
 508                         return False;
 509         }
 510
 511         max_offset = MAX(max_offset, prs_offset(ps));
 512
 513         if (IS_BITS_SET_ALL(psd->type, SEC_DESC_SACL_PRESENT) && psd->off_sacl) {
 514                 if(!prs_set_offset(ps, old_offset + psd->off_sacl))
 515                         return False;
 516                 if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
 517                         return False;
 518                 if(!prs_align(ps))
 519                         return False;
 520         }
 521
 522         max_offset = MAX(max_offset, prs_offset(ps));
 523
 524         if (IS_BITS_SET_ALL(psd->type, SEC_DESC_DACL_PRESENT) && psd->off_dacl != 0) {
 525                 if(!prs_set_offset(ps, old_offset + psd->off_dacl))
 526                         return False;
 527                 if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
 528                         return False;
 529                 if(!prs_align(ps))
 530                         return False;
 531         }
 532
 533         max_offset = MAX(max_offset, prs_offset(ps));
 534
 535         if(!prs_set_offset(ps, max_offset))
 536                 return False;
 537         return True;
 538 }
 539
 540 /*******************************************************************
 541  Creates a SEC_DESC_BUF structure.
 542 ********************************************************************/
 543
 544 SEC_DESC_BUF *make_sec_desc_buf(size_t len, SEC_DESC *sec_desc)
 545 {
 546         SEC_DESC_BUF *dst;
 547
 548         if((dst = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
 549                 return NULL;
 550
 551         ZERO_STRUCTP(dst);
 552
 553         /* max buffer size (allocated size) */
 554         dst->max_len = (uint32)len;
 555         dst->len = (uint32)len;
 556
 557         if(sec_desc && ((dst->sec = dup_sec_desc(sec_desc)) == NULL)) {
 558                 free_sec_desc_buf(&dst);
 559                 return NULL;
 560         }
 561
 562         return dst;
 563 }
 564
 565 /*******************************************************************
 566  Duplicates a SEC_DESC_BUF structure.
 567 ********************************************************************/
 568
 569 SEC_DESC_BUF *dup_sec_desc_buf(SEC_DESC_BUF *src)
 570 {
 571         if(src == NULL)
 572                 return NULL;
 573
 574         return make_sec_desc_buf( src->len, src->sec);
 575 }
 576
 577 /*******************************************************************
 578  Deletes a SEC_DESC_BUF structure.
 579 ********************************************************************/
 580
 581 void free_sec_desc_buf(SEC_DESC_BUF **ppsdb)
 582 {
 583         SEC_DESC_BUF *psdb;
 584
 585         if(ppsdb == NULL || *ppsdb == NULL)
 586                 return;
 587
 588         psdb = *ppsdb;
 589         free_sec_desc(&psdb->sec);
 590         free(psdb);
 591         *ppsdb = NULL;
 592 }
 593
 594
 595 /*******************************************************************
 596  Reads or writes a SEC_DESC_BUF structure.
 597 ********************************************************************/
 598
 599 BOOL sec_io_desc_buf(char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
 600 {
 601         uint32 off_len;
 602         uint32 off_max_len;
 603         uint32 old_offset;
 604         uint32 size;
 605         SEC_DESC_BUF *psdb;
 606
 607         if (ppsdb == NULL)
 608                 return False;
 609
 610         psdb = *ppsdb;
 611
 612         if (UNMARSHALLING(ps) && psdb == NULL) {
 613                 if((psdb = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
 614                         return False;
 615                 ZERO_STRUCTP(psdb);
 616                 *ppsdb = psdb;
 617         }
 618
 619         prs_debug(ps, depth, desc, "sec_io_desc_buf");
 620         depth++;
 621
 622         if(!prs_align(ps))
 623                 return False;
 624
 625         if(!prs_uint32_pre("max_len", ps, depth, &psdb->max_len, &off_max_len))
 626                 return False;
 627
 628         if(!prs_uint32    ("undoc  ", ps, depth, &psdb->undoc))
 629                 return False;
 630
 631         if(!prs_uint32_pre("len    ", ps, depth, &psdb->len, &off_len))
 632                 return False;
 633
 634         old_offset = prs_offset(ps);
 635
 636         /* reading, length is non-zero; writing, descriptor is non-NULL */
 637         if ((UNMARSHALLING(ps) && psdb->len != 0) || (MARSHALLING(ps) && psdb->sec != NULL)) {
 638                 if(!sec_io_desc("sec   ", &psdb->sec, ps, depth))
 639                         return False;
 640         }
 641
 642         if(!prs_align(ps))
 643                 return False;
 644
 645         size = prs_offset(ps) - old_offset;
 646         if(!prs_uint32_post("max_len", ps, depth, &psdb->max_len, off_max_len, size == 0 ? psdb->max_len : size))
 647                 return False;
 648
 649         if(!prs_uint32_post("len    ", ps, depth, &psdb->len, off_len, size))
 650                 return False;
 651
 652         return True;
 653 }