ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/pbcdedit/pbcdedit

Comparing pbcdedit/pbcdedit (file contents):
Revision 1.27 by root, Wed Aug 14 23:56:22 2019 UTC vs.
Revision 1.76 by root, Tue Aug 9 11:44:54 2022 UTC

…		…
17	#	17	#
18	# You should have received a copy of the GNU General Public License	18	# You should have received a copy of the GNU General Public License
19	# along with this program. If not, see <https://www.gnu.org/licenses/>.	19	# along with this program. If not, see <https://www.gnu.org/licenses/>.
20	#	20	#
21		21
22	use 5.014; # numerous features needed	22	use 5.016; # numerous features need 5.14, __SUB__ needs 5.16
23		23
24	our $VERSION = '1.0';	24	our $VERSION = '1.5';
25	our $JSON_VERSION = 1; # the versiobn of the json objects generated by this program	25	our $JSON_VERSION = 3; # the version of the json objects generated by this program
		26
		27	our $CHANGELOG = <<EOF;
		28
		29	1.5 Mon Nov 25 15:54:34 CET 2019
		30	- add "del" edit instruction.
		31	- work around lsblk bug sometimes giving "dos" pttype for gpt partitions.
		32	- bootmenupolicy in synopsis must be set to 0 to get the text menu.
		33	- minor doc fxes.
		34	- disable use of perldoc for help, doesn't work well.
		35
		36	1.4 Thu Aug 22 10:48:22 CEST 2019
		37	- new "create" subcommand.
		38	- "create" and "edit" try to save and restore ownership/permissions
		39	of bcd hives when writing the new file.
		40	- editorial fixes to the documentation.
		41	- add mininmal hive creation example.
		42
		43	1.3 Sat Aug 17 07:04:15 CEST 2019
		44	- output of pbcdedit elements --json has changed, as it didn't
		45	take the reorganisation by classes fully into account.
		46	- json schema bumped to 3.
		47	- new "bcd-device" and "bcd-legacy-device" subcommands.
		48	- implement --json option for lsblk.
		49
		50	1.2 Fri Aug 16 00:20:41 CEST 2019
		51	- bcd element names now depend on the bcd object type they are in,
		52	also affects "elements" output.
		53	- json schema bumped to 2.
		54	- new version command.
		55	- numerous minor bugfixes.
		56
		57	EOF
26		58
27	=head1 NAME	59	=head1 NAME
28		60
29	pbcdedit - portable boot configuration data (BCD) store editor	61	pbcdedit - portable boot configuration data (BCD) store editor
30		62
31	=head1 SYNOPSIS	63	=head1 SYNOPSIS
32		64
33	pbcdedit help # output manual page	65	pbcdedit help # output manual page
		66	pbcdedit version # output version and changelog
		67
34	pbcdedit export path/to/BCD # output BCD hive as JSON	68	pbcdedit export path/to/BCD # output BCD hive as JSON
35	pbcdedit import path/to/bcd # convert standard input to BCD hive	69	pbcdedit import path/to/BCD # convert standard input to BCD hive
36	pbcdedit edit path/to/BCD edit-instructions...	70	pbcdedit edit path/to/BCD edit-instructions...
37		71
38	pbcdedit objects # list all supported object aliases and types	72	pbcdedit objects # list all supported object aliases and types
39	pbcdedit elements # list all supported bcd element aliases	73	pbcdedit elements # list all supported bcd element aliases
40		74
		75	# Example: enable text-based boot menu.
		76	pbcdedit edit /my/BCD set '{default}' bootmenupolicy 0
		77
		78	# Example change system device to first partition containing winload.
		79	pbcdedit edit /my/BCD \
		80	set '{default}' device 'locate=<null>,element,path' \
		81	set '{default}' osdevice 'locate=<null>,element,path'
		82
		83
41	=head1 DESCRIPTION	84	=head1 DESCRIPTION
42		85
43	This program allows you to create, read and modify Boot Configuration Data	86	This program allows you to create, read and modify Boot Configuration Data
44	(BCD) stores used by Windows Vista and newer versions of Windows.	87	(BCD) stores used by Windows Vista and newer versions of Windows.
45		88
…		…
58		101
59	=item Does not rely on Windows	102	=item Does not rely on Windows
60		103
61	As the "portable" in the name implies, this program does not rely on	104	As the "portable" in the name implies, this program does not rely on
62	C<bcdedit> or other windows programs or libraries, it works on any system	105	C<bcdedit> or other windows programs or libraries, it works on any system
63	that supports at least perl version 5.14.	106	that supports at least perl version 5.16.
64		107
65	=item Decodes and encodes BCD device elements	108	=item Decodes and encodes BCD device elements
66		109
67	PBCDEDIT can concisely decode and encode BCD device element contents. This	110	PBCDEDIT can concisely decode and encode BCD device element contents. This
68	is pretty unique, and offers a lot of potential that can't be realised	111	is pretty unique, and offers a lot of potential that can't be realised
…		…
91		134
92	=item C<help>	135	=item C<help>
93		136
94	Displays the whole manual page (this document).	137	Displays the whole manual page (this document).
95		138
		139	=item C<version>
		140
		141	This outputs the PBCDEDIT version, the JSON schema version it uses and the
		142	full log of changes.
		143
96	=item C<export> F<path>	144	=item C<export> F<path>
97		145
98	Reads a BCD data store and writes a JSON representation of it to standard	146	Reads a BCD data store and writes a JSON representation of it to standard
99	output.	147	output.
100		148
…		…
119	=item C<parse> F<path> I<instructions...>	167	=item C<parse> F<path> I<instructions...>
120		168
121	Same as C<edit>, above, except it doesn't save the data store again. Can	169	Same as C<edit>, above, except it doesn't save the data store again. Can
122	be useful to extract some data from it.	170	be useful to extract some data from it.
123		171
124	=item C<lsblk>	172	=item C<create> F<path> I<instructions...>
		173
		174	Same as C<edit>, above, except it creates a new data store from scratch if
		175	needed. An existing store will be emptied completely.
		176
		177	=item C<lsblk> [C<--json>]
125		178
126	On a GNU/Linux system, you can get a list of partition device descriptors	179	On a GNU/Linux system, you can get a list of partition device descriptors
127	using this command - the external C<lsblk> command is required, as well as	180	using this command - the external C<lsblk> command is required, as well as
128	a mounted C</sys> file system.	181	a mounted C</sys> file system.
129		182
130	The output will be a list of all partitions in the system and C<partition>	183	The output will be a list of all partitions in the system and C<partition>
131	descriptors for GPT and both C<legacypartition> and C<partition>	184	descriptors for GPT and both C<legacypartition> and C<partition>
132	descriptors for MBR partitions.	185	descriptors for MBR partitions.
133		186
		187	With C<--json> it will print similar information as C<lsblk --json>, but
		188	with extra C<bcd_device> and C<bcd_legacy_device> attributes.
		189
		190	=item C<bcd-device> F<path>
		191
		192	Tries to find the BCD device element for the given device, which currently
		193	must be a a partition of some kind. Prints the C<partition=> descriptor as
		194	a result, or nothing. Exit status will be true on success, and false on
		195	failure.
		196
		197	Like C<lsblk>, above, this likely only works on GNU/Linux systems.
		198
		199	Example: print the partition descriptor of tghe partition with label DATA.
		200
		201	$ pbcdedit bcd-device /dev/disk/by-label/DATA
		202	partition=<null>,harddisk,mbr,47cbc08a,213579202560
		203
		204	=item C<bcd-legacy-device> F<path>
		205
		206	Like above, but uses a C<legacypartition> descriptor instead.
		207
134	=item C<objects> [C<--json>]	208	=item C<objects> [C<--json>]
135		209
136	Outputs two tables: a table listing all type aliases with their hex BCD	210	Outputs two tables: a table listing all type aliases with their hex BCD
137	element ID, and all object name aliases with their GUID and default type	211	element ID, and all object name aliases with their GUID and default type
138	(if any).	212	(if any).
…		…
146		220
147	With C<--json> it prints similar information as a JSON object, for easier parsing.	221	With C<--json> it prints similar information as a JSON object, for easier parsing.
148		222
149	=item C<export-regf> F<path>	223	=item C<export-regf> F<path>
150		224
151	This has nothing to do with BCD stores - it takes a registry hive	225	This has nothing to do with BCD stores, but simply exposes PCBEDIT's
		226	internal registry hive reader - it takes a registry hive file as argument
152	file as argument and outputs a JSON representation of it to standard	227	and outputs a JSON representation of it to standard output.
153	output.
154		228
155	Hive versions 1.2 till 1.6 are supported.	229	Hive versions 1.2 till 1.6 are supported.
156		230
157	=item C<import-regf> F<path>	231	=item C<import-regf> F<path>
158		232
…		…
216	}	290	}
217		291
218	=head2 Minimal BCD to boot windows	292	=head2 Minimal BCD to boot windows
219		293
220	Experimentally I found the following BCD is the minimum required to	294	Experimentally I found the following BCD is the minimum required to
221	successfully boot any post-XP version of Windows (suitable C<device> and	295	successfully boot any post-XP version of Windows (assuming suitable
222	C<osdevice> values, of course):	296	C<device> and C<osdevice> values, of course, and assuming a BIOS boot -
		297	for UEFI, you should use F<winload.efi> instead of F<winload.exe>):
223		298
224	{	299	{
225	"{bootmgr}" : {	300	"{bootmgr}" : {
226	"resumeobject" : "{45b547a7-8ca6-4417-9eb0-a257b61f35b4}"	301	"default" : "{45b547a7-8ca6-4417-9eb0-a257b61f35b4}"
227	},	302	},
228		303
229	"{45b547a7-8ca6-4417-9eb0-a257b61f35b1}" : {	304	"{45b547a7-8ca6-4417-9eb0-a257b61f35b1}" : {
230	"type" : "application::osloader",	305	"type" : "application::osloader",
231	"description" : "Windows Boot",	306	"description" : "Windows Boot",
…		…
238		313
239	Note that minimal doesn't mean recommended - Windows itself will add stuff	314	Note that minimal doesn't mean recommended - Windows itself will add stuff
240	to this during or after boot, and you might or might not run into issues	315	to this during or after boot, and you might or might not run into issues
241	when installing updates as it might not be able to find the F<bootmgr>.	316	when installing updates as it might not be able to find the F<bootmgr>.
242		317
		318	This is how you would create a minimal hive with PBCDEDIT from within
		319	GNU/Linux, assuming F</dev/sdc3> is the windows partition, using
		320	a random GUID for the osloader and using C<partition> instead of
		321	C<legacypartition>:
		322
		323	osldr="{$(uuidgen)}"
		324	part=$(pbcdedit bcd-device /dev/sdc3)
		325	pbcdedit create minimal.bcd \
		326	set '{bootmgr}' default "$osldr" \
		327	set "$osldr" type application::osloader \
		328	set "$osldr" description 'Windows Boot' \
		329	set "$osldr" device "$part" \
		330	set "$osldr" osdevice "$part" \
		331	set "$osldr" path '\Windows\system32\winload.exe' \
		332	set "$osldr" systemroot '\Windows'
		333
243	=head2 The C<meta> key	334	=head2 The C<meta> key
244		335
245	The C<meta> key is not stored in the BCD data store but is used only	336	The C<meta> key is not stored in the BCD data store but is used only
246	by PBCDEDIT. It is always generated when exporting, and importing will	337	by PBCDEDIT. It is always generated when exporting, and importing will
247	be refused when it exists and the version stored inside doesn't store	338	be refused when it exists and the version stored inside doesn't match
248	the JSON schema version of PBCDEDIT. This ensures that different and	339	the JSON schema version of PBCDEDIT. This ensures that different and
249	incompatible versions of PBCDEDIT will not read and misinterpret each	340	incompatible versions of PBCDEDIT will not read and misinterpret each
250	others data.	341	others data.
251		342
252	=head2 The object keys	343	=head2 The object keys
…		…
261		352
262	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode	353	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode
263	into human-readable strings such as C<{globalsettings}>, which is the same	354	into human-readable strings such as C<{globalsettings}>, which is the same
264	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.	355	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.
265		356
266	Each BCD, object has an associated type. For example,	357	Each BCD object has an associated type. For example,
267	C<application::osloader> for objects loading Windows via F<winload.exe>,	358	C<application::osloader> for objects loading Windows via F<winload.exe>,
268	C<application::bootsector> for real mode applications and so on.	359	C<application::bootsector> for real mode applications and so on.
269		360
270	The type of a object is stored in the pseudo BCD element C<type> (see next	361	The type of a object is stored in the pseudo BCD element C<type> (see next
271	section).	362	section).
…		…
334		425
335	"displaybootmenu" : 0,	426	"displaybootmenu" : 0,
336		427
337	=item integer	428	=item integer
338		429
339	Again, very simple, this is a 64 bit integer. IT can be either specified	430	Again, very simple, this is a 64 bit integer. It can be either specified
340	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a	431	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a
341	binary number (prefix C<0b>).	432	binary number (prefix C<0b>).
342		433
343	For example, the boot C<timeout> is an integer, specifying the automatic	434	For example, the boot C<timeout> is an integer, specifying the automatic
344	boot delay in seconds:	435	boot delay in seconds:
…		…
346	"timeout" : 30,	437	"timeout" : 30,
347		438
348	=item integer list	439	=item integer list
349		440
350	This is a list of 64 bit integers separated by whitespace. It is not used	441	This is a list of 64 bit integers separated by whitespace. It is not used
351	much, so here is a somewhat artificial an untested example of using	442	much, so here is a somewhat artificial and untested example of using
352	C<customactions> to specify a certain custom, eh, action to be executed	443	C<customactions> to specify a certain custom, eh, action to be executed
353	when pressing C<F10> at boot:	444	when pressing C<F10> at boot:
354		445
355	"customactions" : "0x1000044000001 0x54000001",	446	"customactions" : "0x1000044000001 0x54000001",
356		447
…		…
358		449
359	This represents a single GUID value wrapped in curly braces. It is used a	450	This represents a single GUID value wrapped in curly braces. It is used a
360	lot to refer from one BCD object to other one.	451	lot to refer from one BCD object to other one.
361		452
362	For example, The C<{bootmgr}> object might refer to a resume boot option	453	For example, The C<{bootmgr}> object might refer to a resume boot option
363	using C<resumeobject>:	454	using C<default>:
364		455
365	"resumeobject" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",	456	"default" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",
366		457
367	Human readable aliases are used and allowed.	458	Human readable aliases are used and allowed.
368		459
369	=item guid list	460	=item guid list
370		461
…		…
384	This type is why I write I<most> are easy to explain earlier: This type	475	This type is why I write I<most> are easy to explain earlier: This type
385	is the pinnacle of Microsoft-typical hacks layered on top of other	476	is the pinnacle of Microsoft-typical hacks layered on top of other
386	hacks. Understanding this type took more time than writing all the rest of	477	hacks. Understanding this type took more time than writing all the rest of
387	PBCDEDIT, and because it is so complex, this type has its own subsection	478	PBCDEDIT, and because it is so complex, this type has its own subsection
388	below.	479	below.
		480
389	=back	481	=back
390		482
391	=head4 The BCD "device" element type	483	=head3 The BCD "device" element type
392		484
393	Device elements specify, well, devices. They are used for such diverse	485	Device elements specify, well, devices. They are used for such diverse
394	purposes such as finding a TFTP network boot image, serial ports or VMBUS	486	purposes such as finding a TFTP network boot image, serial ports or VMBUS
395	devices, but most commonly they are used to specify the disk (harddisk,	487	devices, but most commonly they are used to specify the disk (harddisk,
396	cdrom, ramdisk, vhd...) to boot from.	488	cdrom, ramdisk, vhd...) to boot from.
…		…
404	element, so almost everything known about it had to be researched first	496	element, so almost everything known about it had to be researched first
405	in the process of writing this script, and consequently, support for BCD	497	in the process of writing this script, and consequently, support for BCD
406	device elements is partial only.	498	device elements is partial only.
407		499
408	On the other hand, the expressive power of PBCDEDIT in specifying devices	500	On the other hand, the expressive power of PBCDEDIT in specifying devices
409	is much bigger than BCDEDIT and therefore more can be done with it. The	501	is much greater than BCDEDIT and therefore more can be done with it. The
410	downside is that BCD device elements are much more complicated than what	502	downside is that BCD device elements are much more complicated than what
411	you might think from reading the BCDEDIT documentation.	503	you might think from reading the BCDEDIT documentation.
412		504
413	In other words, simple things are complicated, and complicated things are	505	In other words, simple things are complicated, and complicated things are
414	possible.	506	possible.
…		…
421	[{GUID}]type[<flags>][=arg,arg...]	513	[{GUID}]type[<flags>][=arg,arg...]
422		514
423	Here are some examples:	515	Here are some examples:
424		516
425	boot	517	boot
426	{b097d29f-bc00-11e9-8a9a-525400123456}block=file,<boot>,\\EFI"	518	{b097d29f-bc00-11e9-8a9a-525400123456}block=file,<boot>,\EFI
427	locate=<null>,element,systemroot	519	locate=<null>,element,systemroot
428	partition=<null>,harddisk,mbr,47cbc08a,1048576	520	partition=<null>,harddisk,mbr,47cbc08a,1048576
429	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd	521	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd
430	block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,68720525312>,0,0,0,\Recovery\b097d29e-bc00-11e9-8a9a-525400123456\Winre.wim	522	block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,68720525312>,0,0,0,\Recovery\b097d29e-bc00-11e9-8a9a-525400123456\Winre.wim
431	block=file,<partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,ee3a393a-f0de-4057-9946-88584245ed48>,\	523	block=file,<partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,ee3a393a-f0de-4057-9946-88584245ed48>,\
…		…
457	the leading GUID, which it can always decode). In such cases, it will	549	the leading GUID, which it can always decode). In such cases, it will
458	convert the device into this type with a hexdump of the element data.	550	convert the device into this type with a hexdump of the element data.
459		551
460	=item C<null>	552	=item C<null>
461		553
462	This is another special type - sometimes, a device all zero-filled, which	554	This is another special type - sometimes, a device is all zero-filled,
463	is not valid. This can mark the absence of a device or something PBCDEDIT	555	which is not valid. This can mark the absence of a device or something
464	does not understand, so it decodes it into this special "all zero" type	556	PBCDEDIT does not understand, so it decodes it into this special "all
465	called C<null>.	557	zero" type called C<null>.
466		558
467	It's most commonly found in devices that can use an optional parent	559	It's most commonly found in devices that can use an optional parent
468	device, when no parent device is used.	560	device, when no parent device is used.
469		561
470	=item C<boot>	562	=item C<boot>
…		…
581		673
582	Last not least, the most complex type, C<block>, which... specifies block	674	Last not least, the most complex type, C<block>, which... specifies block
583	devices (which could be inside a F<vhdx> file for example).	675	devices (which could be inside a F<vhdx> file for example).
584		676
585	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,	677	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,
586	C<file> or C<vhd> - the same as for C<partiion=>.	678	C<file> or C<vhd> - the same as for C<partition=>.
587		679
588	The remaining arguments change depending on the I<devicetype>:	680	The remaining arguments change depending on the I<devicetype>:
589		681
590	=over	682	=over
591		683
…		…
621		713
622	Probably not yet implemented. Tell me of your needs...	714	Probably not yet implemented. Tell me of your needs...
623		715
624	=back	716	=back
625		717
626	=back5 Examples	718	=back
		719
		720	=head4 Examples
627		721
628	This concludes the syntax overview for device elements, but probably	722	This concludes the syntax overview for device elements, but probably
629	leaves many questions open. I can't help with most of them, as I also ave	723	leaves many questions open. I can't help with most of them, as I also have
630	many questions, but I can walk you through some actual examples using more	724	many questions, but I can walk you through some actual examples using more
631	complex aspects.	725	complex aspects.
		726
		727	=over
632		728
633	=item C<< locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path >>	729	=item C<< locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path >>
634		730
635	Just like with C declarations, you best treat device descriptors as	731	Just like with C declarations, you best treat device descriptors as
636	instructions to find your device and work your way from the inside out:	732	instructions to find your device and work your way from the inside out:
…		…
708	I don't know what the purpose of the C<< <1> >> flag value is, but it	804	I don't know what the purpose of the C<< <1> >> flag value is, but it
709	seems to be always there on this kind of entry.	805	seems to be always there on this kind of entry.
710		806
711	If you have some good examples to add here, feel free to mail me.	807	If you have some good examples to add here, feel free to mail me.
712		808
		809	=back
		810
713		811
714	=head1 EDITING BCD STORES	812	=head1 EDITING BCD STORES
715		813
716	The C<edit> and C<parse> subcommands allow you to read a BCD data store	814	The C<edit> and C<parse> subcommands allow you to read a BCD data store
717	and modify it or extract data from it. This is done by executing a series	815	and modify it or extract data from it. This is done by executing a series
…		…
735	Similar to C<get>, but sets the element to the given I<value> instead.	833	Similar to C<get>, but sets the element to the given I<value> instead.
736		834
737	Example: change the bootmgr default too	835	Example: change the bootmgr default too
738	C<{b097d2ad-bc00-11e9-8a9a-525400123456}>:	836	C<{b097d2ad-bc00-11e9-8a9a-525400123456}>:
739		837
740	pbcdedit edit BCD set "{bootmgr}" resumeobject "{b097d2ad-bc00-11e9-8a9a-525400123456}"	838	pbcdedit edit BCD set "{bootmgr}" default "{b097d2ad-bc00-11e9-8a9a-525400123456}"
		839
		840	=item C<del> I<object> I<element>
		841
		842	Similar to C<get>, but removed the BCD element from the specified BCD object.
741		843
742	=item C<eval> I<perlcode>	844	=item C<eval> I<perlcode>
743		845
744	This takes the next argument, interprets it as Perl code and	846	This takes the next argument, interprets it as Perl code and
745	evaluates it. This allows you to do more complicated modifications or	847	evaluates it. This allows you to do more complicated modifications or
…		…
768		870
769	pbcdedit edit BCD eval 'say $BCD->{$DEFAULT}{description}'	871	pbcdedit edit BCD eval 'say $BCD->{$DEFAULT}{description}'
770		872
771	The example given for C<set> could be expressed like this:	873	The example given for C<set> could be expressed like this:
772		874
773	pbcdedit edit BCD eval '$BCD->{$DEFAULT}{resumeobject} = "{b097d2ad-bc00-11e9-8a9a-525400123456}"'	875	pbcdedit edit BCD eval '$BCD->{"{bootmgr}"{default} = "{b097d2ad-bc00-11e9-8a9a-525400123456}"'
774		876
775	=item C<do> I<path>	877	=item C<do> I<path>
776		878
777	Similar to C<eval>, above, but instead of using the argument as perl code,	879	Similar to C<eval>, above, but instead of using the argument as perl code,
778	it loads the perl code from the given file and executes it. This makes it	880	it loads the perl code from the given file and executes it. This makes it
…		…
823	free to change and redistribute it. There is NO WARRANTY, to the extent	925	free to change and redistribute it. There is NO WARRANTY, to the extent
824	permitted by law.	926	permitted by law.
825		927
826	=cut	928	=cut
827		929
828	BEGIN { require "common/sense.pm"; common::sense->import } # common sense is optional, but recommended	930	# common sense is optional, but recommended
		931	BEGIN { eval { require "common/sense.pm"; } && common::sense->import }
829		932
830	use Data::Dump;	933	no warnings 'portable'; # avoid 32 bit integer warnings
		934
831	use Encode ();	935	use Encode ();
832	use List::Util ();	936	use List::Util ();
833	use IO::Handle ();	937	use IO::Handle ();
834	use Time::HiRes ();	938	use Time::HiRes ();
835		939
…		…
844		948
845	# hack used for debugging	949	# hack used for debugging
846	sub xxd($$) {	950	sub xxd($$) {
847	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";	951	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";
848	syswrite $xxd, $_[1];	952	syswrite $xxd, $_[1];
		953	}
		954
		955	# get some meta info on a file (uid, gid, perms)
		956	sub stat_get($) {
		957	[(stat shift)[4, 5, 2]]
		958	}
		959
		960	# set stat info on a file
		961	sub stat_set($$) {
		962	my ($fh_or_path, $stat) = @_;
		963
		964	return unless $stat;
		965	chown $stat->[0], $stat->[1], $fh_or_path;
		966	chmod +($stat->[2] & 07777), $fh_or_path;
849	}	967	}
850		968
851	sub file_load($) {	969	sub file_load($) {
852	my ($path) = @_;	970	my ($path) = @_;
853		971
…		…
858	or die "$path: short read\n";	976	or die "$path: short read\n";
859		977
860	$buf	978	$buf
861	}	979	}
862		980
		981	sub file_save($$;$) {
		982	my ($path, $data, $stat) = @_;
		983
		984	open my $fh, ">:raw", "$path~"
		985	or die "$path~: $!\n";
		986	print $fh $data
		987	or die "$path~: short write\n";
		988	stat_set $fh, $stat;
		989	$fh->sync;
		990	close $fh;
		991
		992	rename "$path~", $path;
		993	}
		994
863	# sources and resources used for this:	995	# sources and resources used for writing pbcdedit
		996	#
864	# registry:	997	# registry:
865	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md	998	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md
866	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/	999	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/
867	# bcd:	1000	# bcd:
868	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm	1001	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm
…		…
1050	my ($rname, $root) = $decode_key->($rootcell);	1183	my ($rname, $root) = $decode_key->($rootcell);
1051		1184
1052	[$rname, $root]	1185	[$rname, $root]
1053	}	1186	}
1054		1187
1055	# return a binary windows fILETIME struct	1188	# return a binary windows FILETIME struct
1056	sub filetime_now {	1189	sub filetime_now {
1057	my ($s, $ms) = Time::HiRes::gettimeofday;	1190	my ($s, $ms) = Time::HiRes::gettimeofday;
1058		1191
1059	pack "Q<", $s = ($s * 1_000_000 + $ms) * 10 + 116_444_736_000_000_000	1192	pack "Q<", ($s * 1_000_000 + $ms) * 10
		1193	+ 116_444_736_000_000_000 # 1970-01-01 00:00:00
1060	}	1194	}
1061		1195
1062	# encode a registry hive	1196	# encode a registry hive
1063	sub regf_encode($) {	1197	sub regf_encode($) {
1064	my ($hive) = @_;	1198	my ($hive) = @_;
…		…
1067		1201
1068	# the filetime is apparently used to verify log file validity,	1202	# the filetime is apparently used to verify log file validity,
1069	# so by generating a new timestamp the log files *should* automatically	1203	# so by generating a new timestamp the log files *should* automatically
1070	# become invalidated and windows would "self-heal" them.	1204	# become invalidated and windows would "self-heal" them.
1071	# (update: has been verified by reverse engineering)	1205	# (update: has been verified by reverse engineering)
1072	# possibly the fact that the two sequence numbes match might also	1206	# possibly the fact that the two sequence numbers match might also
1073	# make windows think that the hive is not dirty and ignore logs.	1207	# make windows think that the hive is not dirty and ignore logs.
1074	# (update: has been verified by reverse engineering)	1208	# (update: has been verified by reverse engineering)
1075		1209
1076	my $now = filetime_now;	1210	my $now = filetime_now;
1077		1211
…		…
1221		1355
1222	regf_decode file_load $path	1356	regf_decode file_load $path
1223	}	1357	}
1224		1358
1225	# encode and save registry to file	1359	# encode and save registry to file
1226	sub regf_save {	1360	sub regf_save($$;$) {
1227	my ($path, $hive) = @_;	1361	my ($path, $hive, $stat) = @_;
1228		1362
1229	$hive = regf_encode $hive;	1363	$hive = regf_encode $hive;
1230		1364
1231	open my $regf, ">:raw", "$path~"	1365	file_save $path, $hive, $stat;
1232	or die "$path~: $!\n";
1233	print $regf $hive
1234	or die "$path~: short write\n";
1235	$regf->sync;
1236	close $regf;
1237
1238	rename "$path~", $path;
1239	}	1366	}
1240		1367
1241	#############################################################################	1368	#############################################################################
1242	# bcd stuff	1369	# bcd stuff
1243		1370
1244	# human-readable alises for GUID object identifiers	1371	# human-readable aliases for GUID object identifiers
1245	our %bcd_objects = (	1372	our %bcd_objects = (
1246	'{0ce4991b-e6b3-4b16-b23c-5e0d9250e5d9}' => '{emssettings}',	1373	'{0ce4991b-e6b3-4b16-b23c-5e0d9250e5d9}' => '{emssettings}',
1247	'{1afa9c49-16ab-4a5c-4a90-212802da9460}' => '{resumeloadersettings}',	1374	'{1afa9c49-16ab-4a5c-4a90-212802da9460}' => '{resumeloadersettings}',
1248	'{1cae1eb7-a0df-4d4d-9851-4860e34ef535}' => '{default}',	1375	'{1cae1eb7-a0df-4d4d-9851-4860e34ef535}' => '{default}',
1249	'{313e8eed-7098-4586-a9bf-309c61f8d449}' => '{kerneldbgsettings}',	1376	'{313e8eed-7098-4586-a9bf-309c61f8d449}' => '{kerneldbgsettings}',
…		…
1356	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }	1483	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }
1357	sub BCDE_FORMAT_INTEGER () { 0x05000000 }	1484	sub BCDE_FORMAT_INTEGER () { 0x05000000 }
1358	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }	1485	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }
1359	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }	1486	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }
1360		1487
1361	sub dec_device;
1362	sub enc_device;
1363
1364	sub enc_integer($) {	1488	sub enc_integer($) {
1365	no warnings 'portable'; # ugh
1366	my $value = shift;	1489	my $value = shift;
1367	$value = oct $value if $value =~ /^0[bBxX]/;	1490	$value = oct $value if $value =~ /^0[bBxX]/;
1368	unpack "H*", pack "Q<", $value	1491	unpack "H*", pack "Q<", $value
1369	}	1492	}
		1493
		1494	sub enc_device($$);
		1495	sub dec_device($$);
1370		1496
1371	our %bcde_dec = (	1497	our %bcde_dec = (
1372	BCDE_FORMAT_DEVICE , \&dec_device,	1498	BCDE_FORMAT_DEVICE , \&dec_device,
1373	# # for round-trip verification	1499	# # for round-trip verification
1374	# BCDE_FORMAT_DEVICE , sub {	1500	# BCDE_FORMAT_DEVICE , sub {
…		…
1380	BCDE_FORMAT_STRING , sub { shift },	1506	BCDE_FORMAT_STRING , sub { shift },
1381	BCDE_FORMAT_GUID , sub { dec_wguid enc_wguid shift },	1507	BCDE_FORMAT_GUID , sub { dec_wguid enc_wguid shift },
1382	BCDE_FORMAT_GUID_LIST , sub { join " ", map dec_wguid enc_wguid $_, @{+shift} },	1508	BCDE_FORMAT_GUID_LIST , sub { join " ", map dec_wguid enc_wguid $_, @{+shift} },
1383	BCDE_FORMAT_INTEGER , sub { unpack "Q", pack "a8", pack "H*", shift }, # integer might be 4 or 8 bytes - caused by ms coding bugs	1509	BCDE_FORMAT_INTEGER , sub { unpack "Q", pack "a8", pack "H*", shift }, # integer might be 4 or 8 bytes - caused by ms coding bugs
1384	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },	1510	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },
1385	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this cna be 4 bytes	1511	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this can be 4 bytes
1386	);	1512	);
1387		1513
1388	our %bcde_enc = (	1514	our %bcde_enc = (
1389	BCDE_FORMAT_DEVICE , sub { binary => enc_device shift },	1515	BCDE_FORMAT_DEVICE , sub { binary => enc_device $_[0], $_[1] },
1390	BCDE_FORMAT_STRING , sub { sz => shift },	1516	BCDE_FORMAT_STRING , sub { sz => shift },
1391	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },	1517	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },
1392	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },	1518	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },
1393	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },	1519	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },
1394	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },	1520	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },
1395	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },	1521	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },
1396	);	1522	);
1397		1523
1398	# BCD Elements	1524	# BCD Elements
1399	our %bcde = (	1525	our %bcde_byclass = (
		1526	any => {
1400	0x11000001 => 'device',	1527	0x11000001 => 'device',
1401	0x12000002 => 'path',	1528	0x12000002 => 'path',
1402	0x12000004 => 'description',	1529	0x12000004 => 'description',
1403	0x12000005 => 'locale',	1530	0x12000005 => 'locale',
1404	0x14000006 => 'inherit',	1531	0x14000006 => 'inherit',
1405	0x15000007 => 'truncatememory',	1532	0x15000007 => 'truncatememory',
1406	0x14000008 => 'recoverysequence',	1533	0x14000008 => 'recoverysequence',
1407	0x16000009 => 'recoveryenabled',	1534	0x16000009 => 'recoveryenabled',
1408	0x1700000a => 'badmemorylist',	1535	0x1700000a => 'badmemorylist',
1409	0x1600000b => 'badmemoryaccess',	1536	0x1600000b => 'badmemoryaccess',
1410	0x1500000c => 'firstmegabytepolicy',	1537	0x1500000c => 'firstmegabytepolicy',
1411	0x1500000d => 'relocatephysical',	1538	0x1500000d => 'relocatephysical',
1412	0x1500000e => 'avoidlowmemory',	1539	0x1500000e => 'avoidlowmemory',
1413	0x1600000f => 'traditionalkseg',	1540	0x1600000f => 'traditionalkseg',
1414	0x16000010 => 'bootdebug',	1541	0x16000010 => 'bootdebug',
1415	0x15000011 => 'debugtype',	1542	0x15000011 => 'debugtype',
1416	0x15000012 => 'debugaddress',	1543	0x15000012 => 'debugaddress',
1417	0x15000013 => 'debugport',	1544	0x15000013 => 'debugport',
1418	0x15000014 => 'baudrate',	1545	0x15000014 => 'baudrate',
1419	0x15000015 => 'channel',	1546	0x15000015 => 'channel',
1420	0x12000016 => 'targetname',	1547	0x12000016 => 'targetname',
1421	0x16000017 => 'noumex',	1548	0x16000017 => 'noumex',
1422	0x15000018 => 'debugstart',	1549	0x15000018 => 'debugstart',
1423	0x12000019 => 'busparams',	1550	0x12000019 => 'busparams',
1424	0x1500001a => 'hostip',	1551	0x1500001a => 'hostip',
1425	0x1500001b => 'port',	1552	0x1500001b => 'port',
1426	0x1600001c => 'dhcp',	1553	0x1600001c => 'dhcp',
1427	0x1200001d => 'key',	1554	0x1200001d => 'key',
1428	0x1600001e => 'vm',	1555	0x1600001e => 'vm',
1429	0x16000020 => 'bootems',	1556	0x16000020 => 'bootems',
1430	0x15000022 => 'emsport',	1557	0x15000022 => 'emsport',
1431	0x15000023 => 'emsbaudrate',	1558	0x15000023 => 'emsbaudrate',
1432	0x12000030 => 'loadoptions',	1559	0x12000030 => 'loadoptions',
1433	0x16000040 => 'advancedoptions',	1560	0x16000040 => 'advancedoptions',
1434	0x16000041 => 'optionsedit',	1561	0x16000041 => 'optionsedit',
1435	0x15000042 => 'keyringaddress',	1562	0x15000042 => 'keyringaddress',
1436	0x11000043 => 'bootstatdevice',	1563	0x11000043 => 'bootstatdevice',
1437	0x12000044 => 'bootstatfilepath',	1564	0x12000044 => 'bootstatfilepath',
1438	0x16000045 => 'preservebootstat',	1565	0x16000045 => 'preservebootstat',
1439	0x16000046 => 'graphicsmodedisabled',	1566	0x16000046 => 'graphicsmodedisabled',
1440	0x15000047 => 'configaccesspolicy',	1567	0x15000047 => 'configaccesspolicy',
1441	0x16000048 => 'nointegritychecks',	1568	0x16000048 => 'nointegritychecks',
1442	0x16000049 => 'testsigning',	1569	0x16000049 => 'testsigning',
1443	0x1200004a => 'fontpath',	1570	0x1200004a => 'fontpath',
1444	0x1500004b => 'integrityservices',	1571	0x1500004b => 'integrityservices',
1445	0x1500004c => 'volumebandid',	1572	0x1500004c => 'volumebandid',
1446	0x16000050 => 'extendedinput',	1573	0x16000050 => 'extendedinput',
1447	0x15000051 => 'initialconsoleinput',	1574	0x15000051 => 'initialconsoleinput',
1448	0x15000052 => 'graphicsresolution',	1575	0x15000052 => 'graphicsresolution',
1449	0x16000053 => 'restartonfailure',	1576	0x16000053 => 'restartonfailure',
1450	0x16000054 => 'highestmode',	1577	0x16000054 => 'highestmode',
1451	0x16000060 => 'isolatedcontext',	1578	0x16000060 => 'isolatedcontext',
1452	0x15000065 => 'displaymessage',	1579	0x15000065 => 'displaymessage',
1453	0x15000066 => 'displaymessageoverride',	1580	0x15000066 => 'displaymessageoverride',
1454	0x16000068 => 'nobootuxtext',	1581	0x16000068 => 'nobootuxtext',
1455	0x16000069 => 'nobootuxprogress',	1582	0x16000069 => 'nobootuxprogress',
1456	0x1600006a => 'nobootuxfade',	1583	0x1600006a => 'nobootuxfade',
1457	0x1600006b => 'bootuxreservepooldebug',	1584	0x1600006b => 'bootuxreservepooldebug',
1458	0x1600006c => 'bootuxdisabled',	1585	0x1600006c => 'bootuxdisabled',
1459	0x1500006d => 'bootuxfadeframes',	1586	0x1500006d => 'bootuxfadeframes',
1460	0x1600006e => 'bootuxdumpstats',	1587	0x1600006e => 'bootuxdumpstats',
1461	0x1600006f => 'bootuxshowstats',	1588	0x1600006f => 'bootuxshowstats',
1462	0x16000071 => 'multibootsystem',	1589	0x16000071 => 'multibootsystem',
1463	0x16000072 => 'nokeyboard',	1590	0x16000072 => 'nokeyboard',
1464	0x15000073 => 'aliaswindowskey',	1591	0x15000073 => 'aliaswindowskey',
1465	0x16000074 => 'bootshutdowndisabled',	1592	0x16000074 => 'bootshutdowndisabled',
1466	0x15000075 => 'performancefrequency',	1593	0x15000075 => 'performancefrequency',
1467	0x15000076 => 'securebootrawpolicy',	1594	0x15000076 => 'securebootrawpolicy',
1468	0x17000077 => 'allowedinmemorysettings',	1595	0x17000077 => 'allowedinmemorysettings',
1469	0x15000079 => 'bootuxtransitiontime',	1596	0x15000079 => 'bootuxtransitiontime',
1470	0x1600007a => 'mobilegraphics',	1597	0x1600007a => 'mobilegraphics',
1471	0x1600007b => 'forcefipscrypto',	1598	0x1600007b => 'forcefipscrypto',
1472	0x1500007d => 'booterrorux',	1599	0x1500007d => 'booterrorux',
1473	0x1600007e => 'flightsigning',	1600	0x1600007e => 'flightsigning',
1474	0x1500007f => 'measuredbootlogformat',	1601	0x1500007f => 'measuredbootlogformat',
1475	0x15000080 => 'displayrotation',	1602	0x15000080 => 'displayrotation',
1476	0x15000081 => 'logcontrol',	1603	0x15000081 => 'logcontrol',
1477	0x16000082 => 'nofirmwaresync',	1604	0x16000082 => 'nofirmwaresync',
1478	0x11000084 => 'windowssyspart',	1605	0x11000084 => 'windowssyspart',
1479	0x16000087 => 'numlock',	1606	0x16000087 => 'numlock',
1480	0x22000001 => 'bpbstring',	1607	0x26000202 => 'skipffumode',
		1608	0x26000203 => 'forceffumode',
		1609	0x25000510 => 'chargethreshold',
		1610	0x26000512 => 'offmodecharging',
		1611	0x25000aaa => 'bootflow',
		1612	0x45000001 => 'devicetype',
		1613	0x42000002 => 'applicationrelativepath',
		1614	0x42000003 => 'ramdiskdevicerelativepath',
		1615	0x46000004 => 'omitosloaderelements',
		1616	0x47000006 => 'elementstomigrate',
		1617	0x46000010 => 'recoveryos',
		1618	},
		1619	bootapp => {
		1620	0x26000145 => 'enablebootdebugpolicy',
		1621	0x26000146 => 'enablebootorderclean',
		1622	0x26000147 => 'enabledeviceid',
		1623	0x26000148 => 'enableffuloader',
		1624	0x26000149 => 'enableiuloader',
		1625	0x2600014a => 'enablemassstorage',
		1626	0x2600014b => 'enablerpmbprovisioning',
		1627	0x2600014c => 'enablesecurebootpolicy',
		1628	0x2600014d => 'enablestartcharge',
		1629	0x2600014e => 'enableresettpm',
		1630	},
		1631	bootmgr => {
1481	0x24000001 => 'displayorder',	1632	0x24000001 => 'displayorder',
1482	0x21000001 => 'filedevice',
1483	0x21000001 => 'osdevice',
1484	0x25000001 => 'passcount',
1485	0x26000001 => 'pxesoftreboot',
1486	0x22000002 => 'applicationname',
1487	0x24000002 => 'bootsequence',	1633	0x24000002 => 'bootsequence',
1488	0x22000002 => 'filepath',
1489	0x22000002 => 'systemroot',
1490	0x25000002 => 'testmix',
1491	0x26000003 => 'cacheenable',
1492	0x26000003 => 'customsettings',
1493	0x23000003 => 'default',	1634	0x23000003 => 'default',
1494	0x25000003 => 'failurecount',
1495	0x23000003 => 'resumeobject',
1496	0x26000004 => 'failuresenabled',
1497	0x26000004 => 'pae',
1498	0x26000004 => 'stampdisks',
1499	0x25000004 => 'testtofail',
1500	0x25000004 => 'timeout',	1635	0x25000004 => 'timeout',
1501	0x21000005 => 'associatedosdevice',
1502	0x26000005 => 'cacheenable',
1503	0x26000005 => 'resume',	1636	0x26000005 => 'resume',
1504	0x25000005 => 'stridefailcount',
1505	0x26000006 => 'debugoptionenabled',
1506	0x25000006 => 'invcfailcount',
1507	0x23000006 => 'resumeobject',	1637	0x23000006 => 'resumeobject',
1508	0x25000007 => 'bootux',
1509	0x25000007 => 'matsfailcount',
1510	0x24000007 => 'startupsequence',	1638	0x24000007 => 'startupsequence',
1511	0x25000008 => 'bootmenupolicy',
1512	0x25000008 => 'randfailcount',
1513	0x25000009 => 'chckrfailcount',
1514	0x26000010 => 'detecthal',
1515	0x24000010 => 'toolsdisplayorder',	1639	0x24000010 => 'toolsdisplayorder',
1516	0x22000011 => 'kernel',
1517	0x22000012 => 'hal',
1518	0x22000013 => 'dbgtransport',
1519	0x26000020 => 'displaybootmenu',	1640	0x26000020 => 'displaybootmenu',
1520	0x25000020 => 'nx',
1521	0x26000021 => 'noerrordisplay',	1641	0x26000021 => 'noerrordisplay',
1522	0x25000021 => 'pae',
1523	0x21000022 => 'bcddevice',	1642	0x21000022 => 'bcddevice',
1524	0x26000022 => 'winpe',
1525	0x22000023 => 'bcdfilepath',	1643	0x22000023 => 'bcdfilepath',
1526	0x26000024 => 'hormenabled',	1644	0x26000024 => 'hormenabled',
1527	0x26000024 => 'hormenabled',
1528	0x26000024 => 'nocrashautoreboot',
1529	0x26000025 => 'hiberboot',	1645	0x26000025 => 'hiberboot',
1530	0x26000025 => 'lastknowngood',
1531	0x26000026 => 'oslnointegritychecks',
1532	0x22000026 => 'passwordoverride',	1646	0x22000026 => 'passwordoverride',
1533	0x26000027 => 'osltestsigning',
1534	0x22000027 => 'pinpassphraseoverride',	1647	0x22000027 => 'pinpassphraseoverride',
1535	0x26000028 => 'processcustomactionsfirst',	1648	0x26000028 => 'processcustomactionsfirst',
1536	0x27000030 => 'customactions',	1649	0x27000030 => 'customactions',
1537	0x26000030 => 'nolowmem',
1538	0x26000031 => 'persistbootsequence',	1650	0x26000031 => 'persistbootsequence',
1539	0x25000031 => 'removememory',
1540	0x25000032 => 'increaseuserva',
1541	0x26000032 => 'skipstartupsequence',	1651	0x26000032 => 'skipstartupsequence',
1542	0x25000033 => 'perfmem',
1543	0x22000040 => 'fverecoveryurl',	1652	0x22000040 => 'fverecoveryurl',
1544	0x26000040 => 'vga',
1545	0x22000041 => 'fverecoverymessage',	1653	0x22000041 => 'fverecoverymessage',
		1654	},
		1655	device => {
		1656	0x35000001 => 'ramdiskimageoffset',
		1657	0x35000002 => 'ramdisktftpclientport',
		1658	0x31000003 => 'ramdisksdidevice',
		1659	0x32000004 => 'ramdisksdipath',
		1660	0x35000005 => 'ramdiskimagelength',
		1661	0x36000006 => 'exportascd',
		1662	0x35000007 => 'ramdisktftpblocksize',
		1663	0x35000008 => 'ramdisktftpwindowsize',
		1664	0x36000009 => 'ramdiskmcenabled',
		1665	0x3600000a => 'ramdiskmctftpfallback',
		1666	0x3600000b => 'ramdisktftpvarwindow',
		1667	},
		1668	memdiag => {
		1669	0x25000001 => 'passcount',
		1670	0x25000002 => 'testmix',
		1671	0x25000003 => 'failurecount',
		1672	0x26000003 => 'cacheenable',
		1673	0x25000004 => 'testtofail',
		1674	0x26000004 => 'failuresenabled',
		1675	0x25000005 => 'stridefailcount',
		1676	0x26000005 => 'cacheenable',
		1677	0x25000006 => 'invcfailcount',
		1678	0x25000007 => 'matsfailcount',
		1679	0x25000008 => 'randfailcount',
		1680	0x25000009 => 'chckrfailcount',
		1681	},
		1682	ntldr => {
		1683	0x22000001 => 'bpbstring',
		1684	},
		1685	osloader => {
		1686	0x21000001 => 'osdevice',
		1687	0x22000002 => 'systemroot',
		1688	0x23000003 => 'resumeobject',
		1689	0x26000004 => 'stampdisks',
		1690	0x26000010 => 'detecthal',
		1691	0x22000011 => 'kernel',
		1692	0x22000012 => 'hal',
		1693	0x22000013 => 'dbgtransport',
		1694	0x25000020 => 'nx',
		1695	0x25000021 => 'pae',
		1696	0x26000022 => 'winpe',
		1697	0x26000024 => 'nocrashautoreboot',
		1698	0x26000025 => 'lastknowngood',
		1699	0x26000026 => 'oslnointegritychecks',
		1700	0x26000027 => 'osltestsigning',
		1701	0x26000030 => 'nolowmem',
		1702	0x25000031 => 'removememory',
		1703	0x25000032 => 'increaseuserva',
		1704	0x25000033 => 'perfmem',
		1705	0x26000040 => 'vga',
1546	0x26000041 => 'quietboot',	1706	0x26000041 => 'quietboot',
1547	0x26000042 => 'novesa',	1707	0x26000042 => 'novesa',
1548	0x26000043 => 'novga',	1708	0x26000043 => 'novga',
1549	0x25000050 => 'clustermodeaddressing',	1709	0x25000050 => 'clustermodeaddressing',
1550	0x26000051 => 'usephysicaldestination',	1710	0x26000051 => 'usephysicaldestination',
1551	0x25000052 => 'restrictapiccluster',	1711	0x25000052 => 'restrictapiccluster',
1552	0x22000053 => 'evstore',	1712	0x22000053 => 'evstore',
1553	0x26000054 => 'uselegacyapicmode',	1713	0x26000054 => 'uselegacyapicmode',
1554	0x26000060 => 'onecpu',	1714	0x26000060 => 'onecpu',
1555	0x25000061 => 'numproc',	1715	0x25000061 => 'numproc',
1556	0x26000062 => 'maxproc',	1716	0x26000062 => 'maxproc',
1557	0x25000063 => 'configflags',	1717	0x25000063 => 'configflags',
1558	0x26000064 => 'maxgroup',	1718	0x26000064 => 'maxgroup',
1559	0x26000065 => 'groupaware',	1719	0x26000065 => 'groupaware',
1560	0x25000066 => 'groupsize',	1720	0x25000066 => 'groupsize',
1561	0x26000070 => 'usefirmwarepcisettings',	1721	0x26000070 => 'usefirmwarepcisettings',
1562	0x25000071 => 'msi',	1722	0x25000071 => 'msi',
1563	0x25000072 => 'pciexpress',	1723	0x25000072 => 'pciexpress',
1564	0x25000080 => 'safeboot',	1724	0x25000080 => 'safeboot',
1565	0x26000081 => 'safebootalternateshell',	1725	0x26000081 => 'safebootalternateshell',
1566	0x26000090 => 'bootlog',	1726	0x26000090 => 'bootlog',
1567	0x26000091 => 'sos',	1727	0x26000091 => 'sos',
1568	0x260000a0 => 'debug',	1728	0x260000a0 => 'debug',
1569	0x260000a1 => 'halbreakpoint',	1729	0x260000a1 => 'halbreakpoint',
1570	0x260000a2 => 'useplatformclock',	1730	0x260000a2 => 'useplatformclock',
1571	0x260000a3 => 'forcelegacyplatform',	1731	0x260000a3 => 'forcelegacyplatform',
1572	0x260000a4 => 'useplatformtick',	1732	0x260000a4 => 'useplatformtick',
1573	0x260000a5 => 'disabledynamictick',	1733	0x260000a5 => 'disabledynamictick',
1574	0x250000a6 => 'tscsyncpolicy',	1734	0x250000a6 => 'tscsyncpolicy',
1575	0x260000b0 => 'ems',	1735	0x260000b0 => 'ems',
1576	0x250000c0 => 'forcefailure',	1736	0x250000c0 => 'forcefailure',
1577	0x250000c1 => 'driverloadfailurepolicy',	1737	0x250000c1 => 'driverloadfailurepolicy',
1578	0x250000c2 => 'bootmenupolicy',	1738	0x250000c2 => 'bootmenupolicy',
1579	0x260000c3 => 'onetimeadvancedoptions',	1739	0x260000c3 => 'onetimeadvancedoptions',
1580	0x260000c4 => 'onetimeoptionsedit',	1740	0x260000c4 => 'onetimeoptionsedit',
1581	0x250000e0 => 'bootstatuspolicy',	1741	0x250000e0 => 'bootstatuspolicy',
1582	0x260000e1 => 'disableelamdrivers',	1742	0x260000e1 => 'disableelamdrivers',
1583	0x250000f0 => 'hypervisorlaunchtype',	1743	0x250000f0 => 'hypervisorlaunchtype',
1584	0x220000f1 => 'hypervisorpath',	1744	0x220000f1 => 'hypervisorpath',
1585	0x260000f2 => 'hypervisordebug',	1745	0x260000f2 => 'hypervisordebug',
1586	0x250000f3 => 'hypervisordebugtype',	1746	0x250000f3 => 'hypervisordebugtype',
1587	0x250000f4 => 'hypervisordebugport',	1747	0x250000f4 => 'hypervisordebugport',
1588	0x250000f5 => 'hypervisorbaudrate',	1748	0x250000f5 => 'hypervisorbaudrate',
1589	0x250000f6 => 'hypervisorchannel',	1749	0x250000f6 => 'hypervisorchannel',
1590	0x250000f7 => 'bootux',	1750	0x250000f7 => 'bootux',
1591	0x260000f8 => 'hypervisordisableslat',	1751	0x260000f8 => 'hypervisordisableslat',
1592	0x220000f9 => 'hypervisorbusparams',	1752	0x220000f9 => 'hypervisorbusparams',
1593	0x250000fa => 'hypervisornumproc',	1753	0x250000fa => 'hypervisornumproc',
1594	0x250000fb => 'hypervisorrootprocpernode',	1754	0x250000fb => 'hypervisorrootprocpernode',
1595	0x260000fc => 'hypervisoruselargevtlb',	1755	0x260000fc => 'hypervisoruselargevtlb',
1596	0x250000fd => 'hypervisorhostip',	1756	0x250000fd => 'hypervisorhostip',
1597	0x250000fe => 'hypervisorhostport',	1757	0x250000fe => 'hypervisorhostport',
1598	0x250000ff => 'hypervisordebugpages',	1758	0x250000ff => 'hypervisordebugpages',
1599	0x25000100 => 'tpmbootentropy',	1759	0x25000100 => 'tpmbootentropy',
1600	0x22000110 => 'hypervisorusekey',	1760	0x22000110 => 'hypervisorusekey',
1601	0x22000112 => 'hypervisorproductskutype',	1761	0x22000112 => 'hypervisorproductskutype',
1602	0x25000113 => 'hypervisorrootproc',	1762	0x25000113 => 'hypervisorrootproc',
1603	0x26000114 => 'hypervisordhcp',	1763	0x26000114 => 'hypervisordhcp',
1604	0x25000115 => 'hypervisoriommupolicy',	1764	0x25000115 => 'hypervisoriommupolicy',
1605	0x26000116 => 'hypervisorusevapic',	1765	0x26000116 => 'hypervisorusevapic',
1606	0x22000117 => 'hypervisorloadoptions',	1766	0x22000117 => 'hypervisorloadoptions',
1607	0x25000118 => 'hypervisormsrfilterpolicy',	1767	0x25000118 => 'hypervisormsrfilterpolicy',
1608	0x25000119 => 'hypervisormmionxpolicy',	1768	0x25000119 => 'hypervisormmionxpolicy',
1609	0x2500011a => 'hypervisorschedulertype',	1769	0x2500011a => 'hypervisorschedulertype',
1610	0x25000120 => 'xsavepolicy',	1770	0x25000120 => 'xsavepolicy',
1611	0x25000121 => 'xsaveaddfeature0',	1771	0x25000121 => 'xsaveaddfeature0',
1612	0x25000122 => 'xsaveaddfeature1',	1772	0x25000122 => 'xsaveaddfeature1',
1613	0x25000123 => 'xsaveaddfeature2',	1773	0x25000123 => 'xsaveaddfeature2',
1614	0x25000124 => 'xsaveaddfeature3',	1774	0x25000124 => 'xsaveaddfeature3',
1615	0x25000125 => 'xsaveaddfeature4',	1775	0x25000125 => 'xsaveaddfeature4',
1616	0x25000126 => 'xsaveaddfeature5',	1776	0x25000126 => 'xsaveaddfeature5',
1617	0x25000127 => 'xsaveaddfeature6',	1777	0x25000127 => 'xsaveaddfeature6',
1618	0x25000128 => 'xsaveaddfeature7',	1778	0x25000128 => 'xsaveaddfeature7',
1619	0x25000129 => 'xsaveremovefeature',	1779	0x25000129 => 'xsaveremovefeature',
1620	0x2500012a => 'xsaveprocessorsmask',	1780	0x2500012a => 'xsaveprocessorsmask',
1621	0x2500012b => 'xsavedisable',	1781	0x2500012b => 'xsavedisable',
1622	0x2500012c => 'kerneldebugtype',	1782	0x2500012c => 'kerneldebugtype',
1623	0x2200012d => 'kernelbusparams',	1783	0x2200012d => 'kernelbusparams',
1624	0x2500012e => 'kerneldebugaddress',	1784	0x2500012e => 'kerneldebugaddress',
1625	0x2500012f => 'kerneldebugport',	1785	0x2500012f => 'kerneldebugport',
1626	0x25000130 => 'claimedtpmcounter',	1786	0x25000130 => 'claimedtpmcounter',
1627	0x25000131 => 'kernelchannel',	1787	0x25000131 => 'kernelchannel',
1628	0x22000132 => 'kerneltargetname',	1788	0x22000132 => 'kerneltargetname',
1629	0x25000133 => 'kernelhostip',	1789	0x25000133 => 'kernelhostip',
1630	0x25000134 => 'kernelport',	1790	0x25000134 => 'kernelport',
1631	0x26000135 => 'kerneldhcp',	1791	0x26000135 => 'kerneldhcp',
1632	0x22000136 => 'kernelkey',	1792	0x22000136 => 'kernelkey',
1633	0x22000137 => 'imchivename',	1793	0x22000137 => 'imchivename',
1634	0x21000138 => 'imcdevice',	1794	0x21000138 => 'imcdevice',
1635	0x25000139 => 'kernelbaudrate',	1795	0x25000139 => 'kernelbaudrate',
1636	0x22000140 => 'mfgmode',	1796	0x22000140 => 'mfgmode',
1637	0x26000141 => 'event',	1797	0x26000141 => 'event',
1638	0x25000142 => 'vsmlaunchtype',	1798	0x25000142 => 'vsmlaunchtype',
1639	0x25000144 => 'hypervisorenforcedcodeintegrity',	1799	0x25000144 => 'hypervisorenforcedcodeintegrity',
1640	0x26000145 => 'enablebootdebugpolicy',
1641	0x26000146 => 'enablebootorderclean',
1642	0x26000147 => 'enabledeviceid',
1643	0x26000148 => 'enableffuloader',
1644	0x26000149 => 'enableiuloader',
1645	0x2600014a => 'enablemassstorage',
1646	0x2600014b => 'enablerpmbprovisioning',
1647	0x2600014c => 'enablesecurebootpolicy',
1648	0x2600014d => 'enablestartcharge',
1649	0x2600014e => 'enableresettpm',
1650	0x21000150 => 'systemdatadevice',	1800	0x21000150 => 'systemdatadevice',
1651	0x21000151 => 'osarcdevice',	1801	0x21000151 => 'osarcdevice',
1652	0x21000153 => 'osdatadevice',	1802	0x21000153 => 'osdatadevice',
1653	0x21000154 => 'bspdevice',	1803	0x21000154 => 'bspdevice',
1654	0x21000155 => 'bspfilepath',	1804	0x21000155 => 'bspfilepath',
1655	0x26000202 => 'skipffumode',	1805	},
1656	0x26000203 => 'forceffumode',	1806	resume => {
1657	0x25000510 => 'chargethreshold',
1658	0x26000512 => 'offmodecharging',
1659	0x25000aaa => 'bootflow',
1660	0x35000001 => 'ramdiskimageoffset',
1661	0x35000002 => 'ramdisktftpclientport',
1662	0x31000003 => 'ramdisksdidevice',
1663	0x32000004 => 'ramdisksdipath',
1664	0x35000005 => 'ramdiskimagelength',
1665	0x36000006 => 'exportascd',
1666	0x35000007 => 'ramdisktftpblocksize',
1667	0x35000008 => 'ramdisktftpwindowsize',
1668	0x36000009 => 'ramdiskmcenabled',
1669	0x3600000a => 'ramdiskmctftpfallback',
1670	0x3600000b => 'ramdisktftpvarwindow',
1671	0x45000001 => 'devicetype',	1807	0x21000001 => 'filedevice',
		1808	0x22000002 => 'filepath',
		1809	0x26000003 => 'customsettings',
		1810	0x26000004 => 'pae',
		1811	0x21000005 => 'associatedosdevice',
		1812	0x26000006 => 'debugoptionenabled',
		1813	0x25000007 => 'bootux',
		1814	0x25000008 => 'bootmenupolicy',
		1815	0x26000024 => 'hormenabled',
		1816	},
		1817	startup => {
		1818	0x26000001 => 'pxesoftreboot',
1672	0x42000002 => 'applicationrelativepath',	1819	0x22000002 => 'applicationname',
1673	0x42000003 => 'ramdiskdevicerelativepath',	1820	},
1674	0x46000004 => 'omitosloaderelements',
1675	0x47000006 => 'elementstomigrate',
1676	0x46000010 => 'recoveryos',
1677	);	1821	);
1678		1822
1679	our %rbcde = reverse %bcde;	1823	# mask, value => class
		1824	our @bcde_typeclass = (
		1825	[0x00000000, 0x00000000, 'any'],
		1826	[0xf00fffff, 0x1000000a, 'bootapp'],
		1827	[0xf0ffffff, 0x2020000a, 'bootapp'],
		1828	[0xf00fffff, 0x10000001, 'bootmgr'],
		1829	[0xf00fffff, 0x10000002, 'bootmgr'],
		1830	[0xf0ffffff, 0x20200001, 'bootmgr'],
		1831	[0xf0ffffff, 0x20200002, 'bootmgr'],
		1832	[0xf0f00000, 0x20300000, 'device'],
		1833	[0xf0000000, 0x30000000, 'device'],
		1834	[0xf00fffff, 0x10000005, 'memdiag'],
		1835	[0xf0ffffff, 0x20200005, 'memdiag'],
		1836	[0xf00fffff, 0x10000006, 'ntldr'],
		1837	[0xf00fffff, 0x10000007, 'ntldr'],
		1838	[0xf0ffffff, 0x20200006, 'ntldr'],
		1839	[0xf0ffffff, 0x20200007, 'ntldr'],
		1840	[0xf00fffff, 0x10000003, 'osloader'],
		1841	[0xf0ffffff, 0x20200003, 'osloader'],
		1842	[0xf00fffff, 0x10000004, 'resume'],
		1843	[0xf0ffffff, 0x20200004, 'resume'],
		1844	[0xf00fffff, 0x10000009, 'startup'],
		1845	[0xf0ffffff, 0x20200009, 'startup'],
		1846	);
1680		1847
		1848	our %rbcde_byclass;
		1849
		1850	while (my ($k, $v) = each %bcde_byclass) {
		1851	$rbcde_byclass{$k} = { reverse %$v };
		1852	}
		1853
		1854	# decodes (numerical elem, type) to name
1681	sub dec_bcde_id($) {	1855	sub dec_bcde_id($$) {
		1856	for my $class (@bcde_typeclass) {
		1857	if (($_[1] & $class->[0]) == $class->[1]) {
		1858	if (my $id = $bcde_byclass{$class->[2]}{$_[0]}) {
		1859	return $id;
		1860	}
		1861	}
		1862	}
		1863
1682	$bcde{$_[0]} // sprintf "custom:%08x", $_[0]	1864	sprintf "custom:%08x", $_[0]
1683	}	1865	}
1684		1866
		1867	# encodes (elem as name, type)
1685	sub enc_bcde_id($) {	1868	sub enc_bcde_id($$) {
1686	$_[0] =~ /^custom:([0-9a-fA-F]{8}$)/	1869	$_[0] =~ /^custom:(?:0x)?([0-9a-fA-F]{8}$)/
1687	? hex $1	1870	and return hex $1;
1688	: $rbcde{$_[0]}	1871
		1872	for my $class (@bcde_typeclass) {
		1873	if (($_[1] & $class->[0]) == $class->[1]) {
		1874	if (my $value = $rbcde_byclass{$class->[2]}{$_[0]}) {
		1875	return $value;
		1876	}
		1877	}
		1878	}
		1879
		1880	undef
1689	}	1881	}
1690		1882
1691	# decode/encode bcd device element - the horror, no documentaion	1883	# decode/encode bcd device element - the horror, no documentaion
1692	# whatsoever, supercomplex, superinconsistent.	1884	# whatsoever, supercomplex, superinconsistent.
1693		1885
…		…
1696	our @part_type = qw(gpt mbr raw);	1888	our @part_type = qw(gpt mbr raw);
1697		1889
1698	our $NULL_DEVICE = "\x00" x 16;	1890	our $NULL_DEVICE = "\x00" x 16;
1699		1891
1700	# biggest bitch to decode, ever	1892	# biggest bitch to decode, ever
1701	# this decoded a device portion after the GUID	1893	# this decodes a device portion after the GUID
1702	sub dec_device_($);	1894	sub dec_device_($$);
1703	sub dec_device_($) {	1895	sub dec_device_($$) {
1704	my ($device) = @_;	1896	my ($device, $type) = @_;
1705		1897
1706	my $res;	1898	my $res;
1707		1899
1708	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";	1900	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";
1709		1901
…		…
1754		1946
1755	my $partid = $parttype eq "gpt" ? dec_guid $partdata	1947	my $partid = $parttype eq "gpt" ? dec_guid $partdata
1756	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start	1948	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start
1757	: unpack "L<", $partdata; # partition number, one-based	1949	: unpack "L<", $partdata; # partition number, one-based
1758		1950
1759	(my $parent, $device) = dec_device_ $device;	1951	(my $parent, $device) = dec_device_ $device, $type;
1760		1952
1761	$res .= "=";	1953	$res .= "=";
1762	$res .= "<$parent>";	1954	$res .= "<$parent>";
1763	$res .= ",$blocktype,$parttype,$diskid,$partid";	1955	$res .= ",$blocktype,$parttype,$diskid,$partid";
1764		1956
…		…
1784	or die "unsupported file descriptor version '$fver'\n";	1976	or die "unsupported file descriptor version '$fver'\n";
1785		1977
1786	$ftype == 5	1978	$ftype == 5
1787	or die "unsupported file descriptor path type '$type'\n";	1979	or die "unsupported file descriptor path type '$type'\n";
1788		1980
1789	(my $parent, $path) = dec_device_ $path;	1981	(my $parent, $path) = dec_device_ $path, $type;
1790		1982
1791	$path = $dec_path->($path, "file device without path");	1983	$path = $dec_path->($path, "file device without path");
1792		1984
1793	($parent, $path)	1985	($parent, $path)
1794	};	1986	};
…		…
1800		1992
1801	} elsif ($blocktype eq "vhd") {	1993	} elsif ($blocktype eq "vhd") {
1802	$device =~ s/^\x00{20}//s	1994	$device =~ s/^\x00{20}//s
1803	or die "virtualdisk has non-zero fields I don't understand\n";	1995	or die "virtualdisk has non-zero fields I don't understand\n";
1804		1996
1805	(my $parent, $device) = dec_device_ $device;	1997	(my $parent, $device) = dec_device_ $device, $type;
1806		1998
1807	$res .= "=vhd,<$parent>";	1999	$res .= "=vhd,<$parent>";
1808		2000
1809	} elsif ($blocktype eq "ramdisk") {	2001	} elsif ($blocktype eq "ramdisk") {
1810	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";	2002	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";
…		…
1823	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";	2015	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";
1824		2016
1825	if ($parent) {	2017	if ($parent) {
1826	# not sure why this is an offset - it must come after the path	2018	# not sure why this is an offset - it must come after the path
1827	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";	2019	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";
1828	($parent, my $tail) = dec_device_ $parent;	2020	($parent, my $tail) = dec_device_ $parent, $type;
1829	0 == length $tail	2021	0 == length $tail
1830	or die "trailing data after locate device parent\n";	2022	or die "trailing data after locate device parent\n";
1831	} else {	2023	} else {
1832	$parent = "null";	2024	$parent = "null";
1833	}	2025	}
…		…
1839		2031
1840	if ($mode == 0) { # "Element"	2032	if ($mode == 0) { # "Element"
1841	!length $path	2033	!length $path
1842	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";	2034	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";
1843		2035
1844	$elem = dec_bcde_id $elem;	2036	$elem = dec_bcde_id $elem, $type;
1845	$res .= "element,$elem";	2037	$res .= "element,$elem";
1846		2038
1847	} elsif ($mode == 1) { # "String"	2039	} elsif ($mode == 1) { # "String"
1848	!$elem	2040	!$elem
1849	or die "device locate mode 1 having non-zero element\n";	2041	or die "device locate mode 1 having non-zero element\n";
…		…
1874		2066
1875	($res, $tail)	2067	($res, $tail)
1876	}	2068	}
1877		2069
1878	# decode a full binary BCD device descriptor	2070	# decode a full binary BCD device descriptor
1879	sub dec_device($) {	2071	sub dec_device($$) {
1880	my ($device) = @_;	2072	my ($device, $type) = @_;
1881		2073
1882	$device = pack "H*", $device;	2074	$device = pack "H*", $device;
1883		2075
1884	my $guid = dec_guid substr $device, 0, 16, "";	2076	my $guid = dec_guid substr $device, 0, 16, "";
1885	$guid = $guid eq "00000000-0000-0000-0000-000000000000"	2077	$guid = $guid eq "00000000-0000-0000-0000-000000000000"
1886	? "" : "{$guid}";	2078	? "" : "{$guid}";
1887		2079
1888	eval {	2080	eval {
1889	my ($dev, $tail) = dec_device_ $device;	2081	my ($dev, $tail) = dec_device_ $device, $type;
1890		2082
1891	$tail eq ""	2083	$tail eq ""
1892	or die "unsupported trailing data after device descriptor\n";	2084	or die "unsupported trailing data after device descriptor\n";
1893		2085
1894	"$guid$dev"	2086	"$guid$dev"
…		…
1906		2098
1907	undef	2099	undef
1908	}	2100	}
1909		2101
1910	# encode the device portion after the GUID	2102	# encode the device portion after the GUID
1911	sub enc_device_;	2103	sub enc_device_($$);
1912	sub enc_device_ {	2104	sub enc_device_($$) {
1913	my ($device) = @_;	2105	my ($device, $type) = @_;
1914		2106
1915	my $enc_path = sub {	2107	my $enc_path = sub {
1916	my $path = shift;	2108	my $path = shift;
1917	$path =~ s/\//\\/g;	2109	$path =~ s/\//\\/g;
1918	(Encode::encode "UTF-16LE", $path) . "\x00\x00"	2110	(Encode::encode "UTF-16LE", $path) . "\x00\x00"
…		…
1936		2128
1937	my $parse_parent = sub {	2129	my $parse_parent = sub {
1938	my $parent;	2130	my $parent;
1939		2131
1940	if (s/^<//) {	2132	if (s/^<//) {
1941	($parent, $_) = enc_device_ $_;	2133	($parent, $_) = enc_device_ $_, $type;
1942	s/^>//	2134	s/^>//
1943	or die "$device: syntax error: parent device not followed by '>'\n";	2135	or die "$device: syntax error: parent device not followed by '>'\n";
1944	} else {	2136	} else {
1945	$parent = $NULL_DEVICE;	2137	$parent = $NULL_DEVICE;
1946	}	2138	}
…		…
2034		2226
2035	s/^,//	2227	s/^,//
2036	or die "$_: missing comma after locate parent device\n";	2228	or die "$_: missing comma after locate parent device\n";
2037		2229
2038	if (s/^element,//) {	2230	if (s/^element,//) {
2039	s/^([0-9a-z]+)//i	2231	s/^([0-9a-z:]+)//i
2040	or die "$_ locate element must be either name or 8-digit hex id\n";	2232	or die "$_ locate element must be either name or 8-digit hex id\n";
2041	$elem = enc_bcde_id $1;	2233	$elem = enc_bcde_id $1, $type;
2042	$mode = 0;	2234	$mode = 0;
2043	$path = $enc_path->("");	2235	$path = $enc_path->("");
2044		2236
2045	} elsif (s/^path,//) {	2237	} elsif (s/^path,//) {
2046	$mode = 1;	2238	$mode = 1;
…		…
2113	or die "$_: malformed or missing vmbus interface instance guid\n";	2305	or die "$_: malformed or missing vmbus interface instance guid\n";
2114	my $instance = enc_guid $1;	2306	my $instance = enc_guid $1;
2115		2307
2116	$payload = pack "a16a16x24", $type, $instance;	2308	$payload = pack "a16a16x24", $type, $instance;
2117		2309
		2310	# } elsif ($type eq "udp") {
		2311	# $payload = pack "Va16", 1, "12345678";
		2312
2118	} else {	2313	} else {
2119	die "$type: not a supported device type (binary, null, boot, legacypartition, partition, block, locate)\n";	2314	die "$type: not a supported device type (binary, null, boot, legacypartition, partition, block, locate)\n";
2120	}	2315	}
2121		2316
2122	return (	2317	return (
…		…
2125	);	2320	);
2126	}	2321	}
2127	}	2322	}
2128		2323
2129	# encode a full binary BCD device descriptor	2324	# encode a full binary BCD device descriptor
2130	sub enc_device {	2325	sub enc_device($$) {
2131	my ($device) = @_;	2326	my ($device, $type) = @_;
2132		2327
2133	my $guid = "\x00" x 16;	2328	my $guid = "\x00" x 16;
2134		2329
2135	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {	2330	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {
2136	$guid = enc_guid $1	2331	$guid = enc_guid $1
2137	or die "$device: does not start with valid guid\n";	2332	or die "$device: does not start with valid guid\n";
2138	}	2333	}
2139		2334
2140	my ($descriptor, $tail) = enc_device_ $device;	2335	my ($descriptor, $tail) = enc_device_ $device, $type;
2141		2336
2142	length $tail	2337	length $tail
2143	and die "$device: garbage after device descriptor\n";	2338	and die "$device: garbage after device descriptor\n";
2144		2339
2145	unpack "H*", $guid . $descriptor	2340	unpack "H*", $guid . $descriptor
…		…
2160	$k = $bcd_objects{$k} // $k;	2355	$k = $bcd_objects{$k} // $k;
2161		2356
2162	my $type = $v->{Description}[0]{Type}[1];	2357	my $type = $v->{Description}[0]{Type}[1];
2163		2358
2164	if ($type != $bcd_object_types{$k}) {	2359	if ($type != $bcd_object_types{$k}) {
2165	$type = $bcd_types{$type} // sprintf "0x%08x", $type;	2360	$kv{type} = $bcd_types{$type} // sprintf "0x%08x", $type;
2166	$kv{type} = $type;
2167	}	2361	}
2168		2362
2169	my $elems = $v->{Elements}[1];	2363	my $elems = $v->{Elements}[1];
2170		2364
2171	while (my ($k, $v) = each %$elems) {	2365	while (my ($k, $v) = each %$elems) {
2172	my $k = hex $k;	2366	my $k = hex $k;
2173		2367
2174	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1]);	2368	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1], $type);
2175	my $k = dec_bcde_id $k;	2369	my $k = dec_bcde_id $k, $type;
2176		2370
2177	$kv{$k} = $v;	2371	$kv{$k} = $v;
2178	}	2372	}
2179		2373
2180	$bcd{$k} = \%kv;	2374	$bcd{$k} = \%kv;
…		…
2221	my %elem;	2415	my %elem;
2222		2416
2223	while (my ($k, $v) = each %$v) {	2417	while (my ($k, $v) = each %$v) {
2224	next if $k eq "type";	2418	next if $k eq "type";
2225		2419
2226	$k = (enc_bcde_id $k) // die "$k: invalid bcde element name or id\n";	2420	$k = (enc_bcde_id $k, $type) // die "$k: invalid bcde element name or id\n";
2227	$elem{sprintf "%08x", $k} = [{	2421	$elem{sprintf "%08x", $k} = [{
2228	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]	2422	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]
2229	}];	2423	}];
2230	}	2424	}
2231		2425
…		…
2247	Objects => [undef, \%objects],	2441	Objects => [undef, \%objects],
2248	}]]	2442	}]]
2249	}	2443	}
2250		2444
2251	#############################################################################	2445	#############################################################################
		2446	# edit instructions
2252		2447
2253	sub bcd_edit_eval {	2448	sub bcd_edit_eval {
2254	package pbcdedit;	2449	package pbcdedit;
2255		2450
2256	our ($PATH, $BCD, $DEFAULT);	2451	our ($PATH, $BCD, $DEFAULT);
…		…
2260	}	2455	}
2261		2456
2262	sub bcd_edit {	2457	sub bcd_edit {
2263	my ($path, $bcd, @insns) = @_;	2458	my ($path, $bcd, @insns) = @_;
2264		2459
2265	my $default = $bcd->{"{bootmgr}"}{resumeobject};	2460	my $default = $bcd->{"{bootmgr}"}{default};
2266		2461
2267	# prepare "officially visible" variables	2462	# prepare "officially visible" variables
2268	local $pbcdedit::PATH = $path;	2463	local $pbcdedit::PATH = $path;
2269	local $pbcdedit::BCD = $bcd;	2464	local $pbcdedit::BCD = $bcd;
2270	local $pbcdedit::DEFAULT = $default;	2465	local $pbcdedit::DEFAULT = $default;
…		…
2287		2482
2288	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;	2483	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
2289		2484
2290	$bcd->{$object}{$elem} = $value;	2485	$bcd->{$object}{$elem} = $value;
2291		2486
		2487	} elsif ($insn eq "del") {
		2488	my $object = shift @insns;
		2489	my $elem = shift @insns;
		2490
		2491	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
		2492
		2493	delete $bcd->{$object}{$elem};
		2494
2292	} elsif ($insn eq "eval") {	2495	} elsif ($insn eq "eval") {
2293	bcd_edit_eval shift @insns;	2496	my $perl = shift @insns;
		2497	bcd_edit_eval "#line 1 'eval'\n$perl";
2294		2498
2295	} elsif ($insn eq "do") {	2499	} elsif ($insn eq "do") {
2296	my $path = shift @insns;	2500	my $path = shift @insns;
2297	my $file = file_load $path;	2501	my $file = file_load $path;
2298	bcd_edit_eval "#line 1 '$path'\n$file";	2502	bcd_edit_eval "#line 1 '$path'\n$file";
2299		2503
2300	} else {	2504	} else {
2301	die "$insn: not a recognized instruction for edit/parse\n";	2505	die "$insn: not a recognized instruction for create/edit/parse\n";
2302	}	2506	}
2303	}	2507	}
2304		2508
2305	}	2509	}
2306		2510
2307	#############################################################################	2511	#############################################################################
		2512	# other utilities
2308		2513
2309	# json to stdout	2514	# json to stdout
2310	sub prjson($) {	2515	sub prjson($) {
2311	print $json_coder->encode ($_[0]);	2516	print $json_coder->encode ($_[0]);
2312	}	2517	}
…		…
2316	my $json;	2521	my $json;
2317	1 while read STDIN, $json, 65536, length $json;	2522	1 while read STDIN, $json, 65536, length $json;
2318	$json_coder->decode ($json)	2523	$json_coder->decode ($json)
2319	}	2524	}
2320		2525
2321	# all subcommands	2526	sub lsblk() {
		2527	my $lsblk = $json_coder->decode (scalar qx<lsblk --json -o PATH,KNAME,MAJ:MIN,TYPE,PTTYPE,PTUUID,PARTUUID,LABEL,FSTYPE>);
		2528
		2529	for my $dev (@{ $lsblk->{blockdevices} }) {
		2530	if ($dev->{type} eq "part") {
		2531
		2532	# lsblk sometimes gives a bogus pttype, so we recreate it here
		2533	$dev->{pttype} = $dev->{ptuuid} =~ /^$RE_GUID\z/
		2534	? "gpt" : "dos";
		2535
		2536	if ($dev->{pttype} eq "gpt") {
		2537	$dev->{bcd_device} = "partition=<null>,harddisk,gpt,$dev->{ptuuid},$dev->{partuuid}";
		2538	} elsif ($dev->{pttype} eq "dos") { # why not "mbr" :(
		2539	if ($dev->{partuuid} =~ /^([0-9a-f]{8})-([0-9a-f]{2})\z/i) {
		2540	my ($diskid, $partno) = ($1, hex $2);
		2541	$dev->{bcd_legacy_device} = "legacypartition=<null>,harddisk,mbr,$diskid,$partno";
		2542	if (open my $fh, "/sys/class/block/$dev->{kname}/start") {
		2543	my $start = 512 * readline $fh;
		2544	$dev->{bcd_device} = "partition=<null>,harddisk,mbr,$diskid,$start";
		2545	}
		2546	}
		2547	}
		2548	}
		2549	}
		2550
		2551	$lsblk->{blockdevices}
		2552	}
		2553
		2554	sub prdev($$) {
		2555	my ($path, $attribute) = @_;
		2556
		2557	# rather than stat'ing and guessing how devices are encoded, we use lsblk for this
		2558	my $mm = $json_coder->decode (scalar qx<lsblk -d -o MAJ:MIN -J \Q$path\E>)->{blockdevices}[0]{"maj:min"};
		2559
		2560	my $lsblk = lsblk;
		2561
		2562	for my $dev (@$lsblk) {
		2563	if ($dev->{"maj:min"} eq $mm && $dev->{$attribute}) {
		2564	say $dev->{$attribute};
		2565	exit 0;
		2566	}
		2567	}
		2568
		2569	exit 1;
		2570	}
		2571
		2572	#############################################################################
		2573	# command line parser
		2574
2322	our %CMD = (	2575	our %CMD = (
2323	help => sub {	2576	help => sub {
2324	require Pod::Usage;	2577	require Pod::Usage;
2325	Pod::Usage::pod2usage (-verbose => 2);	2578	Pod::Usage::pod2usage (-verbose => 2, -quotes => "none", -noperldoc => 1);
2326	},	2579	},
2327		2580
2328	objects => sub {	2581	objects => sub {
2329	my %rbcd_types = reverse %bcd_types;	2582	my %rbcd_types = reverse %bcd_types;
2330	$_ = sprintf "%08x", $_ for values %rbcd_types;	2583	$_ = sprintf "%08x", $_ for values %rbcd_types;
…		…
2351		2604
2352	print "\n";	2605	print "\n";
2353		2606
2354	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";	2607	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";
2355	for my $name (sort keys %rbcd_objects) {	2608	for my $name (sort keys %rbcd_objects) {
2356	my $guid = $rbcd_objects{$name};	2609	my $guid = $rbcd_objects{$name};
2357	my $type = $bcd_object_types{$name};	2610	my $type = $bcd_object_types{$name};
2358	my $tname = $bcd_types{$type};	2611	my $tname = $bcd_types{$type};
2359		2612
2360	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";	2613	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";
2361		2614
2362	printf "%-39s %-23s %s\n", $guid, $name, $type;	2615	printf "%-39s %-23s %s\n", $guid, $name, $type;
…		…
2376	BCDE_FORMAT_GUID_LIST , "guid list",	2629	BCDE_FORMAT_GUID_LIST , "guid list",
2377	BCDE_FORMAT_INTEGER , "integer",	2630	BCDE_FORMAT_INTEGER , "integer",
2378	BCDE_FORMAT_BOOLEAN , "boolean",	2631	BCDE_FORMAT_BOOLEAN , "boolean",
2379	BCDE_FORMAT_INTEGER_LIST, "integer list",	2632	BCDE_FORMAT_INTEGER_LIST, "integer list",
2380	);	2633	);
2381	my %rbcde = reverse %bcde;
2382	$_ = sprintf "%08x", $_ for values %rbcde;
2383		2634
2384	my %element;	2635	my @element;
2385		2636
		2637	for my $class (sort keys %rbcde_byclass) {
		2638	my $rbcde = $rbcde_byclass{$class};
		2639
2386	unless ($json) {	2640	unless ($json) {
2387	print "\n";	2641	print "\n";
		2642	printf "Elements applicable to class(es): $class\n";
2388	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";	2643	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";
2389	}	2644	}
2390	for my $name (sort keys %rbcde) {	2645	for my $name (sort keys %$rbcde) {
2391	my $id = $rbcde{$name};	2646	my $id = $rbcde->{$name};
2392	my $format = $format_name{(hex $id) & BCDE_FORMAT};	2647	my $format = $format_name{$id & BCDE_FORMAT};
2393		2648
2394	if ($json) {	2649	if ($json) {
2395	$element{$id} = [$format, $name];	2650	push @element, [$class, $id * 1, $format, $name];
2396	} else {	2651	} else {
		2652	$id = sprintf "%08x", $id;
2397	printf "%-9s %-12s %s\n", $id, $format, $name;	2653	printf "%-9s %-12s %s\n", $id, $format, $name;
		2654	}
2398	}	2655	}
2399	}	2656	}
2400	print "\n" unless $json;	2657	print "\n" unless $json;
2401		2658
2402	prjson {	2659	prjson {
2403	version => $JSON_VERSION,	2660	version => $JSON_VERSION,
2404	element => \%element,	2661	element => \@element,
		2662	class => \@bcde_typeclass,
2405	} if $json;	2663	} if $json;
2406		2664
2407	},	2665	},
2408		2666
2409	export => sub {	2667	export => sub {
…		…
2412		2670
2413	import => sub {	2671	import => sub {
2414	regf_save shift, bcd_encode rdjson;	2672	regf_save shift, bcd_encode rdjson;
2415	},	2673	},
2416		2674
		2675	create => sub {
		2676	my $path = shift;
		2677	my $stat = stat_get $path; # should actually be done at file load time
		2678	my $bcd = { };
		2679	bcd_edit $path, $bcd, @_;
		2680	regf_save $path, bcd_encode $bcd;
		2681	stat_set $path, $stat;
		2682	},
		2683
2417	edit => sub {	2684	edit => sub {
2418	my $path = shift;	2685	my $path = shift;
		2686	my $stat = stat_get $path; # should actually be done at file load time
2419	my $bcd = bcd_decode regf_load $path;	2687	my $bcd = bcd_decode regf_load $path;
2420	bcd_edit $path, $bcd, @_;	2688	bcd_edit $path, $bcd, @_;
2421	regf_save $path, bcd_encode $bcd;	2689	regf_save $path, bcd_encode $bcd;
		2690	stat_set $path, $stat;
2422	},	2691	},
2423		2692
2424	parse => sub {	2693	parse => sub {
2425	my $path = shift;	2694	my $path = shift;
2426	my $bcd = bcd_decode regf_load $path;	2695	my $bcd = bcd_decode regf_load $path;
…		…
2435	"import-regf" => sub {	2704	"import-regf" => sub {
2436	regf_save shift, rdjson;	2705	regf_save shift, rdjson;
2437	},	2706	},
2438		2707
2439	lsblk => sub {	2708	lsblk => sub {
		2709	my $json = $_[0] eq "--json";
		2710
		2711	my $lsblk = lsblk;
		2712
		2713	if ($json) {
		2714	prjson $lsblk;
		2715	} else {
2440	printf "%-10s %-8.8s %-6.6s %-3s %s\n", "DEVICE", "LABEL", "FSTYPE", "PT", "DEVICE DESCRIPTOR";	2716	printf "%-10s %-8.8s %-6.6s %-3s %s\n", "DEVICE", "LABEL", "FSTYPE", "PT", "DEVICE DESCRIPTOR";
2441		2717	for my $dev (@$lsblk) {
2442	my $lsblk = $json_coder->decode (scalar qx<lsblk --json -o PATH,KNAME,TYPE,PTTYPE,PTUUID,PARTUUID,LABEL,FSTYPE>);	2718	for my $bcd ($dev->{bcd_device}, $dev->{bcd_legacy_device}) {
2443
2444	for my $dev (@{ $lsblk->{blockdevices} }) {
2445	my $pr = sub {
2446	printf "%-10s %-8.8s %-6.6s %-3s %s\n",	2719	printf "%-10s %-8.8s %-6.6s %-3s %s\n",
2447	$dev->{path}, $dev->{label}, $dev->{fstype}, $dev->{pttype}, $_[0];	2720	$dev->{path}, $dev->{label}, $dev->{fstype}, $dev->{pttype}, $bcd
2448	};
2449
2450	if ($dev->{type} eq "part") {
2451	if ($dev->{pttype} eq "gpt") {
2452	$pr->("partition=<null>,harddisk,gpt,$dev->{ptuuid},$dev->{partuuid}");
2453	} elsif ($dev->{pttype} eq "dos") { # why not "mbr" :(
2454	if ($dev->{partuuid} =~ /^([0-9a-f]{8})-([0-9a-f]{2})\z/i) {
2455	my ($diskid, $partno) = ($1, hex $2);
2456	$pr->("legacypartition=<null>,harddisk,mbr,$diskid,$partno");
2457	if (open my $fh, "/sys/class/block/$dev->{kname}/start") {
2458	my $start = 512 * readline $fh;
2459	$pr->("partition=<null>,harddisk,mbr,$diskid,$start");
2460	}	2721	if $bcd;
2461	}
2462	}	2722	}
2463	}	2723	}
2464	}	2724	}
2465	},	2725	},
		2726
		2727	"bcd-device" => sub {
		2728	prdev shift, "bcd_device";
		2729	},
		2730
		2731	"bcd-legacy-device" => sub {
		2732	prdev shift, "bcd_legacy_device";
		2733	},
		2734
		2735	version => sub {
		2736	print "\n",
		2737	"PBCDEDIT version $VERSION, copyright 2019 Marc A. Lehmann <pbcdedit\@schmorp.de>.\n",
		2738	"JSON schema version: $JSON_VERSION\n",
		2739	"Licensed under the GNU General Public License Version 3.0, or any later version.\n",
		2740	"\n",
		2741	$CHANGELOG,
		2742	"\n";
		2743	},
2466	);	2744	);
2467		2745
2468	my $cmd = shift;	2746	my $cmd = shift;
2469		2747
2470	unless (exists $CMD{$cmd}) {	2748	unless (exists $CMD{$cmd}) {

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines