source3/utils/profiles.c

   1 /*
   2    Samba Unix/Linux SMB client utility profiles.c
   3    Copyright (C) 2002 Richard Sharpe, rsharpe@richardsharpe.com
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 /*************************************************************************
  20
  21  A utility to report and change SIDs in registry files
  22
  23  Many of the ideas in here come from other people and software.
  24  I first looked in Wine in misc/registry.c and was also influenced by
  25  http://www.wednesday.demon.co.uk/dosreg.html
  26
  27  Which seems to contain comments from someone else. I reproduce them here
  28  incase the site above disappears. It actually comes from
  29  http://home.eunet.no/~pnordahl/ntpasswd/WinReg.txt.
  30
  31 The windows NT registry has 2 different blocks, where one can occure many
  32 times...
  33
  34 the "regf"-Block
  35 ================
  36
  37 "regf" is obviosly the abbreviation for "Registry file". "regf" is the
  38 signature of the header-block which is always 4kb in size, although only
  39 the first 64 bytes seem to be used and a checksum is calculated over
  40 the first 0x200 bytes only!
  41
  42 Offset            Size      Contents
  43 0x00000000      D-Word      ID: ASCII-"regf" = 0x66676572
  44 0x00000004      D-Word      ???? //see struct REGF
  45 0x00000008      D-Word      ???? Always the same value as at 0x00000004
  46 0x0000000C      Q-Word      last modify date in WinNT date-format
  47 0x00000014      D-Word      1
  48 0x00000018      D-Word      3
  49 0x0000001C      D-Word      0
  50 0x00000020      D-Word      1
  51 0x00000024      D-Word      Offset of 1st key record
  52 0x00000028      D-Word      Size of the data-blocks (Filesize-4kb)
  53 0x0000002C      D-Word      1
  54 0x000001FC      D-Word      Sum of all D-Words from 0x00000000 to
  55 0x000001FB  //XOR of all words. Nigel
  56
  57 I have analyzed more registry files (from multiple machines running
  58 NT 4.0 german version) and could not find an explanation for the values
  59 marked with ???? the rest of the first 4kb page is not important...
  60
  61 the "hbin"-Block
  62 ================
  63 I don't know what "hbin" stands for, but this block is always a multiple
  64 of 4kb in size.
  65
  66 Inside these hbin-blocks the different records are placed. The memory-
  67 management looks like a C-compiler heap management to me...
  68
  69 hbin-Header
  70 ===========
  71 Offset      Size      Contents
  72 0x0000      D-Word      ID: ASCII-"hbin" = 0x6E696268
  73 0x0004      D-Word      Offset from the 1st hbin-Block
  74 0x0008      D-Word      Offset to the next hbin-Block
  75 0x001C      D-Word      Block-size
  76
  77 The values in 0x0008 and 0x001C should be the same, so I don't know
  78 if they are correct or swapped...
  79
  80 From offset 0x0020 inside a hbin-block data is stored with the following
  81 format:
  82
  83 Offset      Size      Contents
  84 0x0000      D-Word      Data-block size    //this size must be a
  85 multiple of 8. Nigel
  86 0x0004      ????      Data
  87
  88 If the size field is negative (bit 31 set), the corresponding block
  89 is free and has a size of -blocksize!
  90
  91 The data is stored as one record per block. Block size is a multiple
  92 of 4 and the last block reaches the next hbin-block, leaving no room.
  93
  94 Records in the hbin-blocks
  95 ==========================
  96
  97 nk-Record
  98
  99       The nk-record can be treated as a kombination of tree-record and
 100       key-record of the win 95 registry.
 101
 102 lf-Record
 103
 104       The lf-record is the counterpart to the RGKN-record (the
 105       hash-function)
 106
 107 vk-Record
 108
 109       The vk-record consists information to a single value.
 110
 111 sk-Record
 112
 113       sk (? Security Key ?) is the ACL of the registry.
 114
 115 Value-Lists
 116
 117       The value-lists contain information about which values are inside a
 118       sub-key and don't have a header.
 119
 120 Datas
 121
 122       The datas of the registry are (like the value-list) stored without a
 123       header.
 124
 125 All offset-values are relative to the first hbin-block and point to the
 126 block-size field of the record-entry. to get the file offset, you have to add
 127 the header size (4kb) and the size field (4 bytes)...
 128
 129 the nk-Record
 130 =============
 131 Offset      Size      Contents
 132 0x0000      Word      ID: ASCII-"nk" = 0x6B6E
 133 0x0002      Word      for the root-key: 0x2C, otherwise 0x20  //key symbolic links 0x10. Nigel
 134 0x0004      Q-Word      write-date/time in windows nt notation
 135 0x0010      D-Word      Offset of Owner/Parent key
 136 0x0014      D-Word      number of sub-Keys
 137 0x001C      D-Word      Offset of the sub-key lf-Records
 138 0x0024      D-Word      number of values
 139 0x0028      D-Word      Offset of the Value-List
 140 0x002C      D-Word      Offset of the sk-Record
 141
 142 0x0030      D-Word      Offset of the Class-Name //see NK structure for the use of these fields. Nigel
 143 0x0044      D-Word      Unused (data-trash)  //some kind of run time index. Does not appear to be important. Nigel
 144 0x0048      Word      name-length
 145 0x004A      Word      class-name length
 146 0x004C      ????      key-name
 147
 148 the Value-List
 149 ==============
 150 Offset      Size      Contents
 151 0x0000      D-Word      Offset 1st Value
 152 0x0004      D-Word      Offset 2nd Value
 153 0x????      D-Word      Offset nth Value
 154
 155 To determine the number of values, you have to look at the owner-nk-record!
 156
 157 Der vk-Record
 158 =============
 159 Offset      Size      Contents
 160 0x0000      Word      ID: ASCII-"vk" = 0x6B76
 161 0x0002      Word      name length
 162 0x0004      D-Word      length of the data   //if top bit is set when offset contains data. Nigel
 163 0x0008      D-Word      Offset of Data
 164 0x000C      D-Word      Type of value
 165 0x0010      Word      Flag
 166 0x0012      Word      Unused (data-trash)
 167 0x0014      ????      Name
 168
 169 If bit 0 of the flag-word is set, a name is present, otherwise the value has no name (=default)
 170
 171 If the data-size is lower 5, the data-offset value is used to store the data itself!
 172
 173 The data-types
 174 ==============
 175 Wert      Beteutung
 176 0x0001      RegSZ:             character string (in UNICODE!)
 177 0x0002      ExpandSZ:   string with "%var%" expanding (UNICODE!)
 178 0x0003      RegBin:           raw-binary value
 179 0x0004      RegDWord:   Dword
 180 0x0007      RegMultiSZ:      multiple strings, seperated with 0
 181                   (UNICODE!)
 182
 183 The "lf"-record
 184 ===============
 185 Offset      Size      Contents
 186 0x0000      Word      ID: ASCII-"lf" = 0x666C
 187 0x0002      Word      number of keys
 188 0x0004      ????      Hash-Records
 189
 190 Hash-Record
 191 ===========
 192 Offset      Size      Contents
 193 0x0000      D-Word      Offset of corresponding "nk"-Record
 194 0x0004      D-Word      ASCII: the first 4 characters of the key-name, padded with 0's. Case sensitiv!
 195
 196 Keep in mind, that the value at 0x0004 is used for checking the data-consistency! If you change the
 197 key-name you have to change the hash-value too!
 198
 199 //These hashrecords must be sorted low to high within the lf record. Nigel.
 200
 201 The "sk"-block
 202 ==============
 203 (due to the complexity of the SAM-info, not clear jet)
 204
 205 Offset      Size      Contents
 206 0x0000      Word      ID: ASCII-"sk" = 0x6B73
 207 0x0002      Word      Unused
 208 0x0004      D-Word      Offset of previous "sk"-Record
 209 0x0008      D-Word      Offset of next "sk"-Record
 210 0x000C      D-Word      usage-counter
 211 0x0010      D-Word      Size of "sk"-record in bytes
 212 ????                                             //standard self
 213 relative security desciptor. Nigel
 214 ????  ????      Security and auditing settings...
 215 ????
 216
 217 The usage counter counts the number of references to this
 218 "sk"-record. You can use one "sk"-record for the entire registry!
 219
 220 Windows nt date/time format
 221 ===========================
 222 The time-format is a 64-bit integer which is incremented every
 223 0,0000001 seconds by 1 (I don't know how accurate it realy is!)
 224 It starts with 0 at the 1st of january 1601 0:00! All values are
 225 stored in GMT time! The time-zone is important to get the real
 226 time!
 227
 228 Common values for win95 and win-nt
 229 ==================================
 230 Offset values marking an "end of list", are either 0 or -1 (0xFFFFFFFF).
 231 If a value has no name (length=0, flag(bit 0)=0), it is treated as the
 232 "Default" entry...
 233 If a value has no data (length=0), it is displayed as empty.
 234
 235 simplyfied win-3.?? registry:
 236 =============================
 237
 238 +-----------+
 239 | next rec. |---+                      +----->+------------+
 240 | first sub |   |                      |      | Usage cnt. |
 241 | name      |   |  +-->+------------+  |      | length     |
 242 | value     |   |  |   | next rec.  |  |      | text       |------->+-------+
 243 +-----------+   |  |   | name rec.  |--+      +------------+        | xxxxx |
 244    +------------+  |   | value rec. |-------->+------------+        +-------+
 245    v               |   +------------+         | Usage cnt. |
 246 +-----------+      |                          | length     |
 247 | next rec. |      |                          | text       |------->+-------+
 248 | first sub |------+                          +------------+        | xxxxx |
 249 | name      |                                                       +-------+
 250 | value     |
 251 +-----------+
 252
 253 Greatly simplyfied structure of the nt-registry:
 254 ================================================
 255
 256 +---------------------------------------------------------------+
 257 |                                                               |
 258 v                                                               |
 259 +---------+     +---------->+-----------+  +----->+---------+   |
 260 | "nk"    |     |           | lf-rec.   |  |      | nk-rec. |   |
 261 | ID      |     |           | # of keys |  |      | parent  |---+
 262 | Date    |     |           | 1st key   |--+      | ....    |
 263 | parent  |     |           +-----------+         +---------+
 264 | suk-keys|-----+
 265 | values  |--------------------->+----------+
 266 | SK-rec. |---------------+      | 1. value |--> +----------+
 267 | class   |--+            |      +----------+    | vk-rec.  |
 268 +---------+  |            |                      | ....     |
 269              v            |                      | data     |--> +-------+
 270       +------------+      |                      +----------+    | xxxxx |
 271       | Class name |      |                                      +-------+
 272       +------------+      |
 273                           v
 274           +---------+    +---------+
 275    +----->| next sk |--->| Next sk |--+
 276    |  +---| prev sk |<---| prev sk |  |
 277    |  |   | ....    |    | ...     |  |
 278    |  |   +---------+    +---------+  |
 279    |  |         ^          |          |
 280       |         +----------+          |
 281       +-------------------------------+
 282
 283 ---------------------------------------------------------------------------
 284
 285 Hope this helps....  (Although it was "fun" for me to uncover this things,
 286                   it took me several sleepless nights ;)
 287
 288             B.D.
 289
 290 *************************************************************************/
 291 #include "includes.h"
 292 #include <stdio.h>
 293 #include <errno.h>
 294 #include <sys/types.h>
 295 #include <sys/stat.h>
 296 #include <unistd.h>
 297 #include <sys/mman.h>
 298
 299 typedef unsigned int DWORD;
 300 typedef unsigned short WORD;
 301
 302 #define REG_REGF_ID 0x66676572
 303
 304 typedef struct regf_block {
 305   DWORD REGF_ID;     /* regf */
 306   DWORD uk1;
 307   DWORD uk2;
 308   DWORD tim1, tim2;
 309   DWORD uk3;             /* 1 */
 310   DWORD uk4;             /* 3 */
 311   DWORD uk5;             /* 0 */
 312   DWORD uk6;             /* 1 */
 313   DWORD first_key;       /* offset */
 314   unsigned int dblk_size;
 315   DWORD uk7[116];        /* 1 */
 316   DWORD chksum;
 317 } REGF_HDR;
 318
 319 typedef struct hbin_sub_struct {
 320   DWORD dblocksize;
 321   char data[1];
 322 } HBIN_SUB_HDR;
 323
 324 #define REG_HBIN_ID 0x6E696268
 325
 326 typedef struct hbin_struct {
 327   DWORD HBIN_ID; /* hbin */
 328   DWORD next_off;
 329   DWORD prev_off;
 330   DWORD uk1;
 331   DWORD uk2;
 332   DWORD uk3;
 333   DWORD uk4;
 334   DWORD blk_size;
 335   HBIN_SUB_HDR hbin_sub_hdr;
 336 } HBIN_HDR;
 337
 338 #define REG_NK_ID 0x6B6E
 339
 340 typedef struct nk_struct {
 341   WORD NK_ID;
 342   WORD type;
 343   DWORD t1, t2;
 344   DWORD uk1;
 345   DWORD own_off;
 346   DWORD subk_num;
 347   DWORD uk2;
 348   DWORD lf_off;
 349   DWORD uk3;
 350   DWORD val_cnt;
 351   DWORD val_off;
 352   DWORD sk_off;
 353   DWORD clsnam_off;
 354 } NK_HDR;
 355
 356 #define REG_SK_ID 0x6B73
 357
 358 typedef struct sk_struct {
 359   WORD SK_ID;
 360   WORD uk1;
 361   DWORD prev_off;
 362   DWORD next_off;
 363   DWORD ref_cnt;
 364   DWORD rec_size;
 365   char sec_desc[1];
 366 } SK_HDR;
 367
 368 typedef struct sec_desc_rec {
 369   WORD rev;
 370   WORD type;
 371   DWORD owner_off;
 372   DWORD group_off;
 373   DWORD sacl_off;
 374   DWORD dacl_off;
 375 } MY_SEC_DESC;
 376
 377 typedef struct ace_struct {
 378     unsigned char type;
 379     unsigned char flags;
 380     unsigned short length;
 381     unsigned int perms;
 382     DOM_SID trustee;
 383 } ACE;
 384
 385 typedef struct acl_struct {
 386   WORD rev;
 387   WORD size;
 388   DWORD num_aces;
 389   ACE *aces;   /* One or more ACEs */
 390 } ACL;
 391
 392 #define OFF(f) (0x1000 + (f) + 4)
 393
 394 void print_sid(DOM_SID *sid);
 395
 396 int verbose = 1;
 397 DOM_SID old_sid, new_sid;
 398 int change = 0, new = 0;
 399
 400 /* Compare two SIDs for equality */
 401 int my_sid_equal(DOM_SID *s1, DOM_SID *s2)
 402 {
 403   int sa1, sa2;
 404
 405   if (s1->sid_rev_num != s2->sid_rev_num) return 0;
 406
 407   sa1 = s1->num_auths; sa2 = s2->num_auths;
 408
 409   if (sa1 != sa2) return 0;
 410
 411   return !bcmp((char *)&s1->id_auth, (char *)&s2->id_auth,
 412                 6 + sa1 * 4);
 413
 414 }
 415
 416 /*
 417  * Quick and dirty to read a SID in S-1-5-21-x-y-z-rid format and
 418  * construct a DOM_SID
 419  */
 420 int get_sid(DOM_SID *sid, char *sid_str)
 421 {
 422   int i = 0, auth;
 423   char *lstr;
 424
 425   if (strncmp(sid_str, "S-1-5", 5)) {
 426     fprintf(stderr, "Does not conform to S-1-5...: %s\n", sid_str);
 427     return 0;
 428   }
 429
 430   /* We only allow strings of form S-1-5... */
 431
 432   sid->sid_rev_num = 1;
 433   sid->id_auth[5] = 5;
 434
 435   lstr = sid_str + 5;
 436
 437   while (1) {
 438     if (!lstr || !lstr[0] || sscanf(lstr, "-%d", &auth) == 0) {
 439       if (i < 4) {
 440         fprintf(stderr, "Not of form -d-d...: %s, %u\n", lstr, i);
 441         return 0;
 442       }
 443       sid->num_auths=i;
 444       print_sid(sid);
 445       return 1;
 446     }
 447
 448     sid->sub_auths[i++] = auth;
 449     lstr = strchr(lstr + 1, '-');
 450   }
 451
 452   return 1;
 453 }
 454
 455 /*
 456  * Replace SID1, component by component with SID2
 457  * Assumes will never be called with unequal length SIDS
 458  * so only touches 21-x-y-z-rid portion
 459  */
 460 void change_sid(DOM_SID *s1, DOM_SID *s2)
 461 {
 462   int i;
 463
 464   for (i=0; i<s1->num_auths; i++) {
 465     s1->sub_auths[i] = s2->sub_auths[i];
 466   }
 467 }
 468
 469 void print_sid(DOM_SID *sid)
 470 {
 471   int i, comps = sid->num_auths;
 472   fprintf(stdout, "S-%u-%u", sid->sid_rev_num, sid->id_auth[5]);
 473
 474   for (i = 0; i < comps; i++) {
 475
 476     fprintf(stdout, "-%u", sid->sub_auths[i]);
 477
 478   }
 479   fprintf(stdout, "\n");
 480 }
 481
 482 void process_sid(DOM_SID *sid, DOM_SID *o_sid, DOM_SID *n_sid)
 483 {
 484   int i;
 485   if (my_sid_equal(sid, o_sid)) {
 486
 487     for (i=0; i<sid->num_auths; i++) {
 488       sid->sub_auths[i] = n_sid->sub_auths[i];
 489
 490     }
 491
 492   }
 493
 494 }
 495
 496 void process_acl(ACL *acl, char *prefix)
 497 {
 498   int ace_cnt, i;
 499   ACE *ace;
 500
 501   ace_cnt = acl->num_aces;
 502   ace = (ACE *)&acl->aces;
 503   if (verbose) fprintf(stdout, "%sACEs: %u\n", prefix, ace_cnt);
 504   for (i=0; i<ace_cnt; i++) {
 505     if (verbose) fprintf(stdout, "%s  Perms: %08X, SID: ", prefix, ace->perms);
 506     if (change)
 507       process_sid(&ace->trustee, &old_sid, &new_sid);
 508     print_sid(&ace->trustee);
 509     ace = (ACE *)((char *)ace + ace->length);
 510   }
 511 }
 512
 513 void usage(voi)
 514 {
 515   fprintf(stderr, "usage: profiles [-c <OLD-SID> -n <NEW-SID>] <profilefile>\n");
 516   fprintf(stderr, "Version: %s\n", VERSION);
 517   fprintf(stderr, "\n\t-c S-1-5-21-z-y-x-oldrid - provides SID to change");
 518   fprintf(stderr, "\n\t-n S-1-5-21-a-b-c-newrid - provides SID to change to");
 519   fprintf(stderr, "\n\t\tBoth must be present if the other is.");
 520   fprintf(stderr, "\n\t\tIf neither present, just report the SIDs found\n");
 521 }
 522
 523 int main(int argc, char *argv[])
 524 {
 525   extern char *optarg;
 526   extern int optind;
 527   int opt;
 528   int i, fd, aces, start = 0;
 529   int process_sids = 0;
 530   void *base;
 531   struct stat sbuf;
 532   fstring sid_str;
 533   REGF_HDR *regf_hdr;
 534   HBIN_HDR *hbin_hdr;
 535   NK_HDR *nk_hdr;
 536   SK_HDR *sk_hdr;
 537   WORD first_sk_off, sk_off;
 538   MY_SEC_DESC *sec_desc;
 539   int *ptr;
 540
 541   if (argc < 2) {
 542     usage();
 543     exit(1);
 544   }
 545
 546   /*
 547    * Now, process the arguments
 548    */
 549
 550   while ((opt = getopt(argc, argv, "c:n:")) != EOF) {
 551     switch (opt) {
 552     case 'c':
 553       change = 1;
 554       if (!get_sid(&old_sid, optarg)) {
 555         fprintf(stderr, "Argument to -c should be a SID in form of S-1-5-...\n");
 556         usage();
 557         exit(254);
 558       }
 559       break;
 560
 561     case 'n':
 562       new = 1;
 563       if (!get_sid(&new_sid, optarg)) {
 564         fprintf(stderr, "Argument to -n should be a SID in form of S-1-5-...\n");
 565         usage();
 566         exit(253);
 567       }
 568
 569       break;
 570
 571     default:
 572       usage();
 573       exit(255);
 574     }
 575   }
 576
 577   if ((!change & new) || (change & !new)) {
 578     fprintf(stderr, "You must specify both -c and -n if one or the other is set!\n");
 579     usage();
 580     exit(252);
 581   }
 582
 583   fd = open(argv[optind], O_RDWR, 0000);
 584
 585   if (fd < 0) {
 586     fprintf(stderr, "Could not open %s: %s\n", argv[optind],
 587         strerror(errno));
 588     exit(2);
 589   }
 590
 591   if (fstat(fd, &sbuf) < 0) {
 592     fprintf(stderr, "Could not stat file %s, %s\n", argv[optind],
 593         strerror(errno));
 594     exit(3);
 595   }
 596
 597   /*
 598    * Now, mmap the file into memory, check the header and start
 599    * dealing with the records. We are interested in the sk record
 600    */
 601   start = 0;
 602   base = mmap(&start, sbuf.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 603
 604   if ((int)base == -1) {
 605     fprintf(stderr, "Could not mmap file: %s, %s\n", argv[optind],
 606         strerror(errno));
 607     exit(4);
 608   }
 609
 610   regf_hdr = (REGF_HDR *)base;
 611
 612   if (verbose) fprintf(stdout, "Registry file size: %u\n", sbuf.st_size);
 613
 614   if (regf_hdr->REGF_ID != REG_REGF_ID) {
 615     fprintf(stderr, "Incorrect Registry file (doesn't have header ID): %s\n", argv[optind]);
 616     exit(5);
 617   }
 618
 619   if (verbose) fprintf(stdout, "First Key Off: %u, Data Block Size: %u\n",
 620                        regf_hdr->first_key, regf_hdr->dblk_size);
 621
 622   hbin_hdr = (HBIN_HDR *)(base + 0x1000);
 623
 624   /*
 625    * This should be the hbin_hdr
 626    */
 627
 628   if (hbin_hdr->HBIN_ID != REG_HBIN_ID) {
 629     fprintf(stderr, "Incorrect hbin hdr: %s\n", argv[optind]);
 630     exit(6);
 631   }
 632
 633   if (verbose) fprintf(stdout, "Next Off: %u, Prev Off: %u\n",
 634                        hbin_hdr->next_off, hbin_hdr->prev_off);
 635
 636   nk_hdr = (NK_HDR *)(base + 0x1000 + regf_hdr->first_key + 4);
 637
 638   if (nk_hdr->NK_ID != REG_NK_ID) {
 639     fprintf(stderr, "Incorrect NK Header: %s\n", argv[optind]);
 640     exit(7);
 641   }
 642
 643   if (verbose) {
 644     fprintf(stdout, "Type: %0x\n", nk_hdr->type);
 645     fprintf(stdout, "SK Off    : %o\n", (0x1000 + nk_hdr->sk_off + 4));
 646   }
 647
 648   sk_hdr = (SK_HDR *)(base + 0x1000 + nk_hdr->sk_off + 4);
 649   sk_off = first_sk_off = nk_hdr->sk_off;
 650
 651   do {
 652     DOM_SID *owner_sid, *group_sid;
 653     ACL *sacl, *dacl;
 654     if (sk_hdr->SK_ID != REG_SK_ID) {
 655       fprintf(stderr, "Incorrect SK Header format: %08X\n",
 656               (0x1000 + nk_hdr->sk_off + 4));
 657       exit(8);
 658     }
 659     ptr = (int *)sk_hdr;
 660     if (verbose) fprintf(stdout, "Off: %08X, Refs: %u, Size: %u\n",
 661                          sk_off, sk_hdr->ref_cnt, sk_hdr->rec_size);
 662
 663     sec_desc = (MY_SEC_DESC *)&(sk_hdr->sec_desc[0]);
 664     owner_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] + sec_desc->owner_off);
 665     group_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] + sec_desc->group_off);
 666     sacl = (ACL *)(&sk_hdr->sec_desc[0] + sec_desc->sacl_off);
 667     dacl = (ACL *)(&sk_hdr->sec_desc[0] + sec_desc->dacl_off);
 668     if (verbose)fprintf(stdout, "  Owner SID: ");
 669     if (change) process_sid(owner_sid, &old_sid, &new_sid);
 670     if (verbose) print_sid(owner_sid);
 671     if (verbose) fprintf(stdout, "  Group SID: ");
 672     if (change) process_sid(group_sid, &old_sid, &new_sid);
 673     if (verbose) print_sid(group_sid);
 674     fprintf(stdout, "  SACL: ");
 675     if (!sec_desc->sacl_off) {
 676       if (verbose) fprintf(stdout, "NONE\n");
 677     }
 678     else
 679       process_acl(sacl, "    ");
 680     if (verbose) fprintf(stdout, "  DACL: ");
 681     if (!sec_desc->dacl_off) {
 682       if (verbose) fprintf(stdout, "NONE\n");
 683     }
 684     else
 685       process_acl(dacl, "    ");
 686     sk_off = sk_hdr->prev_off;
 687     sk_hdr = (SK_HDR *)(base + OFF(sk_hdr->prev_off));
 688   } while (sk_off != first_sk_off);
 689
 690   munmap(base, sbuf.st_size);
 691
 692   close(fd);
 693
 694 }