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, separated 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, "-%u", &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     SIVAL(&sid->sub_auths[i], 0, auth);
 449     i++;
 450     lstr = strchr(lstr + 1, '-');
 451   }
 452
 453   return 1;
 454 }
 455
 456 /*
 457  * Replace SID1, component by component with SID2
 458  * Assumes will never be called with unequal length SIDS
 459  * so only touches 21-x-y-z-rid portion
 460  * This routine does not need to deal with endianism as
 461  * long as the incoming SIDs are both in the same (LE) format.
 462  */
 463 void change_sid(DOM_SID *s1, DOM_SID *s2)
 464 {
 465   int i;
 466
 467   for (i=0; i<s1->num_auths; i++) {
 468     s1->sub_auths[i] = s2->sub_auths[i];
 469   }
 470 }
 471
 472 void print_sid(DOM_SID *sid)
 473 {
 474   int i, comps = sid->num_auths;
 475   fprintf(stdout, "S-%u-%u", sid->sid_rev_num, sid->id_auth[5]);
 476
 477   for (i = 0; i < comps; i++) {
 478
 479     fprintf(stdout, "-%u", IVAL(&sid->sub_auths[i],0));
 480
 481   }
 482   fprintf(stdout, "\n");
 483 }
 484
 485 void process_sid(DOM_SID *sid, DOM_SID *o_sid, DOM_SID *n_sid)
 486 {
 487   int i;
 488   if (my_sid_equal(sid, o_sid)) {
 489
 490     for (i=0; i<sid->num_auths; i++) {
 491       sid->sub_auths[i] = n_sid->sub_auths[i];
 492
 493     }
 494
 495   }
 496
 497 }
 498
 499 void process_acl(ACL *acl, const char *prefix)
 500 {
 501   int ace_cnt, i;
 502   ACE *ace;
 503
 504   ace_cnt = IVAL(&acl->num_aces, 0);
 505   ace = (ACE *)&acl->aces;
 506   if (verbose) fprintf(stdout, "%sACEs: %u\n", prefix, ace_cnt);
 507   for (i=0; i<ace_cnt; i++) {
 508     if (verbose) fprintf(stdout, "%s  Perms: %08X, SID: ", prefix,
 509                          IVAL(&ace->perms, 0));
 510     if (change)
 511       process_sid(&ace->trustee, &old_sid, &new_sid);
 512     print_sid(&ace->trustee);
 513     ace = (ACE *)((char *)ace + SVAL(&ace->length, 0));
 514   }
 515 }
 516
 517 void usage(void)
 518 {
 519   fprintf(stderr, "usage: profiles [-c <OLD-SID> -n <NEW-SID>] <profilefile>\n");
 520   fprintf(stderr, "Version: %s\n", VERSION);
 521   fprintf(stderr, "\n\t-v\t sets verbose mode");
 522   fprintf(stderr, "\n\t-c S-1-5-21-z-y-x-oldrid - provides SID to change");
 523   fprintf(stderr, "\n\t-n S-1-5-21-a-b-c-newrid - provides SID to change to");
 524   fprintf(stderr, "\n\t\tBoth must be present if the other is.");
 525   fprintf(stderr, "\n\t\tIf neither present, just report the SIDs found\n");
 526 }
 527
 528 int main(int argc, char *argv[])
 529 {
 530   extern char *optarg;
 531   extern int optind;
 532   int opt;
 533   int fd, start = 0;
 534   char *base;
 535   struct stat sbuf;
 536   REGF_HDR *regf_hdr;
 537   HBIN_HDR *hbin_hdr;
 538   NK_HDR *nk_hdr;
 539   SK_HDR *sk_hdr;
 540   DWORD first_sk_off, sk_off;
 541   MY_SEC_DESC *sec_desc;
 542   int *ptr;
 543
 544   if (argc < 2) {
 545     usage();
 546     exit(1);
 547   }
 548
 549   /*
 550    * Now, process the arguments
 551    */
 552
 553   while ((opt = getopt(argc, argv, "c:n:v")) != EOF) {
 554     switch (opt) {
 555     case 'c':
 556       change = 1;
 557       if (!get_sid(&old_sid, optarg)) {
 558         fprintf(stderr, "Argument to -c should be a SID in form of S-1-5-...\n");
 559         usage();
 560         exit(254);
 561       }
 562       break;
 563
 564     case 'n':
 565       new = 1;
 566       if (!get_sid(&new_sid, optarg)) {
 567         fprintf(stderr, "Argument to -n should be a SID in form of S-1-5-...\n");
 568         usage();
 569         exit(253);
 570       }
 571
 572       break;
 573
 574     case 'v':
 575       verbose++;
 576       break;
 577
 578     default:
 579       usage();
 580       exit(255);
 581     }
 582   }
 583
 584   if ((!change & new) || (change & !new)) {
 585     fprintf(stderr, "You must specify both -c and -n if one or the other is set!\n");
 586     usage();
 587     exit(252);
 588   }
 589
 590   fd = open(argv[optind], O_RDWR, 0000);
 591
 592   if (fd < 0) {
 593     fprintf(stderr, "Could not open %s: %s\n", argv[optind],
 594         strerror(errno));
 595     exit(2);
 596   }
 597
 598   if (fstat(fd, &sbuf) < 0) {
 599     fprintf(stderr, "Could not stat file %s, %s\n", argv[optind],
 600         strerror(errno));
 601     exit(3);
 602   }
 603
 604   /*
 605    * Now, mmap the file into memory, check the header and start
 606    * dealing with the records. We are interested in the sk record
 607    */
 608   start = 0;
 609   base = mmap(&start, sbuf.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 610
 611   if ((int)base == -1) {
 612     fprintf(stderr, "Could not mmap file: %s, %s\n", argv[optind],
 613         strerror(errno));
 614     exit(4);
 615   }
 616
 617   /*
 618    * In what follows, and in places above, in order to work on both LE and
 619    * BE platforms, we have to use the Samba macros to extract SHORT, LONG
 620    * and associated UNSIGNED quantities from the data in the mmap'd file.
 621    * NOTE, however, that we do not need to do anything with memory
 622    * addresses that we construct from pointers in our address space.
 623    * For example,
 624    *
 625    *    sec_desc = (MY_SEC_DESC *)&(sk_hdr->sec_desc[0]);
 626    *
 627    * is simply taking the address of a structure we already have the address
 628    * of in our address space, while, the fields within it, will have to
 629    * be accessed with the macros:
 630    *
 631    * owner_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] +
 632    *                         IVAL(&sec_desc->owner_off, 0));
 633    *
 634    * Which is pulling out an offset and adding it to an existing pointer.
 635    *
 636    */
 637
 638   regf_hdr = (REGF_HDR *)base;
 639
 640   if (verbose) fprintf(stdout, "Registry file size: %u\n", (unsigned int)sbuf.st_size);
 641
 642   if (IVAL(&regf_hdr->REGF_ID, 0) != REG_REGF_ID) {
 643     fprintf(stderr, "Incorrect Registry file (doesn't have header ID): %s\n", argv[optind]);
 644     exit(5);
 645   }
 646
 647   if (verbose) fprintf(stdout, "First Key Off: %u, Data Block Size: %u\n",
 648                        IVAL(&regf_hdr->first_key, 0),
 649                        IVAL(&regf_hdr->dblk_size, 0));
 650
 651   hbin_hdr = (HBIN_HDR *)(base + 0x1000); /* No need for Endian stuff */
 652
 653   /*
 654    * This should be the hbin_hdr
 655    */
 656
 657   if (IVAL(&hbin_hdr->HBIN_ID, 0) != REG_HBIN_ID) {
 658     fprintf(stderr, "Incorrect hbin hdr: %s\n", argv[optind]);
 659     exit(6);
 660   }
 661
 662   if (verbose) fprintf(stdout, "Next Off: %u, Prev Off: %u\n",
 663                        IVAL(&hbin_hdr->next_off, 0),
 664                        IVAL(&hbin_hdr->prev_off, 0));
 665
 666   nk_hdr = (NK_HDR *)(base + 0x1000 + IVAL(&regf_hdr->first_key, 0) + 4);
 667
 668   if (SVAL(&nk_hdr->NK_ID, 0) != REG_NK_ID) {
 669     fprintf(stderr, "Incorrect NK Header: %s\n", argv[optind]);
 670     exit(7);
 671   }
 672
 673   sk_off = first_sk_off = IVAL(&nk_hdr->sk_off, 0);
 674   if (verbose) {
 675     fprintf(stdout, "Type: %0x\n", SVAL(&nk_hdr->type, 0));
 676     fprintf(stdout, "SK Off    : %o\n", (0x1000 + sk_off + 4));
 677   }
 678
 679   sk_hdr = (SK_HDR *)(base + 0x1000 + sk_off + 4);
 680
 681   do {
 682     DOM_SID *owner_sid, *group_sid;
 683     ACL *sacl, *dacl;
 684     if (SVAL(&sk_hdr->SK_ID, 0) != REG_SK_ID) {
 685       fprintf(stderr, "Incorrect SK Header format: %08X\n",
 686               (0x1000 + sk_off + 4));
 687       exit(8);
 688     }
 689     ptr = (int *)sk_hdr;
 690     if (verbose) fprintf(stdout, "Off: %08X, Refs: %u, Size: %u\n",
 691                          sk_off, IVAL(&sk_hdr->ref_cnt, 0),
 692                          IVAL(&sk_hdr->rec_size, 0));
 693
 694     sec_desc = (MY_SEC_DESC *)&(sk_hdr->sec_desc[0]);
 695     owner_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] +
 696                             IVAL(&sec_desc->owner_off, 0));
 697     group_sid = (DOM_SID *)(&sk_hdr->sec_desc[0] +
 698                             IVAL(&sec_desc->group_off, 0));
 699     sacl = (ACL *)(&sk_hdr->sec_desc[0] +
 700                    IVAL(&sec_desc->sacl_off, 0));
 701     dacl = (ACL *)(&sk_hdr->sec_desc[0] +
 702                    IVAL(&sec_desc->dacl_off, 0));
 703     if (verbose)fprintf(stdout, "  Owner SID: ");
 704     if (change) process_sid(owner_sid, &old_sid, &new_sid);
 705     if (verbose) print_sid(owner_sid);
 706     if (verbose) fprintf(stdout, "  Group SID: ");
 707     if (change) process_sid(group_sid, &old_sid, &new_sid);
 708     if (verbose) print_sid(group_sid);
 709     fprintf(stdout, "  SACL: ");
 710     if (!sec_desc->sacl_off) { /* LE zero == BE zero */
 711       if (verbose) fprintf(stdout, "NONE\n");
 712     }
 713     else
 714       process_acl(sacl, "    ");
 715     if (verbose) fprintf(stdout, "  DACL: ");
 716     if (!sec_desc->dacl_off) {
 717       if (verbose) fprintf(stdout, "NONE\n");
 718     }
 719     else
 720       process_acl(dacl, "    ");
 721     sk_off = IVAL(&sk_hdr->prev_off, 0);
 722     sk_hdr = (SK_HDR *)(base + OFF(IVAL(&sk_hdr->prev_off, 0)));
 723   } while (sk_off != first_sk_off);
 724
 725   munmap(base, sbuf.st_size);
 726
 727   close(fd);
 728   return 0;
 729 }