Implement setting of Windows-specific XML information
[wimlib] / src / registry.c
1 /*
2  * registry.c
3  *
4  * Extract information from Windows NT registry hives.
5  */
6
7 /*
8  * Copyright (C) 2016 Eric Biggers
9  *
10  * This file is free software; you can redistribute it and/or modify it under
11  * the terms of the GNU Lesser General Public License as published by the Free
12  * Software Foundation; either version 3 of the License, or (at your option) any
13  * later version.
14  *
15  * This file is distributed in the hope that it will be useful, but WITHOUT
16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this file; if not, see http://www.gnu.org/licenses/.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #  include "config.h"
26 #endif
27
28 #include <string.h>
29
30 #include "wimlib/encoding.h"
31 #include "wimlib/endianness.h"
32 #include "wimlib/error.h"
33 #include "wimlib/registry.h"
34 #include "wimlib/util.h"
35
36 /* Registry hive file header  */
37 struct regf {
38 #define REGF_MAGIC              cpu_to_le32(0x66676572) /* "regf" */
39         le32 magic;
40         le32 f1[4];
41 #define REGF_MAJOR              cpu_to_le32(1)
42         le32 major_version;
43         le32 minor_version;
44         le32 f2[2];
45         le32 root_key_offset;           /* Offset, in hbin area, to root nk  */
46         le32 total_hbin_size;           /* Total size of all hbins  */
47         le32 f3[1013];
48         u8 hbin_area[0];                /* Start of hbin area  */
49 } _packed_attribute;
50
51
52 /* Cell header  */
53 struct cell {
54         /* The cell size in bytes, negated for in-use cells  */
55         le32 size;
56
57         /* Magic characters which identify the cell type  */
58         le16 magic;
59 } _packed_attribute;
60
61 /* NK cell - represents a registry key  */
62 struct nk {
63 #define NK_MAGIC                cpu_to_le16(0x6B6E)     /* "nk" */
64         struct cell base;
65 #define NK_COMPRESSED_NAME      cpu_to_le16(0x0020)
66         le16 flags;
67         le64 unknown_0x08;
68         le32 unknown_0x10;
69         le32 parent_offset;
70         le32 num_subkeys;
71         le32 unknown_0x1C;
72         le32 subkey_list_offset;
73         le32 unknown_0x24;
74         le32 num_values;
75         le32 value_list_offset;
76         le32 unknown_0x30;
77         le32 unknown_0x34;
78         le16 unknown_0x38;
79         le16 unknown_0x3A;
80         le32 unknown_0x3C;
81         le32 unknown_0x40;
82         le32 unknown_0x44;
83         le32 unknown_0x48;
84         le16 name_size;
85         le16 unknown_0x4E;
86         char name[0];
87 } _packed_attribute;
88
89 /* LF (or LH) cell - contains a list of subkey references.  LF and LH cells are
90  * the same except they use different hashing algorithms.  But this
91  * implementation doesn't yet make use of the hashes anyway.  */
92 struct lf {
93 #define LF_MAGIC        cpu_to_le16(0x666C)     /* "lf" */
94 #define LH_MAGIC        cpu_to_le16(0x686C)     /* "lh" */
95         struct cell base;
96         le16 num_subkeys;
97         struct {
98                 le32 offset;
99                 le32 subkey_name_hash;
100         } subkeys[0];
101 } _packed_attribute;
102
103 /* Value list cell - contains a list of value references  */
104 struct value_list {
105         le32 size;
106         le32 vk_offsets[0];
107 } _packed_attribute;
108
109 /* VK cell - contains a value's data, or a reference to it  */
110 struct vk {
111         struct cell base;
112         le16 name_size;
113         le32 data_size;
114         le32 data_offset;
115 #define REG_NONE                        cpu_to_le32(0x00000000)
116 #define REG_SZ                          cpu_to_le32(0x00000001)
117 #define REG_EXPAND_SZ                   cpu_to_le32(0x00000002)
118 #define REG_BINARY                      cpu_to_le32(0x00000003)
119 #define REG_DWORD                       cpu_to_le32(0x00000004)
120 #define REG_DWORD_LITTLE_ENDIAN         cpu_to_le32(0x00000004)
121 #define REG_DWORD_BIG_ENDIAN            cpu_to_le32(0x00000005)
122 #define REG_LINK                        cpu_to_le32(0x00000006)
123 #define REG_MULTI_SZ                    cpu_to_le32(0x00000007)
124 #define REG_RESOURCE_LIST               cpu_to_le32(0x00000008)
125 #define REG_FULL_RESOURCE_DESCRIPTOR    cpu_to_le32(0x00000009)
126 #define REG_RESOURCE_REQUIREMENTS_LIST  cpu_to_le32(0x0000000A)
127 #define REG_QWORD                       cpu_to_le32(0x0000000B)
128 #define REG_QWORD_LITTLE_ENDIAN         cpu_to_le32(0x0000000B)
129         le32 data_type;
130 #define VK_COMPRESSED_NAME              cpu_to_le16(0x0001)
131         le16 flags;
132         le16 unknown_0x16;
133         char name[0];
134 };
135
136 /* Data cell - contains a value's data  */
137 struct data_cell {
138         le32 size;
139         u8 data[0];
140 };
141
142 static enum hive_status
143 translate_wimlib_error(int ret)
144 {
145         if (likely(!ret))
146                 return HIVE_OK;
147         if (ret == WIMLIB_ERR_NOMEM)
148                 return HIVE_OUT_OF_MEMORY;
149         return HIVE_UNSUPPORTED;
150 }
151
152 /* Compare a UTF-16LE name with a key or value name in the registry.  The
153  * comparison is case insensitive.  */
154 static inline bool
155 names_equal(const utf16lechar *name, size_t name_nchars,
156             const void *disk_name, size_t disk_name_size,
157             bool compressed)
158 {
159         if (compressed) {
160                 /* ISO-8859-1 (LATIN1) on-disk  */
161                 const u8 *p = disk_name;
162                 if (disk_name_size != name_nchars)
163                         return false;
164                 for (size_t i = 0; i < name_nchars; i++)
165                         if (upcase[le16_to_cpu(name[i])] != upcase[p[i]])
166                                 return false;
167                 return true;
168         } else {
169                 /* UTF-16LE on disk  */
170                 disk_name_size /= 2;
171                 if (disk_name_size != name_nchars)
172                         return false;
173                 return !cmp_utf16le_strings(name, name_nchars,
174                                             disk_name, disk_name_size, true);
175         }
176 }
177
178 /* Get a pointer to a cell, with alignment and bounds checking.  Returns NULL if
179  * the requested information does not specify a properly aligned, sized, and
180  * in-use cell.  */
181 static const void *
182 get_cell_pointer(const struct regf *regf, le32 offset, size_t wanted_size)
183 {
184         u32 total = le32_to_cpu(regf->total_hbin_size);
185         u32 offs = le32_to_cpu(offset);
186         const struct cell *cell;
187         s32 actual_size;
188
189         if ((offs > total) || (offs & 7) || (wanted_size > total - offs))
190                 return NULL;
191
192         cell = (const struct cell *)&regf->hbin_area[offs];
193         actual_size = le32_to_cpu(cell->size);
194         if (actual_size >= 0) /* Cell not in use?  */
195                 return NULL;
196         if (wanted_size > -actual_size) /* Cell too small?  */
197                 return NULL;
198         return cell;
199 }
200
201 /* Revalidate the cell with its full length.  Returns true iff the cell is
202  * valid.  */
203 static bool
204 revalidate_cell(const struct regf *regf, le32 offset, size_t wanted_size)
205 {
206         return get_cell_pointer(regf, offset, wanted_size) != NULL;
207 }
208
209 /*
210  * Given a registry key cell @nk, look up the next component of the key
211  * *key_namep.  If found, return HIVE_OK, advance *key_namep past the key name
212  * component, and return the subkey cell in @sub_nk_ret.  Otherwise, return
213  * another HIVE_* error code.
214  */
215 static enum hive_status
216 lookup_subkey(const struct regf *regf, const utf16lechar **key_namep,
217               const struct nk *nk, const struct nk **sub_nk_ret)
218 {
219         const utf16lechar *key_name = *key_namep;
220         size_t key_name_nchars = 0;
221         size_t num_subkeys;
222         const struct cell *subkey_list;
223
224         for (const utf16lechar *p = key_name;
225              *p && *p != cpu_to_le16('\\'); p++)
226                 key_name_nchars++;
227
228         num_subkeys = le32_to_cpu(nk->num_subkeys);
229
230         if (num_subkeys == 0) /* No subkeys?  */
231                 return HIVE_KEY_NOT_FOUND;
232
233         if (num_subkeys > 65536) /* Arbitrary limit */
234                 return HIVE_CORRUPT;
235
236         /* Find the subkey list cell.  */
237         subkey_list = get_cell_pointer(regf, nk->subkey_list_offset,
238                                        sizeof(struct cell));
239         if (!subkey_list)
240                 return HIVE_CORRUPT;
241
242         if (subkey_list->magic == LF_MAGIC || subkey_list->magic == LH_MAGIC) {
243                 const struct lf *lf;
244
245                 /* Handle LF and LH subkey lists.  */
246
247                 lf = get_cell_pointer(regf, nk->subkey_list_offset,
248                                       sizeof(struct lf) +
249                                       (num_subkeys * sizeof(lf->subkeys[0])));
250                 if (!lf)
251                         return HIVE_CORRUPT;
252
253                 /* Look for the subkey in the subkey list.  */
254                 for (size_t i = 0; i < num_subkeys; i++) {
255                         const struct nk *sub_nk;
256                         size_t name_size;
257
258                         sub_nk = get_cell_pointer(regf, lf->subkeys[i].offset,
259                                                   sizeof(struct nk));
260                         if (!sub_nk)
261                                 return HIVE_CORRUPT;
262
263                         name_size = le16_to_cpu(sub_nk->name_size);
264
265                         if (!revalidate_cell(regf, lf->subkeys[i].offset,
266                                              sizeof(struct nk) + name_size))
267                                 return HIVE_CORRUPT;
268
269                         if (names_equal(key_name, key_name_nchars,
270                                         sub_nk->name, name_size,
271                                         (sub_nk->flags & NK_COMPRESSED_NAME)))
272                         {
273                                 key_name += key_name_nchars;
274                                 while (*key_name == cpu_to_le16('\\'))
275                                         key_name++;
276                                 *key_namep = key_name;
277                                 *sub_nk_ret = sub_nk;
278                                 return HIVE_OK;
279                         }
280                 }
281                 return HIVE_KEY_NOT_FOUND;
282         }
283
284         return HIVE_UNSUPPORTED;
285 }
286
287 /* Find the nk cell for the key named @key_name in the registry hive @regf.  */
288 static enum hive_status
289 lookup_key(const struct regf *regf, const tchar *key_name,
290            const struct nk **nk_ret)
291 {
292         const struct nk *nk;
293         enum hive_status status;
294         const utf16lechar *key_uname, *key_unamep;
295
296         nk = get_cell_pointer(regf, regf->root_key_offset, sizeof(struct nk));
297         if (!nk)
298                 return HIVE_CORRUPT;
299
300         status = translate_wimlib_error(tstr_get_utf16le(key_name, &key_uname));
301         if (status != HIVE_OK)
302                 return status;
303         key_unamep = key_uname;
304         while (*key_unamep) {
305                 status = lookup_subkey(regf, &key_unamep, nk, &nk);
306                 if (status != HIVE_OK)
307                         goto out;
308         }
309         *nk_ret = nk;
310         status = HIVE_OK;
311 out:
312         tstr_put_utf16le(key_uname);
313         return status;
314 }
315
316 /* Find the vk cell for the value named @value_name of the key named @key_name
317  * in the registry hive @regf.  */
318 static enum hive_status
319 lookup_value(const struct regf *regf, const tchar *key_name,
320              const tchar *value_name, const struct vk **vk_ret)
321 {
322         enum hive_status status;
323         const struct nk *nk;
324         size_t num_values;
325         const struct value_list *value_list;
326         const  utf16lechar *value_uname;
327         size_t value_uname_nchars;
328
329         /* Look up the nk cell for the key.  */
330         status = lookup_key(regf, key_name, &nk);
331         if (status != HIVE_OK)
332                 return status;
333
334         num_values = le32_to_cpu(nk->num_values);
335
336         if (num_values == 0) /* No values?  */
337                 return HIVE_VALUE_NOT_FOUND;
338
339         if (num_values > 65536) /* Arbitrary limit */
340                 return HIVE_CORRUPT;
341
342         value_list = get_cell_pointer(regf, nk->value_list_offset,
343                                       sizeof(struct value_list) +
344                                       (num_values *
345                                        sizeof(value_list->vk_offsets[0])));
346         if (!value_list)
347                 return HIVE_CORRUPT;
348
349         /* Look for the value in the value list.  */
350
351         status = translate_wimlib_error(
352                         tstr_get_utf16le_and_len(value_name, &value_uname,
353                                                  &value_uname_nchars));
354         if (status != HIVE_OK)
355                 return status;
356         value_uname_nchars /= 2;
357
358         for (size_t i = 0; i < num_values; i++) {
359                 const struct vk *vk;
360                 size_t name_size;
361
362                 status = HIVE_CORRUPT;
363                 vk = get_cell_pointer(regf, value_list->vk_offsets[i],
364                                       sizeof(struct vk));
365                 if (!vk)
366                         goto out;
367
368                 name_size = le16_to_cpu(vk->name_size);
369
370                 if (!revalidate_cell(regf, value_list->vk_offsets[i],
371                                      sizeof(struct vk) + name_size))
372                         goto out;
373
374                 if (names_equal(value_uname, value_uname_nchars,
375                                 vk->name, name_size,
376                                  (vk->flags & VK_COMPRESSED_NAME)))
377                 {
378                         *vk_ret = vk;
379                         status = HIVE_OK;
380                         goto out;
381                 }
382         }
383
384         status = HIVE_VALUE_NOT_FOUND;
385 out:
386         tstr_put_utf16le(value_uname);
387         return status;
388 }
389
390 /*
391  * Retrieve the data of the value named @value_name of the key named @key_name
392  * in the registry hive @regf.  If the value was found, return HIVE_OK and
393  * return the data, its size, and its type in @data_ret, @data_size_ret, and
394  * @data_type_ret.  Otherwise, return another HIVE_* error code.
395  */
396 static enum hive_status
397 retrieve_value(const struct regf *regf, const tchar *key_name,
398                const tchar *value_name, void **data_ret,
399                size_t *data_size_ret, le32 *data_type_ret)
400 {
401         enum hive_status status;
402         const struct vk *vk;
403         size_t data_size;
404         bool is_inline;
405         const void *data;
406
407         /* Find the vk cell.  */
408         status = lookup_value(regf, key_name, value_name, &vk);
409         if (status != HIVE_OK)
410                 return status;
411
412         /* Extract the value data from the vk cell (for inline data) or from the
413          * data cell which it references (for non-inline data).  */
414
415         data_size = le32_to_cpu(vk->data_size);
416
417         is_inline = (data_size & 0x80000000);
418         data_size &= 0x7FFFFFFF;
419
420         if (data_size > 1048576)        /* Arbitrary limit */
421                 return HIVE_CORRUPT;
422
423         if (is_inline) {
424                 if (data_size > 4)
425                         return HIVE_CORRUPT;
426                 data = &vk->data_offset;
427         } else {
428                 const struct data_cell *data_cell;
429
430                 data_cell = get_cell_pointer(regf, vk->data_offset,
431                                              sizeof(struct data_cell));
432                 if (!data_cell)
433                         return HIVE_CORRUPT;
434
435                 if (!revalidate_cell(regf, vk->data_offset,
436                                      sizeof(struct data_cell) + data_size))
437                         return HIVE_UNSUPPORTED; /* Possibly a big data cell  */
438
439                 data = data_cell->data;
440         }
441
442         *data_ret = memdup(data, data_size);
443         if (!*data_ret)
444                 return HIVE_OUT_OF_MEMORY;
445         *data_size_ret = data_size;
446         *data_type_ret = vk->data_type;
447         return HIVE_OK;
448 }
449
450 /* Validate the registry hive file given in memory as @hive_mem and @hive_size.
451  * If valid, return HIVE_OK.  If invalid, return another HIVE_* error code.  */
452 enum hive_status
453 hive_validate(const void *hive_mem, size_t hive_size)
454 {
455         const struct regf *regf = hive_mem;
456
457         STATIC_ASSERT(sizeof(struct regf) == 4096);
458
459         if (hive_size < sizeof(struct regf))
460                 return HIVE_CORRUPT;
461
462         if (regf->magic != REGF_MAGIC || regf->major_version != REGF_MAJOR)
463                 return HIVE_UNSUPPORTED;
464
465         if (le32_to_cpu(regf->total_hbin_size) > hive_size - sizeof(struct regf))
466                 return HIVE_CORRUPT;
467
468         return HIVE_OK;
469 }
470
471 /* Get a string value from the registry hive file.  */
472 enum hive_status
473 hive_get_string(const struct regf *regf, const tchar *key_name,
474                 const tchar *value_name, tchar **value_ret)
475 {
476         void *data;
477         size_t data_size;
478         le32 data_type;
479         enum hive_status status;
480
481         /* Retrieve the raw value data.  */
482         status = retrieve_value(regf, key_name, value_name,
483                                 &data, &data_size, &data_type);
484         if (status != HIVE_OK)
485                 return status;
486
487         /* Interpret the data as a string, when possible.  */
488         switch (data_type) {
489         case REG_SZ:
490         case REG_MULTI_SZ:
491                 status = translate_wimlib_error(
492                         utf16le_to_tstr(data, data_size, value_ret, &data_size));
493                 break;
494         default:
495                 status = HIVE_VALUE_IS_WRONG_TYPE;
496                 break;
497         }
498         FREE(data);
499         return status;
500 }
501
502 /* Get a number value from the registry hive file.  */
503 enum hive_status
504 hive_get_number(const struct regf *regf, const tchar *key_name,
505                 const tchar *value_name, s64 *value_ret)
506 {
507         void *data;
508         size_t data_size;
509         le32 data_type;
510         enum hive_status status;
511
512         /* Retrieve the raw value data.  */
513         status = retrieve_value(regf, key_name, value_name,
514                                 &data, &data_size, &data_type);
515         if (status != HIVE_OK)
516                 return status;
517
518         /* Interpret the data as a number, when possible.  */
519         switch (data_type) {
520         case REG_DWORD_LITTLE_ENDIAN:
521                 if (data_size == 4) {
522                         *value_ret = le32_to_cpu(*(le32 *)data);
523                         status = HIVE_OK;
524                 } else {
525                         status = HIVE_CORRUPT;
526                 }
527                 break;
528         case REG_DWORD_BIG_ENDIAN:
529                 if (data_size == 4) {
530                         *value_ret = be32_to_cpu(*(be32 *)data);
531                         status = HIVE_OK;
532                 } else {
533                         status = HIVE_CORRUPT;
534                 }
535                 break;
536         case REG_QWORD_LITTLE_ENDIAN:
537                 if (data_size == 8) {
538                         *value_ret = le64_to_cpu(*(le64 *)data);
539                         status = HIVE_OK;
540                 } else {
541                         status = HIVE_CORRUPT;
542                 }
543                 break;
544         default:
545                 status = HIVE_VALUE_IS_WRONG_TYPE;
546                 break;
547         }
548
549         FREE(data);
550         return status;
551 }
552
553 /* List the subkeys of the specified registry key.  */
554 enum hive_status
555 hive_list_subkeys(const struct regf *regf, const tchar *key_name,
556                   tchar ***subkeys_ret)
557 {
558         enum hive_status status;
559         const struct nk *nk;
560         size_t num_subkeys;
561         const struct cell *subkey_list;
562         tchar **subkeys;
563
564         /* Look up the nk cell for the key.  */
565         status = lookup_key(regf, key_name, &nk);
566         if (status != HIVE_OK)
567                 return status;
568
569         num_subkeys = le32_to_cpu(nk->num_subkeys);
570
571         if (num_subkeys > 65536) /* Arbitrary limit */
572                 return HIVE_CORRUPT;
573
574         /* Prepare the array of subkey names to return.  */
575         subkeys = CALLOC(num_subkeys + 1, sizeof(subkeys[0]));
576         if (!subkeys)
577                 return HIVE_OUT_OF_MEMORY;
578         *subkeys_ret = subkeys;
579
580         /* No subkeys?  */
581         if (num_subkeys == 0)
582                 return HIVE_OK;
583
584         /* Find the subkey list cell.  */
585         status = HIVE_CORRUPT;
586         subkey_list = get_cell_pointer(regf, nk->subkey_list_offset,
587                                        sizeof(struct cell));
588         if (!subkey_list)
589                 goto err;
590
591         if (subkey_list->magic == LF_MAGIC || subkey_list->magic == LH_MAGIC) {
592                 const struct lf *lf;
593
594                 /* Handle LF and LH subkey lists.  */
595
596                 status = HIVE_CORRUPT;
597                 lf = get_cell_pointer(regf, nk->subkey_list_offset,
598                                       sizeof(struct lf) +
599                                       (num_subkeys * sizeof(lf->subkeys[0])));
600                 if (!lf)
601                         goto err;
602
603                 /* Iterate through the subkey list and gather the subkey names.
604                  */
605                 for (size_t i = 0; i < num_subkeys; i++) {
606                         const struct nk *sub_nk;
607                         size_t name_size;
608                         tchar *subkey;
609                         size_t dummy;
610
611                         status = HIVE_CORRUPT;
612                         sub_nk = get_cell_pointer(regf, lf->subkeys[i].offset,
613                                                   sizeof(struct nk));
614                         if (!sub_nk)
615                                 goto err;
616
617                         name_size = le16_to_cpu(sub_nk->name_size);
618
619                         if (!revalidate_cell(regf, lf->subkeys[i].offset,
620                                              sizeof(struct nk) + name_size))
621                                 goto err;
622
623                         if (sub_nk->flags & NK_COMPRESSED_NAME) {
624                                 status = HIVE_OUT_OF_MEMORY;
625                                 subkey = MALLOC((name_size + 1) * sizeof(tchar));
626                                 if (!subkey)
627                                         goto err;
628                                 for (size_t j = 0; j < name_size; j++)
629                                         subkey[j] = sub_nk->name[j];
630                                 subkey[name_size] = '\0';
631                         } else {
632                                 status = translate_wimlib_error(
633                                         utf16le_to_tstr((utf16lechar *)sub_nk->name,
634                                                         name_size, &subkey, &dummy));
635                                 if (status != HIVE_OK)
636                                         goto err;
637                         }
638                         subkeys[i] = subkey;
639                 }
640                 return HIVE_OK;
641         }
642
643         status = HIVE_UNSUPPORTED;
644 err:
645         hive_free_subkeys_list(subkeys);
646         return status;
647 }
648
649 void
650 hive_free_subkeys_list(tchar **subkeys)
651 {
652         for (tchar **p = subkeys; *p; p++)
653                 FREE(*p);
654         FREE(subkeys);
655 }
656
657 const char *
658 hive_status_to_string(enum hive_status status)
659 {
660         switch (status) {
661         case HIVE_OK:
662                 return "HIVE_OK";
663         case HIVE_CORRUPT:
664                 return "HIVE_CORRUPT";
665         case HIVE_UNSUPPORTED:
666                 return "HIVE_UNSUPPORTED";
667         case HIVE_KEY_NOT_FOUND:
668                 return "HIVE_KEY_NOT_FOUND";
669         case HIVE_VALUE_NOT_FOUND:
670                 return "HIVE_VALUE_NOT_FOUND";
671         case HIVE_VALUE_IS_WRONG_TYPE:
672                 return "HIVE_VALUE_IS_WRONG_TYPE";
673         case HIVE_OUT_OF_MEMORY:
674                 return "HIVE_OUT_OF_MEMORY";
675         }
676         return NULL;
677 }