Write REG_MULTI_SZ with Hex data - powershell
I am trying to write to a multi string, but using data gleaned from a REG file, so it's in Hex format. I have managed to convert the string to a byte array using the Convert-HexStringToByteArray here, but that doesn't produce the same result in the registry as loading the REG, so I am thinking that is not actually the right data type to be casting to.
The initial data looks like this
"NavigatorLayoutOrder"=hex(7):31,00,30,00,00,00,31,00,00,00,32,00,00,00,33,00,00,00,30,00,00,00,34,00,00,00,35,00,00,00,36,00,00,00,37,00,00,00,38,00,00,00,39,00,00,00,31,00,31,00,00,00,31,00,32,00,00,00,31,00,33,00,00,00,31,00,34,00,00,00,31,00,35,00,00,00,31,00,36,00,00,00,31,00,37,00,00,00,31,00,38,00,00,00,31,00,39,00,00,00,32,00,30,00,00,00,32,00,31,00,00,00,32,00,32,00,00,00,00,00
and I have removed the hex(7): off the front, then tried it as a pure string and casting to a byte array, and neither seems to work.
I have found reference to REG_MULTI_SZ being UTF-16le, but my understanding is that this is also the default for PowerShell, so I shouldn't need to be changing the encoding, but perhaps I am wrong there?
EDIT: I also tried this, with again a successful write, but the wrong result.
$enc = [system.Text.Encoding]::UTF8
[byte[]]$bytes = $enc.GetBytes($string)
Also tried
$array = $string.Split(',')
$byte = [byte[]]$array
This also puts data into the registry, but the result is not the same as importing the REG. And, everything I am finding keeps pointing at the idea that the REG file is UTF16, so I tried
$enc = [system.Text.Encoding]::Unicode
[byte[]]$bytes = $enc.GetBytes($string)
both with BigEndianUnicode & Unicode. Not only did it not work, the result is the same which I find odd. Seems like changing the endian-ness SHOULD change the result.
EDIT: To clarify, the input string as taken from the REG file is shown above. I simply removed the hex(7): from the front of the data.
The results are seen here, where the second value is what results from PowerShell, while the first is what the REG file produced.
The code used to produce this was
$string = "31,00,30,00,00,00,31,00,00,00,32,00,00,00,33,00,00,00,30,00,00,00,34,00,00,00,35,00,00,00,36,00,00,00,37,00,00,00,38,00,00,00,39,00,00,00,31,00,31,00,00,00,31,00,32,00,00,00,31,00,33,00,00,00,31,00,34,00,00,00,31,00,35,00,00,00,31,00,36,00,00,00,31,00,37,00,00,00,31,00,38,00,00,00,31,00,39,00,00,00,32,00,30,00,00,00,32,00,31,00,00,00,32,00,32,00,00,00,00,00"
$enc = [system.Text.Encoding]::BigEndianUnicode
[byte[]]$bytes = $enc.GetBytes($string)
New-ItemProperty "HKCU:\Software\Synchro\Synchro\ProjectConfig" -name:"NavigatorLayoutOrder2" -value:$bytes -propertyType:MultiString -force
Using Unicode encoding produces a very slightly different, but still wrong, result.
For one thing, the multistring is little endian encoded, so you need [Text.Encoding]::Unicode, not [Text.Encoding]::BigEndianUnicode. Plus, using [Text.Encoding]::Unicode.GetBytes() on the string from the .reg file ("31,00,30,00,...") would give you a byte array of the characters of that string:
'3' → 51, 0
'1' → 49, 0
',' → 44, 0
'0' → 48, 0
…
What you actually want is a byte array of the comma-separated hexadecimal values in that string:
31 → 49 (character '1')
00 → 0 (character NUL)
30 → 48 (character '0')
…
Split the string at commas, convert the hexadecimal number strings to integers, and cast the resulting list of integers to a byte array:
[byte[]]$bytes = $string -split ',' | ForEach-Object { [int]"0x$_" }
Then you can convert that (little endian encoded) byte array to a string:
$ms = [Text.Encoding]::Unicode.GetString($bytes)
and write that to the registry:
$key = 'HKCU:\Software\Synchro\Synchro\ProjectConfig'
$name = 'NavigatorLayoutOrder2'
New-ItemProperty $key -Name $name -Value $ms -PropertyType MultiString -Force
Related
Powershell number format
I am creating a script converting a csv file in an another format. To do so, i need my numbers to have a fixed format to respect column size : 00000000000000000,00 (20 characters, 2 digits after comma) I have tried to format the number with -f and the method $value.toString("#################.##") without success Here is an example Input : 4000000 45817,43 400000 570425,02 15864155,69 1068635,69 128586256,9 8901900,04 29393,88 126858346,88 1190011,46 2358411,95 139594,82 13929,74 11516,85 55742,78 96722,57 21408,86 717,01 54930,49 391,13 2118,64 Any hints are welcome :) Thank you !
tl;dr: Use 0 instead of # in the format string: PS> $value = 128586256.9; $value.ToString('00000000000000000000.00') 00000000000128586256.90 Note: Alternatively, you could construct the format string as an expression: $value.ToString('0' * 20 + '.00') The resulting string reflects the current culture with respect to the decimal mark; e.g., with fr-FR (French) in effect, , rather than . would be used; you can pass a specific [cultureinfo] object as the second argument to control what culture is used for formatting; see the docs. As in your question, I'm assuming that $value already contains a number, which implies that you've already converted the CSV column values - which are invariably strings - to numbers. To convert a string culture-sensitively to a number, use [double]::Parse('1,2'), for instance (this method too has an overload that allows specifying what culture to use). Caveat: By contrast, a PowerShell cast (e.g. [double] '1.2') is by design always culture-invariant and only recognizes . as the decimal mark, irrespective of the culture currently in effect. zerocukor287 has provided the crucial pointer: To unconditionally represent a digit in a formatted string and default to 0 in the absence of an available digit, use 0, the zero placeholder in a .NET custom numeric format string By contrast, #, the digit placeholder, represents only digits actually present in the input number. To illustrate the difference: PS> (9.1).ToString('.##') 9.1 # only 1 decimal place available, nothing is output for the missing 2nd PS> (9.1).ToString('.00') 9.10 # only 1 decimal place available, 0 is output for the missing 2nd
Since your input uses commas as decimal point, you can split on the comma and format the whole number and the decimal part separately. Something like this: $csv = #' Item;Price Item1;4000000 Item2;45817,43 Item3;400000 Item4;570425,02 Item5;15864155,69 Item6;1068635,69 Item7;128586256,9 Item8;8901900,04 Item9;29393,88 Item10;126858346,88 Item11;1190011,46 Item12;2358411,95 Item13;139594,82 Item14;13929,74 Item15;11516,85 Item16;55742,78 Item17;96722,57 Item18;21408,86 Item19;717,01 Item20;54930,49 Item21;391,13 Item22;2118,64 '# | ConvertFrom-Csv -Delimiter ';' foreach ($item in $csv) { $num,$dec = $item.Price -split ',' $item.Price = '{0:D20},{1:D2}' -f [int64]$num, [int]$dec } # show on screen $csv # output to (new) csv file $csv | Export-Csv -Path 'D:\Test\formatted.csv' -Delimiter ';' Output in screen: Item Price ---- ----- Item1 00000000000004000000,00 Item2 00000000000000045817,43 Item3 00000000000000400000,00 Item4 00000000000000570425,02 Item5 00000000000015864155,69 Item6 00000000000001068635,69 Item7 00000000000128586256,09 Item8 00000000000008901900,04 Item9 00000000000000029393,88 Item10 00000000000126858346,88 Item11 00000000000001190011,46 Item12 00000000000002358411,95 Item13 00000000000000139594,82 Item14 00000000000000013929,74 Item15 00000000000000011516,85 Item16 00000000000000055742,78 Item17 00000000000000096722,57 Item18 00000000000000021408,86 Item19 00000000000000000717,01 Item20 00000000000000054930,49 Item21 00000000000000000391,13 Item22 00000000000000002118,64
I do things like this all the time, usually for generating computernames. That custom numeric format string reference will come in handy. If you want a literal period, you have to backslash it. 1..5 | % tostring 00000000000000000000.00 00000000000000000001.00 00000000000000000002.00 00000000000000000003.00 00000000000000000004.00 00000000000000000005.00 Adding commas to long numbers: psdrive c | % free | % tostring '0,0' # or '#,#' 18,272,501,760 "Per mille" character ‰ : .00354 | % tostring '#0.##‰' 3.54‰
PowerShell New-ADComputer binary attribute
I am new to PowerShell and I have a one shot task to perform which must be done with PowerShell. This involves Active Directory as well. I need to add a new computer object into our AD and one of the attributes I must set at creation time is a 16 bytes binary value. I am getting as input a string which is an hexadecimal representation of the value I must set for the attribute. I tried to input the value asis and it doesn't work. I tried escaping each byte with a backslash, it doesn't work neither. How should I format the input for this to work with the New-ADComputer command? I am setting a bunch of other attributes successfully. When I remove this binary entry from my hashtable passed to the -OtherAttributes option it works fine. So, obviously a format problem. I found nothing about the expected format for such attributes. Any hints? TIA. EDIT 2018-06-05 19:44 EDT: I tried converting the string to a byte array as follow: Function Convert-Hex2ByteArray { [cmdletbinding()] param( [parameter(Mandatory=$true)] [String] $HexString ) [byte[]] $Bytes = #(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0) For($i=0; $i -lt $HexString.Length; $i+=2) { $Bytes[$i/2] = [convert]::ToByte($HexString.Substring($i, 2), 16) } $Bytes } (...) $netbootGUID = Convert-Hex2ByteArray($args[$indiceArgs]) $otherAttributes.add( "netbootGUID", $netbootGUID ) (...) New-ADComputer -Credential $cred -Server $ADhost -Path "CN=Computers,$baseDN" -SAMAccountName $sAMAccountName -Name $name-Instance 4 -OtherAttributes $otherAttributes This leads to the following error (I apologize for my own translation since the original message is shown in French): Many values were specified for an attribut which can only have one Problem solved: $netbootGUID = New-Object Guid $args[$indiceArgs] $otherAttributs.add( "netbootGUID", $netbootGUID ) Did the trick.
Typically for binary storage you need to convert the string to a byte array: $String = '3c6ef75eaa2c4b23992bbd65ac891917' $ByteArray = [byte[]]$(for ($i = 0; $i -lt $String.Length; $i+=2) { [Convert]::ToByte($String.Substring($i,2), 16) }) To convert it back: $NewString = -join $(foreach($Byte in $ByteArray) { $Byte.ToString('x2') }) If you want the characters upper case, specify 'X2' instead of 'x2'. Since you're storing 16 byte values, I'll note that if you're storing GUIDs you may need to change the storage order since the order of bytes in a string representation of a GUID does not match the order of bytes in a byte representation of a GUID on an x86 system. Fortunately, there are built in functions for handling this conversion with the built-in System.Guid data type: $GUID = 'f8d89eb2b49c4bfeab44a85ccdc4191a' $ByteArray = [Guid]::new($GUID).ToByteArray() And a constructor for converting back: $NewGUID = [Guid]::new($ByteArray) Whether or not you should use this method depends on exactly what property you're updating and whether or not the application(s) that will be using the property in question will correctly be handling the GUIDs or if they're just storing the GUID as raw bytes (which is incorrect but not surprising). You'll have to test by seeing what GUID your application sees and comparing it to the byte array in Active Directory to verify that it's correct. For specifics on the byte ordering, see the documentation for Guid.ToByteArray(): Note that the order of bytes in the returned byte array is different from the string representation of a Guid value. The order of the beginning four-byte group and the next two two-byte groups is reversed, whereas the order of the last two-byte group and the closing six-byte group is the same. The example provides an illustration. The reason for this is that a GUID is partially constructed from a series of integers of varying sizes, and the UUID standard specifies big endianness for those numbers. x86 computers are little-endian systems.
How to add multiple values to case sensitive powershell hashtable?
I need a (key,value) hashtable of alphabet to convert letters and numbers to codes in PowerShell, i did it like this: $symbols = #{"A"="0x41"; "B"="0x42"; "C"="0x43"; "D"="0x44"; "E"="0x45"; "F"="0x46"; "G"="0x47"; "H"="0x48"; "I"="0x49"; ....} But then i noticed that hashtables are case insensitive by default, and i need case sensitivity. I found that i can create case sensitive hashtable with: $symbols = New-Object System.Collections.Hashtable and then add values: $symbols.Add("a","0x41") $symbols.Add("A","shift+0x41") .... But that will take 52 lines of code, is there any way to add multiple values to CASE SENSITIVE hashtable in one line? Because if i try to combine two hashtables or add values in one line, it becomes case INsensitive and throws error about duplicate values.
I think this potentially does what you're after: $symbols = New-Object System.Collections.Hashtable ((65..90) + (97..122)) | ForEach-Object { $symbols.Add([char]$_,"$(if ($_ -lt 97) {'shift+'})0x{0:x}" -f $( if ($_ -lt 97) { $_ } Else { $_ -32 })) } $symbols.GetEnumerator() | sort name This assumes that you're converting the character to hex code. Explanation: ((65..90) + (97..122)) creates an array of two ranges of numbers, which are the decimal codes for A..Z and a..z. Converts the decimal code to it's corresponding character letter with [Char] If the code is less than 97 add the text Shift+ to the start of the value. Uses "0x{0:x}" -f <number> to convert the number to its hex equivalent, changing the range back to the lower case range for the uppercase characters by subtracting 32.
Getting the binary value of a character string in Powershell
$getInput = Read-Host "ASCII or Binary? `n" $getInput = $getInput.toLower() if($getInput -eq "ascii"){ "" #Write-Host "Type In Your ASCII" -backgroundcolor "black" $getAscii = Read-Host "Type In Your ASCII`n" "" "" $readAscii = #($getAscii) [byte[]]$outBytes = $readAscii } elseif($getInput -eq "binary"){ } else{ Write-Host "Wrong Input... [ASCII] or [BINARY]" -backgroundcolor "red" -foregroundcolor "white" } I want to be able to get a users paragraph or whatever string they put in and convert it to binary. The [conver]::toString($getAscii,2) only works for integers.
Try this $string = "ABCDEF" [system.Text.Encoding]::Default.GetBytes($String) | %{[System.Convert]::ToString($_,2).PadLeft(8,'0') } [system.Text.Encoding]::Default.GetBytes($String) This turns a string into a byte array. You can change Default to another Encoding | %{[System.Convert]::ToString($_,2).PadLeft(8,'0') } This turns each byte in the byte array into a binary representation. ToString([object],[Enum]), in this case the byte will have a number value like 65 if converted to string the 2 will say turn the 65 into base 2. You could also use 8(octo), 10(which is the same as none aka base 10) and 16(Hex). Then it pads the left till its 8 char long with char 0's
'hello world' -split '' | % { if ($_ -ne '') { #[int][char]$_ [System.Convert]::ToString(([int][char]$_),2) } } Use the split operator to split the string by each character Send that down the pipeline to a foreach-object loop The split operation ends up including the space character in the string so the conditional makes sure we don't act upon it--we filter it out. The commented line was for testing purposes. Each character has a TYPE of [string] and we need it as a [char] so we explicitly cast it as such and the PowerShell engine dynamically switches it for us (as long as it can). In the same line, we explicitly cast the [char] to an [int] to get the ASCII->decimal representation. This test was just to ensure I was getting the right output and I left it commented in case the OP wanted to see it. Finally, we use the ToString() method of the System.Convert class which accepts a "base" parameter to define that we want a base2 (binary) representation of the integer supplied in position 1, casted as TYPE [string].
I recommend utilizing the Encoding library similarly to this user: $stringToConvert = "Hello World" $test = [System.Text.Encoding]::UTF8.GetBytes($stringToConvert) | %{ [System.Convert]::ToString($_,2).PadLeft(8,'0') } $test Source: https://www.reddit.com/r/PowerShell/comments/3e82vk/convert_string_to_binary_and_back/ *Note: I believe the original poster of this method intended to assign $foo to the second conversion. I believe it will work either way because the return will be dumped to the variable below.
Convert Byte Array (from legacy program data file) to Powershell object
I have a "structured" file (logical fixed-length records) from a legacy program on a legacy (non-MS) operating system. I know how the records were structured in the original program, but the original O/S handled structured data as a sequence of bytes for file I/O, so a hex dump won't show you anything more than what the record length is (there are marker bytes and other record overhead imposed by the access method API used to generate the file originally). Once I have the sequence of bytes in a Powershell variable, with the overhead bytes "cut away", how can I convert this into a structured object? Some of the "fields" are 16-bit integers, some are strings of the form [s]data (where [s] is a byte giving the length of the "real" data in that field), some are BCD coded fixed-point numbers, some are IEEE floats. (I haven't been specific about the structure, either on the Powershell side or on the legacy side, because I am seeking a more-or-less 'generic' solution/technique, as I actually have several different files with different record structures to process.)
Initially, I tried to do it by creating a type that could take the buffer and overwrite a struct so that all the fields were nicely filled in. However, certain issues arose (regarding struct layout, fixed buffers and mixing fixed and managed members) and I also realised that there was no guarantee that the data in the buffer would be properly (or even legally) aligned. Decided to try a more programmatic path. "Manual" parsing is out, so how about automatic parsing? You're going to need to define the members of your PSobject at some point, why not do it in a way that can help programmatically parse the data. This method does not require the data in the buffer to be correctly aligned or even contiguous. You can also have fields overlap to separate raw unions into the individual members (though, typically, only one will contain a "correct" value). First step, build a hash table to identify the members, the offset in the buffer, their data types and, if an array, the number of elements : $struct = #{ field1 = 0,[int],0; # 0 means not an array field2 = 4,[byte],16; # a C string maybe field3 = 24,[char],32; # wchar_t[32] ? note: skipped over bytes 20-23 field4 = 56,[double],0 } # the names field1/2/3/4 are arbitrary, any valid member name may be used (but not # necessarily any valid hash key if you want a PSObject as the end result). # also, the values could be hash tables instead of arrays. that would allow # descriptive names for the values but doesn't affect the end result. Next, use [BitConverter] to extract the required data. The problem here is that we need to call the correct method for all the varying types. Just use a (big) switch statement. The basic principle is the same for most values, get the type indicator and initial offset from the $struct definition then call the correct [BitConverter] method and supply the buffer and initial offset, update the offset to where the next element of an array would be and then repeat for as many array elements as are required. The only trap here is that the data in the buffer must have the same format as expected by [BitConverter], so for the [double] example, the bytes in the buffer must conform to IEEE-754 floating point format (assuming that [BitConverter]::ToDouble() is used). Thus, for example, raw data from a Paradox database will need some tweeking because it flips the high bit to simplify sorting. $struct.keys | foreach { # key order is undefined but that won't affect the final object's members $hashobject = #{} } { $fieldoffs = $struct[$_][0] $fieldtype = $struct[$_][1] if (($arraysize = $struct[$_][2]) -ne 0) { # yes, I'm a C programmer from way back $array = #() } else { $array = $null } :w while ($arraysize-- -ge 0) { switch($fieldtype) { ([int]) { $value = [bitconverter]::toint32($buffer, $fieldoffs) $fieldoffs += 4 } ([byte]) { $value = $buffer[$fieldoffs++] } ([char]) { $value = [bitconverter]::tochar($buffer, $fieldoffs) $fieldoffs += 2 } ([string]) { # ANSI string, 1 byte per character $array = new-object string (,[char[]]$buffer[$fieldoffs..($fieldoffs+$arraysize)]) # $arraysize has already been decremented so don't need to subtract 1 break w # "array size" was actually string length so don't loop # # description: # first, get a slice of the buffer as a byte[] (assume single byte characters) # next, convert each byte to a char in a char[] # then, invoke the constructor String(Char[]) # finally, put the String into $array ready for insertion into $hashobject # # Note the convoluted syntax - New-Object expects the second argument to be # an array of the constructor parameters but String(Char[]) requires only # one argument that is itself an array. By itself, # [char[]]$buffer[$fieldoffs..($fieldoffs+$arraysize)] # is treated by PowerShell as an argument list of individual chars, corrupting the # constructor call. The normal trick is to prepend a single comma to create an array # of one element which is itself an array # ,[char[]]$buffer[$fieldoffs..($fieldoffs+$arraysize)] # but this won't work because of the way PowerShell parses the command line. The # space before the comma is ignored so that instead of getting 2 arguments (a string # "String" and the array of an array of char), there is only one argument, an array # of 2 elements ("String" and array of array of char) thereby totally confusing # New-Object. To make it work you need to ALSO isolate the single element array into # its own expression. Hence the parentheses # (,[char[]]$buffer[$fieldoffs..($fieldoffs+$arraysize)]) # } } if ($null -ne $array) { # must be in this order* to stop the -ne from enumerating $array to compare against # $null. this would result in the condition being considered false if $array were # empty ( (#() -ne $null) -> $null -> $false ) or contained only one element with # the value 0 ( (#(0) -ne $null) -> (scalar) 0 -> $false ). $array += $value # $array is not $null so must be an array to which $value is appended } else { # $array is $null only if $arraysize -eq 0 before the loop (and is now -1) $array = $value # so the loop won't repeat thus leaving this one scalar in $array } } $hashobject[$_] = $array } #*could have reversed it as # if ($array -eq $null) { scalar } else { collect array } # since the condition will only be true if $array is actually $null or contains at # least 2 $null elements (but no valid conversion will produce $null) At this point there is a hash table, $hashobject, with keys equal to the field names and values containing the bytes from the buffer arranged into single (or arrays of) numeric (inc. char/boolean) values or (ANSI) strings. To create a (proper) object, just invoke New-Object -TypeName PSObject -Property $hashobject or use [PSCustomObject]$hashobject. Of course, if the buffer actually contained structured data then the process would be more complicated but the basic procedure would be the same. Note also that the "types" used in the $struct hash table have no direct effect on the resultant types of the object members, they are only convenient selectors for the switch statement. It would work just as well with strings or numbers. In fact, the parentheses around the case labels are because switch parses them the same as command arguments. Without the parentheses, the labels would be treated as literal strings. With them, the labels are evaluated as a type object. Both the label and the switch value are then converted to strings (that's what switch does for values other than script blocks or $null) but each type has a distinct string representation so the case labels will still match up correctly. (Not really on point but still interesting, I think.) Several optimisations are possible but increase the complexity slightly. E.g. ([byte]) { # already have a byte[] so why collect bytes one at a time if ($arraysize -ge 0) { # was originally -gt 0 so want a byte[] $array = [byte[]]$buffer[$fieldoffs..($fieldoffs+$arraysize)] # slicing the byte array produces an object array (of bytes) so cast it back } else { # $arraysize was 0 so just a single byte $array = $buffer[$fieldoffs] } break w # $array ready for insertion into $hashobject, don't need to loop } But what if my strings are actually Unicode?, you say. Easy, just use existing methods from the [Text.Encoding] class, [string] { # Unicode string, 2 (LE) bytes per character $array = [text.encoding]::unicode.getstring([byte[]]$buffer[$fieldoffs..($fieldoffs+$arraysize*2+1)]) # $arraysize should be the string length so, initially, $arraysize*2 is the byte # count and $arraysize*2-1 is the end index (relative to $fieldoffs) but $arraysize # was decremented so the end index is now $arraysize*2+1, i.e. length*2-1 = (length-1)*2+1 break w # got $array, no loop } You could also have both ANSI and Unicode by utilising a different type indicator for the ANSI string, maybe [char[]]. Remember, the type indicators do not affect the result, they just have to be distinct (and hopefully meaningful) identifiers. I realise that this is not quite the "just dump the bytes into a union or variant record" solution mentioned in the OPs comment but PowerShell is based in .NET and uses managed objects where this sort of thing is largely prohibited (or difficult to get working, as I found). For example, assuming you could just dump raw chars (not bytes) into a String, how would the Length property get updated? This method also allows some useful preprocessing such as splitting up unions as noted above or converting raw byte or char arrays into the Strings they represent.