Как получить доступ к 64-разрядному реестру из 32-разрядного экземпляра Powershell?

Question

Если вы запустите 32-битный экземпляр Powershell (% SystemRoot% \ syswow64 \ WindowsPowerShell \ v1.0 \ powershell.exe), то поставщик реестра увидит только ограниченные 32-битные части реестра.

**32-bit console**
PS> (dir HKLM:\SOFTWARE | measure).count - (dir HKLM:\SOFTWARE\wow6432node | measure).count

0

**64-bit console**
PS> (dir HKLM:\SOFTWARE | measure).count - (dir HKLM:\SOFTWARE\wow6432node | measure).count

-5

Есть ли способ заставить провайдера перейти в 64-битный режим? Я мог бы перейти к [Microsoft.Win32] .Net API, или, может быть, WMI, но я бы предпочел не. Я использую Powershell v2 CTP3, если это вообще расширяет возможности.

Answer 1

С помощью .NET API вы можете читать 64-битные значения, например:

$key = [Microsoft.Win32.RegistryKey]::OpenBaseKey([Microsoft.Win32.RegistryHive]::LocalMachine, [Microsoft.Win32.RegistryView]::Registry64)
$subKey =  $key.OpenSubKey("SOFTWARE\Microsoft\.NETFramework")
$root = $subKey.GetValue("InstallRoot")

Answer 2

Когда Powershell работает как 32-битный процесс, я не знаю механизма «переключения» в 64-битный режим. Весь смысл поддержки виртуализации в 64-битных системах состоит в том, чтобы заставить 32-битные процессы полагать, что они живут в 32-битной ОС ...

Однако это говорит о том, что я использовал следующую технику в прошлом, и она очень хорошо работала для меня (следующий код был протестирован на Vista SP1 x64 с Powershell v1). Этот метод основан на том факте, что исполняемые файлы .NET «Любой ЦП» будут работать как 64-битный процесс, даже если он вызывается из 32-битного процесса. Шаги, которые мы будем выполнять:

1. Скомпилируйте короткую C # -программу, которая запустит PowerShell (т.е. очень простая реализация "fork" :-))
2. Запустите скомпилированную программу C #
3. Скомпилированная программа C # запустит Powershell, но, поскольку это «Любой ЦП», он будет работать как 64-битный процесс, поэтому он запустит 64-битный Powershell (обратите внимание, что, поскольку это всего лишь подтверждение концепции, я ожидаю powershell быть на твоем «пути»)
4. Новый 64-битный Powershell будет запускать выбранный нами командлет

Это скриншот выше в действии (обратите внимание на битность процессов): Дерево процессов http://img3.imageshack.us/img3/3248/powershellfork.png

Следующая программа ожидает, что все перечисленные файлы будут находиться в одном каталоге. Я рекомендую создать тестовый каталог, например, C: \ Temp \ PowershellTest и сохраняя там все файлы).

Точкой входа в программу будет простой командлет:

# file "test.ps1"
$basePath = Split-Path -resolve $myInvocation.MyCommand.Path
$exe = Join-Path $basePath test.exe
&"$env:SystemRoot\Microsoft.NET\Framework\v3.5\csc.exe" /nologo /target:exe /out:$exe (Join-Path $basePath test.cs)
&$exe (Join-Path $basePath visibility.ps1)

Он запускает csc (32 бита, но это не имеет значения :-)), а затем запускает результат компилятора csc, передавая один аргумент (полный путь к) visibility.ps1 (это командлет, который мы хотим запустить в 64 бите Powershell).

Код C # также очень прост:

// file "test.cs"
using System.Diagnostics;
static class Program {
    static int Main(string[] args) {
        ProcessStartInfo i = new ProcessStartInfo("powershell", args[0]);
        i.UseShellExecute = false;
        using(Process p = Process.Start(i)) {
            p.WaitForExit();
            return p.ExitCode;
        }
    }
}

И, наконец, ваш сценарий «видимости»:

# file "visibility.ps1"
(dir HKLM:\SOFTWARE).count - (dir HKLM:\SOFTWARE\wow6432node).count

Запуск сценария ввода из 32-битного Powershell теперь дает желаемый результат (просто чтобы показать, что я не обманывал, сначала запускаю сценарий видимости, а затем используем нашу технику форка):

Запуск программы http://img3.imageshack.us/img3/2766/powershellrunc.png

Answer 3

Я полагаю, что встроенный командлет Start-Job позволит вам проверить 64-битный реестр из 32-битного экземпляра.

Если нет, используйте Invoke-Command для возврата к локальной машине. 64-разрядная машина будет иметь две конечные точки (64-разрядную и 32-разрядную), а 64-разрядная конечная точка будет использоваться по умолчанию.

Пример создания значения реестра и обеспечения его соответствия 64-битному пути, а не 32.

Invoke-Command -scriptblock {
    New-ItemProperty -Path HKLM:\SOFTWARE\Acme 
                     -Name NameofNewReg 
                     -PropertyType String -Value "1"
    } -computername .

Answer 4

Самый простой способ - использовать этот ярлык: C: \ Windows \ Sysnative что эквивалентно C: \ Windows \ System32 - но ключевое отличие состоит в том, что процесс запускается как 64-битный процесс. Поэтому самый простой способ получить доступ к 64-разрядному реестру из 32-разрядного PowerShell - это вызвать reg.exe через C: \ Windows \ sysnative. Например:

C:\Windows\sysnative\reg.exe QUERY HKLM\SOFTWARE\JavaSoft\JDK

источник: https://stackoverflow.com/a/25103599

Если по какой-то причине вам необходим доступ к 32-разрядному реестру из 64-разрядной командной строки, используйте C: \ Windows \ syswow64

C:\Windows\syswow64\reg.exe QUERY HKLM\SOFTWARE\JavaSoft

Answer 5

Чтобы расширить ответ Милана Гардиана, используйте эту функцию для небольших блоков кода:

function RunAs-64Bit ([ScriptBlock]$scriptblock)
{
    [string]$code = 'using System.Diagnostics; static class Program { static int Main(string[] args) { ProcessStartInfo i = new ProcessStartInfo("powershell", args[0]); i.UseShellExecute = false; using(Process p = Process.Start(i)) { p.WaitForExit(); return p.ExitCode; } } }'
    [string]$exeName = $env:temp + '\' + [System.IO.Path]::GetRandomFileName() + '.exe';
    $params = New-Object 'System.CodeDom.Compiler.CompilerParameters'; 
    @('mscorlib.dll',  'System.dll', ([System.Reflection.Assembly]::GetAssembly([PSObject]).Location)) | %{ $params.ReferencedAssemblies.Add( $_ ) } | Out-Null
    $params.GenerateExecutable      = $true
    $params.GenerateInMemory        = $false;
    $params.CompilerOptions         = '/optimize';
    $params.OutputAssembly          = $exeName;
    $params.TreatWarningsAsErrors   = $false;
    $params.WarningLevel            = 4;

    $csprovider = New-Object 'Microsoft.CSharp.CSharpCodeProvider'; #disposable
    try {
        $compileResults = $csprovider.CompileAssemblyFromSource($params, $code)
        $errors = $compileResults.Errors | ?{ -not $_.IsWarning }
        if ($errors.Count -gt 0) 
        {
            Write-Host -f red 'Compiler errors are found.'
            foreach ($output in $compileResults.Output) { Write-Host -$output }
            foreach ($err in $errors) { Write-Host -f red $('Compile Error: ' + $err); }            
        }
        else 
        {
            $compileResults.Errors | %{ Abr-Write-UtilLog 'Util Get assembly from code' $('Compile Warning: ' + $_); }            
            $assembly = $compileResults.CompiledAssembly
            $commandParam = '-encodedCommand  ' + [System.Convert]::ToBase64String([System.Text.Encoding]::UNICODE.GetBytes($scriptblock));
            &$exeName $commandParam
        }
        Remove-Item -force $exeName -ErrorAction 'SilentlyContinue';
    } finally{
        $csprovider.Dispose();
        Remove-Variable 'csprovider';
    }
}

Теперь используйте эту функцию для запуска любого скриптового блока (если он не слишком большой) в 64-битном режиме, когда доступен 64-битный режим

Answer 6

Если переменная окружения PROCESSOR_ARCHITEW6432 существует и имеет значение AMD64, значит, вы работаете в 32-битном режиме на 64-битном компьютере. Чем вам нужно запустить powershell в виртуальном 64-битном пути% windir% \ sysnative.

if ($env:PROCESSOR_ARCHITEW6432 -eq "AMD64") {
    write-warning "changing from 32bit to 64bit PowerShell..."
    $powershell=$PSHOME.tolower().replace("syswow64","sysnative").replace("system32","sysnative")

    if ($myInvocation.Line) {
        &"$powershell\powershell.exe" -NonInteractive -NoProfile $myInvocation.Line
    } else {
        &"$powershell\powershell.exe" -NonInteractive -NoProfile -file "$($myInvocation.InvocationName)" $args
    }

    exit $lastexitcode
}

Answer 7

Небольшой вариант ответа из Милана - хостинг PowerShell с использованием программы на C # согласно блогу Барта Де Смета . Хотя эта запись в блоге посвящена компиляции под .NET 4.0, вы можете скомпилировать ее и с .NET 3.5. В результате получается двоичный файл, который является хостом PowerShell, который может получить доступ к 64-битным системным реестрам при вызове из 32-битного процесса:

using System;
using System.Management.Automation.Runspaces;
using Microsoft.PowerShell;

namespace PSHost
{
    class Program
    {
        static void Main(string[] args)
        {

            var config = RunspaceConfiguration.Create();
            ConsoleShell.Start(
                config,
                "Windows PowerShell - Compiled for ANY CPU",
                "",
                args
            );

        }
    }
}