private RemoteRunspace CreateRunspaceWhenUriParameterSpecified()
{
RemoteRunspace runspace = null;
try
{
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(this.ConnectionUri, this.ConfigurationName, this.Credential) {
AuthenticationMechanism = this.Authentication
};
base.UpdateConnectionInfo(connectionInfo);
connectionInfo.EnableNetworkAccess = (bool) this.EnableNetworkAccess;
runspace = this.CreateTemporaryRemoteRunspace(base.Host, connectionInfo);
}
catch (UriFormatException exception)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception, this.ConnectionUri);
}
catch (InvalidOperationException exception2)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception2, this.ConnectionUri);
}
catch (ArgumentException exception3)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception3, this.ConnectionUri);
}
catch (PSRemotingTransportException exception4)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception4, this.ConnectionUri);
}
catch (NotSupportedException exception5)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception5, this.ConnectionUri);
}
return runspace;
}
public WSManConnectionInfo ExchangeScriptInit()
{
try
{
var SHELL_URI = "http://schemas.microsoft.com/powershell/Microsoft.Exchange";
// 邮件服务器地址赋值
//System.Uri serverUri = new Uri(String.Format("http://Xd-svr0185.xd-ad.com.cn/PowerShell", @"xd-ad\admin"));
//System.Uri serverUri = new Uri(String.Format("http://exchangedag.xd-ad.com.cn/PowerShell", @"xd-ad\admin"));
//var serverUri =new Uri(string.Format("http://" + _expath + "/PowerShell", @"" + _exadmin + ""));
var serverUri = new Uri(string.Format("http://" + _exIp + "/PowerShell"));
PSCredential creds;
//在内存中加密字符串
var securePassword = new SecureString();
foreach (var c in _expwd)
{
securePassword.AppendChar(c);
}
//creds = new PSCredential(@"xd-ad\admin", securePassword);
// 生成凭证（根据exchange的管理员用户名和密码）
creds = new PSCredential(@"" + _exadmin + "", securePassword);
// 生成一个连接类型，传入exchange服务器IP、将要使用的Scheme以及管理员凭据
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(serverUri, SHELL_URI, creds);
return(connectionInfo);
}
catch (Exception)
{
return(null);
}
#endregion
}
public void Connect(PSCredential credentials, CultureInfo sessionUiCulture)
{
this.CheckDisposed();
try
{
Dns.GetHostEntry(this.targetServer);
}
catch (SocketException ex)
{
throw new CouldNotResolveServerException(this.targetServer, ex, ex);
}
Uri uri = null;
string shellUri = "http://schemas.microsoft.com/powershell/Microsoft.Exchange";
switch (this.connectionType)
{
case PowershellConnectionType.WSMan:
uri = new Uri(string.Format("{0}{1}/wsman", this.useSSL ? "https://" : "http://", this.targetServer));
shellUri = "http://schemas.microsoft.com/powershell/Microsoft.PowerShell";
break;
case PowershellConnectionType.OnPrem:
this.useSSL = false;
uri = new Uri(string.Format("{0}{1}/powershell?serializationLevel=Full", this.useSSL ? "https://" : "http://", this.targetServer));
break;
case PowershellConnectionType.Tenant:
{
string uriString = string.Format("{0}{1}/powershell-liveid?serializationLevel=Full", this.useSSL ? "https://" : "http://", this.targetServer);
uri = new Uri(uriString);
break;
}
}
WSManConnectionInfo wsmanConnectionInfo = new WSManConnectionInfo(uri, shellUri, credentials);
if (this.connectionType == PowershellConnectionType.Tenant)
{
wsmanConnectionInfo.AuthenticationMechanism = AuthenticationMechanism.Basic;
}
else if (this.connectionType == PowershellConnectionType.OnPrem)
{
wsmanConnectionInfo.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
}
PowershellHostUI hostUI = new PowershellHostUI();
RemotePowershellHost host = new RemotePowershellHost(hostUI);
wsmanConnectionInfo.Culture = sessionUiCulture;
wsmanConnectionInfo.MaximumConnectionRedirectionCount = 5;
this.runspace = RunspaceFactory.CreateRunspace(host, wsmanConnectionInfo);
this.logger.LogInformation(HybridStrings.HybridInfoOpeningRunspace(uri.ToString()));
try
{
this.runspace.Open();
}
catch (PSRemotingTransportException ex2)
{
throw new CouldNotOpenRunspaceException(ex2, ex2);
}
this.openedRunspace = true;
}
public static WSManConnectionInfo ExchangeScriptInit()
{
var _exIp = "win-2ickeabl4tr.test.com";
//var _exIp = "Localhost";
var _exadmin = "*****@*****.**";
var _expwd = "P@ssw0rd";
try {
var SHELL_URI = "http://schemas.microsoft.com/powershell/Microsoft.Exchange";;
// 邮件服务器地址赋值
//System.Uri serverUri = new Uri(String.Format("http://Xd-svr0185.xd-ad.com.cn/PowerShell";, @"xd-ad\admin"));
//System.Uri serverUri = new Uri(String.Format("http://exchangedag.xd-ad.com.cn/PowerShell";, @"xd-ad\admin"));
//var serverUri =new Uri(string.Format("http://"; + _expath + "/PowerShell", @"" + _exadmin + ""));
var serverUri = new Uri(string.Format("http://"; +_exIp + "/PowerShell"));
PSCredential creds;
//在内存中加密字符串
var securePassword = new SecureString();
foreach (var c in _expwd)
{
securePassword.AppendChar(c);
}
//creds = new PSCredential(@"xd-ad\admin", securePassword);
// 生成凭证（根据exchange的管理员用户名和密码）
creds = new PSCredential(@"" + _exadmin + "", securePassword);
// 生成一个连接类型，传入exchange服务器IP、将要使用的Scheme以及管理员凭据
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(serverUri, SHELL_URI, creds);
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
return(connectionInfo);
} catch (Exception) {
return(null);
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
try
{
if (isConnected)
{
disconnect();
}
}
catch { }
connectionInfo = null;
Username = null;
Password = null;
Hostname = null;
if (Client != null)
{
Client.Dispose();
}
if (remoteRunspace != null)
{
remoteRunspace.Dispose();
}
}
public IEnumerable <dynamic> Execute(ServerConfig server, string commandOrScript,
Action <PowerShellModulesToLoad> modulesToLoad = null, IEnumerable <CommandParameter> parameters = null,
bool logOutput = true)
{
var folders = new RemoteScriptFolders(server);
var modules = new PowerShellModulesToLoad();
if (modulesToLoad != null)
{
modulesToLoad(modules);
}
var remoteCredential = new PSCredential(server.DeploymentUser.UserName,
GetPasswordAsSecString(server.DeploymentUser.Password));
var connectionInfo = new WSManConnectionInfo(server.PowerShell.SSL, server.Name, ResolvePort(server), "/wsman",
SHELL_URI,
remoteCredential);
if (UseCredSSP)
{
using (new CredSSPHandler(connectionInfo, server))
{
return(ExecuteCommand(commandOrScript, connectionInfo, modules, folders, parameters, logOutput));
}
}
return(ExecuteCommand(commandOrScript, connectionInfo, modules, folders, parameters, logOutput));
}
public async Task<bool> InvokeAsync(WSManConnectionInfo ws)
{
try
{
using (var runspace = RunspaceFactory.CreateRunspace(ws))
using (var powershell = PowerShell.Create())
{
runspace.Open();
powershell.Runspace = runspace;
powershell.AddCommand(Command); // [dvalles] 20220601: Change .AddScript -> .AddCommand (AddScript is obsolete)
Results = await Task.Factory.FromAsync(powershell.BeginInvoke(), pResult => powershell.EndInvoke(pResult));
if (powershell.HadErrors)
{
throw powershell.Streams.Error[0].Exception;
}
return true;
}
}
catch (Exception ex)
{
//return false;
throw ex;
}
}
internal static bool CompareConnectionUri(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
if (string.Compare(connectionInfo2.Scheme, connectionInfo1.Scheme, StringComparison.OrdinalIgnoreCase) == 0)
{
if (string.Compare(connectionInfo2.ComputerName, connectionInfo1.ComputerName, StringComparison.OrdinalIgnoreCase) == 0)
{
if (string.Compare(connectionInfo2.AppName, connectionInfo1.AppName, StringComparison.OrdinalIgnoreCase) == 0)
{
if (connectionInfo2.Port == connectionInfo1.Port)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
/// <summary>
/// Creates a new class and stores the passed values containing connection information
/// </summary>
/// <param name="uri">The URI to the Exchange powershell virtual directory</param>
/// <param name="username">DOMAIN\Username to authenticate with</param>
/// <param name="password">Password for the domain user</param>
/// <param name="isKerberos">True if using kerberos authentication, False if using basic authentication</param>
/// <param name="domainController">The domain controller to communicate with</param>
public ExchPowershell()
{
try
{
// Retrieve the settings from the database
SchedulerRetrieve.GetSettings();
// Set our domain controller to communicate with
this.domainController = Config.PrimaryDC;
// Get the type of Exchange connection
bool isKerberos = false;
if (Config.ExchangeConnectionType == Enumerations.ConnectionType.Kerberos)
isKerberos = true;
// Create our connection
this.wsConn = GetConnection(Config.ExchangeURI, Config.Username, Config.Password, isKerberos);
// Create our runspace
runspace = RunspaceFactory.CreateRunspace(wsConn);
// Open our connection
runspace.Open();
}
catch (Exception ex)
{
// ERROR
logger.Fatal("Unable to establish connection to Exchange.", ex);
}
}
// Отключение ActiveSync и WebApp у пользователя
private void DisableActiveSyncWebAppPS(string userLogin, string mailServerAdr, string login, SecureString password, ref string errorMsg)
{
PSCredential credential = new PSCredential(login, password);
WSManConnectionInfo connectionInfo = new WSManConnectionInfo((new Uri(mailServerAdr)), "http://schemas.microsoft.com/powershell/Microsoft.Exchange", credential);
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
Runspace runspace = System.Management.Automation.Runspaces.RunspaceFactory.CreateRunspace(connectionInfo);
PowerShell powershell = PowerShell.Create();
PSCommand command = new PSCommand();
command.AddCommand("Set-CASMailbox");
command.AddParameter("Identity", userLogin);
command.AddParameter("ActiveSyncEnabled", false);
command.AddParameter("OWAEnabled", false);
powershell.Commands = command;
try
{
runspace.Open();
powershell.Runspace = runspace;
powershell.Invoke();
}
catch (Exception ex)
{
errorMsg = ex.Message;
}
finally
{
runspace.Dispose();
runspace = null;
powershell.Dispose();
powershell = null;
}
}
public CredSSPHandler(WSManConnectionInfo connectionInfo, ServerConfig server)
{
_server = server;
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Credssp;
EnableCredSSP();
}
private static object GetSessionOptions(WSManConnectionInfo wsmanConnectionInfo)
{
Collection <PSObject> collection;
using (PowerShell shell = PowerShell.Create())
{
shell.AddCommand("New-WSManSessionOption");
if (wsmanConnectionInfo.ProxyAccessType != ProxyAccessType.None)
{
shell.AddParameter("ProxyAccessType", "Proxy" + wsmanConnectionInfo.ProxyAccessType.ToString());
shell.AddParameter("ProxyAuthentication", wsmanConnectionInfo.ProxyAuthentication.ToString());
if (wsmanConnectionInfo.ProxyCredential != null)
{
shell.AddParameter("ProxyCredential", wsmanConnectionInfo.ProxyCredential);
}
}
if (wsmanConnectionInfo.IncludePortInSPN)
{
shell.AddParameter("SPNPort", wsmanConnectionInfo.Port);
}
shell.AddParameter("SkipCACheck", wsmanConnectionInfo.SkipCACheck);
shell.AddParameter("SkipCNCheck", wsmanConnectionInfo.SkipCNCheck);
shell.AddParameter("SkipRevocationCheck", wsmanConnectionInfo.SkipRevocationCheck);
shell.AddParameter("OperationTimeout", wsmanConnectionInfo.OperationTimeout);
shell.AddParameter("NoEncryption", wsmanConnectionInfo.NoEncryption);
shell.AddParameter("UseUTF16", wsmanConnectionInfo.UseUTF16);
collection = shell.Invoke();
}
return(collection[0].BaseObject);
}
public bool Execute()
{
var connectionInfo = new WSManConnectionInfo {ComputerName = ComputerName};
using (var runspace = RunspaceFactory.CreateRunspace(connectionInfo))
{
try
{
runspace.Open();
}
catch (System.Management.Automation.Remoting.PSRemotingTransportException ex)
{
MessageBox.Show("Could not connect. Please try run editor as administrator: \n" + ex.Message, "Error",
MessageBoxButton.OK, MessageBoxImage.Error);
return false;
}
using (var ps = PowerShell.Create())
{
ps.Runspace = runspace;
ps.AddScript("'aaa'");
var results = ps.Invoke();
Result = string.Join("\n", results);
}
return true;
}
}
internal static bool CompareConnectionUri(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
if (string.Compare(connectionInfo2.Scheme, connectionInfo1.Scheme, StringComparison.OrdinalIgnoreCase) == 0)
{
if (string.Compare(connectionInfo2.ComputerName, connectionInfo1.ComputerName, StringComparison.OrdinalIgnoreCase) == 0)
{
if (string.Compare(connectionInfo2.AppName, connectionInfo1.AppName, StringComparison.OrdinalIgnoreCase) == 0)
{
if (connectionInfo2.Port == connectionInfo1.Port)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
internal static bool CompareProxySettings(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
if (connectionInfo1.ProxyAccessType == connectionInfo2.ProxyAccessType)
{
if (connectionInfo1.ProxyAccessType != ProxyAccessType.None)
{
if (connectionInfo1.ProxyAuthentication == connectionInfo2.ProxyAuthentication)
{
if (WorkflowUtils.CompareCredential(connectionInfo1.ProxyCredential, connectionInfo2.ProxyCredential))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(true);
}
}
else
{
return(false);
}
}
internal static Collection<PSObject> GetRemotePools(WSManConnectionInfo wsmanConnectionInfo)
{
using (PowerShell shell = PowerShell.Create())
{
shell.AddCommand("Get-WSManInstance");
shell.AddParameter("ResourceURI", "Shell");
shell.AddParameter("Enumerate", true);
shell.AddParameter("ComputerName", wsmanConnectionInfo.ComputerName);
shell.AddParameter("Authentication", ConvertPSAuthToWSManAuth(wsmanConnectionInfo.AuthenticationMechanism));
if (wsmanConnectionInfo.Credential != null)
{
shell.AddParameter("Credential", wsmanConnectionInfo.Credential);
}
if (wsmanConnectionInfo.CertificateThumbprint != null)
{
shell.AddParameter("CertificateThumbprint", wsmanConnectionInfo.CertificateThumbprint);
}
if (wsmanConnectionInfo.PortSetting != -1)
{
shell.AddParameter("Port", wsmanConnectionInfo.Port);
}
if (CheckForSSL(wsmanConnectionInfo))
{
shell.AddParameter("UseSSL", true);
}
if (!string.IsNullOrEmpty(wsmanConnectionInfo.AppName))
{
string str = wsmanConnectionInfo.AppName.TrimStart(new char[] { '/' });
shell.AddParameter("ApplicationName", str);
}
shell.AddParameter("SessionOption", GetSessionOptions(wsmanConnectionInfo));
return shell.Invoke();
}
}
public RemotePowerShell(string remoteHostUri, string username, string password, bool useWSMan = true)
{
RemoteHostUri = remoteHostUri;
Credential = new PSCredential(username, (new NetworkCredential(username, password).SecurePassword));
if (useWSMan)
{
AddTrustedHost(RemoteHostUri);
AllowUnencrypted();
Uri remoteComputerUri = new Uri(string.Format("http://{0}:5985/wsman", remoteHostUri));
WSManConnectionInfo connection = new WSManConnectionInfo(remoteComputerUri,
"http://schemas.microsoft.com/powershell/Microsoft.PowerShell",
Credential);
connection.AuthenticationMechanism = AuthenticationMechanism.Basic;
connection.NoEncryption = true;
connection.SkipCACheck = true;
connection.SkipCNCheck = true;
connection.SkipRevocationCheck = true;
//string shellUri = "http://schemas.microsoft.com/powershell/Microsoft.PowerShell";
//WSManConnectionInfo connectionInfo = new WSManConnectionInfo(false, RemoteHostUri, 5985, "/wsman", shellUri, Credential);
Runspace = RunspaceFactory.CreateRunspace(connection);
Runspace.Open();
Session = PS.Create();
Session.Runspace = Runspace;
}
}
void OpenRemoteSession()
{
UI.ConnectionDialog dialog = new UI.ConnectionDialog("New remote interactive");
if (!dialog.Show())
{
return;
}
string computerName = (dialog.ComputerName.Length == 0 || dialog.ComputerName == ".") ? "localhost" : dialog.ComputerName;
PSCredential credential = null;
if (dialog.UserName.Length > 0)
{
credential = NativeMethods.PromptForCredential(null, null, dialog.UserName, string.Empty, PSCredentialTypes.Generic | PSCredentialTypes.Domain, PSCredentialUIOptions.Default);
if (credential == null)
{
return;
}
}
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(false, computerName, 0, null, null, credential);
EnsureHost();
Runspace = RunspaceFactory.CreateRunspace(FarHost, connectionInfo);
RunspaceOpen();
Editor.Title = "PS " + computerName + " session " + Path.GetFileName(Editor.FileName);
InvokeProfile("Profile-Remote.ps1", true);
}
private RemoteRunspace CreateRunspaceWhenComputerNameParameterSpecified()
{
RemoteRunspace runspace = null;
string computerName = base.ResolveComputerName(this.computerName);
try
{
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(this.UseSSL.IsPresent, computerName, this.Port, this.ApplicationName, this.ConfigurationName, this.Credential)
{
AuthenticationMechanism = this.Authentication
};
base.UpdateConnectionInfo(connectionInfo);
connectionInfo.EnableNetworkAccess = (bool)this.EnableNetworkAccess;
runspace = this.CreateTemporaryRemoteRunspace(base.Host, connectionInfo);
}
catch (InvalidOperationException exception)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception, computerName);
}
catch (ArgumentException exception2)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception2, computerName);
}
catch (PSRemotingTransportException exception3)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception3, computerName);
}
return(runspace);
}
public static void WinRMCodeExecutionNET(Computer computer, PlaybookTask playbook_task, Logger logger)
{
string target = "";
if (!computer.Fqdn.Equals(""))
{
target = computer.Fqdn;
}
else if (!computer.ComputerName.Equals(""))
{
target = computer.ComputerName;
}
else
{
target = computer.IPv4;
}
try
{
var connectTo = new Uri(String.Format("http://{0}:5985/wsman", target));
logger.TimestampInfo(String.Format("Connecting to http://{0}:5985/wsman", target));
var connection = new WSManConnectionInfo(connectTo);
var runspace = RunspaceFactory.CreateRunspace(connection);
runspace.Open();
using (var powershell = PowerShell.Create())
{
powershell.Runspace = runspace;
powershell.AddScript(playbook_task.command);
var results = powershell.Invoke();
runspace.Close();
logger.TimestampInfo(String.Format("Successfully executed {0} using WinRM on {1}", playbook_task.command, computer.ComputerName));
/*
* Console.WriteLine("Return command ");
* foreach (var obj in results.Where(o => o != null))
* {
* Console.WriteLine("\t" + obj);
* }
*/
}
}
catch (Exception ex)
{
if (ex.Message.Contains("Access is denied"))
{
logger.TimestampInfo(String.Format("Failed to start a process using WinRM on {0}. (Access Denied)", computer.Fqdn));
throw new Exception();
}
else if (ex.GetType().ToString().Contains("PSRemotingTransportException"))
{
logger.TimestampInfo(String.Format("Failed to start a process using WinRM on {0}. (Connection Issues)", computer.Fqdn));
throw new Exception();
}
else
{
logger.TimestampInfo(String.Format("Failed to start a process using WinRM on {0}. {1}", computer.Fqdn, ex.GetType()));
throw new Exception();
}
}
}
/// <inheritdoc />
protected CassiaCmdlet()
{
_remoteRunspace = new Lazy <Runspace>(() =>
{
var wsmanConnectionInfo = new WSManConnectionInfo
{
ComputerName = ComputerName,
Credential = Credential
};
wsmanConnectionInfo.SetSessionOptions(new PSSessionOption()
{
IncludePortInSPN = true
});
var remoteRunspace = RunspaceFactory.CreateRunspace(wsmanConnectionInfo);
remoteRunspace.Open();
return(remoteRunspace);
});
var scriptRoot = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ??
throw new InvalidOperationException("Failed to get assembly directory");
var cassiaAssemblyPath = Path.Combine(scriptRoot, "Lib", "Cassia.dll");
CassiaAssemblyBase64 = Convert.ToBase64String(File.ReadAllBytes(cassiaAssemblyPath));
var scriptPath = Path.Combine(scriptRoot, "Scripts", "CassiaCmdlet.ps1");
CassiaAssemblyImportScript = File.ReadAllText(scriptPath);
}
public void Open(string username, string livePass, ref Runspace remoteRunspace)
{
try
{
string uri = "https://outlook.office365.com/powershell-liveid/";
string schema = "http://schemas.microsoft.com/powershell/Microsoft.Exchange";
SecureString password = new SecureString();
foreach (char c in livePass.ToCharArray())
{
password.AppendChar(c);
}
PSCredential psc = new PSCredential(username, password);
WSManConnectionInfo rri = new WSManConnectionInfo(new Uri(uri), schema, psc);
rri.AuthenticationMechanism = AuthenticationMechanism.Basic;
remoteRunspace = RunspaceFactory.CreateRunspace(rri);
remoteRunspace.Open();
}
catch (Exception e)
{
remoteRunspace.Close();
remoteRunspace.Dispose();
throw e;
}
}
/// <summary>
/// Creates a new instance of ClientRemoteSessionImpl
/// </summary>
/// <param name="rsPool">
/// The RunspacePool object this session should map to.
/// </param>
/// <param name="uriRedirectionHandler">
/// </param>
internal ClientRemoteSessionImpl(RemoteRunspacePoolInternal rsPool,
URIDirectionReported uriRedirectionHandler)
{
Dbg.Assert(rsPool != null, "RunspacePool cannot be null");
base.RemoteRunspacePoolInternal = rsPool;
Context.RemoteAddress = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <Uri>(rsPool.ConnectionInfo,
"ConnectionUri", null);
_cryptoHelper = new PSRemotingCryptoHelperClient();
_cryptoHelper.Session = this;
Context.ClientCapability = RemoteSessionCapability.CreateClientCapability();
Context.UserCredential = rsPool.ConnectionInfo.Credential;
// shellName validation is not performed on the client side.
// This is recommended by the WinRS team: for the reason that the rules may change in the future.
Context.ShellName = WSManConnectionInfo.ExtractPropertyAsWsManConnectionInfo <string>(rsPool.ConnectionInfo,
"ShellUri", string.Empty);
MySelf = RemotingDestination.Client;
//Create session data structure handler for this session
SessionDataStructureHandler = new ClientRemoteSessionDSHandlerImpl(this,
_cryptoHelper,
rsPool.ConnectionInfo,
uriRedirectionHandler);
BaseSessionDataStructureHandler = SessionDataStructureHandler;
_waitHandleForConfigurationReceived = new ManualResetEvent(false);
//Register handlers for various ClientSessiondata structure handler events
SessionDataStructureHandler.NegotiationReceived += HandleNegotiationReceived;
SessionDataStructureHandler.ConnectionStateChanged += HandleConnectionStateChanged;
SessionDataStructureHandler.EncryptedSessionKeyReceived +=
new EventHandler <RemoteDataEventArgs <string> >(HandleEncryptedSessionKeyReceived);
SessionDataStructureHandler.PublicKeyRequestReceived +=
new EventHandler <RemoteDataEventArgs <string> >(HandlePublicKeyRequestReceived);
}
public void CreateRemoteSession(string User, string Pass, string Host)
{
SecureString ssLoginPassword = new SecureString();
foreach (char x in Pass)
{
ssLoginPassword.AppendChar(x);
}
PSCredential remoteMachineCredentials = new PSCredential(User, ssLoginPassword);
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(new Uri("http://" + Host + ":5985/wsman"), this.ShellURI, remoteMachineCredentials);
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Negotiate;
Runspace runspace = RunspaceFactory.CreateRunspace(connectionInfo);
runspace.Open();
ps.Runspace = runspace;
/* string Command = "$username = \"" + User + "\";";
* Command += "$password = \"" + Pass + "\";";
* Command += "$secpass = New-Object -TypeName System.Security.SecureString;";
* Command += "$password.ToCharArray() | ForEach-Object {$secstr.AppendChar($_)};";
* Command += "$cred = new-object -typename System.Management.Automation.PSCredential -argumentlist $username, $secpass;";
* Command += "$rsess = New-PSSession -ComputerName " + Host + " -Credential $cred";
* Command += "Enter-PSSession $rsess";
* this.Execute(Command);*/
}
public Runspace GetRunSpace()
{
this.connectionInfo = new WSManConnectionInfo(new Uri(liveIdconnectionUri), URL, PSCredential.Empty);
this.connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Default;
return(RunspaceFactory.CreateRunspace(connectionInfo));
}
private RemoteRunspace CreateTemporaryRemoteRunspace(PSHost host, WSManConnectionInfo connectionInfo)
{
int num;
string name = PSSession.GenerateRunspaceName(out num);
RemoteRunspace runspace = new RemoteRunspace(Utils.GetTypeTableFromExecutionContextTLS(), connectionInfo, host, this.SessionOption.ApplicationArguments, name, num);
runspace.URIRedirectionReported += new EventHandler <RemoteDataEventArgs <Uri> >(this.HandleURIDirectionReported);
this.stream = new ObjectStream();
try
{
runspace.Open();
runspace.ShouldCloseOnPop = true;
}
finally
{
runspace.URIRedirectionReported -= new EventHandler <RemoteDataEventArgs <Uri> >(this.HandleURIDirectionReported);
this.stream.ObjectWriter.Close();
if (runspace.RunspaceStateInfo.State != RunspaceState.Opened)
{
runspace.Dispose();
runspace = null;
}
}
return(runspace);
}
public ICustomActivityResult Execute()
{
string command = "Get-MailboxPermission";
DataTable dt = new DataTable("resultSet");
string shellUri = "http://schemas.microsoft.com/powershell/Microsoft.Exchange";
System.Uri serverUri = new Uri(String.Format("HTTPS://{0}/powershell?serializationLevel=Full", HostName));
System.Security.SecureString securePassword = new System.Security.SecureString();
foreach (char c in Password.ToCharArray())
{
securePassword.AppendChar(c);
}
PSCredential creds = new PSCredential(UserName, securePassword);
RunspaceConfiguration rc = RunspaceConfiguration.Create();
WSManConnectionInfo wsManInfo = new WSManConnectionInfo(serverUri, shellUri, creds);
wsManInfo.SkipCNCheck = true;
wsManInfo.SkipCACheck = true;
using (var runspace = RunspaceFactory.CreateRunspace(wsManInfo))
{
runspace.Open();
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = runspace;
powershell.AddCommand(command);
powershell.Commands.AddParameter("Identity", UserLogonName);
powershell.Commands.AddParameter("ErrorAction", "stop");
Collection <PSObject> results = powershell.Invoke();
bool isFirstEntry = true;
foreach (PSObject obj in results)
{
DataRow dr = dt.NewRow();
foreach (PSPropertyInfo psInfo in obj.Properties)
{
string propertyName = psInfo.Name;
if (isFirstEntry)
{
dt.Columns.Add(propertyName, typeof(String));
}
if (psInfo.Value != null)
{
dr[propertyName] = psInfo.Value;
}
}
isFirstEntry = false;
dt.Rows.Add(dr);
}
}
}
return(this.GenerateActivityResult(dt));
}
public ActionResult About()
{
ViewBag.Message = "";
WSManConnectionInfo connectionInfo = new WSManConnectionInfo();
connectionInfo.ComputerName = "";
Runspace runspace = RunspaceFactory.CreateRunspace();
runspace.Open();
using (PowerShell ps = PowerShell.Create())
{
ps.Runspace = runspace;
ps.AddScript("Get-Process");
var results = ps.Invoke();
// Do something with result ...
foreach (var result in results)
{
ViewBag.Message += result.Members["Id"].Value + " ";
ViewBag.Message += result.Members["ProcessName"].Value + " ";
ViewBag.Message += result.Members["PrivateMemorySize64"].Value + "<br>";
}
}
runspace.Close();
return(View());
}
/// <summary>
/// Create a configured remote runspace from provided name.
/// </summary>
/// <param name="configurationName"></param>
/// <param name="host"></param>
/// <returns></returns>
internal static RemoteRunspace CreateConfiguredRunspace(
string configurationName,
PSHost host)
{
// Create a loop-back remote runspace with network access enabled, and
// with the provided endpoint configurationname.
TypeTable typeTable = TypeTable.LoadDefaultTypeFiles();
var connectInfo = new WSManConnectionInfo();
connectInfo.ShellUri = configurationName.Trim();
connectInfo.EnableNetworkAccess = true;
RemoteRunspace remoteRunspace = null;
try
{
remoteRunspace = (RemoteRunspace)RunspaceFactory.CreateRunspace(connectInfo, host, typeTable);
remoteRunspace.Open();
}
catch (Exception e)
{
throw new PSInvalidOperationException(
StringUtil.Format(RemotingErrorIdStrings.CannotCreateConfiguredRunspace, configurationName),
e);
}
remoteRunspace.IsConfiguredLoopBack = true;
return(remoteRunspace);
}
/// <summary>
/// CompareConnectionUri compares two connection URIs
/// by doing a comparison of elements.
/// </summary>
/// <param name="connectionInfo1">Connection info 1</param>
/// <param name="connectionInfo2">Connection info 2</param>
/// <returns>True if they match else false.</returns>
internal static bool CompareConnectionUri(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
Debug.Assert(connectionInfo1 != null && connectionInfo2 != null, "Connections should be != null");
Debug.Assert(!string.IsNullOrEmpty(connectionInfo1.Scheme) && !string.IsNullOrEmpty(connectionInfo1.ComputerName)
&& !string.IsNullOrEmpty(connectionInfo1.AppName), "Connection URI elements should be != null or empty");
Debug.Assert(!string.IsNullOrEmpty(connectionInfo2.Scheme) && !string.IsNullOrEmpty(connectionInfo2.ComputerName)
&& !string.IsNullOrEmpty(connectionInfo2.AppName), "Connection URI elements should be != null or empty");
if (String.Compare(connectionInfo2.Scheme, connectionInfo1.Scheme, StringComparison.OrdinalIgnoreCase) != 0)
{
return false;
}
if (String.Compare(connectionInfo2.ComputerName, connectionInfo1.ComputerName, StringComparison.OrdinalIgnoreCase) != 0)
{
return false;
}
if (String.Compare(connectionInfo2.AppName, connectionInfo1.AppName, StringComparison.OrdinalIgnoreCase) != 0)
{
return false;
}
if (connectionInfo2.Port != connectionInfo1.Port)
{
return false;
}
return true;
} // CompareConnectionUri ...
/// <summary>
/// CompareConnectionUri compares two connection URIs
/// by doing a comparison of elements.
/// </summary>
/// <param name="connectionInfo1">Connection info 1</param>
/// <param name="connectionInfo2">Connection info 2</param>
/// <returns>True if they match else false.</returns>
internal static bool CompareConnectionUri(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
Debug.Assert(connectionInfo1 != null && connectionInfo2 != null, "Connections should be != null");
Debug.Assert(!string.IsNullOrEmpty(connectionInfo1.Scheme) && !string.IsNullOrEmpty(connectionInfo1.ComputerName) &&
!string.IsNullOrEmpty(connectionInfo1.AppName), "Connection URI elements should be != null or empty");
Debug.Assert(!string.IsNullOrEmpty(connectionInfo2.Scheme) && !string.IsNullOrEmpty(connectionInfo2.ComputerName) &&
!string.IsNullOrEmpty(connectionInfo2.AppName), "Connection URI elements should be != null or empty");
if (String.Compare(connectionInfo2.Scheme, connectionInfo1.Scheme, StringComparison.OrdinalIgnoreCase) != 0)
{
return(false);
}
if (String.Compare(connectionInfo2.ComputerName, connectionInfo1.ComputerName, StringComparison.OrdinalIgnoreCase) != 0)
{
return(false);
}
if (String.Compare(connectionInfo2.AppName, connectionInfo1.AppName, StringComparison.OrdinalIgnoreCase) != 0)
{
return(false);
}
if (connectionInfo2.Port != connectionInfo1.Port)
{
return(false);
}
return(true);
} // CompareConnectionUri ...
} // CompareCertificateThumbprint ...
/// <summary>
/// CompareProxySettings compares the proxy settings for two wsman connections
/// by doing a comparison of elements.
/// </summary>
/// <param name="connectionInfo1">Connection info 1</param>
/// <param name="connectionInfo2">Connection info 2</param>
/// <returns>True if they match else false.</returns>
internal static bool CompareProxySettings(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
Debug.Assert(connectionInfo1 != null && connectionInfo2 != null, "Connections should be != null");
if (connectionInfo1.ProxyAccessType != connectionInfo2.ProxyAccessType)
{
return(false);
}
if (connectionInfo1.ProxyAccessType == ProxyAccessType.None)
{
return(true); //stop here if no proxy access type
}
if (connectionInfo1.ProxyAuthentication != connectionInfo2.ProxyAuthentication)
{
return(false);
}
// check the proxy credentials password
if (!WorkflowUtils.CompareCredential(connectionInfo1.ProxyCredential, connectionInfo2.ProxyCredential))
{
return(false);
}
return(true);
} // CompareProxySettings ...
internal static Collection <PSObject> GetRemotePools(WSManConnectionInfo wsmanConnectionInfo)
{
using (PowerShell shell = PowerShell.Create())
{
shell.AddCommand("Get-WSManInstance");
shell.AddParameter("ResourceURI", "Shell");
shell.AddParameter("Enumerate", true);
shell.AddParameter("ComputerName", wsmanConnectionInfo.ComputerName);
shell.AddParameter("Authentication", ConvertPSAuthToWSManAuth(wsmanConnectionInfo.AuthenticationMechanism));
if (wsmanConnectionInfo.Credential != null)
{
shell.AddParameter("Credential", wsmanConnectionInfo.Credential);
}
if (wsmanConnectionInfo.CertificateThumbprint != null)
{
shell.AddParameter("CertificateThumbprint", wsmanConnectionInfo.CertificateThumbprint);
}
if (wsmanConnectionInfo.PortSetting != -1)
{
shell.AddParameter("Port", wsmanConnectionInfo.Port);
}
if (CheckForSSL(wsmanConnectionInfo))
{
shell.AddParameter("UseSSL", true);
}
if (!string.IsNullOrEmpty(wsmanConnectionInfo.AppName))
{
string str = wsmanConnectionInfo.AppName.TrimStart(new char[] { '/' });
shell.AddParameter("ApplicationName", str);
}
shell.AddParameter("SessionOption", GetSessionOptions(wsmanConnectionInfo));
return(shell.Invoke());
}
}
public bool Execute()
{
var connectionInfo = new WSManConnectionInfo {
ComputerName = ComputerName
};
using (var runspace = RunspaceFactory.CreateRunspace(connectionInfo))
{
try
{
runspace.Open();
}
catch (System.Management.Automation.Remoting.PSRemotingTransportException ex)
{
MessageBox.Show("Could not connect. Please try run editor as administrator: \n" + ex.Message, "Error",
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
using (var ps = PowerShell.Create())
{
ps.Runspace = runspace;
ps.AddScript("'aaa'");
var results = ps.Invoke();
Result = string.Join("\n", results);
}
return(true);
}
}
public CredSSPHandler(WSManConnectionInfo connectionInfo, ServerConfig server)
{
_server = server;
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Credssp;
EnableCredSSP();
}
internal ClientRemoteSessionDSHandlerImpl(ClientRemoteSession session, PSRemotingCryptoHelper cryptoHelper, RunspaceConnectionInfo connectionInfo, ClientRemoteSession.URIDirectionReported uriRedirectionHandler)
{
if (session == null)
{
throw PSTraceSource.NewArgumentNullException("session");
}
this._session = session;
this._stateMachine = new ClientRemoteSessionDSHandlerStateMachine();
this._stateMachine.StateChanged += new EventHandler <RemoteSessionStateEventArgs>(this.HandleStateChanged);
this._connectionInfo = connectionInfo;
this._cryptoHelper = cryptoHelper;
if (this._connectionInfo is NewProcessConnectionInfo)
{
this._transportManager = new OutOfProcessClientSessionTransportManager(this._session.RemoteRunspacePoolInternal.InstanceId, (NewProcessConnectionInfo)this._connectionInfo, cryptoHelper);
}
else
{
this._transportManager = new WSManClientSessionTransportManager(this._session.RemoteRunspacePoolInternal.InstanceId, (WSManConnectionInfo)this._connectionInfo, cryptoHelper, this._session.RemoteRunspacePoolInternal.Name);
}
this._transportManager.DataReceived += new EventHandler <RemoteDataEventArgs>(this.DispatchInputQueueData);
this._transportManager.WSManTransportErrorOccured += new EventHandler <TransportErrorOccuredEventArgs>(this.HandleTransportError);
this._transportManager.CloseCompleted += new EventHandler <EventArgs>(this.HandleCloseComplete);
this._transportManager.DisconnectCompleted += new EventHandler <EventArgs>(this.HandleDisconnectComplete);
this._transportManager.ReconnectCompleted += new EventHandler <EventArgs>(this.HandleReconnectComplete);
this._transportManager.RobustConnectionNotification += new EventHandler <ConnectionStatusEventArgs>(this.HandleRobustConnectionNotification);
WSManConnectionInfo info = connectionInfo as WSManConnectionInfo;
if (info != null)
{
this.uriRedirectionHandler = uriRedirectionHandler;
this.maxUriRedirectionCount = info.MaximumConnectionRedirectionCount;
}
}
private RemoteRunspace CreateRunspaceWhenComputerNameParameterSpecified()
{
RemoteRunspace runspace = null;
string computerName = base.ResolveComputerName(this.computerName);
try
{
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(this.UseSSL.IsPresent, computerName, this.Port, this.ApplicationName, this.ConfigurationName, this.Credential) {
AuthenticationMechanism = this.Authentication
};
base.UpdateConnectionInfo(connectionInfo);
connectionInfo.EnableNetworkAccess = (bool) this.EnableNetworkAccess;
runspace = this.CreateTemporaryRemoteRunspace(base.Host, connectionInfo);
}
catch (InvalidOperationException exception)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception, computerName);
}
catch (ArgumentException exception2)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception2, computerName);
}
catch (PSRemotingTransportException exception3)
{
this.WriteErrorCreateRemoteRunspaceFailed(exception3, computerName);
}
return runspace;
}
/// <summary>
/// Call windows powershell sdk to get mailbox usage details.
/// </summary>
/// <param name="credentials">PSCredential object</param>
/// <param name="liveIDConnectionUri">Live ID connection uri</param>
/// <param name="schemaUri">Schema uri</param>
/// <returns>Returns string array with details of ProhibitSendQuota and TotalItemSize</returns>
public string[] GetMailBoxSizeDetails(PSCredential credentials, string liveIDConnectionUri, string schemaUri)
{
Runspace runspace = null;
string[] mailBoxDetail = new string[2];
try
{
// Create basic connection using PSCredential.
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(new Uri(liveIDConnectionUri), schemaUri, credentials);
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Basic;
runspace = RunspaceFactory.CreateRunspace(connectionInfo);
// Open runspace once user authorized.
runspace.Open();
// Get ProhibitSendQuota value.
Collection <PSObject> prohibitSendQuota = GetProhibitSendQuota(runspace);
foreach (PSObject resultProhibitSendQuota in prohibitSendQuota)
{
foreach (PSPropertyInfo psInfo in resultProhibitSendQuota.Properties)
{
if (psInfo.Name == "ProhibitSendQuota")
{
mailBoxDetail[0] = psInfo.Value.ToString();
break;
}
}
}
// Get TotalItemSize value.
Collection <PSObject> usedQuota = GetUsedQuota(runspace);
foreach (PSObject resultUsedQuota in usedQuota)
{
foreach (PSPropertyInfo psInfoUsedQuota in resultUsedQuota.Properties)
{
if (psInfoUsedQuota.Name == "TotalItemSize")
{
mailBoxDetail[1] = psInfoUsedQuota.Value.ToString();
break;
}
}
}
return(mailBoxDetail);
}
catch (Exception)
{
throw;
}
finally
{
if (runspace != null)
{
runspace.Close();
}
}
}
public ExchPowershell()
{
string uri = string.Format("https://{0}/powershell", ServiceSettings.ExchangeServer);
this._connection = GetConnection(uri, ServiceSettings.Username, ServiceSettings.Password, ServiceSettings.ExchangeConnection == "Kerberos" ? true : false);
_runspace = RunspaceFactory.CreateRunspace(_connection);
_runspace.Open();
_powershell = PowerShell.Create();
_powershell.Runspace = _runspace;
}
internal WSManClientCommandTransportManager(WSManConnectionInfo connectionInfo, IntPtr wsManShellOperationHandle, ClientRemotePowerShell shell, bool noInput, WSManClientSessionTransportManager sessnTM) : base(shell, sessnTM.CryptoHelper, sessnTM)
{
this.wsManShellOperationHandle = wsManShellOperationHandle;
base.ReceivedDataCollection.MaximumReceivedDataSize = connectionInfo.MaximumReceivedDataSizePerCommand;
base.ReceivedDataCollection.MaximumReceivedObjectSize = connectionInfo.MaximumReceivedObjectSize;
this.cmdLine = shell.PowerShell.Commands.Commands.GetCommandStringForHistory();
this.onDataAvailableToSendCallback = new System.Management.Automation.Remoting.PrioritySendDataCollection.OnDataAvailableCallback(this.OnDataAvailableCallback);
this._sessnTm = sessnTM;
sessnTM.RobustConnectionsInitiated += new EventHandler<EventArgs>(this.HandleRobustConnectionsIntiated);
sessnTM.RobustConnectionsCompleted += new EventHandler<EventArgs>(this.HandleRobusConnectionsCompleted);
}
internal Collection<PSObject> InvokeCommand(PSCommand command, ExchContext context)
{
if (context == null)
{
throw new ArgumentNullException("Context", "Parametr not defined. [" + _log.Name + "]");
}
PSCredential _credential = GetPSCredential(context);
WSManConnectionInfo _connection = new WSManConnectionInfo(
new Uri(context.Uri),
"http://schemas.microsoft.com/powershell/Microsoft.Exchange",
_credential);
_connection.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
_connection.MaximumConnectionRedirectionCount = 3;
_connection.SkipCACheck = true;
_connection.SkipCNCheck = true;
using (Runspace _runspace = RunspaceFactory.CreateRunspace(_connection))
{
_runspace.Open();
//_runspace.SessionStateProxy.SetVariable("ErrorActionPreference", "Continue");
using (PowerShell _powershell = PowerShell.Create())
{
_powershell.Commands = command;
try
{
//RunspaceInvoke _invoker = new RunspaceInvoke(_runspace);
//Collection<PSObject> _commandResults = _invoker.Invoke(command.ToString());
_powershell.Runspace = _runspace;
Collection<PSObject> _commandResults = _powershell.Invoke();
CheckErrors(_powershell.Streams.Error);
return _commandResults;
//foreach (PSObject _result in _commandResults)
//{
// Console.WriteLine(_result.ToString());
//}
}
catch (Exception ex)
{
throw new Exception(ex.Message + ". [" + _log.Name + "]");
}
}
}
}
internal WSManClientSessionTransportManager(Guid runspacePoolInstanceId, WSManConnectionInfo connectionInfo, PSRemotingCryptoHelper cryptoHelper, string sessionName) : base(runspacePoolInstanceId, cryptoHelper)
{
this.startMode = WSManTransportManagerUtils.tmStartModes.None;
base.CryptoHelper = cryptoHelper;
base.dataToBeSent.Fragmentor = base.Fragmentor;
this.sessionName = sessionName;
base.ReceivedDataCollection.MaximumReceivedDataSize = null;
base.ReceivedDataCollection.MaximumReceivedObjectSize = connectionInfo.MaximumReceivedObjectSize;
this.onDataAvailableToSendCallback = new System.Management.Automation.Remoting.PrioritySendDataCollection.OnDataAvailableCallback(this.OnDataAvailableCallback);
this.Initialize(connectionInfo.ConnectionUri, connectionInfo);
}
public IEnumerable<dynamic> ExecuteLocal(ServerConfig localServer, string commandOrScript, Action<PowerShellModulesToLoad> modulesToLoad = null, IEnumerable<CommandParameter> parameters = null, bool logOutput = true)
{
var connectionInfo = new WSManConnectionInfo();
var modules = new PowerShellModulesToLoad();
if (modulesToLoad != null)
{
modulesToLoad(modules);
}
var folders = new RemoteScriptFolders(localServer);
return ExecuteCommand(commandOrScript, connectionInfo, modules, folders, parameters, logOutput);
}
internal void UpdateConnectionInfo(WSManConnectionInfo connectionInfo)
{
connectionInfo.SetSessionOptions(this.SessionOption);
if (!base.ParameterSetName.Equals("Uri", StringComparison.OrdinalIgnoreCase))
{
connectionInfo.MaximumConnectionRedirectionCount = 0;
}
if (!this.allowRedirection)
{
connectionInfo.MaximumConnectionRedirectionCount = 0;
}
}
private Collection<WSManConnectionInfo> GetConnectionObjects()
{
Collection<WSManConnectionInfo> collection = new Collection<WSManConnectionInfo>();
if ((base.ParameterSetName == "ComputerName") || (base.ParameterSetName == "ComputerInstanceId"))
{
string str = this.UseSSL.IsPresent ? "https" : "http";
foreach (string str2 in this.ComputerName)
{
WSManConnectionInfo connectionInfo = new WSManConnectionInfo {
Scheme = str,
ComputerName = base.ResolveComputerName(str2),
AppName = this.ApplicationName,
ShellUri = this.ConfigurationName,
Port = this.Port
};
if (this.CertificateThumbprint != null)
{
connectionInfo.CertificateThumbprint = this.CertificateThumbprint;
}
else
{
connectionInfo.Credential = this.Credential;
}
connectionInfo.AuthenticationMechanism = this.Authentication;
this.UpdateConnectionInfo(connectionInfo);
collection.Add(connectionInfo);
}
return collection;
}
if ((base.ParameterSetName == "ConnectionUri") || (base.ParameterSetName == "ConnectionUriInstanceId"))
{
foreach (Uri uri in this.ConnectionUri)
{
WSManConnectionInfo info2 = new WSManConnectionInfo {
ConnectionUri = uri,
ShellUri = this.ConfigurationName
};
if (this.CertificateThumbprint != null)
{
info2.CertificateThumbprint = this.CertificateThumbprint;
}
else
{
info2.Credential = this.Credential;
}
info2.AuthenticationMechanism = this.Authentication;
this.UpdateConnectionInfo(info2);
collection.Add(info2);
}
}
return collection;
}
public static WSManConnectionInfo CreateConnectionInfo(Computer computer, int idleTimeout = 60000, int operationTimeout = 1000, int connectionTimeout = 1000)
{
var wSManConnectionInfo = new WSManConnectionInfo(
false, computer.Name, 5985, "/wsman",
"http://schemas.microsoft.com/powershell/Microsoft.PowerShell", PowerShellSupport.PsCredential)
{
AuthenticationMechanism = AuthenticationMechanism.Default
};
wSManConnectionInfo.IdleTimeout = idleTimeout;
wSManConnectionInfo.OperationTimeout = operationTimeout;
wSManConnectionInfo.OpenTimeout = connectionTimeout;
return wSManConnectionInfo;
}
public static void openRunspace(string uri, string schema, string username, string livePass, ref Runspace remoteRunspace)
{
System.Security.SecureString password = new System.Security.SecureString();
foreach (char c in livePass.ToCharArray())
{
password.AppendChar(c);
}
PSCredential psc = new PSCredential(username, password);
WSManConnectionInfo rri = new WSManConnectionInfo(new Uri(uri), schema, psc);
rri.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
rri.ProxyAuthentication = AuthenticationMechanism.Negotiate;
remoteRunspace = RunspaceFactory.CreateRunspace(rri);
remoteRunspace.Open();
}
/// <summary>
/// Start new object
/// </summary>
/// <param name="uri">Uri to Exchange server powershell directory</param>
/// <param name="username">Username to connect</param>
/// <param name="password">Password to connect</param>
/// <param name="kerberos">True to use Kerberos authentication, false to use Basic authentication</param>
/// <param name="domainController">Domain controller to communicate with</param>
public ExchCmds(string uri, string username, string password, bool kerberos, string domainController)
{
// DEBUG //
this.logger.Debug(string.Format("Opened Exchange powershell class with {0}, {1}, {2}, {3}, {4}", uri, username, password, kerberos.ToString(), domainController));
this.wsConn = GetConnection(uri, username, password, kerberos);
this.domainController = domainController;
// Create our runspace
runspace = RunspaceFactory.CreateRunspace(wsConn);
runspace.ThreadOptions = PSThreadOptions.Default;
// Open the connection
runspace.Open();
}
private Runspace CreateRunspace()
{
if (_powerShellConfiguration.IsRemote)
{
var connectionInfo = new WSManConnectionInfo
{
ComputerName = _powerShellConfiguration.RemoteMachineName,
AuthenticationMechanism = AuthenticationMechanism.Negotiate,
};
return RunspaceFactory.CreateRunspace(connectionInfo);
}
return RunspaceFactory.CreateRunspace();
}
public void Conectar()
{
var securePassword = new SecureString();
foreach (var letra in Password.ToCharArray())
securePassword.AppendChar(letra);
var credenciales = new PSCredential(Username, securePassword);
var rri = new WSManConnectionInfo(false, Servidor, Puerto, "/wsman", Namespace, credenciales);
//rri.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
//rri.ProxyAuthentication = AuthenticationMechanism.Negotiate;
_runspace = RunspaceFactory.CreateRunspace(rri);
_runspace.Open();
}
private List<RemoteRunspace> CreateRunspacesWhenComputerNameParameterSpecified()
{
string[] strArray;
List<RemoteRunspace> list = new List<RemoteRunspace>();
base.ResolveComputerNames(this.ComputerName, out strArray);
base.ValidateComputerName(strArray);
for (int i = 0; i < strArray.Length; i++)
{
try
{
int num2;
WSManConnectionInfo connectionInfo = null;
connectionInfo = new WSManConnectionInfo();
string str = this.UseSSL.IsPresent ? "https" : "http";
connectionInfo.ComputerName = strArray[i];
connectionInfo.Port = this.Port;
connectionInfo.AppName = this.ApplicationName;
connectionInfo.ShellUri = this.ConfigurationName;
connectionInfo.Scheme = str;
if (this.CertificateThumbprint != null)
{
connectionInfo.CertificateThumbprint = this.CertificateThumbprint;
}
else
{
connectionInfo.Credential = this.Credential;
}
connectionInfo.AuthenticationMechanism = this.Authentication;
base.UpdateConnectionInfo(connectionInfo);
connectionInfo.EnableNetworkAccess = (bool) this.EnableNetworkAccess;
string runspaceName = this.GetRunspaceName(i, out num2);
RemoteRunspace item = new RemoteRunspace(Utils.GetTypeTableFromExecutionContextTLS(), connectionInfo, base.Host, this.SessionOption.ApplicationArguments, runspaceName, num2);
list.Add(item);
}
catch (UriFormatException exception)
{
PipelineWriter objectWriter = this.stream.ObjectWriter;
ErrorRecord errorRecord = new ErrorRecord(exception, "CreateRemoteRunspaceFailed", ErrorCategory.InvalidArgument, strArray[i]);
Action<Cmdlet> action = delegate (Cmdlet cmdlet) {
cmdlet.WriteError(errorRecord);
};
objectWriter.Write(action);
}
}
return list;
}
internal IEnumerable<dynamic> ExecuteCommand(string commandOrScript, WSManConnectionInfo connectionInfo, PowerShellModulesToLoad modules, RemoteScriptFolders folders, IEnumerable<CommandParameter> parameters = null, bool logOutput = true)
{
var host = new ConDepPSHost();
using (var runspace = RunspaceFactory.CreateRunspace(host, connectionInfo))
{
runspace.Open();
var ps = PowerShell.Create();
ps.Runspace = runspace;
using (var pipeline = ps.Runspace.CreatePipeline("set-executionpolicy remotesigned -force; $VerbosePreference = 'continue'; $DebugPreference = 'continue'"))
{
ConfigureConDepModule(pipeline, folders, modules);
ConfigureConDepNodeModule(pipeline, folders, modules);
ConfigureConDepDotNetLibrary(pipeline, folders, modules);
ConfigureCommand(commandOrScript, parameters, pipeline);
var result = pipeline.Invoke();
if (pipeline.Error.Count > 0)
{
var errorCollection = new PowerShellErrors();
foreach (var exception in pipeline.Error.NonBlockingRead().OfType<ErrorRecord>())
{
errorCollection.Add(exception.Exception);
}
throw errorCollection;
}
if (logOutput && result.Count > 0)
{
Logger.WithLogSection("Script output", () =>
{
foreach (var psObject in result)
{
Logger.Info(psObject.ToString());
}
});
}
return result;
}
}
}
/// <summary>
/// This sample shows how to use WSManConnectionInfo class to set
/// various timeouts and how to establish a remote connection.
/// </summary>
/// <param name="args">This parameter is not used.</param>
public static void Main(string[] args)
{
// Create a WSManConnactionInfo object using the default constructor
// to connect to the "localHost". The WSManConnectionInfo object can
// also specify connections to remote computers.
WSManConnectionInfo connectionInfo = new WSManConnectionInfo();
// Set the OpertationTimeout property. The OperationTimeout is used to tell
// Windows PowerShell how long to wait (in milliseconds) before timing out
// for any operation. This includes sending input data to the remote computer,
// receiving output data from the remote computer, and more. The user can
// change this timeout depending on whether the connection is to a computer
// in the data center or across a slow WAN.
connectionInfo.OperationTimeout = 4 * 60 * 1000; // 4 minutes.
// Set the OpenTimeout property. OpenTimeout is used to tell Windows PowerShell
// how long to wait (in milliseconds) before timing out while establishing a
// remote connection. The user can change this timeout depending on whether the
// connection is to a computer in the data center or across a slow WAN.
connectionInfo.OpenTimeout = 1 * 60 * 1000; // 1 minute.
// Create a remote runspace using the connection information.
using (Runspace remoteRunspace = RunspaceFactory.CreateRunspace(connectionInfo))
{
// Establish the connection by calling the Open() method to open the runspace.
// The OpenTimeout value set previously will be applied while establishing
// the connection. Establishing a remote connection involves sending and
// receiving some data, so the OperationTimeout will also play a role in this process.
remoteRunspace.Open();
// Add the code to run commands in the remote runspace here. The
// OperationTimeout value set previously will play a role here because
// running commands involves sending and receiving data.
// Close the connection by calling the Close() method to close the remote
// runspace. The Dispose() method (called by using primitive) will call
// the Close() method if it is not already called.
remoteRunspace.Close();
}
}
private WSManConnectionInfo GetConnection(string uri, string username, string password, bool kerberos)
{
SecureString pwd = new SecureString();
foreach (char x in password)
pwd.AppendChar(x);
PSCredential ps = new PSCredential(username, pwd);
WSManConnectionInfo wsinfo = new WSManConnectionInfo(new Uri(uri), "http://schemas.microsoft.com/powershell/Microsoft.Exchange", ps);
wsinfo.SkipCACheck = true;
wsinfo.SkipCNCheck = true;
wsinfo.SkipRevocationCheck = true;
wsinfo.OpenTimeout = 9000;
wsinfo.MaximumConnectionRedirectionCount = 1;
if (kerberos)
wsinfo.AuthenticationMechanism = AuthenticationMechanism.Kerberos;
else
wsinfo.AuthenticationMechanism = AuthenticationMechanism.Basic;
return wsinfo;
}
public IEnumerable<dynamic> Execute(ServerConfig server, string commandOrScript, Action<PowerShellModulesToLoad> modulesToLoad = null, IEnumerable<CommandParameter> parameters = null, bool logOutput = true)
{
var folders = new RemoteScriptFolders(server);
var modules = new PowerShellModulesToLoad();
if (modulesToLoad != null)
{
modulesToLoad(modules);
}
var remoteCredential = new PSCredential(server.DeploymentUser.UserName, GetPasswordAsSecString(server.DeploymentUser.Password));
var connectionInfo = new WSManConnectionInfo(server.PowerShell.SSL, server.Name, ResolvePort(server), "/wsman", SHELL_URI,
remoteCredential);
if (UseCredSSP)
{
using (new CredSSPHandler(connectionInfo, server))
{
return ExecuteCommand(commandOrScript, connectionInfo, modules, folders, parameters, logOutput);
}
}
return ExecuteCommand(commandOrScript, connectionInfo, modules, folders, parameters, logOutput);
}
internal static Collection<PSObject> GetRemoteCommands(Guid shellId, WSManConnectionInfo wsmanConnectionInfo)
{
using (PowerShell shell = PowerShell.Create())
{
shell.AddCommand("Get-WSManInstance");
string str = string.Format(CultureInfo.InvariantCulture, "ShellId='{0}'", new object[] { shellId.ToString().ToUpper(CultureInfo.InvariantCulture) });
shell.AddParameter("ResourceURI", "Shell/Command");
shell.AddParameter("Enumerate", true);
shell.AddParameter("Dialect", "Selector");
shell.AddParameter("Filter", str);
shell.AddParameter("ComputerName", wsmanConnectionInfo.ComputerName);
shell.AddParameter("Authentication", ConvertPSAuthToWSManAuth(wsmanConnectionInfo.AuthenticationMechanism));
if (wsmanConnectionInfo.Credential != null)
{
shell.AddParameter("Credential", wsmanConnectionInfo.Credential);
}
if (wsmanConnectionInfo.CertificateThumbprint != null)
{
shell.AddParameter("CertificateThumbprint", wsmanConnectionInfo.CertificateThumbprint);
}
if (wsmanConnectionInfo.PortSetting != -1)
{
shell.AddParameter("Port", wsmanConnectionInfo.Port);
}
if (CheckForSSL(wsmanConnectionInfo))
{
shell.AddParameter("UseSSL", true);
}
if (!string.IsNullOrEmpty(wsmanConnectionInfo.AppName))
{
string str2 = wsmanConnectionInfo.AppName.TrimStart(new char[] { '/' });
shell.AddParameter("ApplicationName", str2);
}
shell.AddParameter("SessionOption", GetSessionOptions(wsmanConnectionInfo));
return shell.Invoke();
}
}
/// <summary>
/// Disposing
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
wsConn = null;
if (runspace != null)
runspace.Dispose();
}
disposed = true;
}
}
internal static bool CompareProxySettings(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
if (connectionInfo1.ProxyAccessType == connectionInfo2.ProxyAccessType)
{
if (connectionInfo1.ProxyAccessType != ProxyAccessType.None)
{
if (connectionInfo1.ProxyAuthentication == connectionInfo2.ProxyAuthentication)
{
if (WorkflowUtils.CompareCredential(connectionInfo1.ProxyCredential, connectionInfo2.ProxyCredential))
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return true;
}
}
else
{
return false;
}
}
internal static bool CompareOtherWSManSettings(WSManConnectionInfo connectionInfo1, WSManConnectionInfo connectionInfo2)
{
bool hasValue;
bool flag;
if (connectionInfo1.SkipCACheck == connectionInfo2.SkipCACheck)
{
if (connectionInfo1.SkipCNCheck == connectionInfo2.SkipCNCheck)
{
if (connectionInfo1.SkipRevocationCheck == connectionInfo2.SkipRevocationCheck)
{
if (connectionInfo1.UseCompression == connectionInfo2.UseCompression)
{
if (connectionInfo1.UseUTF16 == connectionInfo2.UseUTF16)
{
if (connectionInfo1.MaximumConnectionRedirectionCount == connectionInfo2.MaximumConnectionRedirectionCount)
{
int? maximumReceivedDataSizePerCommand = connectionInfo1.MaximumReceivedDataSizePerCommand;
int? nullable = connectionInfo2.MaximumReceivedDataSizePerCommand;
if (maximumReceivedDataSizePerCommand.GetValueOrDefault() != nullable.GetValueOrDefault())
{
hasValue = true;
}
else
{
hasValue = maximumReceivedDataSizePerCommand.HasValue != nullable.HasValue;
}
if (!hasValue)
{
int? maximumReceivedObjectSize = connectionInfo1.MaximumReceivedObjectSize;
int? maximumReceivedObjectSize1 = connectionInfo2.MaximumReceivedObjectSize;
if (maximumReceivedObjectSize.GetValueOrDefault() != maximumReceivedObjectSize1.GetValueOrDefault())
{
flag = true;
}
else
{
flag = maximumReceivedObjectSize.HasValue != maximumReceivedObjectSize1.HasValue;
}
if (!flag)
{
if (connectionInfo1.NoEncryption == connectionInfo2.NoEncryption)
{
if (connectionInfo1.NoMachineProfile == connectionInfo2.NoMachineProfile)
{
if (connectionInfo1.OutputBufferingMode == connectionInfo2.OutputBufferingMode)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
} // ValidateRemoteRunspacesSpecified
/// <summary>
/// Updates connection info with the data read from cmdlet's parameters and
/// sessions variables.
/// The following data is updated:
/// 1. MaxURIRedirectionCount
/// 2. MaxRecvdDataSizePerSession
/// 3. MaxRecvdDataSizePerCommand
/// 4. MaxRecvdObjectSize
/// </summary>
/// <param name="connectionInfo"></param>
internal void UpdateConnectionInfo(WSManConnectionInfo connectionInfo)
{
Dbg.Assert(connectionInfo != null, "connectionInfo cannot be null.");
connectionInfo.SetSessionOptions(this.SessionOption);
if (!ParameterSetName.Equals(PSRemotingBaseCmdlet.UriParameterSet, StringComparison.OrdinalIgnoreCase))
{
// uri redirection is supported only with URI parameter set
connectionInfo.MaximumConnectionRedirectionCount = 0;
}
if (!_allowRedirection)
{
// uri redirection required explicit user consent
connectionInfo.MaximumConnectionRedirectionCount = 0;
}
}
