source/lib/secace.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  SEC_ACE handling functions
   4  *  Copyright (C) Andrew Tridgell              1992-1998,
   5  *  Copyright (C) Jeremy R. Allison            1995-2003.
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
   7  *  Copyright (C) Paul Ashton                  1997-1998.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include "includes.h"
  25
  26 /*******************************************************************
  27  Check if ACE has OBJECT type.
  28 ********************************************************************/
  29
  30 BOOL sec_ace_object(uint8 type)
  31 {
  32         if (type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT ||
  33             type == SEC_ACE_TYPE_ACCESS_DENIED_OBJECT ||
  34             type == SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT ||
  35             type == SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT) {
  36                 return True;
  37         }
  38         return False;
  39 }
  40
  41 /*******************************************************************
  42  copy a SEC_ACE structure.
  43 ********************************************************************/
  44 void sec_ace_copy(SEC_ACE *ace_dest, SEC_ACE *ace_src)
  45 {
  46         ace_dest->type  = ace_src->type;
  47         ace_dest->flags = ace_src->flags;
  48         ace_dest->size  = ace_src->size;
  49         ace_dest->access_mask = ace_src->access_mask;
  50         ace_dest->obj_flags = ace_src->obj_flags;
  51         memcpy(&ace_dest->obj_guid, &ace_src->obj_guid, sizeof(struct GUID));
  52         memcpy(&ace_dest->inh_guid, &ace_src->inh_guid, sizeof(struct GUID));
  53         sid_copy(&ace_dest->trustee, &ace_src->trustee);
  54 }
  55
  56 /*******************************************************************
  57  Sets up a SEC_ACE structure.
  58 ********************************************************************/
  59
  60 void init_sec_ace(SEC_ACE *t, const DOM_SID *sid, uint8 type, SEC_ACCESS mask, uint8 flag)
  61 {
  62         t->type = type;
  63         t->flags = flag;
  64         t->size = sid_size(sid) + 8;
  65         t->access_mask = mask;
  66
  67         ZERO_STRUCTP(&t->trustee);
  68         sid_copy(&t->trustee, sid);
  69 }
  70
  71 /*******************************************************************
  72  adds new SID with its permissions to ACE list
  73 ********************************************************************/
  74
  75 NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, SEC_ACE **pp_new, SEC_ACE *old, unsigned *num, DOM_SID *sid, uint32 mask)
  76 {
  77         unsigned int i = 0;
  78
  79         if (!ctx || !pp_new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
  80
  81         *num += 1;
  82
  83         if((pp_new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
  84                 return NT_STATUS_NO_MEMORY;
  85
  86         for (i = 0; i < *num - 1; i ++)
  87                 sec_ace_copy(&(*pp_new)[i], &old[i]);
  88
  89         (*pp_new)[i].type  = 0;
  90         (*pp_new)[i].flags = 0;
  91         (*pp_new)[i].size  = SEC_ACE_HEADER_SIZE + sid_size(sid);
  92         (*pp_new)[i].access_mask = mask;
  93         sid_copy(&(*pp_new)[i].trustee, sid);
  94         return NT_STATUS_OK;
  95 }
  96
  97 /*******************************************************************
  98   modify SID's permissions at ACL
  99 ********************************************************************/
 100
 101 NTSTATUS sec_ace_mod_sid(SEC_ACE *ace, size_t num, DOM_SID *sid, uint32 mask)
 102 {
 103         unsigned int i = 0;
 104
 105         if (!ace || !sid)  return NT_STATUS_INVALID_PARAMETER;
 106
 107         for (i = 0; i < num; i ++) {
 108                 if (sid_compare(&ace[i].trustee, sid) == 0) {
 109                         ace[i].access_mask = mask;
 110                         return NT_STATUS_OK;
 111                 }
 112         }
 113         return NT_STATUS_NOT_FOUND;
 114 }
 115
 116 /*******************************************************************
 117  delete SID from ACL
 118 ********************************************************************/
 119
 120 NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, SEC_ACE **pp_new, SEC_ACE *old, uint32 *num, DOM_SID *sid)
 121 {
 122         unsigned int i     = 0;
 123         unsigned int n_del = 0;
 124
 125         if (!ctx || !pp_new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
 126
 127         if (*num) {
 128                 if((pp_new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
 129                         return NT_STATUS_NO_MEMORY;
 130         } else {
 131                 pp_new[0] = NULL;
 132         }
 133
 134         for (i = 0; i < *num; i ++) {
 135                 if (sid_compare(&old[i].trustee, sid) != 0)
 136                         sec_ace_copy(&(*pp_new)[i], &old[i]);
 137                 else
 138                         n_del ++;
 139         }
 140         if (n_del == 0)
 141                 return NT_STATUS_NOT_FOUND;
 142         else {
 143                 *num -= n_del;
 144                 return NT_STATUS_OK;
 145         }
 146 }
 147
 148 /*******************************************************************
 149  Compares two SEC_ACE structures
 150 ********************************************************************/
 151
 152 BOOL sec_ace_equal(SEC_ACE *s1, SEC_ACE *s2)
 153 {
 154         /* Trivial case */
 155
 156         if (!s1 && !s2) {
 157                 return True;
 158         }
 159
 160         if (!s1 || !s2) {
 161                 return False;
 162         }
 163
 164         /* Check top level stuff */
 165
 166         if (s1->type != s2->type || s1->flags != s2->flags ||
 167             s1->access_mask != s2->access_mask) {
 168                 return False;
 169         }
 170
 171         /* Check SID */
 172
 173         if (!sid_equal(&s1->trustee, &s2->trustee)) {
 174                 return False;
 175         }
 176
 177         return True;
 178 }
 179
 180 int nt_ace_inherit_comp( SEC_ACE *a1, SEC_ACE *a2)
 181 {
 182         int a1_inh = a1->flags & SEC_ACE_FLAG_INHERITED_ACE;
 183         int a2_inh = a2->flags & SEC_ACE_FLAG_INHERITED_ACE;
 184
 185         if (a1_inh == a2_inh)
 186                 return 0;
 187
 188         if (!a1_inh && a2_inh)
 189                 return -1;
 190         return 1;
 191 }
 192
 193 /*******************************************************************
 194   Comparison function to apply the order explained below in a group.
 195 *******************************************************************/
 196
 197 int nt_ace_canon_comp( SEC_ACE *a1, SEC_ACE *a2)
 198 {
 199         if ((a1->type == SEC_ACE_TYPE_ACCESS_DENIED) &&
 200                                 (a2->type != SEC_ACE_TYPE_ACCESS_DENIED))
 201                 return -1;
 202
 203         if ((a2->type == SEC_ACE_TYPE_ACCESS_DENIED) &&
 204                                 (a1->type != SEC_ACE_TYPE_ACCESS_DENIED))
 205                 return 1;
 206
 207         /* Both access denied or access allowed. */
 208
 209         /* 1. ACEs that apply to the object itself */
 210
 211         if (!(a1->flags & SEC_ACE_FLAG_INHERIT_ONLY) &&
 212                         (a2->flags & SEC_ACE_FLAG_INHERIT_ONLY))
 213                 return -1;
 214         else if (!(a2->flags & SEC_ACE_FLAG_INHERIT_ONLY) &&
 215                         (a1->flags & SEC_ACE_FLAG_INHERIT_ONLY))
 216                 return 1;
 217
 218         /* 2. ACEs that apply to a subobject of the object, such as
 219          * a property set or property. */
 220
 221         if (a1->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT) &&
 222                         !(a2->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT)))
 223                 return -1;
 224         else if (a2->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT) &&
 225                         !(a1->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT)))
 226                 return 1;
 227
 228         return 0;
 229 }
 230
 231 /*******************************************************************
 232  Functions to convert a SEC_DESC ACE DACL list into canonical order.
 233  JRA.
 234
 235 --- from http://msdn.microsoft.com/library/default.asp?url=/library/en-us/security/security/order_of_aces_in_a_dacl.asp
 236
 237 The following describes the preferred order:
 238
 239  To ensure that noninherited ACEs have precedence over inherited ACEs,
 240  place all noninherited ACEs in a group before any inherited ACEs.
 241  This ordering ensures, for example, that a noninherited access-denied ACE
 242  is enforced regardless of any inherited ACE that allows access.
 243
 244  Within the groups of noninherited ACEs and inherited ACEs, order ACEs according to ACE type, as the following shows:
 245         1. Access-denied ACEs that apply to the object itself
 246         2. Access-denied ACEs that apply to a subobject of the object, such as a property set or property
 247         3. Access-allowed ACEs that apply to the object itself
 248         4. Access-allowed ACEs that apply to a subobject of the object"
 249
 250 ********************************************************************/
 251
 252 void dacl_sort_into_canonical_order(SEC_ACE *srclist, unsigned int num_aces)
 253 {
 254         unsigned int i;
 255
 256         if (!srclist || num_aces == 0)
 257                 return;
 258
 259         /* Sort so that non-inherited ACE's come first. */
 260         qsort( srclist, num_aces, sizeof(srclist[0]), QSORT_CAST nt_ace_inherit_comp);
 261
 262         /* Find the boundary between non-inherited ACEs. */
 263         for (i = 0; i < num_aces; i++ ) {
 264                 SEC_ACE *curr_ace = &srclist[i];
 265
 266                 if (curr_ace->flags & SEC_ACE_FLAG_INHERITED_ACE)
 267                         break;
 268         }
 269
 270         /* i now points at entry number of the first inherited ACE. */
 271
 272         /* Sort the non-inherited ACEs. */
 273         if (i)
 274                 qsort( srclist, i, sizeof(srclist[0]), QSORT_CAST nt_ace_canon_comp);
 275
 276         /* Now sort the inherited ACEs. */
 277         if (num_aces - i)
 278                 qsort( &srclist[i], num_aces - i, sizeof(srclist[0]), QSORT_CAST nt_ace_canon_comp);
 279 }
 280
 281 /*******************************************************************
 282  Check if this ACE has a SID in common with the token.
 283 ********************************************************************/
 284
 285 BOOL token_sid_in_ace(const NT_USER_TOKEN *token, const SEC_ACE *ace)
 286 {
 287         size_t i;
 288
 289         for (i = 0; i < token->num_sids; i++) {
 290                 if (sid_equal(&ace->trustee, &token->user_sids[i]))
 291                         return True;
 292         }
 293
 294         return False;
 295 }