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 = SD_HEADER_SIZE;
 260
 261         if (psd->owner_sid != NULL)
 262                 offset += ((sid_size(psd->owner_sid) + 3) & ~3);
 263
 264         if (psd->grp_sid != NULL)
 265                 offset += ((sid_size(psd->grp_sid) + 3) & ~3);
 266
 267         if (psd->sacl != NULL)
 268                 offset += ((psd->sacl->size + 3) & ~3);
 269
 270         if (psd->dacl != NULL)
 271                 offset += ((psd->dacl->size + 3) & ~3);
 272
 273         return offset;
 274 }
 275
 276 /*******************************************************************
 277  Creates a SEC_DESC structure
 278 ********************************************************************/
 279
 280 SEC_DESC *make_sec_desc(uint16 revision, uint16 type,
 281                         DOM_SID *owner_sid, DOM_SID *grp_sid,
 282                         SEC_ACL *sacl, SEC_ACL *dacl, size_t *sd_size)
 283 {
 284         SEC_DESC *dst;
 285         uint32 offset;
 286
 287         *sd_size = 0;
 288
 289         if(( dst = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
 290                 return NULL;
 291
 292         ZERO_STRUCTP(dst);
 293
 294         dst->revision = revision;
 295         dst->type     = type;
 296
 297         dst->off_owner_sid = 0;
 298         dst->off_grp_sid   = 0;
 299         dst->off_sacl      = 0;
 300         dst->off_dacl      = 0;
 301
 302         if(owner_sid && ((dst->owner_sid = sid_dup(owner_sid)) == NULL))
 303                 goto error_exit;
 304
 305         if(grp_sid && ((dst->grp_sid = sid_dup(grp_sid)) == NULL))
 306                 goto error_exit;
 307
 308         if(sacl && ((dst->sacl = dup_sec_acl(sacl)) == NULL))
 309                 goto error_exit;
 310
 311         if(dacl && ((dst->dacl = dup_sec_acl(dacl)) == NULL))
 312                 goto error_exit;
 313
 314         offset = 0;
 315
 316         /*
 317          * Work out the linearization sizes.
 318          */
 319
 320         if (dst->owner_sid != NULL) {
 321
 322                 if (offset == 0)
 323                         offset = SD_HEADER_SIZE;
 324
 325                 dst->off_owner_sid = offset;
 326                 offset += ((sid_size(dst->owner_sid) + 3) & ~3);
 327         }
 328
 329         if (dst->grp_sid != NULL) {
 330
 331                 if (offset == 0)
 332                         offset = SD_HEADER_SIZE;
 333
 334                 dst->off_grp_sid = offset;
 335                 offset += ((sid_size(dst->grp_sid) + 3) & ~3);
 336         }
 337
 338         if (dst->sacl != NULL) {
 339
 340                 if (offset == 0)
 341                         offset = SD_HEADER_SIZE;
 342
 343                 dst->off_sacl = offset;
 344                 offset += ((sacl->size + 3) & ~3);
 345         }
 346
 347         if (dst->dacl != NULL) {
 348
 349                 if (offset == 0)
 350                         offset = SD_HEADER_SIZE;
 351
 352                 dst->off_dacl = offset;
 353                 offset += ((dacl->size + 3) & ~3);
 354         }
 355
 356         *sd_size = (size_t)((offset == 0) ? SD_HEADER_SIZE : offset);
 357         return dst;
 358
 359 error_exit:
 360
 361         *sd_size = 0;
 362         free_sec_desc(&dst);
 363         return NULL;
 364 }
 365
 366 /*******************************************************************
 367  Duplicate a SEC_DESC structure.
 368 ********************************************************************/
 369
 370 SEC_DESC *dup_sec_desc( SEC_DESC *src)
 371 {
 372         size_t dummy;
 373
 374         if(src == NULL)
 375                 return NULL;
 376
 377         return make_sec_desc( src->revision, src->type,
 378                                 src->owner_sid, src->grp_sid, src->sacl,
 379                                 src->dacl, &dummy);
 380 }
 381
 382 /*******************************************************************
 383  Deletes a SEC_DESC structure
 384 ********************************************************************/
 385
 386 void free_sec_desc(SEC_DESC **ppsd)
 387 {
 388         SEC_DESC *psd;
 389
 390         if(ppsd == NULL || *ppsd == NULL)
 391                 return;
 392
 393         psd = *ppsd;
 394
 395         free_sec_acl(&psd->dacl);
 396         free_sec_acl(&psd->dacl);
 397         free(psd->owner_sid);
 398         free(psd->grp_sid);
 399         free(psd);
 400         *ppsd = NULL;
 401 }
 402
 403 /*******************************************************************
 404  Creates a SEC_DESC structure with typical defaults.
 405 ********************************************************************/
 406
 407 SEC_DESC *make_standard_sec_desc(DOM_SID *owner_sid, DOM_SID *grp_sid,
 408                                  SEC_ACL *dacl, size_t *sd_size)
 409 {
 410         return make_sec_desc(1, SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT,
 411                              owner_sid, grp_sid, NULL, dacl, sd_size);
 412 }
 413
 414
 415 /*******************************************************************
 416  Reads or writes a SEC_DESC structure.
 417  If reading and the *ppsd = NULL, allocates the structure.
 418 ********************************************************************/
 419
 420 BOOL sec_io_desc(char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
 421 {
 422         uint32 old_offset;
 423         uint32 max_offset = 0; /* after we're done, move offset to end */
 424         SEC_DESC *psd;
 425
 426         if (ppsd == NULL)
 427                 return False;
 428
 429         psd = *ppsd;
 430
 431         if(UNMARSHALLING(ps) && psd == NULL) {
 432                 if((psd = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
 433                         return False;
 434                 ZERO_STRUCTP(psd);
 435                 *ppsd = psd;
 436         }
 437
 438         prs_debug(ps, depth, desc, "sec_io_desc");
 439         depth++;
 440
 441         if(!prs_align(ps))
 442                 return False;
 443
 444         /* start of security descriptor stored for back-calc offset purposes */
 445         old_offset = prs_offset(ps);
 446
 447         if(!prs_uint16("revision ", ps, depth, &psd->revision))
 448                 return False;
 449
 450         if(!prs_uint16("type     ", ps, depth, &psd->type))
 451                 return False;
 452
 453         if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid))
 454                 return False;
 455
 456         if(!prs_uint32("off_grp_sid  ", ps, depth, &psd->off_grp_sid))
 457                 return False;
 458
 459         if(!prs_uint32("off_sacl     ", ps, depth, &psd->off_sacl))
 460                 return False;
 461
 462         if(!prs_uint32("off_dacl     ", ps, depth, &psd->off_dacl))
 463                 return False;
 464
 465         max_offset = MAX(max_offset, prs_offset(ps));
 466
 467         if (psd->off_owner_sid != 0) {
 468
 469                 if (UNMARSHALLING(ps)) {
 470                         if(!prs_set_offset(ps, old_offset + psd->off_owner_sid))
 471                                 return False;
 472                         /* reading */
 473                         if((psd->owner_sid = malloc(sizeof(*psd->owner_sid))) == NULL)
 474                                 return False;
 475                         ZERO_STRUCTP(psd->owner_sid);
 476                 }
 477
 478                 if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
 479                         return False;
 480                 if(!prs_align(ps))
 481                         return False;
 482         }
 483
 484         max_offset = MAX(max_offset, prs_offset(ps));
 485
 486         if (psd->off_grp_sid != 0) {
 487
 488                 if (UNMARSHALLING(ps)) {
 489                         /* reading */
 490                         if(!prs_set_offset(ps, old_offset + psd->off_grp_sid))
 491                                 return False;
 492                         if((psd->grp_sid = malloc(sizeof(*psd->grp_sid))) == NULL)
 493                                 return False;
 494                         ZERO_STRUCTP(psd->grp_sid);
 495                 }
 496
 497                 if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth))
 498                         return False;
 499                 if(!prs_align(ps))
 500                         return False;
 501         }
 502
 503         max_offset = MAX(max_offset, prs_offset(ps));
 504
 505         if (IS_BITS_SET_ALL(psd->type, SEC_DESC_SACL_PRESENT) && psd->off_sacl) {
 506                 if(!prs_set_offset(ps, old_offset + psd->off_sacl))
 507                         return False;
 508                 if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
 509                         return False;
 510                 if(!prs_align(ps))
 511                         return False;
 512         }
 513
 514         max_offset = MAX(max_offset, prs_offset(ps));
 515
 516         if (IS_BITS_SET_ALL(psd->type, SEC_DESC_DACL_PRESENT) && psd->off_dacl != 0) {
 517                 if(!prs_set_offset(ps, old_offset + psd->off_dacl))
 518                         return False;
 519                 if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
 520                         return False;
 521                 if(!prs_align(ps))
 522                         return False;
 523         }
 524
 525         max_offset = MAX(max_offset, prs_offset(ps));
 526
 527         if(!prs_set_offset(ps, max_offset))
 528                 return False;
 529         return True;
 530 }
 531
 532 /*******************************************************************
 533  Creates a SEC_DESC_BUF structure.
 534 ********************************************************************/
 535
 536 SEC_DESC_BUF *make_sec_desc_buf(size_t len, SEC_DESC *sec_desc)
 537 {
 538         SEC_DESC_BUF *dst;
 539
 540         if((dst = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
 541                 return NULL;
 542
 543         ZERO_STRUCTP(dst);
 544
 545         /* max buffer size (allocated size) */
 546         dst->max_len = (uint32)len;
 547         dst->len = (uint32)len;
 548
 549         if(sec_desc && ((dst->sec = dup_sec_desc(sec_desc)) == NULL)) {
 550                 free_sec_desc_buf(&dst);
 551                 return NULL;
 552         }
 553
 554         return dst;
 555 }
 556
 557 /*******************************************************************
 558  Duplicates a SEC_DESC_BUF structure.
 559 ********************************************************************/
 560
 561 SEC_DESC_BUF *dup_sec_desc_buf(SEC_DESC_BUF *src)
 562 {
 563         if(src == NULL)
 564                 return NULL;
 565
 566         return make_sec_desc_buf( src->len, src->sec);
 567 }
 568
 569 /*******************************************************************
 570  Deletes a SEC_DESC_BUF structure.
 571 ********************************************************************/
 572
 573 void free_sec_desc_buf(SEC_DESC_BUF **ppsdb)
 574 {
 575         SEC_DESC_BUF *psdb;
 576
 577         if(ppsdb == NULL || *ppsdb == NULL)
 578                 return;
 579
 580         psdb = *ppsdb;
 581         free_sec_desc(&psdb->sec);
 582         free(psdb);
 583         *ppsdb = NULL;
 584 }
 585
 586
 587 /*******************************************************************
 588  Reads or writes a SEC_DESC_BUF structure.
 589 ********************************************************************/
 590
 591 BOOL sec_io_desc_buf(char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
 592 {
 593         uint32 off_len;
 594         uint32 off_max_len;
 595         uint32 old_offset;
 596         uint32 size;
 597         SEC_DESC_BUF *psdb;
 598
 599         if (ppsdb == NULL)
 600                 return False;
 601
 602         psdb = *ppsdb;
 603
 604         if (UNMARSHALLING(ps) && psdb == NULL) {
 605                 if((psdb = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
 606                         return False;
 607                 ZERO_STRUCTP(psdb);
 608                 *ppsdb = psdb;
 609         }
 610
 611         prs_debug(ps, depth, desc, "sec_io_desc_buf");
 612         depth++;
 613
 614         if(!prs_align(ps))
 615                 return False;
 616
 617         if(!prs_uint32_pre("max_len", ps, depth, &psdb->max_len, &off_max_len))
 618                 return False;
 619
 620         if(!prs_uint32    ("undoc  ", ps, depth, &psdb->undoc))
 621                 return False;
 622
 623         if(!prs_uint32_pre("len    ", ps, depth, &psdb->len, &off_len))
 624                 return False;
 625
 626         old_offset = prs_offset(ps);
 627
 628         /* reading, length is non-zero; writing, descriptor is non-NULL */
 629         if ((psdb->len != 0 || MARSHALLING(ps)) && psdb->sec != NULL) {
 630                 if(!sec_io_desc("sec   ", &psdb->sec, ps, depth))
 631                         return False;
 632         }
 633
 634         if(!prs_align(ps))
 635                 return False;
 636
 637         size = prs_offset(ps) - old_offset;
 638         if(!prs_uint32_post("max_len", ps, depth, &psdb->max_len, off_max_len, size == 0 ? psdb->max_len : size))
 639                 return False;
 640
 641         if(!prs_uint32_post("len    ", ps, depth, &psdb->len, off_len, size))
 642                 return False;
 643
 644         return True;
 645 }