source/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 #include "includes.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_RPC_PARSE
  29
  30 /*******************************************************************
  31  Sets up a SEC_ACCESS structure.
  32 ********************************************************************/
  33
  34 void init_sec_access(SEC_ACCESS *t, uint32 mask)
  35 {
  36         t->mask = mask;
  37 }
  38
  39 /*******************************************************************
  40  Reads or writes a SEC_ACCESS structure.
  41 ********************************************************************/
  42
  43 BOOL sec_io_access(const char *desc, SEC_ACCESS *t, prs_struct *ps, int depth)
  44 {
  45         if (t == NULL)
  46                 return False;
  47
  48         prs_debug(ps, depth, desc, "sec_io_access");
  49         depth++;
  50
  51         if(!prs_uint32("mask", ps, depth, &(t->mask)))
  52                 return False;
  53
  54         return True;
  55 }
  56
  57 /*******************************************************************
  58  Check if ACE has OBJECT type.
  59 ********************************************************************/
  60
  61 BOOL sec_ace_object(uint8 type)
  62 {
  63         if (type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT ||
  64             type == SEC_ACE_TYPE_ACCESS_DENIED_OBJECT ||
  65             type == SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT ||
  66             type == SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT) {
  67                 return True;
  68         }
  69         return False;
  70 }
  71
  72 /*******************************************************************
  73  copy a SEC_ACE structure.
  74 ********************************************************************/
  75 void sec_ace_copy(SEC_ACE *ace_dest, SEC_ACE *ace_src)
  76 {
  77         ace_dest->type  = ace_src->type;
  78         ace_dest->flags = ace_src->flags;
  79         ace_dest->size  = ace_src->size;
  80         ace_dest->info.mask = ace_src->info.mask;
  81         ace_dest->obj_flags = ace_src->obj_flags;
  82         memcpy(&ace_dest->obj_guid, &ace_src->obj_guid, GUID_SIZE);
  83         memcpy(&ace_dest->inh_guid, &ace_src->inh_guid, GUID_SIZE);
  84         sid_copy(&ace_dest->trustee, &ace_src->trustee);
  85 }
  86
  87 /*******************************************************************
  88  Sets up a SEC_ACE structure.
  89 ********************************************************************/
  90
  91 void init_sec_ace(SEC_ACE *t, DOM_SID *sid, uint8 type, SEC_ACCESS mask, uint8 flag)
  92 {
  93         t->type = type;
  94         t->flags = flag;
  95         t->size = sid_size(sid) + 8;
  96         t->info = mask;
  97
  98         ZERO_STRUCTP(&t->trustee);
  99         sid_copy(&t->trustee, sid);
 100 }
 101
 102 /*******************************************************************
 103  Reads or writes a SEC_ACE structure.
 104 ********************************************************************/
 105
 106 BOOL sec_io_ace(const char *desc, SEC_ACE *psa, prs_struct *ps, int depth)
 107 {
 108         uint32 old_offset;
 109         uint32 offset_ace_size;
 110
 111         if (psa == NULL)
 112                 return False;
 113
 114         prs_debug(ps, depth, desc, "sec_io_ace");
 115         depth++;
 116
 117         old_offset = prs_offset(ps);
 118
 119         if(!prs_uint8("type ", ps, depth, &psa->type))
 120                 return False;
 121
 122         if(!prs_uint8("flags", ps, depth, &psa->flags))
 123                 return False;
 124
 125         if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size))
 126                 return False;
 127
 128         if(!sec_io_access("info ", &psa->info, ps, depth))
 129                 return False;
 130
 131         /* check whether object access is present */
 132         if (!sec_ace_object(psa->type)) {
 133                 if (!smb_io_dom_sid("trustee  ", &psa->trustee , ps, depth))
 134                         return False;
 135         } else {
 136                 if (!prs_uint32("obj_flags", ps, depth, &psa->obj_flags))
 137                         return False;
 138
 139                 if (psa->obj_flags & SEC_ACE_OBJECT_PRESENT)
 140                         if (!prs_uint8s(False, "obj_guid", ps, depth, psa->obj_guid.info, GUID_SIZE))
 141                                 return False;
 142
 143                 if (psa->obj_flags & SEC_ACE_OBJECT_INHERITED_PRESENT)
 144                         if (!prs_uint8s(False, "inh_guid", ps, depth, psa->inh_guid.info, GUID_SIZE))
 145                                 return False;
 146
 147                 if(!smb_io_dom_sid("trustee  ", &psa->trustee , ps, depth))
 148                         return False;
 149         }
 150
 151         if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset))
 152                 return False;
 153         return True;
 154 }
 155
 156 /*******************************************************************
 157  adds new SID with its permissions to ACE list
 158 ********************************************************************/
 159
 160 NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, SEC_ACE **new, SEC_ACE *old, unsigned *num, DOM_SID *sid, uint32 mask)
 161 {
 162         int i = 0;
 163
 164         if (!ctx || !new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
 165
 166         *num += 1;
 167
 168         if((new[0] = (SEC_ACE *) talloc_zero(ctx, (*num) * sizeof(SEC_ACE))) == 0)
 169                 return NT_STATUS_NO_MEMORY;
 170
 171         for (i = 0; i < *num - 1; i ++)
 172                 sec_ace_copy(&(*new)[i], &old[i]);
 173
 174         (*new)[i].type  = 0;
 175         (*new)[i].flags = 0;
 176         (*new)[i].size  = SEC_ACE_HEADER_SIZE + sid_size(sid);
 177         (*new)[i].info.mask = mask;
 178         sid_copy(&(*new)[i].trustee, sid);
 179         return NT_STATUS_OK;
 180 }
 181
 182 /*******************************************************************
 183   modify SID's permissions at ACL
 184 ********************************************************************/
 185
 186 NTSTATUS sec_ace_mod_sid(SEC_ACE *ace, size_t num, DOM_SID *sid, uint32 mask)
 187 {
 188         int i = 0;
 189
 190         if (!ace || !sid)  return NT_STATUS_INVALID_PARAMETER;
 191
 192         for (i = 0; i < num; i ++) {
 193                 if (sid_compare(&ace[i].trustee, sid) == 0) {
 194                         ace[i].info.mask = mask;
 195                         return NT_STATUS_OK;
 196                 }
 197         }
 198         return NT_STATUS_NOT_FOUND;
 199 }
 200
 201 /*******************************************************************
 202  delete SID from ACL
 203 ********************************************************************/
 204
 205 NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, SEC_ACE **new, SEC_ACE *old, size_t *num, DOM_SID *sid)
 206 {
 207         int i     = 0;
 208         int n_del = 0;
 209
 210         if (!ctx || !new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
 211
 212         if((new[0] = (SEC_ACE *) talloc_zero(ctx, *num * sizeof(SEC_ACE))) == 0)
 213                 return NT_STATUS_NO_MEMORY;
 214
 215         for (i = 0; i < *num; i ++) {
 216                 if (sid_compare(&old[i].trustee, sid) != 0)
 217                         sec_ace_copy(&(*new)[i], &old[i]);
 218                 else
 219                         n_del ++;
 220         }
 221         if (n_del == 0)
 222                 return NT_STATUS_NOT_FOUND;
 223         else {
 224                 *num -= n_del;
 225                 return NT_STATUS_OK;
 226         }
 227 }
 228
 229 /*******************************************************************
 230  Create a SEC_ACL structure.
 231 ********************************************************************/
 232
 233 SEC_ACL *make_sec_acl(TALLOC_CTX *ctx, uint16 revision, int num_aces, SEC_ACE *ace_list)
 234 {
 235         SEC_ACL *dst;
 236         int i;
 237
 238         if((dst = (SEC_ACL *)talloc_zero(ctx,sizeof(SEC_ACL))) == NULL)
 239                 return NULL;
 240
 241         dst->revision = revision;
 242         dst->num_aces = num_aces;
 243         dst->size = SEC_ACL_HEADER_SIZE;
 244
 245         /* Now we need to return a non-NULL address for the ace list even
 246            if the number of aces required is zero.  This is because there
 247            is a distinct difference between a NULL ace and an ace with zero
 248            entries in it.  This is achieved by checking that num_aces is a
 249            positive number. */
 250
 251         if ((num_aces) &&
 252             ((dst->ace = (SEC_ACE *)talloc(ctx, sizeof(SEC_ACE) * num_aces))
 253              == NULL)) {
 254                 return NULL;
 255         }
 256
 257         for (i = 0; i < num_aces; i++) {
 258                 dst->ace[i] = ace_list[i]; /* Structure copy. */
 259                 dst->size += ace_list[i].size;
 260         }
 261
 262         return dst;
 263 }
 264
 265 /*******************************************************************
 266  Duplicate a SEC_ACL structure.
 267 ********************************************************************/
 268
 269 SEC_ACL *dup_sec_acl(TALLOC_CTX *ctx, SEC_ACL *src)
 270 {
 271         if(src == NULL)
 272                 return NULL;
 273
 274         return make_sec_acl(ctx, src->revision, src->num_aces, src->ace);
 275 }
 276
 277 /*******************************************************************
 278  Reads or writes a SEC_ACL structure.
 279
 280  First of the xx_io_xx functions that allocates its data structures
 281  for you as it reads them.
 282 ********************************************************************/
 283
 284 BOOL sec_io_acl(const char *desc, SEC_ACL **ppsa, prs_struct *ps, int depth)
 285 {
 286         int i;
 287         uint32 old_offset;
 288         uint32 offset_acl_size;
 289         SEC_ACL *psa;
 290
 291         /*
 292          * Note that the size is always a multiple of 4 bytes due to the
 293          * nature of the data structure.  Therefore the prs_align() calls
 294          * have been removed as they through us off when doing two-layer
 295          * marshalling such as in the printing code (NEW_BUFFER).  --jerry
 296          */
 297
 298         if (ppsa == NULL)
 299                 return False;
 300
 301         psa = *ppsa;
 302
 303         if(UNMARSHALLING(ps) && psa == NULL) {
 304                 /*
 305                  * This is a read and we must allocate the stuct to read into.
 306                  */
 307                 if((psa = (SEC_ACL *)prs_alloc_mem(ps, sizeof(SEC_ACL))) == NULL)
 308                         return False;
 309                 *ppsa = psa;
 310         }
 311
 312         prs_debug(ps, depth, desc, "sec_io_acl");
 313         depth++;
 314
 315         old_offset = prs_offset(ps);
 316
 317         if(!prs_uint16("revision", ps, depth, &psa->revision))
 318                 return False;
 319
 320         if(!prs_uint16_pre("size     ", ps, depth, &psa->size, &offset_acl_size))
 321                 return False;
 322
 323         if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces))
 324                 return False;
 325
 326         if (UNMARSHALLING(ps)) {
 327                 /*
 328                  * Even if the num_aces is zero, allocate memory as there's a difference
 329                  * between a non-present DACL (allow all access) and a DACL with no ACE's
 330                  * (allow no access).
 331                  */
 332                 if((psa->ace = (SEC_ACE *)prs_alloc_mem(ps,sizeof(psa->ace[0]) * (psa->num_aces+1))) == NULL)
 333                         return False;
 334         }
 335
 336         for (i = 0; i < psa->num_aces; i++) {
 337                 fstring tmp;
 338                 slprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i);
 339                 if(!sec_io_ace(tmp, &psa->ace[i], ps, depth))
 340                         return False;
 341         }
 342
 343         if(!prs_uint16_post("size     ", ps, depth, &psa->size, offset_acl_size, old_offset))
 344                 return False;
 345
 346         return True;
 347 }
 348
 349 /*******************************************************************
 350  Works out the linearization size of a SEC_DESC.
 351 ********************************************************************/
 352
 353 size_t sec_desc_size(SEC_DESC *psd)
 354 {
 355         size_t offset;
 356
 357         if (!psd) return 0;
 358
 359         offset = SEC_DESC_HEADER_SIZE;
 360
 361         /* don't align */
 362
 363         if (psd->owner_sid != NULL)
 364                 offset += sid_size(psd->owner_sid);
 365
 366         if (psd->grp_sid != NULL)
 367                 offset += sid_size(psd->grp_sid);
 368
 369         if (psd->sacl != NULL)
 370                 offset += psd->sacl->size;
 371
 372         if (psd->dacl != NULL)
 373                 offset += psd->dacl->size;
 374
 375         return offset;
 376 }
 377
 378 /*******************************************************************
 379  Compares two SEC_ACE structures
 380 ********************************************************************/
 381
 382 BOOL sec_ace_equal(SEC_ACE *s1, SEC_ACE *s2)
 383 {
 384         /* Trivial case */
 385
 386         if (!s1 && !s2) return True;
 387
 388         /* Check top level stuff */
 389
 390         if (s1->type != s2->type || s1->flags != s2->flags ||
 391             s1->info.mask != s2->info.mask) {
 392                 return False;
 393         }
 394
 395         /* Check SID */
 396
 397         if (!sid_equal(&s1->trustee, &s2->trustee)) {
 398                 return False;
 399         }
 400
 401         return True;
 402 }
 403
 404 /*******************************************************************
 405  Compares two SEC_ACL structures
 406 ********************************************************************/
 407
 408 BOOL sec_acl_equal(SEC_ACL *s1, SEC_ACL *s2)
 409 {
 410         int i, j;
 411
 412         /* Trivial cases */
 413
 414         if (!s1 && !s2) return True;
 415         if (!s1 || !s2) return False;
 416
 417         /* Check top level stuff */
 418
 419         if (s1->revision != s2->revision) {
 420                 DEBUG(10, ("sec_acl_equal(): revision differs (%d != %d)\n",
 421                            s1->revision, s2->revision));
 422                 return False;
 423         }
 424
 425         if (s1->num_aces != s2->num_aces) {
 426                 DEBUG(10, ("sec_acl_equal(): num_aces differs (%d != %d)\n",
 427                            s1->revision, s2->revision));
 428                 return False;
 429         }
 430
 431         /* The ACEs could be in any order so check each ACE in s1 against
 432            each ACE in s2. */
 433
 434         for (i = 0; i < s1->num_aces; i++) {
 435                 BOOL found = False;
 436
 437                 for (j = 0; j < s2->num_aces; j++) {
 438                         if (sec_ace_equal(&s1->ace[i], &s2->ace[j])) {
 439                                 found = True;
 440                                 break;
 441                         }
 442                 }
 443
 444                 if (!found) return False;
 445         }
 446
 447         return True;
 448 }
 449
 450 /*******************************************************************
 451  Compares two SEC_DESC structures
 452 ********************************************************************/
 453
 454 BOOL sec_desc_equal(SEC_DESC *s1, SEC_DESC *s2)
 455 {
 456         /* Trivial case */
 457
 458         if (!s1 && !s2) {
 459                 goto done;
 460         }
 461
 462         /* Check top level stuff */
 463
 464         if (s1->revision != s2->revision) {
 465                 DEBUG(10, ("sec_desc_equal(): revision differs (%d != %d)\n",
 466                            s1->revision, s2->revision));
 467                 return False;
 468         }
 469
 470         if (s1->type!= s2->type) {
 471                 DEBUG(10, ("sec_desc_equal(): type differs (%d != %d)\n",
 472                            s1->type, s2->type));
 473                 return False;
 474         }
 475
 476         /* Check owner and group */
 477
 478         if (!sid_equal(s1->owner_sid, s2->owner_sid)) {
 479                 fstring str1, str2;
 480
 481                 sid_to_string(str1, s1->owner_sid);
 482                 sid_to_string(str2, s2->owner_sid);
 483
 484                 DEBUG(10, ("sec_desc_equal(): owner differs (%s != %s)\n",
 485                            str1, str2));
 486                 return False;
 487         }
 488
 489         if (!sid_equal(s1->grp_sid, s2->grp_sid)) {
 490                 fstring str1, str2;
 491
 492                 sid_to_string(str1, s1->grp_sid);
 493                 sid_to_string(str2, s2->grp_sid);
 494
 495                 DEBUG(10, ("sec_desc_equal(): group differs (%s != %s)\n",
 496                            str1, str2));
 497                 return False;
 498         }
 499
 500         /* Check ACLs present in one but not the other */
 501
 502         if ((s1->dacl && !s2->dacl) || (!s1->dacl && s2->dacl) ||
 503             (s1->sacl && !s2->sacl) || (!s1->sacl && s2->sacl)) {
 504                 DEBUG(10, ("sec_desc_equal(): dacl or sacl not present\n"));
 505                 return False;
 506         }
 507
 508         /* Sigh - we have to do it the hard way by iterating over all
 509            the ACEs in the ACLs */
 510
 511         if (!sec_acl_equal(s1->dacl, s2->dacl) ||
 512             !sec_acl_equal(s1->sacl, s2->sacl)) {
 513                 DEBUG(10, ("sec_desc_equal(): dacl/sacl list not equal\n"));
 514                 return False;
 515         }
 516
 517  done:
 518         DEBUG(10, ("sec_desc_equal(): secdescs are identical\n"));
 519         return True;
 520 }
 521
 522 /*******************************************************************
 523  Merge part of security descriptor old_sec in to the empty sections of
 524  security descriptor new_sec.
 525 ********************************************************************/
 526
 527 SEC_DESC_BUF *sec_desc_merge(TALLOC_CTX *ctx, SEC_DESC_BUF *new_sdb, SEC_DESC_BUF *old_sdb)
 528 {
 529         DOM_SID *owner_sid, *group_sid;
 530         SEC_DESC_BUF *return_sdb;
 531         SEC_ACL *dacl, *sacl;
 532         SEC_DESC *psd = NULL;
 533         uint16 secdesc_type;
 534         size_t secdesc_size;
 535
 536         /* Copy over owner and group sids.  There seems to be no flag for
 537            this so just check the pointer values. */
 538
 539         owner_sid = new_sdb->sec->owner_sid ? new_sdb->sec->owner_sid :
 540                 old_sdb->sec->owner_sid;
 541
 542         group_sid = new_sdb->sec->grp_sid ? new_sdb->sec->grp_sid :
 543                 old_sdb->sec->grp_sid;
 544
 545         secdesc_type = new_sdb->sec->type;
 546
 547         /* Ignore changes to the system ACL.  This has the effect of making
 548            changes through the security tab audit button not sticking.
 549            Perhaps in future Samba could implement these settings somehow. */
 550
 551         sacl = NULL;
 552         secdesc_type &= ~SEC_DESC_SACL_PRESENT;
 553
 554         /* Copy across discretionary ACL */
 555
 556         if (secdesc_type & SEC_DESC_DACL_PRESENT) {
 557                 dacl = new_sdb->sec->dacl;
 558         } else {
 559                 dacl = old_sdb->sec->dacl;
 560         }
 561
 562         /* Create new security descriptor from bits */
 563
 564         psd = make_sec_desc(ctx, new_sdb->sec->revision,
 565                             owner_sid, group_sid, sacl, dacl, &secdesc_size);
 566
 567         return_sdb = make_sec_desc_buf(ctx, secdesc_size, psd);
 568
 569         return(return_sdb);
 570 }
 571
 572 /*******************************************************************
 573  Creates a SEC_DESC structure
 574 ********************************************************************/
 575
 576 SEC_DESC *make_sec_desc(TALLOC_CTX *ctx, uint16 revision,
 577                         DOM_SID *owner_sid, DOM_SID *grp_sid,
 578                         SEC_ACL *sacl, SEC_ACL *dacl, size_t *sd_size)
 579 {
 580         SEC_DESC *dst;
 581         uint32 offset     = 0;
 582         uint32 offset_sid = SEC_DESC_HEADER_SIZE;
 583         uint32 offset_acl = 0;
 584
 585         *sd_size = 0;
 586
 587         if(( dst = (SEC_DESC *)talloc_zero(ctx, sizeof(SEC_DESC))) == NULL)
 588                 return NULL;
 589
 590         dst->revision = revision;
 591         dst->type     = SEC_DESC_SELF_RELATIVE;
 592
 593         if (sacl) dst->type |= SEC_DESC_SACL_PRESENT;
 594         if (dacl) dst->type |= SEC_DESC_DACL_PRESENT;
 595
 596         dst->off_owner_sid = 0;
 597         dst->off_grp_sid   = 0;
 598         dst->off_sacl      = 0;
 599         dst->off_dacl      = 0;
 600
 601         if(owner_sid && ((dst->owner_sid = sid_dup_talloc(ctx,owner_sid)) == NULL))
 602                 goto error_exit;
 603
 604         if(grp_sid && ((dst->grp_sid = sid_dup_talloc(ctx,grp_sid)) == NULL))
 605                 goto error_exit;
 606
 607         if(sacl && ((dst->sacl = dup_sec_acl(ctx, sacl)) == NULL))
 608                 goto error_exit;
 609
 610         if(dacl && ((dst->dacl = dup_sec_acl(ctx, dacl)) == NULL))
 611                 goto error_exit;
 612
 613         offset = 0;
 614
 615         /*
 616          * Work out the linearization sizes.
 617          */
 618         if (dst->owner_sid != NULL) {
 619
 620                 if (offset == 0)
 621                         offset = SEC_DESC_HEADER_SIZE;
 622
 623                 offset += sid_size(dst->owner_sid);
 624         }
 625
 626         if (dst->grp_sid != NULL) {
 627
 628                 if (offset == 0)
 629                         offset = SEC_DESC_HEADER_SIZE;
 630
 631                 offset += sid_size(dst->grp_sid);
 632         }
 633
 634         if (dst->sacl != NULL) {
 635
 636                 offset_acl = SEC_DESC_HEADER_SIZE;
 637
 638                 dst->off_sacl  = offset_acl;
 639                 offset_acl    += dst->sacl->size;
 640                 offset        += dst->sacl->size;
 641                 offset_sid    += dst->sacl->size;
 642         }
 643
 644         if (dst->dacl != NULL) {
 645
 646                 if (offset_acl == 0)
 647                         offset_acl = SEC_DESC_HEADER_SIZE;
 648
 649                 dst->off_dacl  = offset_acl;
 650                 offset_acl    += dst->dacl->size;
 651                 offset        += dst->dacl->size;
 652                 offset_sid    += dst->dacl->size;
 653         }
 654
 655         *sd_size = (size_t)((offset == 0) ? SEC_DESC_HEADER_SIZE : offset);
 656
 657         if (dst->owner_sid != NULL)
 658                 dst->off_owner_sid = offset_sid;
 659
 660         /* sid_size() returns 0 if the sid is NULL so this is ok */
 661
 662         if (dst->grp_sid != NULL)
 663                 dst->off_grp_sid = offset_sid + sid_size(dst->owner_sid);
 664
 665         return dst;
 666
 667 error_exit:
 668
 669         *sd_size = 0;
 670         return NULL;
 671 }
 672
 673 /*******************************************************************
 674  Duplicate a SEC_DESC structure.
 675 ********************************************************************/
 676
 677 SEC_DESC *dup_sec_desc( TALLOC_CTX *ctx, SEC_DESC *src)
 678 {
 679         size_t dummy;
 680
 681         if(src == NULL)
 682                 return NULL;
 683
 684         return make_sec_desc( ctx, src->revision,
 685                                 src->owner_sid, src->grp_sid, src->sacl,
 686                                 src->dacl, &dummy);
 687 }
 688
 689 /*******************************************************************
 690  Creates a SEC_DESC structure with typical defaults.
 691 ********************************************************************/
 692
 693 SEC_DESC *make_standard_sec_desc(TALLOC_CTX *ctx, DOM_SID *owner_sid, DOM_SID *grp_sid,
 694                                  SEC_ACL *dacl, size_t *sd_size)
 695 {
 696         return make_sec_desc(ctx, SEC_DESC_REVISION,
 697                              owner_sid, grp_sid, NULL, dacl, sd_size);
 698 }
 699
 700 /*******************************************************************
 701  Reads or writes a SEC_DESC structure.
 702  If reading and the *ppsd = NULL, allocates the structure.
 703 ********************************************************************/
 704
 705 BOOL sec_io_desc(const char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
 706 {
 707         uint32 old_offset;
 708         uint32 max_offset = 0; /* after we're done, move offset to end */
 709         uint32 tmp_offset = 0;
 710
 711         SEC_DESC *psd;
 712
 713         if (ppsd == NULL)
 714                 return False;
 715
 716         psd = *ppsd;
 717
 718         if (psd == NULL) {
 719                 if(UNMARSHALLING(ps)) {
 720                         if((psd = (SEC_DESC *)prs_alloc_mem(ps,sizeof(SEC_DESC))) == NULL)
 721                                 return False;
 722                         *ppsd = psd;
 723                 } else {
 724                         /* Marshalling - just ignore. */
 725                         return True;
 726                 }
 727         }
 728
 729         prs_debug(ps, depth, desc, "sec_io_desc");
 730         depth++;
 731
 732 #if 0
 733         /*
 734          * if alignment is needed, should be done by the the
 735          * caller.  Not here.  This caused me problems when marshalling
 736          * printer info into a buffer.   --jerry
 737          */
 738         if(!prs_align(ps))
 739                 return False;
 740 #endif
 741
 742         /* start of security descriptor stored for back-calc offset purposes */
 743         old_offset = prs_offset(ps);
 744
 745         if(!prs_uint16("revision ", ps, depth, &psd->revision))
 746                 return False;
 747
 748         if(!prs_uint16("type     ", ps, depth, &psd->type))
 749                 return False;
 750
 751         if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid))
 752                 return False;
 753
 754         if(!prs_uint32("off_grp_sid  ", ps, depth, &psd->off_grp_sid))
 755                 return False;
 756
 757         if(!prs_uint32("off_sacl     ", ps, depth, &psd->off_sacl))
 758                 return False;
 759
 760         if(!prs_uint32("off_dacl     ", ps, depth, &psd->off_dacl))
 761                 return False;
 762
 763         max_offset = MAX(max_offset, prs_offset(ps));
 764
 765         if (psd->off_owner_sid != 0) {
 766
 767                 tmp_offset = prs_offset(ps);
 768                 if(!prs_set_offset(ps, old_offset + psd->off_owner_sid))
 769                         return False;
 770
 771                 if (UNMARSHALLING(ps)) {
 772                         /* reading */
 773                         if((psd->owner_sid = (DOM_SID *)prs_alloc_mem(ps,sizeof(*psd->owner_sid))) == NULL)
 774                                 return False;
 775                 }
 776
 777                 if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
 778                         return False;
 779
 780                 max_offset = MAX(max_offset, prs_offset(ps));
 781
 782                 if (!prs_set_offset(ps,tmp_offset))
 783                         return False;
 784         }
 785
 786         if (psd->off_grp_sid != 0) {
 787
 788                 tmp_offset = prs_offset(ps);
 789                 if(!prs_set_offset(ps, old_offset + psd->off_grp_sid))
 790                         return False;
 791
 792                 if (UNMARSHALLING(ps)) {
 793                         /* reading */
 794                         if((psd->grp_sid = (DOM_SID *)prs_alloc_mem(ps,sizeof(*psd->grp_sid))) == NULL)
 795                                 return False;
 796                 }
 797
 798                 if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth))
 799                         return False;
 800
 801                 max_offset = MAX(max_offset, prs_offset(ps));
 802
 803                 if (!prs_set_offset(ps,tmp_offset))
 804                         return False;
 805         }
 806
 807         if ((psd->type & SEC_DESC_SACL_PRESENT) && psd->off_sacl) {
 808                 tmp_offset = prs_offset(ps);
 809                 if(!prs_set_offset(ps, old_offset + psd->off_sacl))
 810                         return False;
 811                 if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
 812                         return False;
 813                 max_offset = MAX(max_offset, prs_offset(ps));
 814                 if (!prs_set_offset(ps,tmp_offset))
 815                         return False;
 816         }
 817
 818
 819         if ((psd->type & SEC_DESC_DACL_PRESENT) && psd->off_dacl != 0) {
 820                 tmp_offset = prs_offset(ps);
 821                 if(!prs_set_offset(ps, old_offset + psd->off_dacl))
 822                         return False;
 823                 if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
 824                         return False;
 825                 max_offset = MAX(max_offset, prs_offset(ps));
 826                 if (!prs_set_offset(ps,tmp_offset))
 827                         return False;
 828         }
 829
 830         if(!prs_set_offset(ps, max_offset))
 831                 return False;
 832         return True;
 833 }
 834
 835 /*******************************************************************
 836  Creates a SEC_DESC_BUF structure.
 837 ********************************************************************/
 838
 839 SEC_DESC_BUF *make_sec_desc_buf(TALLOC_CTX *ctx, size_t len, SEC_DESC *sec_desc)
 840 {
 841         SEC_DESC_BUF *dst;
 842
 843         if((dst = (SEC_DESC_BUF *)talloc_zero(ctx, sizeof(SEC_DESC_BUF))) == NULL)
 844                 return NULL;
 845
 846         /* max buffer size (allocated size) */
 847         dst->max_len = (uint32)len;
 848         dst->len = (uint32)len;
 849
 850         if(sec_desc && ((dst->sec = dup_sec_desc(ctx, sec_desc)) == NULL)) {
 851                 return NULL;
 852         }
 853
 854         dst->ptr = 0x1;
 855
 856         return dst;
 857 }
 858
 859 /*******************************************************************
 860  Duplicates a SEC_DESC_BUF structure.
 861 ********************************************************************/
 862
 863 SEC_DESC_BUF *dup_sec_desc_buf(TALLOC_CTX *ctx, SEC_DESC_BUF *src)
 864 {
 865         if(src == NULL)
 866                 return NULL;
 867
 868         return make_sec_desc_buf( ctx, src->len, src->sec);
 869 }
 870
 871 /*******************************************************************
 872  Reads or writes a SEC_DESC_BUF structure.
 873 ********************************************************************/
 874
 875 BOOL sec_io_desc_buf(const char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
 876 {
 877         uint32 off_len;
 878         uint32 off_max_len;
 879         uint32 old_offset;
 880         uint32 size;
 881         SEC_DESC_BUF *psdb;
 882
 883         if (ppsdb == NULL)
 884                 return False;
 885
 886         psdb = *ppsdb;
 887
 888         if (UNMARSHALLING(ps) && psdb == NULL) {
 889                 if((psdb = (SEC_DESC_BUF *)prs_alloc_mem(ps,sizeof(SEC_DESC_BUF))) == NULL)
 890                         return False;
 891                 *ppsdb = psdb;
 892         }
 893
 894         prs_debug(ps, depth, desc, "sec_io_desc_buf");
 895         depth++;
 896
 897         if(!prs_align(ps))
 898                 return False;
 899
 900         if(!prs_uint32_pre("max_len", ps, depth, &psdb->max_len, &off_max_len))
 901                 return False;
 902
 903         if(!prs_uint32    ("ptr  ", ps, depth, &psdb->ptr))
 904                 return False;
 905
 906         if(!prs_uint32_pre("len    ", ps, depth, &psdb->len, &off_len))
 907                 return False;
 908
 909         old_offset = prs_offset(ps);
 910
 911         /* reading, length is non-zero; writing, descriptor is non-NULL */
 912         if ((UNMARSHALLING(ps) && psdb->len != 0) || (MARSHALLING(ps) && psdb->sec != NULL)) {
 913                 if(!sec_io_desc("sec   ", &psdb->sec, ps, depth))
 914                         return False;
 915         }
 916
 917         if(!prs_align(ps))
 918                 return False;
 919
 920         size = prs_offset(ps) - old_offset;
 921         if(!prs_uint32_post("max_len", ps, depth, &psdb->max_len, off_max_len, size == 0 ? psdb->max_len : size))
 922                 return False;
 923
 924         if(!prs_uint32_post("len    ", ps, depth, &psdb->len, off_len, size))
 925                 return False;
 926
 927         return True;
 928 }
 929
 930 /*******************************************************************
 931  adds new SID with its permissions to SEC_DESC
 932 ********************************************************************/
 933
 934 NTSTATUS sec_desc_add_sid(TALLOC_CTX *ctx, SEC_DESC **psd, DOM_SID *sid, uint32 mask, size_t *sd_size)
 935 {
 936         SEC_DESC *sd   = 0;
 937         SEC_ACL  *dacl = 0;
 938         SEC_ACE  *ace  = 0;
 939         NTSTATUS  status;
 940
 941         *sd_size = 0;
 942
 943         if (!ctx || !psd || !sid || !sd_size)  return NT_STATUS_INVALID_PARAMETER;
 944
 945         status = sec_ace_add_sid(ctx, &ace, psd[0]->dacl->ace, &psd[0]->dacl->num_aces, sid, mask);
 946
 947         if (!NT_STATUS_IS_OK(status))
 948                 return status;
 949
 950         if (!(dacl = make_sec_acl(ctx, psd[0]->dacl->revision, psd[0]->dacl->num_aces, ace)))
 951                 return NT_STATUS_UNSUCCESSFUL;
 952
 953         if (!(sd = make_sec_desc(ctx, psd[0]->revision, psd[0]->owner_sid,
 954                 psd[0]->grp_sid, psd[0]->sacl, dacl, sd_size)))
 955                 return NT_STATUS_UNSUCCESSFUL;
 956
 957         *psd = sd;
 958          sd  = 0;
 959         return NT_STATUS_OK;
 960 }
 961
 962 /*******************************************************************
 963  modify SID's permissions at SEC_DESC
 964 ********************************************************************/
 965
 966 NTSTATUS sec_desc_mod_sid(SEC_DESC *sd, DOM_SID *sid, uint32 mask)
 967 {
 968         NTSTATUS status;
 969
 970         if (!sd || !sid) return NT_STATUS_INVALID_PARAMETER;
 971
 972         status = sec_ace_mod_sid(sd->dacl->ace, sd->dacl->num_aces, sid, mask);
 973
 974         if (!NT_STATUS_IS_OK(status))
 975                 return status;
 976
 977         return NT_STATUS_OK;
 978 }
 979
 980 /*******************************************************************
 981  delete SID from SEC_DESC
 982 ********************************************************************/
 983
 984 NTSTATUS sec_desc_del_sid(TALLOC_CTX *ctx, SEC_DESC **psd, DOM_SID *sid, size_t *sd_size)
 985 {
 986         SEC_DESC *sd   = 0;
 987         SEC_ACL  *dacl = 0;
 988         SEC_ACE  *ace  = 0;
 989         NTSTATUS  status;
 990
 991         *sd_size = 0;
 992
 993         if (!ctx || !psd[0] || !sid || !sd_size) return NT_STATUS_INVALID_PARAMETER;
 994
 995         status = sec_ace_del_sid(ctx, &ace, psd[0]->dacl->ace, &psd[0]->dacl->num_aces, sid);
 996
 997         if (!NT_STATUS_IS_OK(status))
 998                 return status;
 999
1000         if (!(dacl = make_sec_acl(ctx, psd[0]->dacl->revision, psd[0]->dacl->num_aces, ace)))
1001                 return NT_STATUS_UNSUCCESSFUL;
1002
1003         if (!(sd = make_sec_desc(ctx, psd[0]->revision, psd[0]->owner_sid,
1004                 psd[0]->grp_sid, psd[0]->sacl, dacl, sd_size)))
1005                 return NT_STATUS_UNSUCCESSFUL;
1006
1007         *psd = sd;
1008          sd  = 0;
1009         return NT_STATUS_OK;
1010 }