source3/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->object = ace_src->object;
  51         sid_copy(&ace_dest->trustee, &ace_src->trustee);
  52 }
  53
  54 /*******************************************************************
  55  Sets up a SEC_ACE structure.
  56 ********************************************************************/
  57
  58 void init_sec_ace(SEC_ACE *t, const DOM_SID *sid, uint8 type, uint32 mask, uint8 flag)
  59 {
  60         t->type = type;
  61         t->flags = flag;
  62         t->size = sid_size(sid) + 8;
  63         t->access_mask = mask;
  64
  65         ZERO_STRUCTP(&t->trustee);
  66         sid_copy(&t->trustee, sid);
  67 }
  68
  69 /*******************************************************************
  70  adds new SID with its permissions to ACE list
  71 ********************************************************************/
  72
  73 NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, SEC_ACE **pp_new, SEC_ACE *old, unsigned *num, DOM_SID *sid, uint32 mask)
  74 {
  75         unsigned int i = 0;
  76
  77         if (!ctx || !pp_new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
  78
  79         *num += 1;
  80
  81         if((pp_new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
  82                 return NT_STATUS_NO_MEMORY;
  83
  84         for (i = 0; i < *num - 1; i ++)
  85                 sec_ace_copy(&(*pp_new)[i], &old[i]);
  86
  87         (*pp_new)[i].type  = 0;
  88         (*pp_new)[i].flags = 0;
  89         (*pp_new)[i].size  = SEC_ACE_HEADER_SIZE + sid_size(sid);
  90         (*pp_new)[i].access_mask = mask;
  91         sid_copy(&(*pp_new)[i].trustee, sid);
  92         return NT_STATUS_OK;
  93 }
  94
  95 /*******************************************************************
  96   modify SID's permissions at ACL
  97 ********************************************************************/
  98
  99 NTSTATUS sec_ace_mod_sid(SEC_ACE *ace, size_t num, DOM_SID *sid, uint32 mask)
 100 {
 101         unsigned int i = 0;
 102
 103         if (!ace || !sid)  return NT_STATUS_INVALID_PARAMETER;
 104
 105         for (i = 0; i < num; i ++) {
 106                 if (sid_compare(&ace[i].trustee, sid) == 0) {
 107                         ace[i].access_mask = mask;
 108                         return NT_STATUS_OK;
 109                 }
 110         }
 111         return NT_STATUS_NOT_FOUND;
 112 }
 113
 114 /*******************************************************************
 115  delete SID from ACL
 116 ********************************************************************/
 117
 118 NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, SEC_ACE **pp_new, SEC_ACE *old, uint32 *num, DOM_SID *sid)
 119 {
 120         unsigned int i     = 0;
 121         unsigned int n_del = 0;
 122
 123         if (!ctx || !pp_new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
 124
 125         if((pp_new[0] = TALLOC_ZERO_ARRAY(ctx, SEC_ACE, *num )) == 0)
 126                 return NT_STATUS_NO_MEMORY;
 127
 128         for (i = 0; i < *num; i ++) {
 129                 if (sid_compare(&old[i].trustee, sid) != 0)
 130                         sec_ace_copy(&(*pp_new)[i], &old[i]);
 131                 else
 132                         n_del ++;
 133         }
 134         if (n_del == 0)
 135                 return NT_STATUS_NOT_FOUND;
 136         else {
 137                 *num -= n_del;
 138                 return NT_STATUS_OK;
 139         }
 140 }
 141
 142 /*******************************************************************
 143  Compares two SEC_ACE structures
 144 ********************************************************************/
 145
 146 BOOL sec_ace_equal(SEC_ACE *s1, SEC_ACE *s2)
 147 {
 148         /* Trivial case */
 149
 150         if (!s1 && !s2) {
 151                 return True;
 152         }
 153
 154         if (!s1 || !s2) {
 155                 return False;
 156         }
 157
 158         /* Check top level stuff */
 159
 160         if (s1->type != s2->type || s1->flags != s2->flags ||
 161             s1->access_mask != s2->access_mask) {
 162                 return False;
 163         }
 164
 165         /* Check SID */
 166
 167         if (!sid_equal(&s1->trustee, &s2->trustee)) {
 168                 return False;
 169         }
 170
 171         return True;
 172 }
 173
 174 int nt_ace_inherit_comp( SEC_ACE *a1, SEC_ACE *a2)
 175 {
 176         int a1_inh = a1->flags & SEC_ACE_FLAG_INHERITED_ACE;
 177         int a2_inh = a2->flags & SEC_ACE_FLAG_INHERITED_ACE;
 178
 179         if (a1_inh == a2_inh)
 180                 return 0;
 181
 182         if (!a1_inh && a2_inh)
 183                 return -1;
 184         return 1;
 185 }
 186
 187 /*******************************************************************
 188   Comparison function to apply the order explained below in a group.
 189 *******************************************************************/
 190
 191 int nt_ace_canon_comp( SEC_ACE *a1, SEC_ACE *a2)
 192 {
 193         if ((a1->type == SEC_ACE_TYPE_ACCESS_DENIED) &&
 194                                 (a2->type != SEC_ACE_TYPE_ACCESS_DENIED))
 195                 return -1;
 196
 197         if ((a2->type == SEC_ACE_TYPE_ACCESS_DENIED) &&
 198                                 (a1->type != SEC_ACE_TYPE_ACCESS_DENIED))
 199                 return 1;
 200
 201         /* Both access denied or access allowed. */
 202
 203         /* 1. ACEs that apply to the object itself */
 204
 205         if (!(a1->flags & SEC_ACE_FLAG_INHERIT_ONLY) &&
 206                         (a2->flags & SEC_ACE_FLAG_INHERIT_ONLY))
 207                 return -1;
 208         else if (!(a2->flags & SEC_ACE_FLAG_INHERIT_ONLY) &&
 209                         (a1->flags & SEC_ACE_FLAG_INHERIT_ONLY))
 210                 return 1;
 211
 212         /* 2. ACEs that apply to a subobject of the object, such as
 213          * a property set or property. */
 214
 215         if (a1->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT) &&
 216                         !(a2->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT)))
 217                 return -1;
 218         else if (a2->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT) &&
 219                         !(a1->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT)))
 220                 return 1;
 221
 222         return 0;
 223 }
 224
 225 /*******************************************************************
 226  Functions to convert a SEC_DESC ACE DACL list into canonical order.
 227  JRA.
 228
 229 --- from http://msdn.microsoft.com/library/default.asp?url=/library/en-us/security/security/order_of_aces_in_a_dacl.asp
 230
 231 The following describes the preferred order:
 232
 233  To ensure that noninherited ACEs have precedence over inherited ACEs,
 234  place all noninherited ACEs in a group before any inherited ACEs.
 235  This ordering ensures, for example, that a noninherited access-denied ACE
 236  is enforced regardless of any inherited ACE that allows access.
 237
 238  Within the groups of noninherited ACEs and inherited ACEs, order ACEs according to ACE type, as the following shows:
 239         1. Access-denied ACEs that apply to the object itself
 240         2. Access-denied ACEs that apply to a subobject of the object, such as a property set or property
 241         3. Access-allowed ACEs that apply to the object itself
 242         4. Access-allowed ACEs that apply to a subobject of the object"
 243
 244 ********************************************************************/
 245
 246 void dacl_sort_into_canonical_order(SEC_ACE *srclist, unsigned int num_aces)
 247 {
 248         unsigned int i;
 249
 250         if (!srclist || num_aces == 0)
 251                 return;
 252
 253         /* Sort so that non-inherited ACE's come first. */
 254         qsort( srclist, num_aces, sizeof(srclist[0]), QSORT_CAST nt_ace_inherit_comp);
 255
 256         /* Find the boundary between non-inherited ACEs. */
 257         for (i = 0; i < num_aces; i++ ) {
 258                 SEC_ACE *curr_ace = &srclist[i];
 259
 260                 if (curr_ace->flags & SEC_ACE_FLAG_INHERITED_ACE)
 261                         break;
 262         }
 263
 264         /* i now points at entry number of the first inherited ACE. */
 265
 266         /* Sort the non-inherited ACEs. */
 267         if (i)
 268                 qsort( srclist, i, sizeof(srclist[0]), QSORT_CAST nt_ace_canon_comp);
 269
 270         /* Now sort the inherited ACEs. */
 271         if (num_aces - i)
 272                 qsort( &srclist[i], num_aces - i, sizeof(srclist[0]), QSORT_CAST nt_ace_canon_comp);
 273 }
 274
 275 /*******************************************************************
 276  Check if this ACE has a SID in common with the token.
 277 ********************************************************************/
 278
 279 BOOL token_sid_in_ace(const NT_USER_TOKEN *token, const SEC_ACE *ace)
 280 {
 281         size_t i;
 282
 283         for (i = 0; i < token->num_sids; i++) {
 284                 if (sid_equal(&ace->trustee, &token->user_sids[i]))
 285                         return True;
 286         }
 287
 288         return False;
 289 }