source: trunk/lib/regfi.c @ 254

Last change on this file since 254 was 253, checked in by tim, 13 years ago

added preliminary interface to security descriptors in pyregfi
misc bug fixes

  • Property svn:keywords set to Id
File size: 105.8 KB
Line 
1/*
2 * Copyright (C) 2005-2010 Timothy D. Morgan
3 * Copyright (C) 2005 Gerald (Jerry) Carter
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; version 3 of the License.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 *
18 * $Id: regfi.c 253 2011-06-13 02:27:42Z tim $
19 */
20
21/**
22 * @file
23 *
24 * Windows NT (and later) read-only registry library
25 *
26 * See @ref regfi.h for more information.
27 *
28 * Branched from Samba project Subversion repository, version #7470:
29 *   http://viewcvs.samba.org/cgi-bin/viewcvs.cgi/trunk/source/registry/regfio.c?rev=7470&view=auto
30 *
31 * Since then, it has been heavily rewritten, simplified, and improved.
32 */
33
34#include "regfi.h"
35
36/* Library version can be overridden at build time */
37#ifndef REGFI_VERSION
38#define REGFI_VERSION "trunk"
39#endif
40
41
42/* Registry types mapping */
43const unsigned int regfi_num_reg_types = 12;
44static const char* regfi_type_names[] =
45  {"NONE", "SZ", "EXPAND_SZ", "BINARY", "DWORD", "DWORD_BE", "LINK",
46   "MULTI_SZ", "RSRC_LIST", "RSRC_DESC", "RSRC_REQ_LIST", "QWORD"};
47
48const char* regfi_encoding_names[] =
49  {"US-ASCII//TRANSLIT", "UTF-8//TRANSLIT", "UTF-16LE//TRANSLIT"};
50
51
52/* Ensures regfi_init runs only once */
53static pthread_once_t regfi_init_once = PTHREAD_ONCE_INIT;
54
55
56/******************************************************************************
57 ******************************************************************************/
58const char* regfi_version()
59{
60  return REGFI_VERSION;
61}
62
63
64/******************************************************************************
65 ******************************************************************************/
66void regfi_log_free(void* ptr)
67{
68  REGFI_LOG* log_info = (REGFI_LOG*)ptr;
69 
70  if(log_info->messages != NULL)
71    free(log_info->messages);
72
73  talloc_free(log_info);
74}
75
76
77/******************************************************************************
78 ******************************************************************************/
79void regfi_init()
80{
81  int err;
82  if((err = pthread_key_create(&regfi_log_key, regfi_log_free)) != 0)
83    fprintf(stderr, "ERROR: key_create: %s\n", strerror(err));
84  errno = err;
85}
86
87
88/******************************************************************************
89 ******************************************************************************/
90REGFI_LOG* regfi_log_new()
91{
92  int err;
93  REGFI_LOG* log_info = talloc(NULL, REGFI_LOG);
94  if(log_info == NULL)
95    return NULL;
96
97  log_info->msg_mask = REGFI_DEFAULT_LOG_MASK;
98  log_info->messages = NULL;
99
100  pthread_once(&regfi_init_once, regfi_init);
101
102  if((err = pthread_setspecific(regfi_log_key, log_info)) != 0)
103  {
104    fprintf(stderr, "ERROR: setspecific: %s\n", strerror(err));
105    goto fail;
106  }
107
108  return log_info;
109
110 fail:
111  talloc_free(log_info);
112  errno = err;
113  return NULL;
114}
115
116
117/******************************************************************************
118 ******************************************************************************/
119void regfi_log_add(uint16_t msg_type, const char* fmt, ...)
120{
121  /* XXX: Switch internal storage over to a linked list or stack.
122   *      Then add a regfi_log_get function that returns the list in some
123   *      convenient, user-friendly data structure.  regfi_log_get_str should
124   *      stick around and will simply smush the list into a big string when
125   *      it's called, rather than having messages smushed when they're first
126   *      written to the log.
127   */
128  uint32_t buf_size, buf_used;
129  char* new_msg;
130  REGFI_LOG* log_info;
131  va_list args;
132
133  log_info = (REGFI_LOG*)pthread_getspecific(regfi_log_key);
134  if(log_info == NULL && (log_info = regfi_log_new()) == NULL)
135    return;
136
137  if((log_info->msg_mask & msg_type) == 0)
138    return;
139
140  if(log_info->messages == NULL)
141    buf_used = 0;
142  else
143    buf_used = strlen(log_info->messages);
144 
145  buf_size = buf_used+strlen(fmt)+160;
146  new_msg = realloc(log_info->messages, buf_size);
147  if(new_msg == NULL)
148    /* XXX: should we report this? */
149    return;
150 
151  switch (msg_type)
152  {
153  case REGFI_LOG_INFO:
154    strcpy(new_msg+buf_used, "INFO: ");
155    buf_used += 6;
156    break;
157  case REGFI_LOG_WARN:
158    strcpy(new_msg+buf_used, "WARN: ");
159    buf_used += 6;
160    break;
161  case REGFI_LOG_ERROR:
162    strcpy(new_msg+buf_used, "ERROR: ");
163    buf_used += 7;
164    break;
165  }
166 
167  va_start(args, fmt);
168  vsnprintf(new_msg+buf_used, buf_size-buf_used, fmt, args);
169  va_end(args);
170  strncat(new_msg, "\n", buf_size-1);
171 
172  log_info->messages = new_msg;
173}
174
175
176/******************************************************************************
177 ******************************************************************************/
178char* regfi_log_get_str()
179{
180  char* ret_val;
181  REGFI_LOG* log_info = (REGFI_LOG*)pthread_getspecific(regfi_log_key);
182  if(log_info == NULL && (log_info = regfi_log_new()) == NULL)
183    return NULL;
184 
185  ret_val = log_info->messages;
186  log_info->messages = NULL;
187
188  return ret_val;
189}
190
191
192/******************************************************************************
193 ******************************************************************************/
194bool regfi_log_set_mask(uint16_t msg_mask)
195{
196  REGFI_LOG* log_info = (REGFI_LOG*)pthread_getspecific(regfi_log_key);
197  if(log_info == NULL && (log_info = regfi_log_new()) == NULL)
198  {
199      return false;
200  }
201
202  log_info->msg_mask = msg_mask;
203  return true;
204}
205
206
207/******************************************************************************
208 * Returns NULL for an invalid e
209 *****************************************************************************/
210static const char* regfi_encoding_int2str(REGFI_ENCODING e)
211{
212  if(e < REGFI_NUM_ENCODINGS)
213    return regfi_encoding_names[e];
214
215  return NULL;
216}
217
218
219/******************************************************************************
220 * Returns NULL for an invalid val
221 *****************************************************************************/
222const char* regfi_type_val2str(unsigned int val)
223{
224  if(val == REG_KEY)
225    return "KEY";
226 
227  if(val >= regfi_num_reg_types)
228    return NULL;
229 
230  return regfi_type_names[val];
231}
232
233
234/******************************************************************************
235 * Returns -1 on error
236 *****************************************************************************/
237int regfi_type_str2val(const char* str)
238{
239  int i;
240
241  if(strcmp("KEY", str) == 0)
242    return REG_KEY;
243
244  for(i=0; i < regfi_num_reg_types; i++)
245    if (strcmp(regfi_type_names[i], str) == 0) 
246      return i;
247
248  if(strcmp("DWORD_LE", str) == 0)
249    return REG_DWORD_LE;
250
251  return -1;
252}
253
254
255/* Security descriptor formatting functions  */
256
257const char* regfi_ace_type2str(uint8_t type)
258{
259  static const char* map[7] 
260    = {"ALLOW", "DENY", "AUDIT", "ALARM", 
261       "ALLOW CPD", "OBJ ALLOW", "OBJ DENY"};
262  if(type < 7)
263    return map[type];
264  else
265    /* XXX: would be nice to return the unknown integer value. 
266     *      However, as it is a const string, it can't be free()ed later on,
267     *      so that would need to change.
268     */
269    return "UNKNOWN";
270}
271
272
273/* XXX: need a better reference on the meaning of each flag. */
274/* For more info, see:
275 *   http://msdn2.microsoft.com/en-us/library/aa772242.aspx
276 */
277char* regfi_ace_flags2str(uint8_t flags)
278{
279  static const char* flag_map[32] = 
280    { "OI", /* Object Inherit */
281      "CI", /* Container Inherit */
282      "NP", /* Non-Propagate */
283      "IO", /* Inherit Only */
284      "IA", /* Inherited ACE */
285      NULL,
286      NULL,
287      NULL,
288    };
289
290  char* ret_val = malloc(35*sizeof(char));
291  char* fo = ret_val;
292  uint32_t i;
293  uint8_t f;
294
295  if(ret_val == NULL)
296    return NULL;
297
298  fo[0] = '\0';
299  if (!flags)
300    return ret_val;
301
302  for(i=0; i < 8; i++)
303  {
304    f = (1<<i);
305    if((flags & f) && (flag_map[i] != NULL))
306    {
307      strcpy(fo, flag_map[i]);
308      fo += strlen(flag_map[i]);
309      *(fo++) = ' ';
310      flags ^= f;
311    }
312  }
313 
314  /* Any remaining unknown flags are added at the end in hex. */
315  if(flags != 0)
316    sprintf(fo, "0x%.2X ", flags);
317
318  /* Chop off the last space if we've written anything to ret_val */
319  if(fo != ret_val)
320    fo[-1] = '\0';
321
322  return ret_val;
323}
324
325
326char* regfi_ace_perms2str(uint32_t perms)
327{
328  uint32_t i, p;
329  /* This is more than is needed by a fair margin. */
330  char* ret_val = malloc(350*sizeof(char));
331  char* r = ret_val;
332
333  /* Each represents one of 32 permissions bits.  NULL is for undefined/reserved bits.
334   * For more information, see:
335   *   http://msdn2.microsoft.com/en-gb/library/aa374892.aspx
336   *   http://msdn2.microsoft.com/en-gb/library/ms724878.aspx
337   */
338  static const char* perm_map[32] = 
339    {/* object-specific permissions (registry keys, in this case) */
340      "QRY_VAL",       /* KEY_QUERY_VALUE */
341      "SET_VAL",       /* KEY_SET_VALUE */
342      "CREATE_KEY",    /* KEY_CREATE_SUB_KEY */
343      "ENUM_KEYS",     /* KEY_ENUMERATE_SUB_KEYS */
344      "NOTIFY",        /* KEY_NOTIFY */
345      "CREATE_LNK",    /* KEY_CREATE_LINK - Reserved for system use. */
346      NULL,
347      NULL,
348      "WOW64_64",      /* KEY_WOW64_64KEY */
349      "WOW64_32",      /* KEY_WOW64_32KEY */
350      NULL,
351      NULL,
352      NULL,
353      NULL,
354      NULL,
355      NULL,
356      /* standard access rights */
357      "DELETE",        /* DELETE */
358      "R_CONT",        /* READ_CONTROL */
359      "W_DAC",         /* WRITE_DAC */
360      "W_OWNER",       /* WRITE_OWNER */
361      "SYNC",          /* SYNCHRONIZE - Shouldn't be set in registries */
362      NULL,
363      NULL,
364      NULL,
365      /* other generic */
366      "SYS_SEC",       /* ACCESS_SYSTEM_SECURITY */
367      "MAX_ALLWD",     /* MAXIMUM_ALLOWED */
368      NULL,
369      NULL,
370      "GEN_A",         /* GENERIC_ALL */
371      "GEN_X",         /* GENERIC_EXECUTE */
372      "GEN_W",         /* GENERIC_WRITE */
373      "GEN_R",         /* GENERIC_READ */
374    };
375
376
377  if(ret_val == NULL)
378    return NULL;
379
380  r[0] = '\0';
381  for(i=0; i < 32; i++)
382  {
383    p = (1<<i);
384    if((perms & p) && (perm_map[i] != NULL))
385    {
386      strcpy(r, perm_map[i]);
387      r += strlen(perm_map[i]);
388      *(r++) = ' ';
389      perms ^= p;
390    }
391  }
392 
393  /* Any remaining unknown permission bits are added at the end in hex. */
394  if(perms != 0)
395    sprintf(r, "0x%.8X ", perms);
396
397  /* Chop off the last space if we've written anything to ret_val */
398  if(r != ret_val)
399    r[-1] = '\0';
400
401  return ret_val;
402}
403
404
405char* regfi_get_acl(WINSEC_ACL* acl)
406{
407  uint32_t i, extra, size = 0;
408  const char* type_str;
409  char* flags_str;
410  char* perms_str;
411  char* sid_str;
412  char* ace_delim = "";
413  char* ret_val = NULL;
414  char* tmp_val = NULL;
415  bool failed = false;
416  char field_delim = ':';
417
418  for (i = 0; i < acl->num_aces && !failed; i++)
419  {
420    sid_str = winsec_sid2str(acl->aces[i]->trustee);
421    type_str = regfi_ace_type2str(acl->aces[i]->type);
422    perms_str = regfi_ace_perms2str(acl->aces[i]->access_mask);
423    flags_str = regfi_ace_flags2str(acl->aces[i]->flags);
424   
425    if(flags_str != NULL && perms_str != NULL 
426       && type_str != NULL && sid_str != NULL)
427    {
428      /* XXX: this is slow */
429      extra = strlen(sid_str) + strlen(type_str) 
430        + strlen(perms_str) + strlen(flags_str) + 5;
431      tmp_val = realloc(ret_val, size+extra);
432
433      if(tmp_val == NULL)
434      {
435        free(ret_val);
436        ret_val = NULL;
437        failed = true;
438      }
439      else
440      {
441        ret_val = tmp_val;
442        size += sprintf(ret_val+size, "%s%s%c%s%c%s%c%s",
443                        ace_delim,sid_str,
444                        field_delim,type_str,
445                        field_delim,perms_str,
446                        field_delim,flags_str);
447        ace_delim = "|";
448      }
449    }
450    else
451      failed = true;
452
453    if(sid_str != NULL)
454      free(sid_str);
455    if(sid_str != NULL)
456      free(perms_str);
457    if(sid_str != NULL)
458      free(flags_str);
459  }
460
461  return ret_val;
462}
463
464
465char* regfi_get_sacl(WINSEC_DESC *sec_desc)
466{
467  if (sec_desc->sacl)
468    return regfi_get_acl(sec_desc->sacl);
469  else
470    return NULL;
471}
472
473
474char* regfi_get_dacl(WINSEC_DESC *sec_desc)
475{
476  if (sec_desc->dacl)
477    return regfi_get_acl(sec_desc->dacl);
478  else
479    return NULL;
480}
481
482
483char* regfi_get_owner(WINSEC_DESC *sec_desc)
484{
485  return winsec_sid2str(sec_desc->owner_sid);
486}
487
488
489char* regfi_get_group(WINSEC_DESC *sec_desc)
490{
491  return winsec_sid2str(sec_desc->grp_sid);
492}
493
494
495bool regfi_read_lock(REGFI_FILE* file, pthread_rwlock_t* lock, const char* context)
496{
497  int lock_ret = pthread_rwlock_rdlock(lock);
498  if(lock_ret != 0)
499  {
500    regfi_log_add(REGFI_LOG_ERROR, "Error obtaining read lock in"
501                      "%s due to: %s\n", context, strerror(lock_ret));
502    return false;
503  }
504
505  return true;
506}
507
508
509bool regfi_write_lock(REGFI_FILE* file, pthread_rwlock_t* lock, const char* context)
510{
511  int lock_ret = pthread_rwlock_wrlock(lock);
512  if(lock_ret != 0)
513  {
514    regfi_log_add(REGFI_LOG_ERROR, "Error obtaining write lock in"
515                      "%s due to: %s\n", context, strerror(lock_ret));
516    return false;
517  }
518
519  return true;
520}
521
522
523bool regfi_rw_unlock(REGFI_FILE* file, pthread_rwlock_t* lock, const char* context)
524{
525  int lock_ret = pthread_rwlock_unlock(lock);
526  if(lock_ret != 0)
527  {
528    regfi_log_add(REGFI_LOG_ERROR, "Error releasing lock in"
529                      "%s due to: %s\n", context, strerror(lock_ret));
530    return false;
531  }
532
533  return true;
534}
535
536
537bool regfi_lock(REGFI_FILE* file, pthread_mutex_t* lock, const char* context)
538{
539  int lock_ret = pthread_mutex_lock(lock);
540  if(lock_ret != 0)
541  {
542    regfi_log_add(REGFI_LOG_ERROR, "Error obtaining mutex lock in"
543                      "%s due to: %s\n", context, strerror(lock_ret));
544    return false;
545  }
546
547  return true;
548}
549
550
551bool regfi_unlock(REGFI_FILE* file, pthread_mutex_t* lock, const char* context)
552{
553  int lock_ret = pthread_mutex_unlock(lock);
554  if(lock_ret != 0)
555  {
556    regfi_log_add(REGFI_LOG_ERROR, "Error releasing mutex lock in"
557                      "%s due to: %s\n", context, strerror(lock_ret));
558    return false;
559  }
560
561  return true;
562}
563
564
565int64_t regfi_raw_seek(REGFI_RAW_FILE* self, uint64_t offset, int whence)
566{
567  if(sizeof(off_t) == 4 && offset > 2147483647)
568  {
569    errno = EOVERFLOW;
570    return -1;
571  }
572  return lseek(*(int*)self->state, offset, whence);
573}
574
575ssize_t regfi_raw_read(REGFI_RAW_FILE* self, void* buf, size_t count)
576{
577  return read(*(int*)self->state, buf, count);
578}
579
580
581/*****************************************************************************
582 * Convenience function to wrap up the ugly callback stuff
583 *****************************************************************************/
584uint64_t regfi_seek(REGFI_RAW_FILE* file_cb, uint64_t offset, int whence)
585{
586  return file_cb->seek(file_cb, offset, whence);
587}
588
589
590/*****************************************************************************
591 * This function is just like read(2), except that it continues to
592 * re-try reading from the file descriptor if EINTR or EAGAIN is received. 
593 * regfi_read will attempt to read length bytes from the file and write them to
594 * buf.
595 *
596 * On success, 0 is returned.  Upon failure, an errno code is returned.
597 *
598 * The number of bytes successfully read is returned through the length
599 * parameter by reference.  If both the return value and length parameter are
600 * returned as 0, then EOF was encountered immediately
601 *****************************************************************************/
602uint32_t regfi_read(REGFI_RAW_FILE* file_cb, uint8_t* buf, uint32_t* length)
603{
604  uint32_t rsize = 0;
605  uint32_t rret = 0;
606
607  do
608  {
609    rret = file_cb->read(file_cb, 
610                         buf + rsize, 
611                         *length - rsize);
612    if(rret > 0)
613      rsize += rret;
614  }while(*length - rsize > 0 
615         && (rret > 0 || (rret == -1 && (errno == EAGAIN || errno == EINTR))));
616 
617  *length = rsize;
618  if (rret == -1 && errno != EINTR && errno != EAGAIN)
619    return errno;
620
621  return 0;
622}
623
624
625/*****************************************************************************
626 *
627 *****************************************************************************/
628bool regfi_parse_cell(REGFI_RAW_FILE* file_cb, uint32_t offset, uint8_t* hdr, 
629                      uint32_t hdr_len, uint32_t* cell_length, bool* unalloc)
630{
631  uint32_t length;
632  int32_t raw_length;
633  uint8_t tmp[4];
634
635  if(regfi_seek(file_cb, offset, SEEK_SET) == -1)
636    return false;
637
638  length = 4;
639  if((regfi_read(file_cb, tmp, &length) != 0) || length != 4)
640    return false;
641  raw_length = IVALS(tmp, 0);
642
643  if(raw_length < 0)
644  {
645    (*cell_length) = raw_length*(-1);
646    (*unalloc) = false;
647  }
648  else
649  {
650    (*cell_length) = raw_length;
651    (*unalloc) = true;
652  }
653
654  if(*cell_length - 4 < hdr_len)
655    return false;
656
657  if(hdr_len > 0)
658  {
659    length = hdr_len;
660    if((regfi_read(file_cb, hdr, &length) != 0) || length != hdr_len)
661      return false;
662  }
663
664  return true;
665}
666
667
668/******************************************************************************
669 * Given an offset and an hbin, is the offset within that hbin?
670 * The offset is a virtual file offset.
671 ******************************************************************************/
672static bool regfi_offset_in_hbin(const REGFI_HBIN* hbin, uint32_t voffset)
673{
674  if(!hbin)
675    return false;
676
677  if((voffset > hbin->first_hbin_off) 
678     && (voffset < (hbin->first_hbin_off + hbin->block_size)))
679    return true;
680               
681  return false;
682}
683
684
685
686/******************************************************************************
687 * Provide a physical offset and receive the correpsonding HBIN
688 * block for it.  NULL if one doesn't exist.
689 ******************************************************************************/
690const REGFI_HBIN* regfi_lookup_hbin(REGFI_FILE* file, uint32_t offset)
691{
692  return (const REGFI_HBIN*)range_list_find_data(file->hbins, offset);
693}
694
695
696/******************************************************************************
697 * Calculate the largest possible cell size given a physical offset.
698 * Largest size is based on the HBIN the offset is currently a member of.
699 * Returns negative values on error.
700 * (Since cells can only be ~2^31 in size, this works out.)
701 ******************************************************************************/
702int32_t regfi_calc_maxsize(REGFI_FILE* file, uint32_t offset)
703{
704  const REGFI_HBIN* hbin = regfi_lookup_hbin(file, offset);
705  if(hbin == NULL)
706    return -1;
707
708  return (hbin->block_size + hbin->file_off) - offset;
709}
710
711
712/******************************************************************************
713 ******************************************************************************/
714REGFI_SUBKEY_LIST* regfi_load_subkeylist(REGFI_FILE* file, uint32_t offset, 
715                                         uint32_t num_keys, uint32_t max_size, 
716                                         bool strict)
717{
718  REGFI_SUBKEY_LIST* ret_val;
719
720  ret_val = regfi_load_subkeylist_aux(file, offset, max_size, strict, 
721                                      REGFI_MAX_SUBKEY_DEPTH);
722  if(ret_val == NULL)
723  {
724    regfi_log_add(REGFI_LOG_WARN, "Failed to load subkey list at"
725                      " offset 0x%.8X.", offset);
726    return NULL;
727  }
728
729  if(num_keys != ret_val->num_keys)
730  {
731    /*  Not sure which should be authoritative, the number from the
732     *  NK record, or the number in the subkey list.  Just emit a warning for
733     *  now if they don't match.
734     */
735    regfi_log_add(REGFI_LOG_WARN, "Number of subkeys listed in parent"
736                      " (%d) did not match number found in subkey list/tree (%d)"
737                      " while parsing subkey list/tree at offset 0x%.8X.", 
738                      num_keys, ret_val->num_keys, offset);
739  }
740
741  return ret_val;
742}
743
744
745/******************************************************************************
746 ******************************************************************************/
747REGFI_SUBKEY_LIST* regfi_load_subkeylist_aux(REGFI_FILE* file, uint32_t offset, 
748                                             uint32_t max_size, bool strict,
749                                             uint8_t depth_left)
750{
751  REGFI_SUBKEY_LIST* ret_val;
752  REGFI_SUBKEY_LIST** sublists;
753  uint32_t i, num_sublists, off;
754  int32_t sublist_maxsize;
755
756  if(depth_left == 0)
757  {
758    regfi_log_add(REGFI_LOG_WARN, "Maximum depth reached"
759                      " while parsing subkey list/tree at offset 0x%.8X.", 
760                      offset);
761    return NULL;
762  }
763
764  ret_val = regfi_parse_subkeylist(file, offset, max_size, strict);
765  if(ret_val == NULL)
766    return NULL;
767
768  if(ret_val->recursive_type)
769  {
770    num_sublists = ret_val->num_children;
771    sublists = (REGFI_SUBKEY_LIST**)malloc(num_sublists
772                                           * sizeof(REGFI_SUBKEY_LIST*));
773    for(i=0; i < num_sublists; i++)
774    {
775      off = ret_val->elements[i].offset + REGFI_REGF_SIZE;
776
777      sublist_maxsize = regfi_calc_maxsize(file, off);
778      if(sublist_maxsize < 0)
779        sublists[i] = NULL;
780      else
781        sublists[i] = regfi_load_subkeylist_aux(file, off, sublist_maxsize, 
782                                                strict, depth_left-1);
783    }
784    talloc_free(ret_val);
785
786    return regfi_merge_subkeylists(num_sublists, sublists, strict);
787  }
788
789  return ret_val;
790}
791
792
793/******************************************************************************
794 ******************************************************************************/
795REGFI_SUBKEY_LIST* regfi_parse_subkeylist(REGFI_FILE* file, uint32_t offset, 
796                                          uint32_t max_size, bool strict)
797{
798  REGFI_SUBKEY_LIST* ret_val;
799  uint32_t i, cell_length, length, elem_size, read_len;
800  uint8_t* elements = NULL;
801  uint8_t buf[REGFI_SUBKEY_LIST_MIN_LEN];
802  bool unalloc;
803  bool recursive_type;
804
805  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_subkeylist"))
806     goto fail;
807
808  if(!regfi_parse_cell(file->cb, offset, buf, REGFI_SUBKEY_LIST_MIN_LEN,
809                       &cell_length, &unalloc))
810  {
811    regfi_log_add(REGFI_LOG_WARN, "Could not parse cell while "
812                      "parsing subkey-list at offset 0x%.8X.", offset);
813    goto fail_locked;
814  }
815
816  if(cell_length > max_size)
817  {
818    regfi_log_add(REGFI_LOG_WARN, "Cell size longer than max_size"
819                      " while parsing subkey-list at offset 0x%.8X.", offset);
820    if(strict)
821      goto fail_locked;
822    cell_length = max_size & 0xFFFFFFF8;
823  }
824
825  recursive_type = false;
826  if(buf[0] == 'r' && buf[1] == 'i')
827  {
828    recursive_type = true;
829    elem_size = sizeof(uint32_t);
830  }
831  else if(buf[0] == 'l' && buf[1] == 'i')
832  {
833    elem_size = sizeof(uint32_t);
834  }
835  else if((buf[0] == 'l') && (buf[1] == 'f' || buf[1] == 'h'))
836    elem_size = sizeof(REGFI_SUBKEY_LIST_ELEM);
837  else
838  {
839    regfi_log_add(REGFI_LOG_ERROR, "Unknown magic number"
840                      " (0x%.2X, 0x%.2X) encountered while parsing"
841                      " subkey-list at offset 0x%.8X.", buf[0], buf[1], offset);
842    goto fail_locked;
843  }
844
845  ret_val = talloc(NULL, REGFI_SUBKEY_LIST);
846  if(ret_val == NULL)
847    goto fail_locked;
848
849  ret_val->offset = offset;
850  ret_val->cell_size = cell_length;
851  ret_val->magic[0] = buf[0];
852  ret_val->magic[1] = buf[1];
853  ret_val->recursive_type = recursive_type;
854  ret_val->num_children = SVAL(buf, 0x2);
855
856  if(!recursive_type)
857    ret_val->num_keys = ret_val->num_children;
858
859  length = elem_size*ret_val->num_children;
860  if(cell_length - REGFI_SUBKEY_LIST_MIN_LEN - sizeof(uint32_t) < length)
861  {
862    regfi_log_add(REGFI_LOG_WARN, "Number of elements too large for"
863                      " cell while parsing subkey-list at offset 0x%.8X.", 
864                      offset);
865    if(strict)
866      goto fail_locked;
867    length = cell_length - REGFI_SUBKEY_LIST_MIN_LEN - sizeof(uint32_t);
868  }
869
870  ret_val->elements = talloc_array(ret_val, REGFI_SUBKEY_LIST_ELEM, 
871                                   ret_val->num_children);
872  if(ret_val->elements == NULL)
873    goto fail_locked;
874
875  elements = (uint8_t*)malloc(length);
876  if(elements == NULL)
877    goto fail_locked;
878
879  read_len = length;
880  if(regfi_read(file->cb, elements, &read_len) != 0 || read_len!=length)
881    goto fail_locked;
882
883  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_subkeylist"))
884     goto fail;
885
886  if(elem_size == sizeof(uint32_t))
887  {
888    for (i=0; i < ret_val->num_children; i++)
889    {
890      ret_val->elements[i].offset = IVAL(elements, i*elem_size);
891      ret_val->elements[i].hash = 0;
892    }
893  }
894  else
895  {
896    for (i=0; i < ret_val->num_children; i++)
897    {
898      ret_val->elements[i].offset = IVAL(elements, i*elem_size);
899      ret_val->elements[i].hash = IVAL(elements, i*elem_size+4);
900    }
901  }
902  free(elements);
903
904  return ret_val;
905
906 fail_locked:
907  regfi_unlock(file, &file->cb_lock, "regfi_parse_subkeylist");
908 fail:
909  if(elements != NULL)
910    free(elements);
911  talloc_free(ret_val);
912  return NULL;
913}
914
915
916/*******************************************************************
917 *******************************************************************/
918REGFI_SUBKEY_LIST* regfi_merge_subkeylists(uint16_t num_lists, 
919                                           REGFI_SUBKEY_LIST** lists,
920                                           bool strict)
921{
922  uint32_t i,j,k;
923  REGFI_SUBKEY_LIST* ret_val;
924
925  if(lists == NULL)
926    return NULL;
927  ret_val = talloc(NULL, REGFI_SUBKEY_LIST);
928
929  if(ret_val == NULL)
930    return NULL;
931 
932  /* Obtain total number of elements */
933  ret_val->num_keys = 0;
934  for(i=0; i < num_lists; i++)
935  {
936    if(lists[i] != NULL)
937      ret_val->num_keys += lists[i]->num_children;
938  }
939  ret_val->num_children = ret_val->num_keys;
940
941  if(ret_val->num_keys > 0)
942  {
943    ret_val->elements = talloc_array(ret_val, REGFI_SUBKEY_LIST_ELEM,
944                                     ret_val->num_keys);
945    k=0;
946
947    if(ret_val->elements != NULL)
948    {
949      for(i=0; i < num_lists; i++)
950      {
951        if(lists[i] != NULL)
952        {
953          for(j=0; j < lists[i]->num_keys; j++)
954          {
955            ret_val->elements[k].hash = lists[i]->elements[j].hash;
956            ret_val->elements[k++].offset = lists[i]->elements[j].offset;
957          }
958        }
959      }
960    }
961  }
962 
963  for(i=0; i < num_lists; i++)
964    talloc_free(lists[i]);
965  free(lists);
966
967  return ret_val;
968}
969
970
971/******************************************************************************
972 *
973 ******************************************************************************/
974REGFI_SK* regfi_parse_sk(REGFI_FILE* file, uint32_t offset, uint32_t max_size, 
975                             bool strict)
976{
977  REGFI_SK* ret_val = NULL;
978  uint8_t* sec_desc_buf = NULL;
979  uint32_t cell_length, length;
980  uint8_t sk_header[REGFI_SK_MIN_LENGTH];
981  bool unalloc = false;
982
983  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_sk"))
984     goto fail;
985
986  if(!regfi_parse_cell(file->cb, offset, sk_header, REGFI_SK_MIN_LENGTH,
987                       &cell_length, &unalloc))
988  {
989    regfi_log_add(REGFI_LOG_WARN, "Could not parse SK record cell"
990                      " at offset 0x%.8X.", offset);
991    goto fail_locked;
992  }
993   
994  if(sk_header[0] != 's' || sk_header[1] != 'k')
995  {
996    regfi_log_add(REGFI_LOG_WARN, "Magic number mismatch in parsing"
997                      " SK record at offset 0x%.8X.", offset);
998    goto fail_locked;
999  }
1000
1001  ret_val = talloc(NULL, REGFI_SK);
1002  if(ret_val == NULL)
1003    goto fail_locked;
1004
1005  ret_val->offset = offset;
1006  /* XXX: Is there a way to be more conservative (shorter) with
1007   *      cell length when cell is unallocated?
1008   */
1009  ret_val->cell_size = cell_length;
1010
1011  if(ret_val->cell_size > max_size)
1012    ret_val->cell_size = max_size & 0xFFFFFFF8;
1013  if((ret_val->cell_size < REGFI_SK_MIN_LENGTH) 
1014     || (strict && (ret_val->cell_size & 0x00000007) != 0))
1015  {
1016    regfi_log_add(REGFI_LOG_WARN, "Invalid cell size found while"
1017                      " parsing SK record at offset 0x%.8X.", offset);
1018    goto fail_locked;
1019  }
1020
1021  ret_val->magic[0] = sk_header[0];
1022  ret_val->magic[1] = sk_header[1];
1023
1024  ret_val->unknown_tag = SVAL(sk_header, 0x2);
1025  ret_val->prev_sk_off = IVAL(sk_header, 0x4);
1026  ret_val->next_sk_off = IVAL(sk_header, 0x8);
1027  ret_val->ref_count = IVAL(sk_header, 0xC);
1028  ret_val->desc_size = IVAL(sk_header, 0x10);
1029
1030  if((ret_val->prev_sk_off & 0x00000007) != 0
1031     || (ret_val->next_sk_off & 0x00000007) != 0)
1032  {
1033    regfi_log_add(REGFI_LOG_WARN, "SK record's next/previous offsets"
1034                      " are not a multiple of 8 while parsing SK record at"
1035                      " offset 0x%.8X.", offset);
1036    goto fail_locked;
1037  }
1038
1039  if(ret_val->desc_size + REGFI_SK_MIN_LENGTH > ret_val->cell_size)
1040  {
1041    regfi_log_add(REGFI_LOG_WARN, "Security descriptor too large for"
1042                      " cell while parsing SK record at offset 0x%.8X.", 
1043                      offset);
1044    goto fail_locked;
1045  }
1046
1047  sec_desc_buf = (uint8_t*)malloc(ret_val->desc_size);
1048  if(sec_desc_buf == NULL)
1049    goto fail_locked;
1050
1051  length = ret_val->desc_size;
1052  if(regfi_read(file->cb, sec_desc_buf, &length) != 0 
1053     || length != ret_val->desc_size)
1054  {
1055    regfi_log_add(REGFI_LOG_ERROR, "Failed to read security"
1056                      " descriptor while parsing SK record at offset 0x%.8X.",
1057                      offset);
1058    goto fail_locked;
1059  }
1060
1061  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_sk"))
1062     goto fail;
1063
1064  if(!(ret_val->sec_desc = winsec_parse_desc(ret_val, sec_desc_buf, 
1065                                                   ret_val->desc_size)))
1066  {
1067    regfi_log_add(REGFI_LOG_ERROR, "Failed to parse security"
1068                      " descriptor while parsing SK record at offset 0x%.8X.",
1069                      offset);
1070    goto fail;
1071  }
1072
1073  free(sec_desc_buf);
1074  return ret_val;
1075
1076 fail_locked:
1077  regfi_unlock(file, &file->cb_lock, "regfi_parse_sk");
1078 fail:
1079  if(sec_desc_buf != NULL)
1080    free(sec_desc_buf);
1081  talloc_free(ret_val);
1082  return NULL;
1083}
1084
1085
1086REGFI_VALUE_LIST* regfi_parse_valuelist(REGFI_FILE* file, uint32_t offset, 
1087                                        uint32_t num_values, bool strict)
1088{
1089  REGFI_VALUE_LIST* ret_val;
1090  uint32_t i, cell_length, length, read_len;
1091  bool unalloc;
1092
1093  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_valuelist"))
1094     goto fail;
1095
1096  if(!regfi_parse_cell(file->cb, offset, NULL, 0, &cell_length, &unalloc))
1097  {
1098    regfi_log_add(REGFI_LOG_ERROR, "Failed to read cell header"
1099                      " while parsing value list at offset 0x%.8X.", offset);
1100    goto fail_locked;
1101  }
1102
1103  if((cell_length & 0x00000007) != 0)
1104  {
1105    regfi_log_add(REGFI_LOG_WARN, "Cell length not a multiple of 8"
1106                      " while parsing value list at offset 0x%.8X.", offset);
1107    if(strict)
1108      goto fail_locked;
1109    cell_length = cell_length & 0xFFFFFFF8;
1110  }
1111
1112  if((num_values * sizeof(uint32_t)) > cell_length-sizeof(uint32_t))
1113  {
1114    regfi_log_add(REGFI_LOG_WARN, "Too many values found"
1115                      " while parsing value list at offset 0x%.8X.", offset);
1116    if(strict)
1117      goto fail_locked;
1118    num_values = cell_length/sizeof(uint32_t) - sizeof(uint32_t);
1119  }
1120
1121  read_len = num_values*sizeof(uint32_t);
1122  ret_val = talloc(NULL, REGFI_VALUE_LIST);
1123  if(ret_val == NULL)
1124    goto fail_locked;
1125
1126  ret_val->elements = (REGFI_VALUE_LIST_ELEM*)talloc_size(ret_val, read_len);
1127  if(ret_val->elements == NULL)
1128    goto fail_locked;
1129
1130  ret_val->offset = offset;
1131  ret_val->cell_size = cell_length;
1132  ret_val->num_values = num_values;
1133
1134  length = read_len;
1135  if((regfi_read(file->cb, (uint8_t*)ret_val->elements, &length) != 0) 
1136     || length != read_len)
1137  {
1138    regfi_log_add(REGFI_LOG_ERROR, "Failed to read value pointers"
1139                      " while parsing value list at offset 0x%.8X.", offset);
1140    goto fail_locked;
1141  }
1142 
1143  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_valuelist"))
1144     goto fail;
1145
1146  for(i=0; i < num_values; i++)
1147  {
1148    /* Fix endianness */
1149    ret_val->elements[i] = IVAL(&ret_val->elements[i], 0);
1150
1151    /* Validate the first num_values values to ensure they make sense */
1152    if(strict)
1153    {
1154      /* XXX: Need to revisit this file length check when we start dealing
1155       *      with partial files. */
1156      if((ret_val->elements[i] + REGFI_REGF_SIZE > file->file_length)
1157         || ((ret_val->elements[i] & 0x00000007) != 0))
1158      {
1159        regfi_log_add(REGFI_LOG_WARN, "Invalid value pointer"
1160                          " (0x%.8X) found while parsing value list at offset"
1161                          " 0x%.8X.", ret_val->elements[i], offset);
1162        goto fail;
1163      }
1164    }
1165  }
1166
1167  return ret_val;
1168
1169 fail_locked:
1170  regfi_unlock(file, &file->cb_lock, "regfi_parse_valuelist");
1171 fail:
1172  talloc_free(ret_val);
1173  return NULL;
1174}
1175
1176/* XXX: should give this boolean return type to indicate errors */
1177void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk, 
1178                               REGFI_ENCODING output_encoding, bool strict)
1179{
1180  /* XXX: Registry value names are supposedly limited to 16383 characters
1181   *      according to:
1182   *      http://msdn.microsoft.com/en-us/library/ms724872%28VS.85%29.aspx
1183   *      Might want to emit a warning if this is exceeded. 
1184   *      It is expected that "characters" could be variable width.
1185   *      Also, it may be useful to use this information to limit false positives
1186   *      when recovering deleted VK records.
1187   */
1188  int32_t tmp_size;
1189  REGFI_ENCODING from_encoding = (vk->flags & REGFI_VK_FLAG_ASCIINAME)
1190    ? REGFI_ENCODING_ASCII : REGFI_ENCODING_UTF16LE;
1191
1192  if(from_encoding == output_encoding)
1193  {
1194    vk->name_raw[vk->name_length] = '\0';
1195    vk->name = (char*)vk->name_raw;
1196  }
1197  else
1198  {
1199    vk->name = talloc_array(vk, char, vk->name_length+1);
1200    if(vk->name == NULL)
1201      return;
1202
1203    tmp_size = regfi_conv_charset(regfi_encoding_int2str(from_encoding),
1204                                  regfi_encoding_int2str(output_encoding),
1205                                  vk->name_raw, vk->name,
1206                                  vk->name_length, vk->name_length+1);
1207    if(tmp_size < 0)
1208    {
1209      regfi_log_add(REGFI_LOG_WARN, "Error occurred while converting"
1210                        " value name to encoding %s.  Error message: %s",
1211                        regfi_encoding_int2str(output_encoding), 
1212                        strerror(-tmp_size));
1213      talloc_free(vk->name);
1214      vk->name = NULL;
1215    }
1216  }
1217}
1218
1219
1220/******************************************************************************
1221 ******************************************************************************/
1222REGFI_VK* regfi_load_value(REGFI_FILE* file, uint32_t offset, 
1223                           REGFI_ENCODING output_encoding, bool strict)
1224{
1225  REGFI_VK* ret_val = NULL;
1226  int32_t max_size;
1227
1228  max_size = regfi_calc_maxsize(file, offset);
1229  if(max_size < 0)
1230    return NULL;
1231 
1232  ret_val = regfi_parse_vk(file, offset, max_size, strict);
1233  if(ret_val == NULL)
1234    return NULL;
1235
1236  regfi_interpret_valuename(file, ret_val, output_encoding, strict);
1237
1238  return ret_val;
1239}
1240
1241
1242/******************************************************************************
1243 * If !strict, the list may contain NULLs, VK records may point to NULL.
1244 ******************************************************************************/
1245REGFI_VALUE_LIST* regfi_load_valuelist(REGFI_FILE* file, uint32_t offset, 
1246                                       uint32_t num_values, uint32_t max_size,
1247                                       bool strict)
1248{
1249  uint32_t usable_num_values;
1250
1251  if((num_values+1) * sizeof(uint32_t) > max_size)
1252  {
1253    regfi_log_add(REGFI_LOG_WARN, "Number of values indicated by"
1254                      " parent key (%d) would cause cell to straddle HBIN"
1255                      " boundary while loading value list at offset"
1256                      " 0x%.8X.", num_values, offset);
1257    if(strict)
1258      return NULL;
1259    usable_num_values = max_size/sizeof(uint32_t) - sizeof(uint32_t);
1260  }
1261  else
1262    usable_num_values = num_values;
1263
1264  return regfi_parse_valuelist(file, offset, usable_num_values, strict);
1265}
1266
1267
1268/* XXX: should give this boolean return type to indicate errors */
1269void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk, 
1270                             REGFI_ENCODING output_encoding, bool strict)
1271{
1272  /* XXX: Registry key names are supposedly limited to 255 characters according to:
1273   *      http://msdn.microsoft.com/en-us/library/ms724872%28VS.85%29.aspx
1274   *      Might want to emit a warning if this is exceeded. 
1275   *      It is expected that "characters" could be variable width.
1276   *      Also, it may be useful to use this information to limit false positives
1277   *      when recovering deleted NK records.
1278   */
1279  int32_t tmp_size;
1280  REGFI_ENCODING from_encoding = (nk->flags & REGFI_NK_FLAG_ASCIINAME) 
1281    ? REGFI_ENCODING_ASCII : REGFI_ENCODING_UTF16LE;
1282 
1283  if(from_encoding == output_encoding)
1284  {
1285    nk->name_raw[nk->name_length] = '\0';
1286    nk->name = (char*)nk->name_raw;
1287  }
1288  else
1289  {
1290    nk->name = talloc_array(nk, char, nk->name_length+1);
1291    if(nk->name == NULL)
1292      return;
1293
1294    memset(nk->name,0,nk->name_length+1);
1295
1296    tmp_size = regfi_conv_charset(regfi_encoding_int2str(from_encoding),
1297                                  regfi_encoding_int2str(output_encoding),
1298                                  nk->name_raw, nk->name,
1299                                  nk->name_length, nk->name_length+1);
1300    if(tmp_size < 0)
1301    {
1302      regfi_log_add(REGFI_LOG_WARN, "Error occurred while converting"
1303                        " key name to encoding %s.  Error message: %s",
1304                        regfi_encoding_int2str(output_encoding), 
1305                        strerror(-tmp_size));
1306      talloc_free(nk->name);
1307      nk->name = NULL;
1308    }
1309  }
1310}
1311
1312
1313/******************************************************************************
1314 *
1315 ******************************************************************************/
1316REGFI_NK* regfi_load_key(REGFI_FILE* file, uint32_t offset,
1317                         REGFI_ENCODING output_encoding, bool strict)
1318{
1319  REGFI_NK* nk;
1320  uint32_t off;
1321  int32_t max_size;
1322
1323  if(file->nk_cache != NULL)
1324  {
1325    /* First, check to see if we have this key in our cache */
1326    if(!regfi_lock(file, &file->mem_lock, "regfi_load_nk"))
1327      return NULL;
1328    regfi_lock(file, &file->nk_lock, "regfi_load_nk");
1329   
1330    nk = (REGFI_NK*)lru_cache_find(file->nk_cache, &offset, 4);
1331    if(nk != NULL)
1332      nk = talloc_reference(NULL, nk);
1333
1334    regfi_unlock(file, &file->nk_lock, "regfi_load_nk");
1335    regfi_unlock(file, &file->mem_lock, "regfi_load_nk");
1336    if(nk != NULL)
1337      return nk;
1338  }
1339
1340  /* Not cached currently, proceed with loading it */
1341  max_size = regfi_calc_maxsize(file, offset);
1342  if (max_size < 0) 
1343    return NULL;
1344
1345  /* get the initial nk record */
1346  if((nk = regfi_parse_nk(file, offset, max_size, true)) == NULL)
1347  {
1348    regfi_log_add(REGFI_LOG_ERROR, "Could not load NK record at"
1349                  " offset 0x%.8X.", offset);
1350    return NULL;
1351  }
1352
1353  regfi_interpret_keyname(file, nk, output_encoding, strict);
1354
1355  /* get value list */
1356  if(nk->num_values && (nk->values_off!=REGFI_OFFSET_NONE)) 
1357  {
1358    off = nk->values_off + REGFI_REGF_SIZE;
1359    max_size = regfi_calc_maxsize(file, off);
1360    if(max_size < 0)
1361    {
1362      if(strict)
1363      {
1364        talloc_free(nk);
1365        return NULL;
1366      }
1367      else
1368        nk->values = NULL;
1369    }
1370    else
1371    {
1372      nk->values = regfi_load_valuelist(file, off, nk->num_values, 
1373                                        max_size, true);
1374      if(nk->values == NULL)
1375      {
1376        regfi_log_add(REGFI_LOG_WARN, "Could not load value list"
1377                      " for NK record at offset 0x%.8X.", offset);
1378        if(strict)
1379        {
1380          talloc_free(nk);
1381          return NULL;
1382        }
1383      }
1384      talloc_reparent(NULL, nk, nk->values);
1385    }
1386  }
1387
1388  /* now get subkey list */
1389  if(nk->num_subkeys && (nk->subkeys_off != REGFI_OFFSET_NONE)) 
1390  {
1391    off = nk->subkeys_off + REGFI_REGF_SIZE;
1392    max_size = regfi_calc_maxsize(file, off);
1393    if(max_size < 0) 
1394    {
1395      if(strict)
1396      {
1397        talloc_free(nk);
1398        return NULL;
1399      }
1400      else
1401        nk->subkeys = NULL;
1402    }
1403    else
1404    {
1405      nk->subkeys = regfi_load_subkeylist(file, off, nk->num_subkeys,
1406                                          max_size, true);
1407
1408      if(nk->subkeys == NULL)
1409      {
1410        regfi_log_add(REGFI_LOG_WARN, "Could not load subkey list"
1411                      " while parsing NK record at offset 0x%.8X.", offset);
1412        nk->num_subkeys = 0;
1413      }
1414      talloc_reparent(NULL, nk, nk->subkeys);
1415    }
1416  }
1417
1418  if(file->nk_cache != NULL)
1419  {
1420    /* All is well, so let us cache this key for later */
1421    if(!regfi_lock(file, &file->mem_lock, "regfi_load_nk"))
1422      return NULL;
1423    regfi_lock(file, &file->nk_lock, "regfi_load_nk");
1424   
1425    lru_cache_update(file->nk_cache, &offset, 4, nk);
1426   
1427    regfi_unlock(file, &file->nk_lock, "regfi_load_nk");
1428    regfi_unlock(file, &file->mem_lock, "regfi_load_nk");
1429  }
1430
1431  return nk;
1432}
1433
1434
1435/******************************************************************************
1436 ******************************************************************************/
1437const REGFI_SK* regfi_load_sk(REGFI_FILE* file, uint32_t offset, bool strict)
1438{
1439  REGFI_SK* ret_val = NULL;
1440  int32_t max_size;
1441  void* failure_ptr = NULL;
1442 
1443  max_size = regfi_calc_maxsize(file, offset);
1444  if(max_size < 0)
1445    return NULL;
1446
1447  if(file->sk_cache == NULL)
1448    return regfi_parse_sk(file, offset, max_size, strict);
1449
1450  if(!regfi_lock(file, &file->mem_lock, "regfi_load_sk"))
1451    return NULL;
1452  regfi_lock(file, &file->sk_lock, "regfi_load_sk");
1453
1454  /* First look if we have already parsed it */
1455  ret_val = (REGFI_SK*)lru_cache_find(file->sk_cache, &offset, 4);
1456
1457  /* Bail out if we have previously cached a parse failure at this offset. */
1458  if(ret_val == (void*)REGFI_OFFSET_NONE)
1459  {
1460    ret_val = NULL;
1461    goto unlock;
1462  }
1463
1464  if(ret_val == NULL)
1465  {
1466    ret_val = regfi_parse_sk(file, offset, max_size, strict);
1467    if(ret_val == NULL)
1468    { /* Cache the parse failure and bail out. */
1469      failure_ptr = talloc(NULL, uint32_t);
1470      if(failure_ptr == NULL)
1471        goto unlock;
1472
1473      *(uint32_t*)failure_ptr = REGFI_OFFSET_NONE;
1474      lru_cache_update(file->sk_cache, &offset, 4, failure_ptr);
1475
1476      /* Let the cache be the only owner of this */
1477      talloc_unlink(NULL, failure_ptr);
1478    }
1479  }
1480  else
1481    ret_val = talloc_reference(NULL, ret_val);
1482
1483 unlock:
1484  regfi_unlock(file, &file->sk_lock, "regfi_load_sk");
1485  regfi_unlock(file, &file->mem_lock, "regfi_load_sk");
1486
1487  return ret_val;
1488}
1489
1490
1491
1492/******************************************************************************
1493 ******************************************************************************/
1494REGFI_NK* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin, 
1495                             REGFI_ENCODING output_encoding)
1496{
1497  REGFI_NK* nk = NULL;
1498  uint32_t cell_length;
1499  uint32_t cur_offset = hbin->file_off+REGFI_HBIN_HEADER_SIZE;
1500  uint32_t hbin_end = hbin->file_off+hbin->block_size;
1501  bool unalloc;
1502
1503  while(cur_offset < hbin_end)
1504  {
1505
1506    if(!regfi_lock(file, &file->cb_lock, "regfi_find_root_nk"))
1507      return NULL;
1508
1509    if(!regfi_parse_cell(file->cb, cur_offset, NULL, 0, &cell_length, &unalloc))
1510    {
1511      regfi_log_add(REGFI_LOG_WARN, "Could not parse cell at offset"
1512                    " 0x%.8X while searching for root key.", cur_offset);
1513      return NULL;
1514    }
1515
1516    if(!regfi_unlock(file, &file->cb_lock, "regfi_find_root_nk"))
1517      return NULL;
1518
1519    if(!unalloc)
1520    {
1521      nk = regfi_load_key(file, cur_offset, output_encoding, true);
1522      if(nk != NULL)
1523      {
1524        if(nk->flags & REGFI_NK_FLAG_ROOT)
1525          return nk;
1526      }
1527    }
1528
1529    cur_offset += cell_length;
1530  }
1531
1532  return NULL;
1533}
1534
1535
1536
1537/******************************************************************************
1538 ******************************************************************************/
1539REGFI_FILE* regfi_alloc(int fd, REGFI_ENCODING output_encoding)
1540{
1541  REGFI_FILE* ret_val;
1542  REGFI_RAW_FILE* file_cb = talloc(NULL, REGFI_RAW_FILE);
1543  if(file_cb == NULL) 
1544    return NULL;
1545
1546  file_cb->state = (void*)talloc(file_cb, int);
1547  if(file_cb->state == NULL)
1548    goto fail;
1549  *(int*)file_cb->state = fd;
1550 
1551  file_cb->cur_off = 0;
1552  file_cb->size = 0;
1553  file_cb->read = &regfi_raw_read;
1554  file_cb->seek = &regfi_raw_seek;
1555 
1556  ret_val = regfi_alloc_cb(file_cb, output_encoding);
1557  if(ret_val == NULL)
1558    goto fail;
1559
1560  /* In this case, we want file_cb to be freed when ret_val is */
1561  talloc_reparent(NULL, ret_val, file_cb);
1562  return ret_val;
1563
1564 fail:
1565    talloc_free(file_cb);
1566    return NULL;
1567}
1568
1569
1570/******************************************************************************
1571 ******************************************************************************/
1572static int regfi_free_cb(void* f)
1573{
1574  REGFI_FILE* file = (REGFI_FILE*)f;
1575
1576  pthread_mutex_destroy(&file->cb_lock);
1577  pthread_rwlock_destroy(&file->hbins_lock);
1578  pthread_mutex_destroy(&file->sk_lock);
1579  pthread_mutex_destroy(&file->nk_lock);
1580  pthread_mutex_destroy(&file->mem_lock);
1581
1582  return 0;
1583}
1584
1585
1586/******************************************************************************
1587 ******************************************************************************/
1588REGFI_FILE* regfi_alloc_cb(REGFI_RAW_FILE* file_cb, 
1589                           REGFI_ENCODING output_encoding)
1590{
1591  REGFI_FILE* rb;
1592  REGFI_HBIN* hbin = NULL;
1593  uint32_t hbin_off, cache_secret;
1594  int64_t file_length;
1595  bool rla;
1596
1597  /* Determine file length.  Must be at least big enough for the header
1598   * and one hbin.
1599   */
1600  file_length = regfi_seek(file_cb, 0, SEEK_END);
1601  if(file_length < REGFI_REGF_SIZE+REGFI_HBIN_ALLOC)
1602  {
1603    regfi_log_add(REGFI_LOG_ERROR, "File length (%d) too short to contain a"
1604                  " header and at least one HBIN.", file_length);
1605    return NULL;
1606  }
1607  regfi_seek(file_cb, 0, SEEK_SET);
1608
1609  if(output_encoding != REGFI_ENCODING_UTF8
1610     && output_encoding != REGFI_ENCODING_ASCII)
1611  { 
1612    regfi_log_add(REGFI_LOG_ERROR, "Invalid output_encoding supplied"
1613                  " in creation of regfi iterator.");
1614    return NULL;
1615  }
1616
1617  /* Read file header */
1618  if ((rb = regfi_parse_regf(file_cb, false)) == NULL)
1619  {
1620    regfi_log_add(REGFI_LOG_ERROR, "Failed to read REGF block.");
1621    return NULL;
1622  }
1623  rb->file_length = file_length;
1624  rb->cb = file_cb;
1625  rb->string_encoding = output_encoding;
1626
1627  if(pthread_mutex_init(&rb->cb_lock, NULL) != 0)
1628  {
1629    regfi_log_add(REGFI_LOG_ERROR, "Failed to create cb_lock mutex.");
1630    goto fail;
1631  }
1632
1633  if(pthread_rwlock_init(&rb->hbins_lock, NULL) != 0)
1634  {
1635    regfi_log_add(REGFI_LOG_ERROR, "Failed to create hbins_lock rwlock.");
1636    goto fail;
1637  }
1638
1639  if(pthread_mutex_init(&rb->sk_lock, NULL) != 0)
1640  {
1641    regfi_log_add(REGFI_LOG_ERROR, "Failed to create sk_lock mutex.");
1642    goto fail;
1643  }
1644
1645  if(pthread_mutex_init(&rb->nk_lock, NULL) != 0)
1646  {
1647    regfi_log_add(REGFI_LOG_ERROR, "Failed to create nk_lock mutex.");
1648    goto fail;
1649  }
1650
1651  if(pthread_mutex_init(&rb->mem_lock, NULL) != 0)
1652  {
1653    regfi_log_add(REGFI_LOG_ERROR, "Failed to create mem_lock mutex.");
1654    goto fail;
1655  }
1656
1657  rb->hbins = range_list_new();
1658  if(rb->hbins == NULL)
1659  {
1660    regfi_log_add(REGFI_LOG_ERROR, "Failed to create HBIN range_list.");
1661    goto fail;
1662  }
1663  talloc_reparent(NULL, rb, rb->hbins);
1664
1665  rla = true;
1666  hbin_off = REGFI_REGF_SIZE;
1667  hbin = regfi_parse_hbin(rb, hbin_off, true);
1668  while(hbin && rla)
1669  {
1670    rla = range_list_add(rb->hbins, hbin->file_off, hbin->block_size, hbin);
1671    if(rla)
1672      talloc_reparent(NULL, rb->hbins, hbin);
1673
1674    hbin_off = hbin->file_off + hbin->block_size;
1675    hbin = regfi_parse_hbin(rb, hbin_off, true);
1676  }
1677
1678  /* This secret isn't very secret, but we don't need a good one.  This
1679   * secret is just designed to prevent someone from trying to blow our
1680   * caching and make things slow.
1681   */
1682  cache_secret = 0x15DEAD05^time(NULL)^(getpid()<<16);
1683
1684  rb->sk_cache = NULL;
1685  if(REGFI_CACHE_SK_MAX > 0)
1686    rb->sk_cache = lru_cache_create_ctx(rb, REGFI_CACHE_SK_MAX, 
1687                                        cache_secret, true);
1688
1689  rb->nk_cache = NULL;
1690  if(REGFI_CACHE_NK_MAX > 0)
1691    rb->nk_cache = lru_cache_create_ctx(rb, REGFI_CACHE_NK_MAX, 
1692                                        cache_secret, true);
1693
1694  /* success */
1695  talloc_set_destructor(rb, regfi_free_cb);
1696  return rb;
1697
1698 fail:
1699  pthread_mutex_destroy(&rb->cb_lock);
1700  pthread_rwlock_destroy(&rb->hbins_lock);
1701  pthread_mutex_destroy(&rb->sk_lock);
1702  pthread_mutex_destroy(&rb->nk_lock);
1703  pthread_mutex_destroy(&rb->mem_lock);
1704
1705  range_list_free(rb->hbins);
1706  talloc_free(rb);
1707  return NULL;
1708}
1709
1710
1711/******************************************************************************
1712 ******************************************************************************/
1713void regfi_free(REGFI_FILE* file)
1714{
1715  /* Callback handles cleanup side effects */
1716  talloc_free(file);
1717}
1718
1719
1720/******************************************************************************
1721 * First checks the offset given by the file header, then checks the
1722 * rest of the file if that fails.
1723 ******************************************************************************/
1724const REGFI_NK* regfi_get_rootkey(REGFI_FILE* file)
1725{
1726  REGFI_NK* nk = NULL;
1727  REGFI_HBIN* hbin;
1728  uint32_t root_offset, i, num_hbins;
1729 
1730  if(!file)
1731    return NULL;
1732
1733  root_offset = file->root_cell+REGFI_REGF_SIZE;
1734  nk = regfi_load_key(file, root_offset, file->string_encoding, true);
1735  if(nk != NULL)
1736  {
1737    if(nk->flags & REGFI_NK_FLAG_ROOT)
1738      return nk;
1739  }
1740
1741  regfi_log_add(REGFI_LOG_WARN, "File header indicated root key at"
1742                " location 0x%.8X, but no root key found."
1743                " Searching rest of file...", root_offset);
1744 
1745  /* If the file header gives bad info, scan through the file one HBIN
1746   * block at a time looking for an NK record with a root key type.
1747   */
1748 
1749  if(!regfi_read_lock(file, &file->hbins_lock, "regfi_get_rootkey"))
1750    return NULL;
1751
1752  num_hbins = range_list_size(file->hbins);
1753  for(i=0; i < num_hbins && nk == NULL; i++)
1754  {
1755    hbin = (REGFI_HBIN*)range_list_get(file->hbins, i)->data;
1756    nk = regfi_find_root_nk(file, hbin, file->string_encoding);
1757  }
1758
1759  if(!regfi_rw_unlock(file, &file->hbins_lock, "regfi_get_rootkey"))
1760    return NULL;
1761
1762  return nk;
1763}
1764
1765
1766/******************************************************************************
1767 *****************************************************************************/
1768void regfi_free_record(REGFI_FILE* file, const void* record)
1769{
1770  if(!regfi_lock(file, &file->mem_lock, "regfi_free_record"))
1771    return;
1772
1773  talloc_unlink(NULL, (void*)record);
1774
1775  regfi_unlock(file, &file->mem_lock, "regfi_free_record");
1776}
1777
1778
1779/******************************************************************************
1780 *****************************************************************************/
1781const void* regfi_reference_record(REGFI_FILE* file, const void* record)
1782{
1783  const void* ret_val = NULL;
1784
1785  if(!regfi_lock(file, &file->mem_lock, "regfi_reference_record"))
1786    return ret_val;
1787
1788  ret_val = talloc_reference(NULL, record);
1789
1790  regfi_unlock(file, &file->mem_lock, "regfi_reference_record");
1791  return ret_val;
1792}
1793
1794
1795/******************************************************************************
1796 *****************************************************************************/
1797uint32_t regfi_fetch_num_subkeys(const REGFI_NK* key)
1798{
1799  uint32_t num_in_list = 0;
1800  if(key == NULL)
1801    return 0;
1802
1803  if(key->subkeys != NULL)
1804    num_in_list = key->subkeys->num_keys;
1805
1806  if(num_in_list != key->num_subkeys)
1807  {
1808    regfi_log_add(REGFI_LOG_INFO, "Key at offset 0x%.8X contains %d keys in its"
1809                  " subkey list but reports %d should be available.", 
1810                  key->offset, num_in_list, key->num_subkeys);
1811    return (num_in_list < key->num_subkeys)?num_in_list:key->num_subkeys;
1812  }
1813 
1814  return num_in_list;
1815}
1816
1817
1818/******************************************************************************
1819 *****************************************************************************/
1820uint32_t regfi_fetch_num_values(const REGFI_NK* key)
1821{
1822  uint32_t num_in_list = 0;
1823  if(key == NULL)
1824    return 0;
1825
1826  if(key->values != NULL)
1827    num_in_list = key->values->num_values;
1828
1829  if(num_in_list != key->num_values)
1830  {
1831    regfi_log_add(REGFI_LOG_INFO, "Key at offset 0x%.8X contains %d values in"
1832                  " its value list but reports %d should be available.",
1833                  key->offset, num_in_list, key->num_values);
1834    return (num_in_list < key->num_values)?num_in_list:key->num_values;
1835  }
1836 
1837  return num_in_list;
1838}
1839
1840
1841/******************************************************************************
1842 *****************************************************************************/
1843REGFI_ITERATOR* regfi_iterator_new(REGFI_FILE* file)
1844{
1845  REGFI_NK* root;
1846  REGFI_ITERATOR* ret_val;
1847
1848  ret_val = talloc(NULL, REGFI_ITERATOR);
1849  if(ret_val == NULL)
1850    return NULL;
1851 
1852  ret_val->cur = talloc(ret_val, REGFI_ITER_POSITION);
1853  if(ret_val->cur == NULL)
1854  {
1855    talloc_free(ret_val);
1856    return NULL;
1857  }
1858
1859  ret_val->key_positions = void_stack_new(REGFI_MAX_DEPTH);
1860  if(ret_val->key_positions == NULL)
1861  {
1862    talloc_free(ret_val);
1863    return NULL;
1864  }
1865  talloc_reparent(NULL, ret_val, ret_val->key_positions);
1866
1867  root = (REGFI_NK*)regfi_get_rootkey(file);
1868  if(root == NULL)
1869  {
1870    talloc_free(ret_val);
1871    return NULL;
1872  }
1873
1874  ret_val->cur->offset = root->offset;
1875  if(root->subkeys_off == REGFI_OFFSET_NONE)
1876    ret_val->cur->num_subkeys = 0;
1877  else
1878    ret_val->cur->num_subkeys = regfi_fetch_num_subkeys(root);
1879 
1880  if(root->values_off == REGFI_OFFSET_NONE)
1881    ret_val->cur->num_values = 0;
1882  else
1883    ret_val->cur->num_values = regfi_fetch_num_values(root);
1884
1885  ret_val->cur->cur_subkey = 0;
1886  ret_val->cur->cur_value = 0;
1887  ret_val->f = file;
1888
1889  regfi_free_record(ret_val->f, root);
1890  return ret_val;
1891}
1892
1893
1894/******************************************************************************
1895 *****************************************************************************/
1896void regfi_iterator_free(REGFI_ITERATOR* i)
1897{
1898  talloc_unlink(NULL, i);
1899}
1900
1901
1902/******************************************************************************
1903 *****************************************************************************/
1904/* XXX: some way of indicating reason for failure should be added. */
1905bool regfi_iterator_down(REGFI_ITERATOR* i)
1906{
1907  REGFI_NK* subkey;
1908  REGFI_ITER_POSITION* pos = talloc(i, REGFI_ITER_POSITION);
1909  if(pos == NULL)
1910    return false;
1911
1912  subkey = (REGFI_NK*)regfi_iterator_cur_subkey(i);
1913  if(subkey == NULL)
1914  {
1915    talloc_free(pos);
1916    return false;
1917  }
1918
1919  if(!void_stack_push(i->key_positions, i->cur))
1920  {
1921    talloc_free(pos);
1922    regfi_free_record(i->f, subkey);
1923    return false;
1924  }
1925
1926  pos->offset = subkey->offset;
1927  if(subkey->subkeys_off == REGFI_OFFSET_NONE)
1928    pos->num_subkeys = 0;
1929  else
1930    pos->num_subkeys = regfi_fetch_num_subkeys(subkey);
1931
1932  if(subkey->values_off == REGFI_OFFSET_NONE)
1933    pos->num_values = 0;
1934  else
1935    pos->num_values = regfi_fetch_num_values(subkey);
1936
1937  pos->cur_subkey = 0;
1938  pos->cur_value = 0;
1939  i->cur = pos;
1940
1941  regfi_free_record(i->f, subkey);
1942  return true;
1943}
1944
1945
1946/******************************************************************************
1947 *****************************************************************************/
1948bool regfi_iterator_up(REGFI_ITERATOR* i)
1949{
1950  REGFI_ITER_POSITION* pos;
1951
1952  pos = (REGFI_ITER_POSITION*)void_stack_pop(i->key_positions);
1953  if(pos == NULL)
1954    return false;
1955
1956  if(!regfi_lock(i->f, &i->f->mem_lock, "regfi_iterator_up"))
1957    return false;
1958 
1959  talloc_unlink(i, i->cur);
1960
1961  regfi_unlock(i->f, &i->f->mem_lock, "regfi_iterator_up");
1962
1963  i->cur = pos;
1964  return true;
1965}
1966
1967
1968/******************************************************************************
1969 *****************************************************************************/
1970bool regfi_iterator_to_root(REGFI_ITERATOR* i)
1971{
1972  while(regfi_iterator_up(i))
1973    continue;
1974
1975  return true;
1976}
1977
1978
1979/******************************************************************************
1980 *****************************************************************************/
1981bool regfi_iterator_find_subkey(REGFI_ITERATOR* i, const char* name)
1982{
1983  const REGFI_NK* cur_key;
1984  uint32_t new_index;
1985  bool ret_val = false;
1986
1987  cur_key = regfi_iterator_cur_key(i);
1988  if(cur_key == NULL)
1989    /* XXX: report error */
1990    return ret_val;
1991
1992  if(regfi_find_subkey(i->f, cur_key, name, &new_index))
1993  {
1994    i->cur->cur_subkey = new_index;
1995    ret_val = true;
1996  }
1997
1998  regfi_free_record(i->f, cur_key);
1999  return ret_val;
2000}
2001
2002
2003/******************************************************************************
2004 *****************************************************************************/
2005bool regfi_iterator_descend(REGFI_ITERATOR* i, const char** path)
2006{
2007  uint32_t x;
2008  if(path == NULL)
2009    return false;
2010
2011  for(x=0; 
2012      ((path[x] != NULL) && regfi_iterator_find_subkey(i, path[x])
2013       && regfi_iterator_down(i));
2014      x++)
2015  { continue; }
2016
2017  if(path[x] == NULL)
2018  {
2019    return true;
2020  }
2021
2022  /* XXX: is this the right number of times? */
2023  for(; x > 0; x--)
2024    regfi_iterator_up(i);
2025 
2026  return false;
2027}
2028
2029
2030/******************************************************************************
2031 *****************************************************************************/
2032const REGFI_NK* regfi_iterator_cur_key(REGFI_ITERATOR* i)
2033{
2034  const REGFI_NK* ret_val = NULL;
2035
2036  ret_val = regfi_load_key(i->f, i->cur->offset, i->f->string_encoding, true);
2037  return ret_val;
2038}
2039
2040
2041/******************************************************************************
2042 *****************************************************************************/
2043const REGFI_SK* regfi_fetch_sk(REGFI_FILE* file, const REGFI_NK* key)
2044{
2045  if(key == NULL || key->sk_off == REGFI_OFFSET_NONE)
2046    return NULL;
2047
2048  return regfi_load_sk(file, key->sk_off + REGFI_REGF_SIZE, true);
2049}
2050
2051
2052/******************************************************************************
2053 *****************************************************************************/
2054const REGFI_SK* regfi_next_sk(REGFI_FILE* file, const REGFI_SK* sk)
2055{
2056  if(sk == NULL || sk->next_sk_off == REGFI_OFFSET_NONE)
2057    return NULL;
2058
2059  return regfi_load_sk(file, sk->next_sk_off + REGFI_REGF_SIZE, true);
2060}
2061
2062
2063/******************************************************************************
2064 *****************************************************************************/
2065const REGFI_SK* regfi_prev_sk(REGFI_FILE* file, const REGFI_SK* sk)
2066{
2067  if(sk == NULL || sk->prev_sk_off == REGFI_OFFSET_NONE)
2068    return NULL;
2069
2070  return regfi_load_sk(file, sk->prev_sk_off + REGFI_REGF_SIZE, true);
2071}
2072
2073
2074/******************************************************************************
2075 *****************************************************************************/
2076bool regfi_iterator_first_subkey(REGFI_ITERATOR* i)
2077{
2078  i->cur->cur_subkey = 0;
2079  return (i->cur->cur_subkey < i->cur->num_subkeys);
2080}
2081
2082
2083/******************************************************************************
2084 *****************************************************************************/
2085const REGFI_NK* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
2086{
2087  const REGFI_NK* cur_key;
2088  const REGFI_NK* ret_val;
2089 
2090  cur_key = regfi_iterator_cur_key(i);
2091  if(cur_key == NULL)
2092    /* XXX: report error */
2093    return NULL;
2094
2095  ret_val = regfi_get_subkey(i->f, cur_key, i->cur->cur_subkey);
2096
2097  regfi_free_record(i->f, cur_key);
2098  return ret_val;
2099}
2100
2101
2102/******************************************************************************
2103 *****************************************************************************/
2104bool regfi_iterator_next_subkey(REGFI_ITERATOR* i)
2105{
2106  i->cur->cur_subkey++;
2107  return (i->cur->cur_subkey < i->cur->num_subkeys);
2108}
2109
2110
2111/******************************************************************************
2112 *****************************************************************************/
2113bool regfi_iterator_find_value(REGFI_ITERATOR* i, const char* name)
2114{
2115  const REGFI_NK* cur_key;
2116  uint32_t new_index;
2117  bool ret_val = false;
2118
2119  cur_key = regfi_iterator_cur_key(i);
2120  if(cur_key == NULL)
2121    /* XXX: report error */
2122    return ret_val;
2123
2124  if(regfi_find_value(i->f, cur_key, name, &new_index))
2125  {
2126    i->cur->cur_value = new_index;
2127    ret_val = true;
2128  }
2129
2130  regfi_free_record(i->f, cur_key);
2131  return ret_val;
2132}
2133
2134
2135/******************************************************************************
2136 *****************************************************************************/
2137bool regfi_iterator_first_value(REGFI_ITERATOR* i)
2138{
2139  i->cur->cur_value = 0;
2140  return (i->cur->cur_value < i->cur->num_values);
2141}
2142
2143
2144/******************************************************************************
2145 *****************************************************************************/
2146const REGFI_VK* regfi_iterator_cur_value(REGFI_ITERATOR* i)
2147{
2148  const REGFI_NK* cur_key;
2149  const REGFI_VK* ret_val = NULL;
2150
2151  cur_key = regfi_iterator_cur_key(i);
2152  if(cur_key == NULL)
2153    /* XXX: report error */
2154    return ret_val;
2155
2156  ret_val = regfi_get_value(i->f, cur_key, i->cur->cur_value);
2157 
2158  regfi_free_record(i->f, cur_key);
2159  return ret_val;
2160}
2161
2162
2163/******************************************************************************
2164 *****************************************************************************/
2165bool regfi_iterator_next_value(REGFI_ITERATOR* i)
2166{
2167  i->cur->cur_value++;
2168  return (i->cur->cur_value < i->cur->num_values);
2169}
2170
2171
2172
2173
2174/******************************************************************************
2175 *****************************************************************************/
2176const REGFI_NK** regfi_iterator_ancestry(REGFI_ITERATOR* i)
2177{
2178  REGFI_NK** ret_val;
2179  void_stack_iterator* iter;
2180  const REGFI_ITER_POSITION* cur;
2181  uint16_t k, num_keys;
2182
2183  num_keys = void_stack_size(i->key_positions)+1;
2184  ret_val = talloc_array(NULL, REGFI_NK*, num_keys+1);
2185  if(ret_val == NULL)
2186    return NULL;
2187
2188  iter = void_stack_iterator_new(i->key_positions);
2189  if (iter == NULL)
2190  {
2191    talloc_free(ret_val);
2192    return NULL;
2193  }
2194
2195  k=0;
2196  for(cur=void_stack_iterator_next(iter);
2197      cur != NULL; cur=void_stack_iterator_next(iter))
2198  { 
2199    ret_val[k++] = regfi_load_key(i->f, cur->offset, i->f->string_encoding, true); 
2200  }
2201  ret_val[k] = regfi_load_key(i->f, i->cur->offset, i->f->string_encoding, true);
2202  void_stack_iterator_free(iter);
2203
2204  if(!regfi_lock(i->f, &i->f->mem_lock, "regfi_iterator_ancestry"))
2205  {
2206    talloc_free(ret_val);
2207    return NULL;
2208  }
2209
2210  for(k=0; k<num_keys; k++)
2211    talloc_reparent(NULL, ret_val, ret_val[k]);
2212
2213  regfi_unlock(i->f, &i->f->mem_lock, "regfi_iterator_ancestry");
2214
2215  ret_val[k] = NULL;
2216  return (const REGFI_NK**)ret_val;
2217}
2218
2219
2220/******************************************************************************
2221 *****************************************************************************/
2222const REGFI_CLASSNAME* regfi_fetch_classname(REGFI_FILE* file,
2223                                             const REGFI_NK* key)
2224{
2225  REGFI_CLASSNAME* ret_val;
2226  uint8_t* raw;
2227  char* interpreted;
2228  uint32_t offset;
2229  int32_t conv_size, max_size;
2230  uint16_t parse_length;
2231
2232  if(key->classname_off == REGFI_OFFSET_NONE || key->classname_length == 0)
2233    return NULL;
2234
2235  offset = key->classname_off + REGFI_REGF_SIZE;
2236  max_size = regfi_calc_maxsize(file, offset);
2237  if(max_size <= 0)
2238    return NULL;
2239
2240  parse_length = key->classname_length;
2241  raw = regfi_parse_classname(file, offset, &parse_length, max_size, true);
2242 
2243  if(raw == NULL)
2244  {
2245    regfi_log_add(REGFI_LOG_WARN, "Could not parse class"
2246                  " name at offset 0x%.8X for key record at offset 0x%.8X.",
2247                  offset, key->offset);
2248    return NULL;
2249  }
2250
2251  ret_val = talloc(NULL, REGFI_CLASSNAME);
2252  if(ret_val == NULL)
2253    return NULL;
2254
2255  ret_val->offset = offset;
2256  ret_val->raw = raw;
2257  ret_val->size = parse_length;
2258  talloc_reparent(NULL, ret_val, raw);
2259
2260  interpreted = talloc_array(NULL, char, parse_length);
2261
2262  conv_size = regfi_conv_charset(regfi_encoding_int2str(REGFI_ENCODING_UTF16LE),
2263                                 regfi_encoding_int2str(file->string_encoding),
2264                                 raw, interpreted,
2265                                 parse_length, parse_length);
2266  if(conv_size < 0)
2267  {
2268    regfi_log_add(REGFI_LOG_WARN, "Error occurred while"
2269                  " converting classname to charset %s.  Error message: %s",
2270                  file->string_encoding, strerror(-conv_size));
2271    talloc_free(interpreted);
2272    ret_val->interpreted = NULL;
2273  }
2274  else
2275  {
2276    /* XXX: check for NULL return here? */
2277    interpreted = talloc_realloc(NULL, interpreted, char, conv_size);
2278    ret_val->interpreted = interpreted;
2279    talloc_reparent(NULL, ret_val, interpreted);
2280  }
2281
2282  return ret_val;
2283}
2284
2285
2286/******************************************************************************
2287 *****************************************************************************/
2288const REGFI_DATA* regfi_fetch_data(REGFI_FILE* file, 
2289                                   const REGFI_VK* value)
2290{
2291  REGFI_DATA* ret_val = NULL;
2292  REGFI_BUFFER raw_data;
2293
2294  if(value->data_size != 0)
2295  {
2296    raw_data = regfi_load_data(file, value->data_off, value->data_size,
2297                               value->data_in_offset, true);
2298    if(raw_data.buf == NULL)
2299    {
2300      regfi_log_add(REGFI_LOG_WARN, "Could not parse data record"
2301                    " while parsing VK record at offset 0x%.8X.",
2302                    value->offset);
2303    }
2304    else
2305    {
2306      ret_val = regfi_buffer_to_data(raw_data);
2307
2308      if(ret_val == NULL)
2309      {
2310        regfi_log_add(REGFI_LOG_WARN, "Error occurred in converting"
2311                      " data buffer to data structure while interpreting "
2312                      "data for VK record at offset 0x%.8X.",
2313                      value->offset);
2314        talloc_free(raw_data.buf);
2315        return NULL;
2316      }
2317
2318      if(!regfi_interpret_data(file, file->string_encoding, 
2319                               value->type, ret_val))
2320      {
2321        regfi_log_add(REGFI_LOG_INFO, "Error occurred while"
2322                      " interpreting data for VK record at offset 0x%.8X.",
2323                      value->offset);
2324      }
2325    }
2326  }
2327 
2328  return ret_val;
2329}
2330
2331
2332
2333/******************************************************************************
2334 *****************************************************************************/
2335bool regfi_find_subkey(REGFI_FILE* file, const REGFI_NK* key, 
2336                       const char* name, uint32_t* index)
2337{
2338  const REGFI_NK* cur;
2339  uint32_t i;
2340  uint32_t num_subkeys = regfi_fetch_num_subkeys(key);
2341  bool found = false;
2342
2343  /* XXX: cur->name can be NULL in the registry. 
2344   *      Should we allow for a way to search for that?
2345   */
2346  if(name == NULL)
2347    return false;
2348
2349  for(i=0; (i < num_subkeys) && (found == false); i++)
2350  {
2351    cur = regfi_get_subkey(file, key, i);
2352    if(cur == NULL)
2353      return false;
2354
2355    if((cur->name != NULL)
2356       && (strcasecmp(cur->name, name) == 0))
2357    {
2358      found = true;
2359      *index = i;
2360    }
2361
2362    regfi_free_record(file, cur);
2363  }
2364
2365  return found;
2366}
2367
2368
2369
2370/******************************************************************************
2371 *****************************************************************************/
2372bool regfi_find_value(REGFI_FILE* file, const REGFI_NK* key, 
2373                      const char* name, uint32_t* index)
2374{
2375  const REGFI_VK* cur;
2376  uint32_t i;
2377  uint32_t num_values = regfi_fetch_num_values(key);
2378  bool found = false;
2379
2380  /* XXX: cur->name can be NULL in the registry. 
2381   *      Should we allow for a way to search for that?
2382   */
2383  if(name == NULL)
2384    return false;
2385
2386  for(i=0; (i < num_values) && (found == false); i++)
2387  {
2388    cur = regfi_get_value(file, key, i);
2389    if(cur == NULL)
2390      return false;
2391
2392    if((cur->name != NULL)
2393       && (strcasecmp(cur->name, name) == 0))
2394    {
2395      found = true;
2396      *index = i;
2397    }
2398
2399    regfi_free_record(file, cur);
2400  }
2401
2402  return found;
2403}
2404
2405
2406
2407/******************************************************************************
2408 *****************************************************************************/
2409const REGFI_NK* regfi_get_subkey(REGFI_FILE* file, const REGFI_NK* key, 
2410                                 uint32_t index)
2411{
2412  if(index < regfi_fetch_num_subkeys(key))
2413  {
2414    return regfi_load_key(file, 
2415                          key->subkeys->elements[index].offset+REGFI_REGF_SIZE,
2416                          file->string_encoding, true);
2417  }
2418
2419  return NULL;
2420}
2421
2422
2423/******************************************************************************
2424 *****************************************************************************/
2425const REGFI_VK* regfi_get_value(REGFI_FILE* file, const REGFI_NK* key, 
2426                                uint32_t index)
2427{
2428  if(index < regfi_fetch_num_values(key))
2429  {
2430    return regfi_load_value(file, 
2431                            key->values->elements[index]+REGFI_REGF_SIZE,
2432                            file->string_encoding, true);
2433  }
2434
2435  return NULL; 
2436}
2437
2438
2439
2440/******************************************************************************
2441 *****************************************************************************/
2442const REGFI_NK* regfi_get_parentkey(REGFI_FILE* file, const REGFI_NK* key)
2443{
2444  if(key != NULL && key->parent_off != REGFI_OFFSET_NONE)
2445    return regfi_load_key(file, 
2446                          key->parent_off+REGFI_REGF_SIZE,
2447                          file->string_encoding, true);
2448
2449  return NULL;
2450}
2451
2452
2453
2454/******************************************************************************
2455 *****************************************************************************/
2456REGFI_DATA* regfi_buffer_to_data(REGFI_BUFFER raw_data)
2457{
2458  REGFI_DATA* ret_val;
2459
2460  if(raw_data.buf == NULL)
2461    return NULL;
2462
2463  ret_val = talloc(NULL, REGFI_DATA);
2464  if(ret_val == NULL)
2465    return NULL;
2466 
2467  talloc_reparent(NULL, ret_val, raw_data.buf);
2468  ret_val->raw = raw_data.buf;
2469  ret_val->size = raw_data.len;
2470  ret_val->interpreted_size = 0;
2471  ret_val->interpreted.qword = 0;
2472
2473  return ret_val;
2474}
2475
2476
2477/******************************************************************************
2478 *****************************************************************************/
2479bool regfi_interpret_data(REGFI_FILE* file, REGFI_ENCODING string_encoding,
2480                          uint32_t type, REGFI_DATA* data)
2481{
2482  uint8_t** tmp_array;
2483  uint8_t* tmp_str;
2484  int32_t tmp_size;
2485  uint32_t i, j, array_size;
2486
2487  if(data == NULL)
2488    return false;
2489
2490  switch (type)
2491  {
2492  case REG_SZ:
2493  case REG_EXPAND_SZ:
2494  /* REG_LINK is a symbolic link, stored as a unicode string. */
2495  case REG_LINK:
2496    tmp_str = talloc_array(NULL, uint8_t, data->size);
2497    if(tmp_str == NULL)
2498    {
2499      data->interpreted.string = NULL;
2500      data->interpreted_size = 0;
2501      return false;
2502    }
2503     
2504    tmp_size = regfi_conv_charset(regfi_encoding_int2str(REGFI_ENCODING_UTF16LE),
2505                                  regfi_encoding_int2str(string_encoding),
2506                                  data->raw, (char*)tmp_str, 
2507                                  data->size, data->size);
2508    if(tmp_size < 0)
2509    {
2510      regfi_log_add(REGFI_LOG_INFO, "Error occurred while"
2511                    " converting data of type %d to %d.  Error message: %s",
2512                    type, string_encoding, strerror(-tmp_size));
2513      talloc_free(tmp_str);
2514      data->interpreted.string = NULL;
2515      data->interpreted_size = 0;
2516      return false;
2517    }
2518
2519    /* XXX: check for NULL */
2520    tmp_str = talloc_realloc(NULL, tmp_str, uint8_t, tmp_size);
2521    data->interpreted.string = tmp_str;
2522    data->interpreted_size = tmp_size;
2523    talloc_reparent(NULL, data, tmp_str);
2524    break;
2525
2526  case REG_DWORD:
2527    if(data->size < 4)
2528    {
2529      data->interpreted.dword = 0;
2530      data->interpreted_size = 0;
2531      return false;
2532    }
2533    data->interpreted.dword = IVAL(data->raw, 0);
2534    data->interpreted_size = 4;
2535    break;
2536
2537  case REG_DWORD_BE:
2538    if(data->size < 4)
2539    {
2540      data->interpreted.dword_be = 0;
2541      data->interpreted_size = 0;
2542      return false;
2543    }
2544    data->interpreted.dword_be = RIVAL(data->raw, 0);
2545    data->interpreted_size = 4;
2546    break;
2547
2548  case REG_QWORD:
2549    if(data->size < 8)
2550    {
2551      data->interpreted.qword = 0;
2552      data->interpreted_size = 0;
2553      return false;
2554    }
2555    data->interpreted.qword = 
2556      (uint64_t)IVAL(data->raw, 0) + (((uint64_t)IVAL(data->raw, 4))<<32);
2557    data->interpreted_size = 8;
2558    break;
2559   
2560  case REG_MULTI_SZ:
2561    tmp_str = talloc_array(NULL, uint8_t, data->size);
2562    if(tmp_str == NULL)
2563    {
2564      data->interpreted.multiple_string = NULL;
2565      data->interpreted_size = 0;
2566      return false;
2567    }
2568
2569    /* Attempt to convert entire string from UTF-16LE to output encoding,
2570     * then parse and quote fields individually.
2571     */
2572    tmp_size = regfi_conv_charset(regfi_encoding_int2str(REGFI_ENCODING_UTF16LE),
2573                                  regfi_encoding_int2str(string_encoding),
2574                                  data->raw, (char*)tmp_str,
2575                                  data->size, data->size);
2576    if(tmp_size < 0)
2577    {
2578      regfi_log_add(REGFI_LOG_INFO, "Error occurred while"
2579                    " converting data of type %d to %s.  Error message: %s",
2580                    type, string_encoding, strerror(-tmp_size));
2581      talloc_free(tmp_str);
2582      data->interpreted.multiple_string = NULL;
2583      data->interpreted_size = 0;
2584      return false;
2585    }
2586
2587    array_size = tmp_size+1;
2588    tmp_array = talloc_array(NULL, uint8_t*, array_size);
2589    if(tmp_array == NULL)
2590    {
2591      talloc_free(tmp_str);
2592      data->interpreted.string = NULL;
2593      data->interpreted_size = 0;
2594      return false;
2595    }
2596   
2597    tmp_array[0] = tmp_str;
2598    for(i=0,j=1; i < tmp_size && j < array_size-1; i++)
2599    {
2600      if(tmp_str[i] == '\0' && (i+1 < tmp_size) && tmp_str[i+1] != '\0')
2601        tmp_array[j++] = tmp_str+i+1;
2602    }
2603    tmp_array[j] = NULL;
2604    tmp_array = talloc_realloc(NULL, tmp_array, uint8_t*, j+1);
2605    data->interpreted.multiple_string = tmp_array;
2606    /* XXX: how meaningful is this?  should we store number of strings instead? */
2607    data->interpreted_size = tmp_size;
2608    talloc_reparent(NULL, tmp_array, tmp_str);
2609    talloc_reparent(NULL, data, tmp_array);
2610    break;
2611
2612  /* XXX: Dont know how to interpret these yet, just treat as binary */
2613  case REG_NONE:
2614    data->interpreted.none = data->raw;
2615    data->interpreted_size = data->size;
2616    break;
2617
2618  case REG_RESOURCE_LIST:
2619    data->interpreted.resource_list = data->raw;
2620    data->interpreted_size = data->size;
2621    break;
2622
2623  case REG_FULL_RESOURCE_DESCRIPTOR:
2624    data->interpreted.full_resource_descriptor = data->raw;
2625    data->interpreted_size = data->size;
2626    break;
2627
2628  case REG_RESOURCE_REQUIREMENTS_LIST:
2629    data->interpreted.resource_requirements_list = data->raw;
2630    data->interpreted_size = data->size;
2631    break;
2632
2633  case REG_BINARY:
2634    data->interpreted.binary = data->raw;
2635    data->interpreted_size = data->size;
2636    break;
2637
2638  default:
2639    data->interpreted.qword = 0;
2640    data->interpreted_size = 0;
2641    return false;
2642  }
2643
2644  data->type = type;
2645  return true;
2646}
2647
2648
2649/******************************************************************************
2650 * Convert from UTF-16LE to specified character set.
2651 * On error, returns a negative errno code.
2652 *****************************************************************************/
2653int32_t regfi_conv_charset(const char* input_charset, const char* output_charset,
2654                           uint8_t* input, char* output, 
2655                           uint32_t input_len, uint32_t output_max)
2656{
2657  iconv_t conv_desc;
2658  char* inbuf = (char*)input;
2659  char* outbuf = output;
2660  size_t in_len = (size_t)input_len;
2661  size_t out_len = (size_t)(output_max-1);
2662  int ret;
2663
2664  /* XXX: Consider creating a couple of conversion descriptors earlier,
2665   *      storing them on an iterator so they don't have to be recreated
2666   *      each time.
2667   */
2668
2669  /* Set up conversion descriptor. */
2670  conv_desc = iconv_open(output_charset, input_charset);
2671
2672  ret = iconv(conv_desc, &inbuf, &in_len, &outbuf, &out_len);
2673  if(ret == -1)
2674  {
2675    iconv_close(conv_desc);
2676    return -errno;
2677  }
2678  *outbuf = '\0';
2679
2680  iconv_close(conv_desc); 
2681  return output_max-out_len-1;
2682}
2683
2684
2685
2686/*******************************************************************
2687 * Computes the checksum of the registry file header.
2688 * buffer must be at least the size of a regf header (4096 bytes).
2689 *******************************************************************/
2690static uint32_t regfi_compute_header_checksum(uint8_t* buffer)
2691{
2692  uint32_t checksum, x;
2693  int i;
2694
2695  /* XOR of all bytes 0x0000 - 0x01FB */
2696
2697  checksum = x = 0;
2698 
2699  for ( i=0; i<0x01FB; i+=4 ) {
2700    x = IVAL(buffer, i );
2701    checksum ^= x;
2702  }
2703 
2704  return checksum;
2705}
2706
2707
2708/*******************************************************************
2709 *******************************************************************/
2710REGFI_FILE* regfi_parse_regf(REGFI_RAW_FILE* file_cb, bool strict)
2711{
2712  uint8_t file_header[REGFI_REGF_SIZE];
2713  uint32_t length;
2714  REGFI_FILE* ret_val;
2715
2716  ret_val = talloc(NULL, REGFI_FILE);
2717  if(ret_val == NULL)
2718    return NULL;
2719
2720  ret_val->sk_cache = NULL;
2721  ret_val->hbins = NULL;
2722
2723  length = REGFI_REGF_SIZE;
2724  if((regfi_read(file_cb, file_header, &length)) != 0 
2725     || length != REGFI_REGF_SIZE)
2726  {
2727    regfi_log_add(REGFI_LOG_WARN, "Read failed while parsing REGF structure.");
2728    goto fail;
2729  }
2730
2731  ret_val->checksum = IVAL(file_header, 0x1FC);
2732  ret_val->computed_checksum = regfi_compute_header_checksum(file_header);
2733  if (strict && (ret_val->checksum != ret_val->computed_checksum))
2734  {
2735    regfi_log_add(REGFI_LOG_WARN, "Stored header checksum (%.8X) did not equal"
2736                  " computed checksum (%.8X).",
2737                  ret_val->checksum, ret_val->computed_checksum);
2738    if(strict)
2739      goto fail;
2740  }
2741
2742  memcpy(ret_val->magic, file_header, REGFI_REGF_MAGIC_SIZE);
2743  if(memcmp(ret_val->magic, "regf", REGFI_REGF_MAGIC_SIZE) != 0)
2744  {
2745    regfi_log_add(REGFI_LOG_ERROR, "Magic number mismatch "
2746                  "(%.2X %.2X %.2X %.2X) while parsing hive header",
2747                  ret_val->magic[0], ret_val->magic[1], 
2748                  ret_val->magic[2], ret_val->magic[3]);
2749    goto fail;
2750  }
2751
2752  ret_val->sequence1 = IVAL(file_header, 0x4);
2753  ret_val->sequence2 = IVAL(file_header, 0x8);
2754  ret_val->mtime = ((uint64_t)IVAL(file_header, 0x10)) << 32;
2755  ret_val->mtime |= IVAL(file_header, 0xC);
2756  ret_val->major_version = IVAL(file_header, 0x14);
2757  ret_val->minor_version = IVAL(file_header, 0x18);
2758  ret_val->type = IVAL(file_header, 0x1C);
2759  ret_val->format = IVAL(file_header, 0x20);
2760  ret_val->root_cell = IVAL(file_header, 0x24);
2761  ret_val->last_block = IVAL(file_header, 0x28);
2762  ret_val->cluster = IVAL(file_header, 0x2C);
2763
2764  memcpy(ret_val->file_name, file_header+0x30,  REGFI_REGF_NAME_SIZE);
2765
2766  /* XXX: Should we add a warning if these uuid parsers fail?  Can they? */
2767  ret_val->rm_id = winsec_parse_uuid(ret_val, file_header+0x70, 16);
2768  ret_val->log_id = winsec_parse_uuid(ret_val, file_header+0x80, 16);
2769  ret_val->flags = IVAL(file_header, 0x90);
2770  ret_val->tm_id = winsec_parse_uuid(ret_val, file_header+0x94, 16);
2771  ret_val->guid_signature = IVAL(file_header, 0xa4);
2772
2773  memcpy(ret_val->reserved1, file_header+0xa8, REGFI_REGF_RESERVED1_SIZE);
2774  memcpy(ret_val->reserved2, file_header+0x200, REGFI_REGF_RESERVED2_SIZE);
2775
2776  ret_val->thaw_tm_id = winsec_parse_uuid(ret_val, file_header+0xFC8, 16);
2777  ret_val->thaw_rm_id = winsec_parse_uuid(ret_val, file_header+0xFD8, 16);
2778  ret_val->thaw_log_id = winsec_parse_uuid(ret_val, file_header+0xFE8, 16);
2779  ret_val->boot_type = IVAL(file_header, 0xFF8);
2780  ret_val->boot_recover = IVAL(file_header, 0xFFC);
2781
2782  return ret_val;
2783
2784 fail:
2785  talloc_free(ret_val);
2786  return NULL;
2787}
2788
2789
2790
2791/******************************************************************************
2792 * Given real file offset, read and parse the hbin at that location
2793 * along with it's associated cells.
2794 ******************************************************************************/
2795REGFI_HBIN* regfi_parse_hbin(REGFI_FILE* file, uint32_t offset, bool strict)
2796{
2797  REGFI_HBIN* hbin = NULL;
2798  uint8_t hbin_header[REGFI_HBIN_HEADER_SIZE];
2799  uint32_t length;
2800 
2801  if(offset >= file->file_length)
2802    goto fail;
2803 
2804  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_hbin"))
2805    goto fail;
2806
2807  if(regfi_seek(file->cb, offset, SEEK_SET) == -1)
2808  {
2809    regfi_log_add(REGFI_LOG_ERROR, "Seek failed"
2810                  " while parsing hbin at offset 0x%.8X.", offset);
2811    goto fail_locked;
2812  }
2813
2814  length = REGFI_HBIN_HEADER_SIZE;
2815  if((regfi_read(file->cb, hbin_header, &length) != 0) 
2816     || length != REGFI_HBIN_HEADER_SIZE)
2817  {
2818    regfi_log_add(REGFI_LOG_ERROR, "Read failed"
2819                  " while parsing hbin at offset 0x%.8X.", offset);
2820    goto fail_locked;
2821  }
2822
2823  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_hbin"))
2824    goto fail;
2825
2826  hbin = talloc(NULL, REGFI_HBIN);
2827  if(hbin == NULL)
2828    goto fail;
2829  hbin->file_off = offset;
2830
2831  memcpy(hbin->magic, hbin_header, 4);
2832  if(strict && (memcmp(hbin->magic, "hbin", 4) != 0))
2833  {
2834    /* This always seems to happen at the end of a file, so we make it an INFO
2835     * message, rather than something more serious.
2836     */
2837    regfi_log_add(REGFI_LOG_INFO, "Magic number mismatch "
2838                  "(%.2X %.2X %.2X %.2X) while parsing hbin at offset"
2839                  " 0x%.8X.", hbin->magic[0], hbin->magic[1], 
2840                  hbin->magic[2], hbin->magic[3], offset);
2841    goto fail;
2842  }
2843
2844  hbin->first_hbin_off = IVAL(hbin_header, 0x4);
2845  hbin->block_size = IVAL(hbin_header, 0x8);
2846  /* this should be the same thing as hbin->block_size, but just in case */
2847  hbin->next_block = IVAL(hbin_header, 0x1C);
2848
2849
2850  /* Ensure the block size is a multiple of 0x1000 and doesn't run off
2851   * the end of the file.
2852   */
2853  /* XXX: This may need to be relaxed for dealing with
2854   *      partial or corrupt files.
2855   */
2856  if((offset + hbin->block_size > file->file_length)
2857     || (hbin->block_size & 0xFFFFF000) != hbin->block_size)
2858  {
2859    regfi_log_add(REGFI_LOG_ERROR, "The hbin offset is not aligned"
2860                  " or runs off the end of the file"
2861                  " while parsing hbin at offset 0x%.8X.", offset);
2862    goto fail;
2863  }
2864
2865  return hbin;
2866
2867 fail_locked:
2868  regfi_unlock(file, &file->cb_lock, "regfi_parse_hbin");
2869 fail:
2870  talloc_free(hbin);
2871  return NULL;
2872}
2873
2874
2875/*******************************************************************
2876 *******************************************************************/
2877REGFI_NK* regfi_parse_nk(REGFI_FILE* file, uint32_t offset, 
2878                         uint32_t max_size, bool strict)
2879{
2880  uint8_t nk_header[REGFI_NK_MIN_LENGTH];
2881  REGFI_NK* ret_val;
2882  uint32_t length,cell_length;
2883  bool unalloc = false;
2884
2885  ret_val = talloc(NULL, REGFI_NK);
2886  if(ret_val == NULL)
2887  {
2888    regfi_log_add(REGFI_LOG_ERROR, "Failed to allocate memory while"
2889                  " parsing NK record at offset 0x%.8X.", offset);
2890    goto fail;
2891  }
2892
2893  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_nk"))
2894    goto fail;
2895
2896  if(!regfi_parse_cell(file->cb, offset, nk_header, REGFI_NK_MIN_LENGTH,
2897                       &cell_length, &unalloc))
2898  {
2899    regfi_log_add(REGFI_LOG_WARN, "Could not parse cell header"
2900                  " while parsing NK record at offset 0x%.8X.", offset);
2901    goto fail_locked;
2902  }
2903
2904  if((nk_header[0x0] != 'n') || (nk_header[0x1] != 'k'))
2905  {
2906    regfi_log_add(REGFI_LOG_WARN, "Magic number mismatch in parsing"
2907                  " NK record at offset 0x%.8X.", offset);
2908    goto fail_locked;
2909  }
2910
2911  ret_val->values = NULL;
2912  ret_val->subkeys = NULL;
2913  ret_val->offset = offset;
2914  ret_val->cell_size = cell_length;
2915
2916  if(ret_val->cell_size > max_size)
2917    ret_val->cell_size = max_size & 0xFFFFFFF8;
2918  if((ret_val->cell_size < REGFI_NK_MIN_LENGTH) 
2919     || (strict && (ret_val->cell_size & 0x00000007) != 0))
2920  {
2921    regfi_log_add(REGFI_LOG_WARN, "A length check failed while"
2922                  " parsing NK record at offset 0x%.8X.", offset);
2923    goto fail_locked;
2924  }
2925
2926  ret_val->magic[0] = nk_header[0x0];
2927  ret_val->magic[1] = nk_header[0x1];
2928  ret_val->flags = SVAL(nk_header, 0x2);
2929 
2930  if((ret_val->flags & ~REGFI_NK_KNOWN_FLAGS) != 0)
2931  {
2932    regfi_log_add(REGFI_LOG_WARN, "Unknown key flags (0x%.4X) while"
2933                  " parsing NK record at offset 0x%.8X.", 
2934                  (ret_val->flags & ~REGFI_NK_KNOWN_FLAGS), offset);
2935  }
2936
2937  ret_val->mtime = ((uint64_t)IVAL(nk_header, 0x8)) << 32;
2938  ret_val->mtime |= IVAL(nk_header, 0x4);
2939  /* If the key is unallocated and the MTIME is earlier than Jan 1, 1990
2940   * or later than Jan 1, 2290, we consider this a bad key.  This helps
2941   * weed out some false positives during deleted data recovery.
2942   */
2943  if(unalloc
2944     && (ret_val->mtime < REGFI_MTIME_MIN
2945         || ret_val->mtime > REGFI_MTIME_MAX))
2946  { goto fail_locked; }
2947
2948  ret_val->unknown1 = IVAL(nk_header, 0xC);
2949  ret_val->parent_off = IVAL(nk_header, 0x10);
2950  ret_val->num_subkeys = IVAL(nk_header, 0x14);
2951  ret_val->unknown2 = IVAL(nk_header, 0x18);
2952  ret_val->subkeys_off = IVAL(nk_header, 0x1C);
2953  ret_val->unknown3 = IVAL(nk_header, 0x20);
2954  ret_val->num_values = IVAL(nk_header, 0x24);
2955  ret_val->values_off = IVAL(nk_header, 0x28);
2956  ret_val->sk_off = IVAL(nk_header, 0x2C);
2957  ret_val->classname_off = IVAL(nk_header, 0x30);
2958
2959  ret_val->max_bytes_subkeyname = IVAL(nk_header, 0x34);
2960  ret_val->max_bytes_subkeyclassname = IVAL(nk_header, 0x38);
2961  ret_val->max_bytes_valuename = IVAL(nk_header, 0x3C);
2962  ret_val->max_bytes_value = IVAL(nk_header, 0x40);
2963  ret_val->unk_index = IVAL(nk_header, 0x44);
2964
2965  ret_val->name_length = SVAL(nk_header, 0x48);
2966  ret_val->classname_length = SVAL(nk_header, 0x4A);
2967  ret_val->name = NULL;
2968
2969  if(ret_val->name_length + REGFI_NK_MIN_LENGTH > ret_val->cell_size)
2970  {
2971    if(strict)
2972    {
2973      regfi_log_add(REGFI_LOG_ERROR, "Contents too large for cell"
2974                    " while parsing NK record at offset 0x%.8X.", offset);
2975      goto fail_locked;
2976    }
2977    else
2978      ret_val->name_length = ret_val->cell_size - REGFI_NK_MIN_LENGTH;
2979  }
2980  else if (unalloc)
2981  { /* Truncate cell_size if it's much larger than the apparent total record length. */
2982    /* Round up to the next multiple of 8 */
2983    length = (ret_val->name_length + REGFI_NK_MIN_LENGTH) & 0xFFFFFFF8;
2984    if(length < ret_val->name_length + REGFI_NK_MIN_LENGTH)
2985      length+=8;
2986
2987    /* If cell_size is still greater, truncate. */
2988    if(length < ret_val->cell_size)
2989      ret_val->cell_size = length;
2990  }
2991
2992  /* +1 to length in case we decided to use this directly as a string later */
2993  ret_val->name_raw = talloc_array(ret_val, uint8_t, ret_val->name_length+1);
2994  if(ret_val->name_raw == NULL)
2995    goto fail_locked;
2996
2997  /* Don't need to seek, should be at the right offset */
2998  length = ret_val->name_length;
2999  if((regfi_read(file->cb, (uint8_t*)ret_val->name_raw, &length) != 0)
3000     || length != ret_val->name_length)
3001  {
3002    regfi_log_add(REGFI_LOG_ERROR, "Failed to read key name"
3003                  " while parsing NK record at offset 0x%.8X.", offset);
3004    goto fail_locked;
3005  }
3006
3007  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_nk"))
3008    goto fail;
3009
3010  return ret_val;
3011
3012 fail_locked:
3013  regfi_unlock(file, &file->cb_lock, "regfi_parse_nk");
3014 fail:
3015  talloc_free(ret_val);
3016  return NULL;
3017}
3018
3019
3020uint8_t* regfi_parse_classname(REGFI_FILE* file, uint32_t offset, 
3021                               uint16_t* name_length, uint32_t max_size, bool strict)
3022{
3023  uint8_t* ret_val = NULL;
3024  uint32_t length;
3025  uint32_t cell_length;
3026  bool unalloc = false;
3027
3028  if(*name_length <= 0 || offset == REGFI_OFFSET_NONE 
3029     || (offset & 0x00000007) != 0)
3030  { goto fail; }
3031
3032  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_classname"))
3033    goto fail;
3034
3035  if(!regfi_parse_cell(file->cb, offset, NULL, 0, &cell_length, &unalloc))
3036  {
3037    regfi_log_add(REGFI_LOG_WARN, "Could not parse cell header"
3038                  " while parsing class name at offset 0x%.8X.", offset);
3039    goto fail_locked;
3040  }
3041 
3042  if((cell_length & 0x0000007) != 0)
3043  {
3044    regfi_log_add(REGFI_LOG_ERROR, "Cell length not a multiple of 8"
3045                  " while parsing class name at offset 0x%.8X.", offset);
3046    goto fail_locked;
3047  }
3048 
3049  if(cell_length > max_size)
3050  {
3051    regfi_log_add(REGFI_LOG_WARN, "Cell stretches past hbin "
3052                  "boundary while parsing class name at offset 0x%.8X.",
3053                  offset);
3054    if(strict)
3055      goto fail_locked;
3056    cell_length = max_size;
3057  }
3058 
3059  if((cell_length - 4) < *name_length)
3060  {
3061    regfi_log_add(REGFI_LOG_WARN, "Class name is larger than"
3062                  " cell_length while parsing class name at offset"
3063                  " 0x%.8X.", offset);
3064    if(strict)
3065      goto fail_locked;
3066    *name_length = cell_length - 4;
3067  }
3068 
3069  ret_val = talloc_array(NULL, uint8_t, *name_length);
3070  if(ret_val != NULL)
3071  {
3072    length = *name_length;
3073    if((regfi_read(file->cb, ret_val, &length) != 0)
3074       || length != *name_length)
3075    {
3076      regfi_log_add(REGFI_LOG_ERROR, "Could not read class name"
3077                    " while parsing class name at offset 0x%.8X.", offset);
3078      goto fail_locked;
3079    }
3080  }
3081
3082  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_classname"))
3083    goto fail;
3084
3085  return ret_val;
3086
3087 fail_locked:
3088  regfi_unlock(file, &file->cb_lock, "regfi_parse_classname");
3089 fail:
3090  talloc_free(ret_val);
3091  return NULL;
3092}
3093
3094
3095/******************************************************************************
3096*******************************************************************************/
3097REGFI_VK* regfi_parse_vk(REGFI_FILE* file, uint32_t offset, 
3098                             uint32_t max_size, bool strict)
3099{
3100  REGFI_VK* ret_val;
3101  uint8_t vk_header[REGFI_VK_MIN_LENGTH];
3102  uint32_t raw_data_size, length, cell_length;
3103  bool unalloc = false;
3104
3105  ret_val = talloc(NULL, REGFI_VK);
3106  if(ret_val == NULL)
3107    goto fail;
3108
3109  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_nk"))
3110    goto fail;
3111
3112  if(!regfi_parse_cell(file->cb, offset, vk_header, REGFI_VK_MIN_LENGTH,
3113                       &cell_length, &unalloc))
3114  {
3115    regfi_log_add(REGFI_LOG_WARN, "Could not parse cell header"
3116                  " while parsing VK record at offset 0x%.8X.", offset);
3117    goto fail_locked;
3118  }
3119
3120  ret_val->offset = offset;
3121  ret_val->cell_size = cell_length;
3122  ret_val->name = NULL;
3123  ret_val->name_raw = NULL;
3124 
3125  if(ret_val->cell_size > max_size)
3126    ret_val->cell_size = max_size & 0xFFFFFFF8;
3127  if((ret_val->cell_size < REGFI_VK_MIN_LENGTH) 
3128     || (ret_val->cell_size & 0x00000007) != 0)
3129  {
3130    regfi_log_add(REGFI_LOG_WARN, "Invalid cell size encountered"
3131                  " while parsing VK record at offset 0x%.8X.", offset);
3132    goto fail_locked;
3133  }
3134
3135  ret_val->magic[0] = vk_header[0x0];
3136  ret_val->magic[1] = vk_header[0x1];
3137  if((ret_val->magic[0] != 'v') || (ret_val->magic[1] != 'k'))
3138  {
3139    /* XXX: This does not account for deleted keys under Win2K which
3140     *      often have this (and the name length) overwritten with
3141     *      0xFFFF.
3142     */
3143    regfi_log_add(REGFI_LOG_WARN, "Magic number mismatch"
3144                  " while parsing VK record at offset 0x%.8X.", offset);
3145    goto fail_locked;
3146  }
3147
3148  ret_val->name_length = SVAL(vk_header, 0x2);
3149  raw_data_size = IVAL(vk_header, 0x4);
3150  ret_val->data_size = raw_data_size & ~REGFI_VK_DATA_IN_OFFSET;
3151  /* The data is typically stored in the offset if the size <= 4,
3152   * in which case this flag is set.
3153   */
3154  ret_val->data_in_offset = (bool)(raw_data_size & REGFI_VK_DATA_IN_OFFSET);
3155  ret_val->data_off = IVAL(vk_header, 0x8);
3156  ret_val->type = IVAL(vk_header, 0xC);
3157  ret_val->flags = SVAL(vk_header, 0x10);
3158  ret_val->unknown1 = SVAL(vk_header, 0x12);
3159
3160  if(ret_val->name_length > 0)
3161  {
3162    if(ret_val->name_length + REGFI_VK_MIN_LENGTH + 4 > ret_val->cell_size)
3163    {
3164      regfi_log_add(REGFI_LOG_WARN, "Name too long for remaining cell"
3165                    " space while parsing VK record at offset 0x%.8X.",
3166                    offset);
3167      if(strict)
3168        goto fail_locked;
3169      else
3170        ret_val->name_length = ret_val->cell_size - REGFI_VK_MIN_LENGTH - 4;
3171    }
3172
3173    /* Round up to the next multiple of 8 */
3174    cell_length = (ret_val->name_length + REGFI_VK_MIN_LENGTH + 4) & 0xFFFFFFF8;
3175    if(cell_length < ret_val->name_length + REGFI_VK_MIN_LENGTH + 4)
3176      cell_length+=8;
3177
3178    /* +1 to length in case we decided to use this directly as a string later */
3179    ret_val->name_raw = talloc_array(ret_val, uint8_t, ret_val->name_length+1);
3180    if(ret_val->name_raw == NULL)
3181      goto fail_locked;
3182
3183    length = ret_val->name_length;
3184    if((regfi_read(file->cb, (uint8_t*)ret_val->name_raw, &length) != 0)
3185       || length != ret_val->name_length)
3186    {
3187      regfi_log_add(REGFI_LOG_ERROR, "Could not read value name"
3188                    " while parsing VK record at offset 0x%.8X.", offset);
3189      goto fail_locked;
3190    }
3191  }
3192  else
3193    cell_length = REGFI_VK_MIN_LENGTH + 4;
3194
3195  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_nk"))
3196    goto fail;
3197
3198  if(unalloc)
3199  {
3200    /* If cell_size is still greater, truncate. */
3201    if(cell_length < ret_val->cell_size)
3202      ret_val->cell_size = cell_length;
3203  }
3204
3205  return ret_val;
3206 
3207 fail_locked:
3208  regfi_unlock(file, &file->cb_lock, "regfi_parse_vk");
3209 fail:
3210  talloc_free(ret_val);
3211  return NULL;
3212}
3213
3214
3215/******************************************************************************
3216 *
3217 ******************************************************************************/
3218REGFI_BUFFER regfi_load_data(REGFI_FILE* file, uint32_t voffset,
3219                             uint32_t length, bool data_in_offset,
3220                             bool strict)
3221{
3222  REGFI_BUFFER ret_val;
3223  uint32_t cell_length, offset;
3224  int32_t max_size;
3225  bool unalloc;
3226 
3227  /* Microsoft's documentation indicates that "available memory" is
3228   * the limit on value sizes for the more recent registry format version.
3229   * This is not only annoying, but it's probably also incorrect, since clearly
3230   * value data sizes are limited to 2^31 (high bit used as a flag) and even
3231   * with big data records, the apparent max size is:
3232   *   16344 * 2^16 = 1071104040 (~1GB).
3233   *
3234   * We choose to limit it to 1M which was the limit in older versions and
3235   * should rarely be exceeded unless the file is corrupt or malicious.
3236   * For more info, see:
3237   *   http://msdn.microsoft.com/en-us/library/ms724872%28VS.85%29.aspx
3238   */
3239  /* XXX: add way to skip this check at user discression. */
3240  if(length > REGFI_VK_MAX_DATA_LENGTH)
3241  {
3242    regfi_log_add(REGFI_LOG_WARN, "Value data size %d larger than "
3243                  "%d, truncating...", length, REGFI_VK_MAX_DATA_LENGTH);
3244    length = REGFI_VK_MAX_DATA_LENGTH;
3245  }
3246
3247  if(data_in_offset)
3248    return regfi_parse_little_data(file, voffset, length, strict);
3249  else
3250  {
3251    offset = voffset + REGFI_REGF_SIZE;
3252    max_size = regfi_calc_maxsize(file, offset);
3253    if(max_size < 0)
3254    {
3255      regfi_log_add(REGFI_LOG_WARN, "Could not find HBIN for data"
3256                    " at offset 0x%.8X.", offset);
3257      goto fail;
3258    }
3259   
3260    if(!regfi_lock(file, &file->cb_lock, "regfi_load_data"))
3261      goto fail;
3262
3263    if(!regfi_parse_cell(file->cb, offset, NULL, 0,
3264                         &cell_length, &unalloc))
3265    {
3266      regfi_log_add(REGFI_LOG_WARN, "Could not parse cell while"
3267                    " parsing data record at offset 0x%.8X.", offset);
3268      goto fail_locked;
3269    }
3270
3271    if(!regfi_unlock(file, &file->cb_lock, "regfi_load_data"))
3272      goto fail;
3273
3274    if((cell_length & 0x00000007) != 0)
3275    {
3276      regfi_log_add(REGFI_LOG_WARN, "Cell length not multiple of 8"
3277                    " while parsing data record at offset 0x%.8X.",
3278                    offset);
3279      goto fail;
3280    }
3281
3282    if(cell_length > max_size)
3283    {
3284      regfi_log_add(REGFI_LOG_WARN, "Cell extends past HBIN boundary"
3285                    " while parsing data record at offset 0x%.8X.",
3286                    offset);
3287      goto fail;
3288    }
3289
3290    if(cell_length - 4 < length)
3291    {
3292      /* XXX: All big data records thus far have been 16 bytes long. 
3293       *      Should we check for this precise size instead of just
3294       *      relying upon the above check?
3295       */
3296      if (file->major_version >= 1 && file->minor_version >= 5)
3297      {
3298        /* Attempt to parse a big data record */
3299        return regfi_load_big_data(file, offset, length, cell_length, 
3300                                   NULL, strict);
3301      }
3302      else
3303      {
3304        regfi_log_add(REGFI_LOG_WARN, "Data length (0x%.8X) larger than"
3305                      " remaining cell length (0x%.8X)"
3306                      " while parsing data record at offset 0x%.8X.", 
3307                      length, cell_length - 4, offset);
3308        if(strict)
3309          goto fail;
3310        else
3311          length = cell_length - 4;
3312      }
3313    }
3314
3315    ret_val = regfi_parse_data(file, offset, length, strict);
3316  }
3317
3318  return ret_val;
3319
3320 fail_locked:
3321  regfi_unlock(file, &file->cb_lock, "regfi_load_data");
3322 fail:
3323  ret_val.buf = NULL;
3324  ret_val.len = 0;
3325  return ret_val;
3326}
3327
3328
3329/******************************************************************************
3330 * Parses the common case data records stored in a single cell.
3331 ******************************************************************************/
3332REGFI_BUFFER regfi_parse_data(REGFI_FILE* file, uint32_t offset,
3333                              uint32_t length, bool strict)
3334{
3335  REGFI_BUFFER ret_val;
3336  uint32_t read_length;
3337
3338  ret_val.buf = NULL;
3339  ret_val.len = 0;
3340 
3341  if((ret_val.buf = talloc_array(NULL, uint8_t, length)) == NULL)
3342    goto fail;
3343  ret_val.len = length;
3344
3345  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_data"))
3346    goto fail;
3347
3348  if(regfi_seek(file->cb, offset+4, SEEK_SET) == -1)
3349  {
3350    regfi_log_add(REGFI_LOG_WARN, "Could not seek while "
3351                  "reading data at offset 0x%.8X.", offset);
3352    goto fail_locked;
3353  }
3354 
3355  read_length = length;
3356  if((regfi_read(file->cb, ret_val.buf, &read_length) != 0)
3357     || read_length != length)
3358  {
3359    regfi_log_add(REGFI_LOG_ERROR, "Could not read data block while"
3360                  " parsing data record at offset 0x%.8X.", offset);
3361    goto fail_locked;
3362  }
3363
3364  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_data"))
3365    goto fail;
3366
3367  return ret_val;
3368
3369 fail_locked:
3370  regfi_unlock(file, &file->cb_lock, "regfi_parse_data");
3371 fail:
3372  talloc_free(ret_val.buf);
3373  ret_val.buf = NULL;
3374  ret_val.buf = 0;
3375  return ret_val;
3376}
3377
3378
3379
3380/******************************************************************************
3381 *
3382 ******************************************************************************/
3383REGFI_BUFFER regfi_parse_little_data(REGFI_FILE* file, uint32_t voffset,
3384                                     uint32_t length, bool strict)
3385{
3386  uint8_t i;
3387  REGFI_BUFFER ret_val;
3388
3389  ret_val.buf = NULL;
3390  ret_val.len = 0;
3391
3392  if(length > 4)
3393  {
3394    regfi_log_add(REGFI_LOG_ERROR, "Data in offset but length > 4"
3395                  " while parsing data record. (voffset=0x%.8X, length=%d)",
3396                  voffset, length);
3397    return ret_val;
3398  }
3399
3400  if((ret_val.buf = talloc_array(NULL, uint8_t, length)) == NULL)
3401    return ret_val;
3402  ret_val.len = length;
3403 
3404  for(i = 0; i < length; i++)
3405    ret_val.buf[i] = (uint8_t)((voffset >> i*8) & 0xFF);
3406
3407  return ret_val;
3408}
3409
3410/******************************************************************************
3411*******************************************************************************/
3412REGFI_BUFFER regfi_parse_big_data_header(REGFI_FILE* file, uint32_t offset, 
3413                                         uint32_t max_size, bool strict)
3414{
3415  REGFI_BUFFER ret_val;
3416  uint32_t cell_length;
3417  bool unalloc;
3418
3419  /* XXX: do something with unalloc? */
3420  ret_val.buf = (uint8_t*)talloc_array(NULL, uint8_t, REGFI_BIG_DATA_MIN_LENGTH);
3421  if(ret_val.buf == NULL)
3422    goto fail;
3423
3424  if(REGFI_BIG_DATA_MIN_LENGTH > max_size)
3425  {
3426    regfi_log_add(REGFI_LOG_WARN, "Big data header exceeded max_size "
3427                  "while parsing big data header at offset 0x%.8X.",offset);
3428    goto fail;
3429  }
3430
3431  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_big_data_header"))
3432    goto fail;
3433
3434
3435  if(!regfi_parse_cell(file->cb, offset, ret_val.buf, REGFI_BIG_DATA_MIN_LENGTH,
3436                       &cell_length, &unalloc))
3437  {
3438    regfi_log_add(REGFI_LOG_WARN, "Could not parse cell while"
3439                  " parsing big data header at offset 0x%.8X.", offset);
3440    goto fail_locked;
3441  }
3442
3443  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_big_data_header"))
3444    goto fail;
3445
3446  if((ret_val.buf[0] != 'd') || (ret_val.buf[1] != 'b'))
3447  {
3448    regfi_log_add(REGFI_LOG_WARN, "Unknown magic number"
3449                  " (0x%.2X, 0x%.2X) encountered while parsing"
3450                  " big data header at offset 0x%.8X.", 
3451                  ret_val.buf[0], ret_val.buf[1], offset);
3452    goto fail;
3453  }
3454
3455  ret_val.len = REGFI_BIG_DATA_MIN_LENGTH;
3456  return ret_val;
3457
3458 fail_locked:
3459  regfi_unlock(file, &file->cb_lock, "regfi_parse_big_data_header");
3460 fail:
3461  talloc_free(ret_val.buf);
3462  ret_val.buf = NULL;
3463  ret_val.len = 0;
3464  return ret_val;
3465}
3466
3467
3468
3469/******************************************************************************
3470 *
3471 ******************************************************************************/
3472uint32_t* regfi_parse_big_data_indirect(REGFI_FILE* file, uint32_t offset,
3473                                      uint16_t num_chunks, bool strict)
3474{
3475  uint32_t* ret_val;
3476  uint32_t indirect_length;
3477  int32_t max_size;
3478  uint16_t i;
3479  bool unalloc;
3480
3481  /* XXX: do something with unalloc? */
3482
3483  max_size = regfi_calc_maxsize(file, offset);
3484  if((max_size < 0) || (num_chunks*sizeof(uint32_t) + 4 > max_size))
3485    return NULL;
3486
3487  ret_val = (uint32_t*)talloc_array(NULL, uint32_t, num_chunks);
3488  if(ret_val == NULL)
3489    goto fail;
3490
3491  if(!regfi_lock(file, &file->cb_lock, "regfi_parse_big_data_indirect"))
3492    goto fail;
3493
3494  if(!regfi_parse_cell(file->cb, offset, (uint8_t*)ret_val,
3495                       num_chunks*sizeof(uint32_t),
3496                       &indirect_length, &unalloc))
3497  {
3498    regfi_log_add(REGFI_LOG_WARN, "Could not parse cell while"
3499                  " parsing big data indirect record at offset 0x%.8X.", 
3500                  offset);
3501    goto fail_locked;
3502  }
3503
3504  if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_big_data_indirect"))
3505    goto fail;
3506
3507  /* Convert pointers to proper endianess, verify they are aligned. */
3508  for(i=0; i<num_chunks; i++)
3509  {
3510    ret_val[i] = IVAL(ret_val, i*sizeof(uint32_t));
3511    if((ret_val[i] & 0x00000007) != 0)
3512      goto fail;
3513  }
3514 
3515  return ret_val;
3516
3517 fail_locked:
3518  regfi_unlock(file, &file->cb_lock, "regfi_parse_big_data_indirect");
3519 fail:
3520  talloc_free(ret_val);
3521  return NULL;
3522}
3523
3524
3525/******************************************************************************
3526 * Arguments:
3527 *  file       --
3528 *  offsets    -- list of virtual offsets.
3529 *  num_chunks --
3530 *  strict     --
3531 *
3532 * Returns:
3533 *  A range_list with physical offsets and complete lengths
3534 *  (including cell headers) of associated cells. 
3535 *  No data in range_list elements.
3536 ******************************************************************************/
3537range_list* regfi_parse_big_data_cells(REGFI_FILE* file, uint32_t* offsets,
3538                                       uint16_t num_chunks, bool strict)
3539{
3540  uint32_t cell_length, chunk_offset;
3541  range_list* ret_val;
3542  uint16_t i;
3543  bool unalloc;
3544 
3545  /* XXX: do something with unalloc? */
3546  ret_val = range_list_new();
3547  if(ret_val == NULL)
3548    goto fail;
3549 
3550  for(i=0; i<num_chunks; i++)
3551  {
3552    if(!regfi_lock(file, &file->cb_lock, "regfi_parse_big_data_cells"))
3553      goto fail;
3554
3555    chunk_offset = offsets[i]+REGFI_REGF_SIZE;
3556    if(!regfi_parse_cell(file->cb, chunk_offset, NULL, 0,
3557                         &cell_length, &unalloc))
3558    {
3559      regfi_log_add(REGFI_LOG_WARN, "Could not parse cell while"
3560                    " parsing big data chunk at offset 0x%.8X.", 
3561                    chunk_offset);
3562      goto fail_locked;
3563    }
3564
3565    if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_big_data_cells"))
3566      goto fail;
3567
3568    if(!range_list_add(ret_val, chunk_offset, cell_length, NULL))
3569      goto fail;
3570  }
3571
3572  return ret_val;
3573
3574 fail_locked:
3575  regfi_unlock(file, &file->cb_lock, "regfi_parse_big_data_cells");
3576 fail:
3577  if(ret_val != NULL)
3578    range_list_free(ret_val);
3579  return NULL;
3580}
3581
3582
3583/******************************************************************************
3584*******************************************************************************/
3585REGFI_BUFFER regfi_load_big_data(REGFI_FILE* file, 
3586                                 uint32_t offset, uint32_t data_length, 
3587                                 uint32_t cell_length, range_list* used_ranges,
3588                                 bool strict)
3589{
3590  REGFI_BUFFER ret_val;
3591  uint16_t num_chunks, i;
3592  uint32_t read_length, data_left, tmp_len, indirect_offset;
3593  uint32_t* indirect_ptrs = NULL;
3594  REGFI_BUFFER bd_header;
3595  range_list* bd_cells = NULL;
3596  const range_list_element* cell_info;
3597
3598  ret_val.buf = NULL;
3599
3600  /* XXX: Add better error/warning messages */
3601
3602  bd_header = regfi_parse_big_data_header(file, offset, cell_length, strict);
3603  if(bd_header.buf == NULL)
3604    goto fail;
3605
3606  /* Keep track of used space for use by reglookup-recover */
3607  if(used_ranges != NULL)
3608    if(!range_list_add(used_ranges, offset, cell_length, NULL))
3609      goto fail;
3610
3611  num_chunks = SVAL(bd_header.buf, 0x2);
3612  indirect_offset = IVAL(bd_header.buf, 0x4) + REGFI_REGF_SIZE;
3613  talloc_free(bd_header.buf);
3614
3615  indirect_ptrs = regfi_parse_big_data_indirect(file, indirect_offset,
3616                                                num_chunks, strict);
3617  if(indirect_ptrs == NULL)
3618    goto fail;
3619
3620  if(used_ranges != NULL)
3621    if(!range_list_add(used_ranges, indirect_offset, num_chunks*4+4, NULL))
3622      goto fail;
3623 
3624  if((ret_val.buf = talloc_array(NULL, uint8_t, data_length)) == NULL)
3625    goto fail;
3626  data_left = data_length;
3627
3628  bd_cells = regfi_parse_big_data_cells(file, indirect_ptrs, num_chunks, strict);
3629  if(bd_cells == NULL)
3630    goto fail;
3631
3632  talloc_free(indirect_ptrs);
3633  indirect_ptrs = NULL;
3634 
3635  for(i=0; (i<num_chunks) && (data_left>0); i++)
3636  {
3637    cell_info = range_list_get(bd_cells, i);
3638    if(cell_info == NULL)
3639      goto fail;
3640
3641    /* XXX: This should be "cell_info->length-4" to account for the 4 byte cell
3642     *      length.  However, it has been observed that some (all?) chunks
3643     *      have an additional 4 bytes of 0 at the end of their cells that
3644     *      isn't part of the data, so we're trimming that off too.
3645     *      Perhaps it's just an 8 byte alignment requirement...
3646     */
3647    if(cell_info->length - 8 >= data_left)
3648    {
3649      if(i+1 != num_chunks)
3650      {
3651        regfi_log_add(REGFI_LOG_WARN, "Left over chunks detected "
3652                      "while constructing big data at offset 0x%.8X "
3653                      "(chunk offset 0x%.8X).", offset, cell_info->offset);
3654      }
3655      read_length = data_left;
3656    }
3657    else
3658      read_length = cell_info->length - 8;
3659
3660
3661    if(read_length > regfi_calc_maxsize(file, cell_info->offset))
3662    {
3663      regfi_log_add(REGFI_LOG_WARN, "A chunk exceeded the maxsize "
3664                    "while constructing big data at offset 0x%.8X "
3665                    "(chunk offset 0x%.8X).", offset, cell_info->offset);
3666      goto fail;
3667    }
3668
3669    if(!regfi_lock(file, &file->cb_lock, "regfi_load_big_data"))
3670      goto fail;
3671
3672    if(regfi_seek(file->cb, cell_info->offset+sizeof(uint32_t), SEEK_SET) == -1)
3673    {
3674      regfi_log_add(REGFI_LOG_WARN, "Could not seek to chunk while "
3675                    "constructing big data at offset 0x%.8X "
3676                    "(chunk offset 0x%.8X).", offset, cell_info->offset);
3677      goto fail_locked;
3678    }
3679
3680    tmp_len = read_length;
3681    if(regfi_read(file->cb, ret_val.buf+(data_length-data_left), 
3682                  &read_length) != 0 || (read_length != tmp_len))
3683    {
3684      regfi_log_add(REGFI_LOG_WARN, "Could not read data chunk while"
3685                    " constructing big data at offset 0x%.8X"
3686                    " (chunk offset 0x%.8X).", offset, cell_info->offset);
3687      goto fail_locked;
3688    }
3689
3690    if(!regfi_unlock(file, &file->cb_lock, "regfi_load_big_data"))
3691      goto fail;
3692
3693    if(used_ranges != NULL)
3694      if(!range_list_add(used_ranges, cell_info->offset,cell_info->length,NULL))
3695        goto fail;
3696
3697    data_left -= read_length;
3698  }
3699  range_list_free(bd_cells);
3700
3701  ret_val.len = data_length-data_left;
3702  return ret_val;
3703
3704 fail_locked:
3705  regfi_unlock(file, &file->cb_lock, "regfi_load_big_data");
3706 fail:
3707  talloc_free(ret_val.buf);
3708  talloc_free(indirect_ptrs);
3709  if(bd_cells != NULL)
3710    range_list_free(bd_cells);
3711  ret_val.buf = NULL;
3712  ret_val.len = 0;
3713  return ret_val;
3714}
3715
3716
3717range_list* regfi_parse_unalloc_cells(REGFI_FILE* file)
3718{
3719  range_list* ret_val;
3720  REGFI_HBIN* hbin;
3721  const range_list_element* hbins_elem;
3722  uint32_t i, num_hbins, curr_off, cell_len;
3723  bool is_unalloc;
3724
3725  ret_val = range_list_new();
3726  if(ret_val == NULL)
3727    return NULL;
3728
3729  if(!regfi_read_lock(file, &file->hbins_lock, "regfi_parse_unalloc_cells"))
3730  {
3731    range_list_free(ret_val);
3732    return NULL;
3733  }
3734
3735  num_hbins = range_list_size(file->hbins);
3736  for(i=0; i<num_hbins; i++)
3737  {
3738    hbins_elem = range_list_get(file->hbins, i);
3739    if(hbins_elem == NULL)
3740      break;
3741    hbin = (REGFI_HBIN*)hbins_elem->data;
3742
3743    curr_off = REGFI_HBIN_HEADER_SIZE;
3744    while(curr_off < hbin->block_size)
3745    {
3746      if(!regfi_lock(file, &file->cb_lock, "regfi_parse_unalloc_cells"))
3747        break;
3748
3749      if(!regfi_parse_cell(file->cb, hbin->file_off+curr_off, NULL, 0,
3750                           &cell_len, &is_unalloc))
3751      {
3752        regfi_unlock(file, &file->cb_lock, "regfi_parse_unalloc_cells");
3753        break;
3754      }
3755
3756      if(!regfi_unlock(file, &file->cb_lock, "regfi_parse_unalloc_cells"))
3757        break;
3758
3759      if((cell_len == 0) || ((cell_len & 0x00000007) != 0))
3760      {
3761        regfi_log_add(REGFI_LOG_ERROR, "Bad cell length encountered"
3762                      " while parsing unallocated cells at offset 0x%.8X.",
3763                      hbin->file_off+curr_off);
3764        break;
3765      }
3766
3767      /* for some reason the record_size of the last record in
3768         an hbin block can extend past the end of the block
3769         even though the record fits within the remaining
3770         space....aaarrrgggghhhhhh */ 
3771      if(curr_off + cell_len >= hbin->block_size)
3772        cell_len = hbin->block_size - curr_off;
3773     
3774      if(is_unalloc)
3775        range_list_add(ret_val, hbin->file_off+curr_off, 
3776                       cell_len, NULL);
3777     
3778      curr_off = curr_off+cell_len;
3779    }
3780  }
3781
3782  if(!regfi_rw_unlock(file, &file->hbins_lock, "regfi_parse_unalloc_cells"))
3783  {
3784    range_list_free(ret_val);
3785    return NULL;
3786  }
3787
3788  return ret_val;
3789}
3790
3791
3792/* From lib/time.c */
3793
3794/****************************************************************************
3795 Returns an 8 byte filetime from a time_t
3796 This takes real GMT as input and converts to kludge-GMT
3797****************************************************************************/
3798REGFI_NTTIME regfi_unix2nt_time(time_t t)
3799{
3800  double d;
3801
3802  if (t==0)
3803    return 0L;
3804 
3805  if (t == TIME_T_MAX) 
3806    return 0x7fffffffffffffffL;
3807 
3808  if (t == -1) 
3809    return 0xffffffffffffffffL;
3810 
3811  /* this converts GMT to kludge-GMT */
3812  /* XXX: This was removed due to difficult dependency requirements. 
3813   *      So far, times appear to be correct without this adjustment, but
3814   *      that may be proven wrong with adequate testing.
3815   */
3816  /* t -= TimeDiff(t) - get_serverzone(); */
3817 
3818  d = (double)(t) + REGFI_TIME_FIXUP;
3819  d *= 1.0e7;
3820  /*
3821  nt->high = (uint32_t)(d * (1.0/c));
3822  nt->low  = (uint32_t)(d - ((double)nt->high) * c);
3823  */
3824
3825  return (REGFI_NTTIME) d;
3826}
3827
3828
3829/****************************************************************************
3830 Interpret an 8 byte "filetime" structure to a time_t
3831 It's originally in "100ns units since jan 1st 1601"
3832
3833 An 8 byte value of 0xffffffffffffffff will be returned as (time_t)0.
3834
3835 It appears to be kludge-GMT (at least for file listings). This means
3836 its the GMT you get by taking a localtime and adding the
3837 serverzone. This is NOT the same as GMT in some cases. This routine
3838 converts this to real GMT.
3839****************************************************************************/
3840double regfi_nt2unix_time(REGFI_NTTIME nt)
3841{
3842  double ret_val;
3843 
3844  if (nt == 0 || nt == 0xffffffffffffffffL)
3845    return 0;
3846 
3847  ret_val = (double)(nt) * 1.0e-7;
3848 
3849  /* now adjust by 369 years to make the secs since 1970 */
3850  ret_val -= REGFI_TIME_FIXUP;
3851 
3852  /* this takes us from kludge-GMT to real GMT */
3853  /* XXX: This was removed due to difficult dependency requirements. 
3854   *      So far, times appear to be correct without this adjustment, but
3855   *      that may be proven wrong with adequate testing.
3856   */
3857  /*
3858    ret -= get_serverzone();
3859    ret += LocTimeDiff(ret);
3860  */
3861
3862  return ret_val;
3863}
3864
3865/* End of stuff from lib/time.c */
Note: See TracBrowser for help on using the repository browser.