Powershell script to generate an executable from a powershell script.

I was helping someone with a bit of powershelling. The guy needed a small script which asked a user a few questions and then the account created a local account on the machine based on the answers. He had started to use some Windows Forms powershell code and helped him with a few small details. The problem is that it's a bit ugly to run a Windows Forms script with a big shell sitting in the background doing nothing.

There are a few different solutions out there to hide the Powershell console window but was thinking in the lines about. Hey why not just compile an executable with the Add-Type cmdlet, embed the script inside the executable and run the script from inside the executable. At deployment you only have to run the executable.

A little script compiles a Powershell script into an executable. The script is not brilliant and is only intended for two different scenarios.

1. Embed scripts where you do NOT want a console window. This executable allows NO console interaction.
2. Embed scripts where you keep the Runspace alive (the -KeepAlive switch) for event listeners. This is useful if you are register for WMI events or other events in your script.

Here it is, enjoy!

function New-PSExecutable {  

param(

[string]$Scriptname=$(throw "Mandatory param -scriptname is missing."),

[string]$Filename,

[switch]$KeepAlive

) 

$code=@" 

using System; using System.Diagnostics;

using System.Windows.Forms;
using System.Management.Automation.Runspaces;
using System.Management.Automation;
namespace CosmosKey.Powershell.Utils
{
class RunEmbedded
{
  private static string codeB64 = "@@@";

private static string funcName = "CosmosKeyRunEmbedded";
private static Pipeline pipe;
  private static Runspace rs = RunspaceFactory.CreateRunspace();

static void Main(string[] args)
{
  try

  {

    rs.Open();

    pipe = rs.CreatePipeline();

    String script = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(codeB64));

    System.Text.StringBuilder sb = new System.Text.StringBuilder();

    sb.AppendLine("function " + funcName + " {");

    sb.AppendLine(script);

    sb.AppendLine("}");

    sb.AppendLine("[reflection.assembly]::loadwithpartialname('System.Xml')");

    sb.AppendLine("[reflection.assembly]::loadwithpartialname('System.Management')");

    sb.AppendLine("[reflection.assembly]::loadwithpartialname('System.DirectoryServices')");

    sb.AppendLine("[reflection.assembly]::loadwithpartialname('System.Data')");

    sb.Append(funcName);

    foreach(string arg in args){

      sb.Append(" ");

      if(arg.StartsWith("-")){

        sb.Append(arg);

      } else if (arg.Contains(" ")){

        sb.Append("\"" + arg + "\"");

      } else {

        sb.Append(arg);

      }

    }

    sb.AppendLine("");

    pipe.Commands.AddScript(sb.ToString());

    ZZZ

    CloseRunspace();

  }

  catch (Exception) { ;}

}

private static void CloseRunspace(){
    pipe.StopAsync();

    rs.CloseAsync();

  }

}
}
"@
if(test-path $scriptname){
$script:scriptFilename = get-item $scriptname
} else {
throw "Can't find script file"
}
if([string]::IsNullOrEmpty($filename)){
$filename = $scriptFilename.Name.ToLower() -replace ".ps1",".exe"
$filename = "$pwd\$filename"
}
Write-Host "Source script file: $($scriptFilename.FullName)"
Write-Host "Output executable : $filename"
$scriptBytes = [io.file]::ReadAllBytes($scriptFilename.FullName)
$b64 = [convert]::tobase64string($scriptBytes)
$newCode = $code -replace "@@@",$b64
if($KeepAlive){
$newCode = $newCode -replace "ZZZ","pipe.InvokeAsync();Application.Run();"
} else {
$newCode = $newCode -replace "ZZZ","pipe.Invoke();"
}
$formsAssembly = [reflection.assembly]::LoadWithPartialName("System.Windows.Forms")

Add-Type $newCode -OutputAssembly $filename -OutputType WindowsApplication -ReferencedAssemblies $formsAssembly.Location 

}

To build the executable just load the function and run

New-PSExecutable [outputfile] [-KeepAlive]

The scriptname vaariable is mandatory obviously but the outputfile will be the scriptname without the .ps1 extension and with an .exe extension if it's left out.
The -KeepAlive flag will make sure that the application stays alive if the script is using events. The executable can be shutdown from within the script with [Windows.Forms.Application]::Exit() when using the -KeepAlive switch, if you need to exit the application from within.

Here are two sample scripts one test script for being executed without the -KeepAlive and one which uses events which is better compiled with the -KeepAlive switch.

Without -KeepAlive:

[void][system.reflection.assembly]::LoadWithPartialName("System.Windows.Forms")
[windows.forms.messagebox]::Show("Hey there's no script here... or is there ;)")

With -KeepAlive:

[void][system.reflection.assembly]::LoadWithPartialName("System.Windows.Forms")
[void][system.reflection.assembly]::LoadWithPartialName("System.Timers")
$timer = New-Object Timers.Timer
$timer.Interval = 5000
$global:maxTimes = 5
$job = Register-ObjectEvent -inputObject $timer -eventName Elapsed -sourceIdentifier Timer.Random -Action {
    $global:maxTimes--
    [windows.forms.messagebox]::Show($maxTimes)
    if($global:maxTimes -le 0) {
        [windows.forms.application]::Exit()
    }
}
[windows.forms.messagebox]::Show("Started. Runs 5 times")
$timer.start()

The scripts aren't perfect but they did what I needed. 

Please Enjoy!

Regards Johan Akerstrom