September, 2009

  • musc@> $daniele.work.ToString()

    PS> Get-Milk

    • 0 Comments

    PS> Get-Milk

    I printed a tshirt for Sara with a baby-friendly Powershell cmdlet ("Get-Milk").
    She already seems to be wondering what script she can write with it.

    PS> Get-Milk

    PS> Get-Milk

  • musc@> $daniele.work.ToString()

    The mystery of the lost registry values

    • 0 Comments

    During the OpsMgr Health Check engagement we use custom code to assess the customer’s Management group, as I wrote here already. Given that the customer tells us which machine is the RMS, one of the very first things that we do in our tool is to connect to the RMS’s registry, and check the values under HKLM\SOFTWARE\Microsoft\Microsoft Operations Manager\3.0\Setup to see which machine holds the database. It is a rather critical piece of information for us, as we run a number of queries afterward… so we need to know where the db is, obviously :-)

    I learned from here http://mybsinfo.blogspot.com/2007/01/powershell-remote-registry-and-you-part.html how to access registry remotely thru powershell, by using .Net classes. This is also one of the methods illustrated in this other article on Technet Script Center http://www.microsoft.com/technet/scriptcenter/resources/qanda/jan09/hey0105.mspx

    Therefore the “core” instructions of the function I was using to access the registry looked like the following

    1. Function GetValueFromRegistry ([string]$computername, $regkey, $value)   
    2. {  
    3.      $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('LocalMachine', $computername)  
    4.      $regKey= $reg.OpenSubKey("$regKey")  
    5.      $result = $regkey.GetValue("$value")  
    6.      return $result 
    7. }  

     

    [Note: the actual function is bigger, and contains error handling, and logging, and a number of other things that are unnecessary here]

    Therefore, the function was called as follows:
    GetValueFromRegistry $RMS "SOFTWARE\\Microsoft\\Microsoft Operations Manager\\3.0\\Setup" "DatabaseServerName"
    Now so far so good.

    In theory.

    Now for some reason that I could not immediately explain, we had noticed that this piece of code performing registry accessm while working most of the times, only on SOME occasions was giving errors about not being able to open the registry value…

    image

    When you are onsite with a customer conducting an assessment, the PFE engineer does not always has the time to troubleshoot the error… as time is critical, we have usually resorted to just running the assessment from ANOTHER machine, and this “solved” the issue… but always left me wondering WHY this was giving an error. I had suspected an issue with permissions first, but it could not be as the permissions were obviously right: performing the assessment from another machine but with the same user was working!

    A few days ago my colleague and buddy Stefan Stranger figured out that this was related to the platform architecture:

    • X64 client to x64 RMS was working
    • X64 client to x86 RMS was working
    • X86 client to x86 RMS was working
    • X86 client to x64 RMS was NOT working

    You don’t need to use our custom code to reproduce this, REGEDIT shows the behavior as well.

    If, from a 64-bit server, you open a remote registry connection to 64-bit RMS server, you can see all OpsMgr registry keys:

    clip_image002

    If, anyhow, from a 32-bit server, you open a remote registry connection to 64-bit RMS server, you don’t see ALL – but only SOME - OpsMgr registry keys:
    clip_image004

    So here’s the reason! This is what was happening! How could I not think of this before? It was nothing related to permissions, but to registry redirection! The issue was happening because the 32 bit machine is using the 32bit registry editor and what it will do when accessing a 64bit machine will be to default to the Wow6432Node location in the registry. There all OpsMgr data won’t be in the WOW64 location on a 64bit machine, only some.

    So, just like regedit, the 32bit powershell and the 32bit .Net framework were being redirected to the 32bit-compatibility registry keys… not finding the stuff we needed, whereas a 64bit application could find that. Any 32bit application by default gets redirected to a 32bit-safe registry.

    So, after finally UNDERSTANDING what the issue was, I started wondering: ok... but how can I access the REAL “HLKM\SOFTWARE\Microsoft” key on a 64bit machine when running this FROM a 32bit machine – WITHOUT being redirected to “HKLM\SOFTWARE\Wow6432Node\Microsoft” ? What if my application CAN deal just fine with those values and actually NEEDs to access them?

    The answer wasn’t as easy as the question. I did a bit of digging on this, and still I have NOT yet found a way to do this with the .Net classes. It seems that in a lot of situations, Powershell or even .Net classes are nice and sweet wrappers on the underlying Windows APIs… but for how sweet and easy they are, they are very often not very complete wrappers – letting you do just about enough for most situations, but not quite everything you would or could with the APi underneath. But I digress, here...

    The good news is that I did manage to get this working, but I had to resort to using dear old WMI StdRegProvider… There are a number of locations on the Internet mentioning the issue of accessing 32bit registry from 64bit machines or vice versa, but all examples I have found were using VBScript. But I needed it in Powershell. Therefore I started with the VBScript example code that is present here, and I ported it to Powershell.

    Handling the WMI COM object from Powershell was slightly less intuitive than in VBScript, and it took me a couple of hours to figure out how to change some stuff, especially this bit that sets the parameters collection:

    Set Inparams = objStdRegProv.Methods_("GetStringValue").Inparameters

    Inparams.Hdefkey = HKLM

    Inparams.Ssubkeyname = RegKey

    Inparams.Svaluename = RegValue

    Set Outparams = objStdRegProv.ExecMethod_("GetStringValue", Inparams,,objCtx)

    INTO this:

    $Inparams = ($objStdRegProv.Methods_ | where {$_.name -eq "GetStringValue"}).InParameters.SpawnInstance_()

    ($Inparams.Properties_ | where {$_.name -eq "Hdefkey"}).Value = $HKLM

    ($Inparams.Properties_ | where {$_.name -eq "Ssubkeyname"}).Value = $regkey

    ($Inparams.Properties_ | where {$_.name -eq "Svaluename"}).Value = $value

    $Outparams = $objStdRegProv.ExecMethod_("GetStringValue", $Inparams, "", $objNamedValueSet)

    I have only done limited testing at this point and, even if the actual work now requires nearly 15 lines of code to be performed vs. the previous 3 lines in the .Net implementation, it at least seems to work just fine.

    What follows is the complete code of my replacement function, in all its uglyness glory:

    1. Function GetValueFromRegistryThruWMI([string]$computername, $regkey, $value)  
    2. {  
    3.     #constant for the HLKM  
    4.     $HKLM = "&h80000002" 
    5.  
    6.     #creates an SwbemNamedValueSet object
    7.     $objNamedValueSet = New-Object -COM "WbemScripting.SWbemNamedValueSet" 
    8.  
    9.     #adds the actual value that will requests the target to provide 64bit-registry info
    10.     $objNamedValueSet.Add("__ProviderArchitecture", 64) | Out-Null 
    11.  
    12.     #back to all the other usual COM objects for WMI that you have used a zillion times in VBScript
    13.     $objLocator = New-Object -COM "Wbemscripting.SWbemLocator" 
    14.     $objServices = $objLocator.ConnectServer($computername,"root\default","","","","","",$objNamedValueSet)  
    15.     $objStdRegProv = $objServices.Get("StdRegProv")  
    16.  
    17.     # Obtain an InParameters object specific to the method.  
    18.     $Inparams = ($objStdRegProv.Methods_ | where {$_.name -eq "GetStringValue"}).InParameters.SpawnInstance_()  
    19.  
    20.     # Add the input parameters  
    21.     ($Inparams.Properties_ | where {$_.name -eq "Hdefkey"}).Value = $HKLM 
    22.     ($Inparams.Properties_ | where {$_.name -eq "Ssubkeyname"}).Value = $regkey 
    23.     ($Inparams.Properties_ | where {$_.name -eq "Svaluename"}).Value = $value 
    24.  
    25.     #Execute the method  
    26.     $Outparams = $objStdRegProv.ExecMethod_("GetStringValue", $Inparams, "", $objNamedValueSet)  
    27.  
    28.     #shows the return value  
    29.     ($Outparams.Properties_ | where {$_.name -eq "ReturnValue"}).Value  
    30.  
    31.     if (($Outparams.Properties_ | where {$_.name -eq "ReturnValue"}).Value -eq 0)  
    32.     {  
    33.        write-host "it worked" 
    34.        $result = ($Outparams.Properties_ | where {$_.name -eq "sValue"}).Value  
    35.        write-host "Result: $result" 
    36.        return $result 
    37.     }  
    38.     else 
    39.     {  
    40.         write-host "nope" 
    41.     }  
    42. }  

     

    which can be called similarly to the previous one:
    GetValueFromRegistryThruWMI $RMS "SOFTWARE\Microsoft\Microsoft Operations Manager\3.0\Setup" "DatabaseServerName"

    [Note: you don’t need the double\escape backslashes here, compared to the .Net implementation]

    Enjoy your cross-architecture registry access: from 32bit to 64bit - and back!

Page 1 of 1 (2 items)