530
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
Another feature of this hosting model is that the authentication mechanism is pluggable, 
which allows for alternate authentication services like 
L
ive
ID
to be used. A guide for set-
ting up remoting is available on 
MSDN
as part of the 
W
in
RM
documentation under the 
topic “
IIS
Host Plug-in Configuration” (but be aware that this isn’t a simple process).
NOTE
IIS
hosting and fan-in remote management aren’t supported 
on 
W
indows 
XP
or Windows Server 2003.  They require  Windows 
Vista or above when using a nonserver operating system and Windows 
Server 2008 or later for a server 
OS
.
Having all the sessions running in the same process has certain implications. Because 
PowerShell lets you get at pretty much everything in a process, multiple users running 
unrestricted in the same process could interfere with one another. On the other hand, 
because the host process persists across multiple connections, it’s possible to share 
process-wide resources like database connections between sessions.
Given the lack of session isolation, this approach isn’t intended for full-featured 
general-purpose PowerShell remoting. Instead, it’s designed for use with constrained, 
special-purpose applications using PowerShell remoting. To build these applications, 
you need two things:
• A way to create a constrained application environment
• A way to connect to PowerShell remoting so the user gets the environment 
you’ve created instead of the default PowerShell configuration
We’ll start with the second one first and look at how you specify custom remoting 
endpoints in the next section.
13.2.2
Working with custom configurations
In section 13.1.6, we talked about connecting to a computer by name (and optionally 
by port number) when using PowerShell remoting. The remoting infrastructure will 
always connect to the default PowerShell remoting service. In the nondefault connec-
tion case, you also have to specify the configuration on the target computer to connect 
to. A configuration is made up of three elements:
• The name you use to connect to the endpoint
• A script that will be run to configure the sessions that will run in the endpoint 
• An 
ACL
used to control who has access to the endpoint
When using the 
Invoke-Command
New-PSSession
, or 
Enter-PSSession
cmdlet, 
you can use the 
-ConfigurationName
parameter to specify the name of the session 
configuration you want to connect to. Alternatively, you can override the normal 
default  configuration  by  setting  the 
$PSSessionConfigurationName
preference 
variable to the name of the endpoint you want to connect to.
When you connect to the named endpoint, a PowerShell session will be created 
and then the configuration script associated with the endpoint will be executed. This
Pdf change page order online - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to move pages around in pdf; rearrange pdf pages
Pdf change page order online - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to reorder pdf pages in reader; reorder pages pdf
B
UILDING
CUSTOM
REMOTING
SERVICES
531
configuration script should define the set of capabilities available when connecting to 
that endpoint. For example, there may be different endpoints for different types of 
management tasks—managing a mail server, managing a database server, or manag-
ing a web server. For each task, a specific endpoint would be configured to expose the 
appropriate commands (and constraints) required for performing that task. In the 
next section, you’ll see how to create your own custom endpoints.
13.2.3
Creating a custom configuration
Following on our theme of remote monitoring from chapter 12, you’re going to cre-
ate a configuration that exposes a single custom command, 
Get-PageFaultRate
This command will return the page fault rate from the target computer.
Session configuration
Every remoting connection will use one of the named configurations on the remote 
computer. These configurations set up the environment for the session and determine 
the set of commands visible to users of that session. 
When  remoting  is  initially  enabled  using  the 
Enable-PSRemoting
cmdlet, a 
default configuration is created on the system called 
Microsoft.PowerShell
(on 
64-bit  operating  systems,  there’s  also  the 
Microsoft.PowerShell32
endpoint). 
This endpoint is configured to load the default PowerShell configuration with all 
commands enabled. The 
Enable-PSRemoting
cmdlet also sets the security descrip-
tor for this configuration so that only members of the local Administrators group can 
access the endpoint.
You can use the session configuration cmdlets to modify these default session con-
figurations, to create new session configurations, and to change the security descrip-
tors of all the session configurations. These cmdlets are shown in table 13.7.
Table 13.7 The cmdlets for managing the remoting endpoint configurations
Cmdlet
Description
Disable-PSSessionConfiguration
Denies access to the specified session configuration 
on the local computer by adding an “Everyone 
AccessDenied” entry to the access control list (ACL) 
on the configuration
Enable-PSSessionConfiguration
Enables existing session configurations on the local 
computer to be accessed remotely
Get-PSSessionConfiguration
Gets a list of the existing, registered session config-
urations on the computer
Register-PSSessionConfiguration
Creates and registers a new session configuration
Set-PSSessionConfiguration
Changes the properties of an existing session con-
figuration
Unregister-PSSessionConfiguration
Deletes the specified registered session configura-
tions from the computer
VB.NET Word: Change Word Page Order & Sort Word Document Pages
Note: if you are trying to change the order controls, please read this Word reading page which has powerful & profession imaging controls, PDF document, image
reorder pdf pages; how to move pages in pdf reader
C# Word - Process Word Document in C#
For example, you may change your Word document order from 1, 2, 3, 4, 5 to 3, 5, 4, 2,1 with C# coding. C#.NET: Extracting Page(s) from Word.
how to reverse pages in pdf; move pages in pdf
532
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
In the next section, we’ll look at using these cmdlets to create and manage a custom 
endpoint.
Registering the endpoint configuration
Endpoints are created using the 
Register-PSSessionConfiguration
cmdlet and 
are customized by registering a startup script. In this example, you’ll use a simple 
startup script that defines a single function, 
Get-PageFaultRate
. The script looks 
like this:
PS (1) > @' 
>> function Get-PageFaultRate { 
>>   (Get-WmiObject Win32_PerfRawData_PerfOS_Memory).PageFaultsPersec 
>> } 
>> '@ > Initialize-HMConfiguration.ps1 
>>
Before you can use this function, you need to register the configuration, specifying 
the full path to the startup script. Call this new configuration 
wpia1
. From an ele-
vated PowerShell session, run the following command to create the endpoint:
PS (2) > Register-PSSessionConfiguration -Name wpia1 ` 
>>   -StartupScript $pwd/Initialize-HMConfiguration.ps1 -Force 
>>
WSManConfig: Microsoft.WSMan.Management\WSMan::localhost\Plugin
Name                      Type                 Keys 
----                      ----                 ----
wpia1                     Container            {Name=wpia1}
The output of the command shows that you’ve created an endpoint in the 
WSM
an 
plug-in folder. To confirm this, 
cd
into that folder and run the 
dir
command:
PS (3) > cd  wsman:\localhost\plugin 
PS (4) > dir
WSManConfig: Microsoft.WSMan.Management\WSMan::localhost\Plugin
Name                      Type                 Keys 
----                      ----                 ----
Event Forwarding Plugin   Container            {Name=Event Fo... 
microsoft.powershell      Container            {Name=microsof... 
Microsoft.PowerShell32    Container            {Name=Microsof... 
WMI Provider              Container            {Name=WMI Prov... 
wpia1                     Container            {Name=wpia1}
This shows a list of all the existing endpoints, including the one you just created, 
wpia1
. Now test this endpoint with the 
Invoke-Command
command and run the 
function defined by the startup script:
PS (5) > Invoke-Command localhost -ConfigurationName wpia1 { 
>>  Get-PageFaultRate } 
58709002
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. C# File: Split PDF; C# Page: Insert PDF pages
move pages in pdf file; pdf move pages
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the position of certain one PowerPoint page in an
change page order in pdf reader; change page order pdf preview
B
UILDING
CUSTOM
REMOTING
SERVICES
533
This code verifies that the endpoint exists and is properly configured. Now clean up 
by unregistering the endpoint:
PS (6) > Unregister-PSSessionConfiguration -Name wpia1 -Force 
PS (7) >
Next, verify that the endpoint has been removed:
PS (8) > dir
WSManConfig: Microsoft.WSMan.Management\WSMan::localhost\Plugin
Name                      Type                 Keys 
----                      ----                 ----
Event Forwarding Plugin   Container            {Name=Event Fo... 
microsoft.powershell      Container            {Name=microsof... 
Microsoft.PowerShell32    Container            {Name=Microsof... 
WMI Provider              Container            {Name=WMI Prov...
This covers the basic tasks needed to create a custom PowerShell remoting endpoint 
using a configuration script to add additional functionality to the session defaults. 
Our ultimate goal, though, was to create a custom endpoint with reduced functional-
ity, exposing a restricted set of commands to qualified users, so clearly you aren’t done 
yet. There are two remaining pieces to look at: controlling individual command visi-
bility, which we’ll get to in section 13.2.5, and controlling overall access to the end-
point, our next topic.
13.2.4
Access controls and endpoints
By default, only members of the Administrators group on a computer have permis-
sion to use the default session configurations. To allow users who aren’t part of the 
Administrators group to connect to the local computer, you have to give those users 
Execute permissions on the session configurations for the desired endpoint on the 
target computer. For example, if you want to enable nonadministrators to connect to 
the default remoting 
Microsoft.PowerShell
endpoint, you can do so by running 
the following command:
Set-PSSessionConfiguration Microsoft.PowerShell -ShowSecurityDescriptorUI
This code launches the dialog box shown in figure 13.8.
You add the name of a user or a group you want to enable to the list, then select 
the Execute (Invoke) check box. Then dismiss the dialog box by clicking 
OK
. At this 
point, you’ll get a prompt telling you that you need to restart the 
W
in
RM
service 
for the change to take effect. Do so by running 
Restart-Service winrm
as shown:
PS (1) > Restart-Service winrm 
PS (2) >
Once the service is restarted, the user or group you’ve enabled can connect to the 
machine using remoting.
C# Word - Sort Word Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Word document pages, or just change the position of certain one Word page in an
reorder pages in pdf reader; reordering pages in pdf document
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page from PDF file and changing the position, orientation and order of PDF file into two or small files, you may refer to this online guide. PDF Page inserting.
rearrange pages in pdf file; how to move pages within a pdf document
534
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
Setting security descriptors on configurations
When 
Enable-PSRemoting
creates the default session configuration, it doesn’t create 
explicit security descriptors for the configurations. Instead, the configurations inherit 
the security descriptor of the 
RootSDDL
. The 
RootSDDL
is the security descriptor that 
controls remote access to the listener, which is secure by default. To see the 
RootSDDL 
security descriptor, run the 
Get-Item
command as shown:
PS (1) > Get-Item wsman:\localhost\Service\RootSDDL
WSManConfig: Microsoft.WSMan.Management\WSMan::localhost\Service
WARNING: column "Type" does not fit into the display and was removed.
Name                      Value 
----                      -----
RootSDDL                  O:NSG:BAD:P(A;;GA;;;BA)S:P(AU;FA;GA;;;WD...
The string format shown in the 
Value
output in the example uses the syntax defined 
by the Security Descriptor Definition Language 
(SDDL)
, which is documented in the 
Windows Data Types specification 
MS-DTYP
in section 2.5.1.
Figure 13.8 This dialog box is 
used to enable the Execute per-
mission on the default remoting 
configuration. Use this dialog 
box to allow a user who isn’t a 
member of the Administrators 
group to connect to this comput-
er using PowerShell remoting.
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using Change PDF original password. VB.NET: Necessary DLLs for PDF Password Edit.
reorder pages in pdf file; rearrange pages in pdf online
C# PDF Password Library: add, remove, edit PDF file password in C#
Able to change password on adobe PDF document in C# in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve
change pdf page order preview; pdf reorder pages online
B
UILDING
CUSTOM
REMOTING
SERVICES
535
To change the 
RootSDDL
, use the 
Set-Item
cmdlet in the 
WSM
an: drive. To 
change the security descriptor for an existing session configuration, use the 
Set-
PSSessionConfiguration
cmdlet with the 
-SecurityDescriptorSDDL
or 
-ShowSecurityDescriptorUI 
parameter. 
At this point, you know how to create and configure an endpoint and how to con-
trol who has access to that endpoint. But in your configuration all you’ve done is add 
new commands to the set of commands you got by default. You haven’t addressed 
the requirement to constrain the environment. The next section introduces the mech-
anisms used to restrict which commands are visible to the remote user.
13.2.5
Constraining a PowerShell session
You first need to know how to constrain a local session. In a constrained environ-
ment, you want to limit the variables and commands available to the user of the ses-
sion. You accomplish this by controlling command and variable visibility. Let’s look at 
command visibility first. 
Command and variable visibility is conceptually similar to exporting functions 
from a module, but it uses a different implementation. When a command is exported 
from a module, it’s registered in the caller’s command table. In the remoting scenario 
with 
Invoke-Command
, there’s no “table” to copy the commands into and so you 
need a different mechanism to control visibility of the command.
NOTE
The same is true of explicit remoting and interactive remoting. 
With implicit remoting, you do copy commands into the caller’s com-
mand table, but they’re local proxy commands instead of local refer-
ences to exported commands.
Another more important consideration is security. Module exports are designed to 
prevent namespace collisions but don’t prevent you from accessing the content of the 
module. In other words, it’s not a security boundary, as shown in figure 13.9.
In  figure  13.9,  the  user can’t call 
Get-Count
directly because it hasn’t been 
exported from the module. But by using the call operator 
&
and the 
PSModuleInfo 
object for that module, users can still indirectly invoke the command with a script-
block, illustrating that a module boundary doesn’t constitute a security boundary.
In a constrained session, you need to establish a boundary and explicitly prevent 
access to the state of the session other than through the public or visible commands. 
Now that you’ve defined the boundary, let’s look at controlling which commands are 
exposed.
NOTE
In local sessions, where the user operates in the same process as 
the session, the session boundary isn’t sufficient to provide a true secu-
rity. Only when you combine a constrained session with remote (and 
therefore out-of-process) access do you actually get a security boundary.
536
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
Controlling command visibility
The mechanism used to control command visibility is the 
Visibility
property on 
the 
CommandInfo
object for that command. This mechanism isn’t restricted to 
remoting, by the way—you can use this mechanism in the normal interactive Power-
Shell session. In fact, it’s a good way of testing your configuration without creating an 
endpoint.
To  make  a  command  invisible  or  private,  first  use 
Get-Command
to get the 
CommandInfo
object, then set the 
Visibility
property on that object to 
Private
You’ll modify your current session to make the 
Get-Date
command private. This is a 
good place to start playing with visibility because hiding 
Get-Date
(typically) won’t 
break anything (more on that later). First, run the command as you might conven-
tionally do:
PS (1) > Get-Date
Saturday, April 16, 2011 9:04:20 PM
This  returns  today’s  date—nothing  unexpected  here.  Now  use 
Get-Command
to 
retrieve the 
CommandInfo
object for 
Get-Date
:
PS (2) > $gd = Get-Command Get-Date
Let’s look at the current setting of the 
Visibility
property:
PS (3) > $gd.Visibility 
Public
It returns 
Public
, meaning it can be seen and therefore executed from outside the 
session. Change this to 
Private
:
PS (4) > $gd.Visibility = "Private"
Module boundary
Accessing a private command in a module
e
Get-Count
& $mc { Get-Count }
External call fails...
Call operator with
module context 
succeeds...
Scriptblock makes an
internal call...
Figure 13.9 Even though the 
Get-Count
command isn’t exported, by 
using the call operator and the 
PSModuleInfo
object for that module, 
the user can still indirectly call the private function. The module bound-
ary only facilitates organizing command namespaces and doesn’t consti-
tute a security boundary.
B
UILDING
CUSTOM
REMOTING
SERVICES
537
Verify the change:
PS (5) > $gd.Visibility
Private
Now try calling the cmdlet again:
PS (6) > Get-Date
The term 'Get-Date' is not recognized as the name of a cmdlet, 
function, script file, or operable program. Check the spelling of 
the name, or if a path was included, verify that the path is 
correct and try again.
At line:1 char:9 
+ Get-Date <<<<
+ CategoryInfo          : ObjectNotFound: (Get-Date:String)
[], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
You got an error complaining that the command doesn’t exist. 
NOTE
Notice that this is the same error you’d get if the command 
really  didn’t  exist.  Obscuring  the  error  message  this  way  prevents 
attacks that probe for hidden commands. We’ll talk more about this 
type of attack in chapter 21 when we discuss security.
Just to be sure, try calling it another way using the call (
&
) operator:
PS (7) > & "Get-Date"
The term 'Get-Date' is not recognized as the name of a cmdlet, 
function, script file, or operable program. Check the spelling of 
the name, or if a path was included, verify that the path is 
correct and try again.
At line:1 char:2 
+ & <<<<  "Get-Date"
+ CategoryInfo          : ObjectNotFound: (Get-Date:String)
[], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
And of course it still fails. But, because you’re a sophisticated PowerShell user, you’ll 
try one more technique: using a scriptblock with the call operator to invoke the com-
mand:
PS (8) > & {Get-Date}
Saturday, April 16, 2011 9:04:20 PM
This time it worked! So what’s going on here? The difference in this case is that the 
external user didn’t call the command directly. Instead, you called a visible func-
tion—the scriptblock—defined inside the session and, because it was calling from 
inside, it was able to call the private function. This is shown in figure 13.10.
This is a very important point to understand because it’s the key to creating a 
restricted  special-purpose  endpoint:  an external  call  can only  access  visible  com-
mands; but these commands, because they’re defined as part of the configuration, can
538
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
see all the other commands in the configuration.  This means that an externally visi-
ble command can call any internal commands in the session. So, if the user makes an 
external  call to a visible command, that visible command is able to call the private 
commands.
These calling  conventions are  very  similar  to the  way  methods on  classes  or 
exported functions work. The external caller of the session/class/module can only call 
the public/exported commands (at least directly) but the private commands  have 
implicit access to the private state of the session/class/module. This means you can 
create a public wrapper function that calls the private function. For example, you can 
create a function 
MyGetDate
that calls 
Get-Date
and then converts the result into a 
string and returns that string. Here’s what that looks like:
PS (9) > function MyGetDate { [string] (Get-Date) }
When you call it, you get the default string representation of the date:
PS (10) > MyGetDate
11/17/2009 22:11:39
Now you’ve officially constrained the session because the 
MyGetDate
wrapper func-
tion has less functionality than the private 
Get-Date
function. There are a couple of 
additional things you need to do to get a truly constrained environment. But first let’s 
make 
Get-Date
visible again. You can do this by setting the 
Visibility
property 
back to 
Public
PS (11) > $gd.Visibility = "public"
PS (12) > Get-Date
Tuesday, November 17, 2009 9:05:59 PM
And everything is back to normal.
Figure 13.10 If the command isn’t visible across the session boundary, the user can’t 
call it. If the user can call a visible command, that visible command can call the private 
internal command.
& { Get-Date }
Internal vs. external command access in a session
Get-Date
Get-Date
Call from inside
& { Get-Date }
User can’t call Get-Date
directly because it’s not visible
outside the session
User can use the call operator
to invoke a scriptblock that
calls Get-Dateindirectly 
PSSession
B
UILDING
CUSTOM
REMOTING
SERVICES
539
It’s not much of a security mechanism if you can just use the properties on the 
command objects to control the visibility of commands. Clearly there needs to be 
more to the story, so in the next section we’ll revisit the restricted language we men-
tioned in section 10.6 when we discussed module manifests and the data language.
Setting the language mode
In the previous section, you learned how to make a command private and then call it 
through a public function. Obviously if you allow external users to create their own 
functions, this won’t be very secure. So the next thing you need to do is constrain 
what PowerShell language features the user has access to. You accomplish this through 
the 
$ExecutionContext
variable. As you saw in chapter 11, 
$ExecutionContext 
captures—well—the execution context of the session. The property of interest in this 
case is 
SessionState
. Let’s see what that property exposes:
PS (1) > $ExecutionContext.SessionState
Drive                         : System.Management.Automation.Dri
veManagementIntrinsics 
Provider                      : System.Management.Automation.Cmd
letProviderManagementIntrinsics 
Path                          : System.Management.Automation.Pat
hIntrinsics 
PSVariable                    : System.Management.Automation.PSV
ariableIntrinsics 
LanguageMode                  : FullLanguage 
UseFullLanguageModeInDebugger : False 
Scripts                       : {*}
Applications                  : {*}
Module                        : 
InvokeProvider                : System.Management.Automation.Pro
viderIntrinsics 
InvokeCommand                 : System.Management.Automation.Com
mandInvocationIntrinsics
And you see a lot of interesting things. Of particular interest are three properties: 
LanguageMode
Scripts
, and 
Applications
.
When we looked at constrain commands in the previous section, you used the 
Visibility
property on the 
CommandInfo
object to make 
Get-Date
private. This 
approach works for commands that exist in memory, but scripts and executables are 
loaded from disk each time, which means that a new 
CommandInfo
object is returned 
each time. Setting the 
Visibility
property won’t be very useful if you’re returning a 
new object each time. Another mechanism is needed for this, and this mechanism is a 
list of permitted commands and scripts. The default setting for these properties is a 
single element, 
*
, which means that any external command or script may be exe-
cuted. If this element is deleted so that the list is empty, it means that no commands 
of this type may be executed. To permit only specific commands to be called, add the 
full path to the command or script to this list.
Documents you may be interested
Documents you may be interested