public NewUserModel(string firstName, string lastName, string username, SecureString password)
{
this.FirstName = firstName;
this.LastName = lastName;
this.Username = username;
this.Password = password;
}
public static SecureString GetSecureStringFromConsole()
{
var password = new SecureString();
Console.Write("Enter Password: ");
while (true)
{
ConsoleKeyInfo cki = Console.ReadKey(true);
if (cki.Key == ConsoleKey.Enter) break;
if (cki.Key == ConsoleKey.Escape)
{
password.Dispose();
return null;
}
if (cki.Key == ConsoleKey.Backspace)
{
if (password.Length != 0)
password.RemoveAt(password.Length - 1);
}
else password.AppendChar(cki.KeyChar);
}
return password;
}
// constructors
public AuthIdentity(string username, SecureString password)
{
Username = null;
UsernameLength = 0;
if (!string.IsNullOrEmpty(username))
{
Username = username;
UsernameLength = username.Length;
}
Password = IntPtr.Zero;
PasswordLength = 0;
if (password != null && password.Length > 0)
{
#if NET45
Password = Marshal.SecureStringToGlobalAllocUnicode(password);
#else
Password = SecureStringMarshal.SecureStringToGlobalAllocUnicode(password);
#endif
PasswordLength = password.Length;
}
Domain = null;
DomainLength = 0;
Flags = AuthIdentityFlag.Unicode;
}
public void OnLogin(string server, int port, string account, SecureString password)
{
m_Login.Client.UserName = account;
m_Login.Client.Password = password;
Manager.CurrentState = new LoggingInState();
}
/// <summary>
/// Create a new SecureString based on the specified binary data.
///
/// The binary data must be byte[] version of unicode char[],
/// otherwise the results are unpredictable.
/// </summary>
///
/// <param name="data"> input data </param>
///
/// <returns> a SecureString </returns>
///
private static SecureString New(byte[] data)
{
if ((data.Length % 2) != 0)
{
// If the data is not an even length, they supplied an invalid key
String error = Serialization.InvalidKey;
throw new PSArgumentException(error);
}
char ch;
SecureString ss = new SecureString();
//
// each unicode char is 2 bytes.
//
int len = data.Length / 2;
for (int i = 0; i < len; i++)
{
ch = (char)(data[2 * i + 1] * 256 + data[2 * i]);
ss.AppendChar(ch);
//
// zero out the data slots as soon as we use them
//
data[2 * i] = 0;
data[2 * i + 1] = 0;
}
return ss;
}
internal static string GetStringFromSecureString(SecureString ss)
{
IntPtr globalAllocUnicode = Marshal.SecureStringToGlobalAllocUnicode(ss);
string stringUni = Marshal.PtrToStringUni(globalAllocUnicode);
Marshal.ZeroFreeGlobalAllocUnicode(globalAllocUnicode);
return stringUni;
}
/// <summary>
/// Performs bytewise comparison of two secure strings.
/// </summary>
/// <param name="valueA"> </param>
/// <param name="valueB"> </param>
/// <returns> True if the strings are equal. </returns>
public static bool Matches(this SecureString valueA, SecureString valueB)
{
if (default(SecureString) == valueA && default(SecureString) == valueB) return true;
if (default(SecureString) == valueA || default(SecureString) == valueB) return false;
if (valueA.Length != valueB.Length) return false;
if (0 == valueA.Length && 0 == valueB.Length) return true;
var ptrA = Marshal.SecureStringToCoTaskMemUnicode(valueA);
var ptrB = Marshal.SecureStringToCoTaskMemUnicode(valueB);
try
{
//parse characters one by one - doesn't change the fact that we have them in memory however...
byte byteA = 1;
byte byteB = 1;
var index = 0;
while (((char) byteA) != '\0' && ((char) byteB) != '\0')
{
byteA = Marshal.ReadByte(ptrA, index);
byteB = Marshal.ReadByte(ptrB, index);
if (byteA != byteB) return false;
index += 2;
}
return true;
}
finally
{
Marshal.ZeroFreeCoTaskMemUnicode(ptrA);
Marshal.ZeroFreeCoTaskMemUnicode(ptrB);
}
}
public SPService(string username, string password, string url)
{
using (ClientContext ctx = new ClientContext(url))
{
var securePassword = new SecureString();
foreach (char c in password)
{
securePassword.AppendChar(c);
}
var onlineCredentials = new SharePointOnlineCredentials(username, securePassword);
ctx.Credentials = onlineCredentials;
web = ctx.Web;
ctx.Load(web);
ctx.ExecuteQuery();
//ctx.GetFormDigestDirect().DigestValue
var authCookie = onlineCredentials.GetAuthenticationCookie(new Uri(url));
//var fedAuthString = authCookie.TrimStart("SPOIDCRL=".ToCharArray());
webinfo = new WebInfo { Title = web.Title, ErrorMessage = "", DigestInfo = authCookie.ToString() };
context = ctx;
}
}
public void SecureStringExtensions_ToByteArray_EmptyInput()
{
SecureString input = new SecureString();
byte[] output = input.ToByteArray();
byte[] expected = new byte[0];
CollectionAssert.AreEqual(expected, output);
}
private static X509Certificate2 GetCertFromPfxFile(string path, SecureString password)
{
X509Certificate2 x509Certificate2 = new X509Certificate2();
string stringFromSecureString = SecurityUtils.GetStringFromSecureString(password);
x509Certificate2.Import(path, stringFromSecureString, X509KeyStorageFlags.DefaultKeySet);
return x509Certificate2;
}
public static SecureString Secure(this string input)
{
var result = new SecureString();
foreach (var c in input) result.AppendChar(c);
result.MakeReadOnly();
return result;
}
public CredToken(string domain, string user, SecureString Password)
{
_usr = user;
_domain = domain;
_pw = Password;
_canImpersonate = false;
}
public void TestOnPremDatasourceEncryptionSQLAuth()
{
SecureString secureString = new SecureString();
string expectedOutput = "My encrypted string " + Guid.NewGuid();
string linkedServiceType = "OnPremisesSqlLinkedService";
string nonCredentialValue = "Driver=mydriver;server=myserver";
string authenticationType = "Basic";
string serverName = null;
string databaseName = null;
var cmdlet = new NewAzureDataFactoryEncryptValueCommand
{
CommandRuntime = this.commandRuntimeMock.Object,
DataFactoryClient = this.dataFactoriesClientMock.Object,
Value = secureString,
ResourceGroupName = ResourceGroupName,
DataFactoryName = DataFactoryName,
GatewayName = GatewayName,
Type = linkedServiceType,
NonCredentialValue = nonCredentialValue,
AuthenticationType = authenticationType,
Server = serverName,
Database = databaseName
};
// Arrange
this.dataFactoriesClientMock.Setup(f => f.OnPremisesEncryptString(secureString, ResourceGroupName, DataFactoryName, GatewayName, null, linkedServiceType, nonCredentialValue, authenticationType, serverName, databaseName)).Returns(expectedOutput);
// Action
cmdlet.ExecuteCmdlet();
// Assert
this.dataFactoriesClientMock.Verify(f => f.OnPremisesEncryptString(secureString, ResourceGroupName, DataFactoryName, GatewayName, null, linkedServiceType, nonCredentialValue, authenticationType, serverName, databaseName), Times.Once());
this.commandRuntimeMock.Verify(f => f.WriteObject(expectedOutput), Times.Once());
}
public IAccessToken Authenticate(
AzureAccount account,
AzureEnvironment environment,
string tenant,
SecureString password,
ShowDialog promptBehavior,
IdentityModel.Clients.ActiveDirectory.TokenCache tokenCache,
AzureEnvironment.Endpoint resourceId = AzureEnvironment.Endpoint.ActiveDirectoryServiceEndpointResourceId)
{
if (account.Id == null)
{
account.Id = "test";
}
if (TokenProvider == null)
{
return new MockAccessToken()
{
AccessToken = account.Id,
LoginType = LoginType.OrgId,
UserId = account.Id
};
}
else
{
return TokenProvider(account, environment, tenant);
}
}
/// <summary>
/// Encrypts a string using the machine's DPAPI
/// </summary>
/// <param name="input">String (SecureString) to encrypt</param>
/// <returns>Encrypted string</returns>
public static string EncryptStringWithDPAPI(System.Security.SecureString input)
{
byte[] encryptedData = System.Security.Cryptography.ProtectedData.Protect(
System.Text.Encoding.Unicode.GetBytes(ToInsecureString(input)), null,
System.Security.Cryptography.DataProtectionScope.LocalMachine);
return(Convert.ToBase64String(encryptedData));
}
public ActionResult Index()
{
User spUser = null;
var url = "https://website/";
var accountName = "accountName";
var password = "******";
var securePassword = new SecureString();
foreach (char c in password)
{
securePassword.AppendChar(c);
}
var onlineCredentials = new SharePointOnlineCredentials(accountName, securePassword);
using (var clientContext = new ClientContext(url))
{
if (clientContext != null)
{
clientContext.Credentials = onlineCredentials;
spUser = clientContext.Web.CurrentUser;
clientContext.Load(spUser, user => user.Title);
clientContext.ExecuteQuery();
ViewBag.UserName = spUser.Title;
}
}
return View();
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
/// <param name="windowService">
/// The window service
/// </param>
/// <param name="addinService">
/// The add-in service
/// </param>
/// <param name="settingsService">
/// The settings service
/// </param>
public MainViewModel(IWindowService windowService, IAddinService addinService, ISettingsService settingsService)
{
this.windowService = windowService;
var projects = settingsService.GetProjects();
var projectModel = projects.FirstOrDefault();
var tt = addinService.TaskTrackers.First();
var qs = tt.GenerateQuerySettings();
if (!projects.Any())
{
projectModel = new ProjectModel("Demo project", tt.Id);
var ss = new SecureString();
ss.AppendChar('H');
ss.AppendChar('e');
ss.AppendChar('l');
ss.AppendChar('l');
ss.AppendChar('o');
var testSettings = new Dictionary<string, SecureString>
{
{ "SomeKey1", ss },
{ "SomeKey2", ss }
};
var projectSettings1 = new SettingsModel(projectModel.InternalUrn, testSettings);
settingsService.SaveProject(projectModel, projectSettings1);
}
var projectSettings2 = settingsService.GetProjectSettings(projectModel);
this.Tasks = new ObservableCollection<ITaskModel>(tt.GetAssignedToUser(projectModel, projectSettings2));
settingsService.SaveProject(projectModel);
}
public static SecureString EnterPassword()
{
SecureString pwd = new SecureString();
while (true)
{
ConsoleKeyInfo i = Console.ReadKey(true);
if (i.Key == ConsoleKey.Enter)
{
break;
}
else if (i.Key == ConsoleKey.Backspace)
{
if (pwd.Length > 0)
{
pwd.RemoveAt(pwd.Length - 1);
Console.Write("\b \b");
}
}
else
{
pwd.AppendChar(i.KeyChar);
Console.Write("*");
}
}
return pwd;
}
public EventLogSession(string server, string domain, string user, SecureString password, SessionAuthentication logOnType)
{
this.renderContextHandleSystem = EventLogHandle.Zero;
this.renderContextHandleUser = EventLogHandle.Zero;
this.handle = EventLogHandle.Zero;
EventLogPermissionHolder.GetEventLogPermission().Demand();
if (server == null)
{
server = "localhost";
}
this.syncObject = new object();
this.server = server;
this.domain = domain;
this.user = user;
this.logOnType = logOnType;
Microsoft.Win32.UnsafeNativeMethods.EvtRpcLogin login = new Microsoft.Win32.UnsafeNativeMethods.EvtRpcLogin {
Server = this.server,
User = this.user,
Domain = this.domain,
Flags = (int) this.logOnType,
Password = CoTaskMemUnicodeSafeHandle.Zero
};
try
{
if (password != null)
{
login.Password.SetMemory(Marshal.SecureStringToCoTaskMemUnicode(password));
}
this.handle = NativeWrapper.EvtOpenSession(Microsoft.Win32.UnsafeNativeMethods.EvtLoginClass.EvtRpcLogin, ref login, 0, 0);
}
finally
{
login.Password.Close();
}
}
/// <summary>
/// Invoke the Enable-AzureServiceProjectRemoteDesktop enableRDCmdlet.
/// </summary>
/// <param name="username">Username.</param>
/// <param name="password">Password.</param>
public static void EnableRemoteDesktop(string username, string password)
{
SecureString securePassword = null;
if (password != null)
{
securePassword = new SecureString();
foreach (char ch in password)
{
securePassword.AppendChar(ch);
}
securePassword.MakeReadOnly();
}
if (enableRDCmdlet == null)
{
enableRDCmdlet = new EnableAzureServiceProjectRemoteDesktopCommand();
if (mockCommandRuntime == null)
{
mockCommandRuntime = new MockCommandRuntime();
}
enableRDCmdlet.CommandRuntime = mockCommandRuntime;
}
enableRDCmdlet.Username = username;
enableRDCmdlet.Password = securePassword;
enableRDCmdlet.EnableRemoteDesktop();
}
/// <summary>
/// Initializes a new instance of the <see cref="Cryptkeeper" /> class.
/// </summary>
/// <param name="passphrase">The encryption key or passphrase represented in a SecureString. This is the preferred method of instantiating this class because it protects the key in memory.</param>
public Cryptkeeper(System.Security.SecureString passphrase)
{
string err = "Cryptkeeper passphrase must be 16 characters (128-bit encryption) or 32 characters (256-bit) in length.";
if (passphrase == null)
{
throw new ApplicationException(err);
}
if (passphrase.Length == 0)
{
throw new ApplicationException(err);
}
if (passphrase.Length > 1 && passphrase.Length <= 16)
{
this.keysize = 128; // 128 bits is 16 bytes or 16 characters in UTF8
this.keyString = passphrase.Copy();
return;
}
if (passphrase.Length > 16 && passphrase.Length <= 32)
{
this.keysize = 256; // 256 bits is 32 bytes or 32 characters in UTF8
this.keyString = passphrase.Copy();
return;
}
if (passphrase.Length > 32)
{
throw new ApplicationException(err);
}
}
public CredToken(string domain, string user, SecureString Password, bool canimpersonate)
{
_usr = user;
_domain = domain;
_pw = Password;
_canImpersonate = canimpersonate;
}
public ActionResult About()
{
Global.globalError1 += "Only World No Hello, ";
using (ClientContext clientContext = new ClientContext("https://stebra.sharepoint.com/sites/sd1"))
{
if (clientContext != null)
{
string userName = "******";
SecureString passWord = new SecureString();
string passStr = "Simoon123";
foreach (char c in passStr.ToCharArray()) passWord.AppendChar(c);
clientContext.Credentials = new SharePointOnlineCredentials(userName, passWord);
new RemoteEventReceiverManager().AssociateRemoteEventsToHostWeb(clientContext);
}
}
// var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
//using (var clientContext = spContext.CreateUserClientContextForSPHost())
//{ new RemoteEventReceiverManager().AssociateRemoteEventsToHostWeb(clientContext); }
ViewBag.RemoteEvent = " Hello globalError: " + Global.globalError + " \n globalError1: " + Global.globalError1;
return View();
}
public byte[] CreateCertificate(SecureString password)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(BaseUri);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.Headers[HttpRequestHeader.Cookie] = "pkild_session=" + Session.SessionID;
using (Stream reqStream = request.GetRequestStream())
using (StreamWriter writer = new StreamWriter(reqStream))
{
String parameters = String.Format("password={0}&confirm_password={0}&submit=create&action_type=pkcs12_cert",
HttpUtility.UrlEncode(password.ConvertToUnsecureString()));
writer.Write(parameters);
parameters.Zero();
}
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode != HttpStatusCode.OK)
throw new Exception("Bad response code: " + response.StatusCode);
if (response.ContentType != "application/x-pkcs12")
return FetchCertificate();
using (Stream responseStream = response.GetResponseStream())
{
byte[] certBytes = new byte[response.ContentLength];
responseStream.Read(certBytes, 0, certBytes.Length);
CertificateState = CertificateState.Present;
return certBytes;
}
}
}
public static bool Compare(SecureString a, SecureString b)
{
if (a == null || b == null)
return a == b;
int length = a.Length;
if (b.Length != length)
return false;
IntPtr _a = IntPtr.Zero;
IntPtr _b = IntPtr.Zero;
try
{
_a = Marshal.SecureStringToBSTR(a);
_b = Marshal.SecureStringToBSTR(b);
for (int i = 0; i < length; i++)
{
if (Marshal.ReadByte(_a, i) != Marshal.ReadByte(_b, i))
return false;
}
return true;
}
finally
{
if (_b != IntPtr.Zero)
Marshal.ZeroFreeBSTR(_b);
if (_a != IntPtr.Zero)
Marshal.ZeroFreeBSTR(_a);
}
}
/// <summary>
/// Constructs a new MingleServer
/// </summary>
/// <param name="hostUrl">Host url</param>
/// <param name="loginName">Login name of the user</param>
/// <param name="password">password</param>
public MingleServer(string hostUrl, string loginName, string password)
{
_host = hostUrl;
_login = loginName;
_password = new SecureString();
foreach (var c in password.ToCharArray()) _password.AppendChar(c);
}
/// <summary>
/// Note: this doesn't keep the SecureString secure.
/// </summary>
/// <param name="writer"></param>
/// <param name="secure"></param>
public static void Write(this BinaryWriter writer, SecureString secure)
{
var bwx = new BinaryWriterEx(writer.BaseStream);
byte[] utf16 = new byte[secure.Length * 2];
var ptr = Marshal.SecureStringToBSTR(secure);
var len = Marshal.ReadInt32(ptr, -4);
for (int i = 0; i < len; i += 2)
{
utf16[i] = Marshal.ReadByte(ptr, i);
}
Marshal.ZeroFreeBSTR(ptr);
byte[] utf8 = UTF8Encoding.Convert(Encoding.Unicode, Encoding.UTF8, utf16);
for (int i = 0; i < utf16.Length; i++)
{
utf16[i] = 0; // clear memory
}
bwx.Write7BitEncodedInt(utf8.Length);
for (int i = 0; i < utf8.Length; i++)
{
bwx.Write(utf8[i]);
utf8[i] = 0;
}
}
/// <summary>
/// This function stores user credentials using the Windows Data Protection API
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
public static void StorePerUserCredentials(string userName, SecureString password, string fileName, string keyName)
{
// Generate additional entropy (will be used as the Initialization vector)
// This is basically the (2048-bit) encryption key used to encrypt the credentials
// The encryption key changes everytime the credentials get stored for increased security (everytime someone logs in with "Remember Me" ticked)
byte[] entropy = new byte[256];
using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
rng.GetBytes(entropy);
}
var currentUserRegistry = Registry.CurrentUser.OpenSubKey("Software\\SystemsUnitedNavy", true);
if (currentUserRegistry == null)
currentUserRegistry = Registry.CurrentUser.CreateSubKey("Software\\SystemsUnitedNavy", RegistryKeyPermissionCheck.Default);
currentUserRegistry.SetValue(keyName, entropy);
var data = ProtectedData.Protect(StringToByteArray(string.Format("{0};#{1}",
userName, SecureStringUtility.SecureStringToString(password))),
entropy,
DataProtectionScope.CurrentUser);
File.WriteAllBytes(fileName, data);
}
public override void Execute(Guid targetInstanceId)
{
var packagesList = Directory.GetFiles(sharedFolder, "*.wsp");
foreach (var packagePath in packagesList)
{
var secureString = new SecureString();
char[] chars = { 'P', 'a', 's', 's', '4', '3', '1', '1' };
foreach (var c in chars)
{
secureString.AppendChar(c);
}
var fileName = new FileInfo(packagePath);
var process = new Process();
process.StartInfo.Domain = "domain";
process.StartInfo.UserName = "******";
process.StartInfo.Password = secureString;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.WorkingDirectory = sharedFolder;
process.StartInfo.FileName = stsadmPath;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
// process.StartInfo.Arguments = "-o deletesolution -name " + packagePath;
process.StartInfo.Arguments = "-o addsolution -filename " + fileName;
process.Start();
this.Title = process.StandardOutput.ReadToEnd();
process.WaitForExit(5000);
this.Update();
}
}
static System.Security.SecureString ReadSecretData()
{
System.Security.SecureString s =
new System.Security.SecureString();
//read in secret data
return(s);
}
static void Main(string[] args)
{
// The SecureString is used with a using statement,
// so the Dispose method is called when you are done with the string
// so that it doesn’t stay in memory any longer then strictly necessary.
using (SecureString ss = new SecureString())
{
Console.WriteLine("Please enter password: "******"*");
}
ss.MakeReadOnly();
Console.WriteLine();
ConvertToUnsecureString(ss);
}
Console.ReadLine();
}
public void SetAzureAutomationCredentialByNameWithParametersSuccessfull()
{
// Setup
string accountName = "automation";
string credentialName = "credential";
string username = "******";
string password = "******";
string description = "desc";
var secureString = new SecureString();
Array.ForEach(password.ToCharArray(), secureString.AppendChar);
secureString.MakeReadOnly();
var value = new PSCredential(username, secureString);
this.mockAutomationClient.Setup(f => f.UpdateCredential(accountName, credentialName, username, password, description));
// Test
this.cmdlet.AutomationAccountName = accountName;
this.cmdlet.Name = credentialName;
this.cmdlet.Description = description;
this.cmdlet.Value = value;
this.cmdlet.ExecuteCmdlet();
// Assert
this.mockAutomationClient.Verify(f => f.UpdateCredential(accountName, credentialName, username, password, description), Times.Once());
}
/// <summary>
/// Encrypts the string with an entropy (salt). Only user that has encrypted the string can decrypt it.
/// </summary>
/// <param name="input">SecureString to be encrypted</param>
/// <returns>encrypted Base64 string</returns>
/// <see cref="https://weblogs.asp.net/jongalloway/encrypting-passwords-in-a-net-app-config-file"/>
public static string EncryptString(System.Security.SecureString input)
{
byte[] encryptedData = ProtectedData.Protect(
System.Text.Encoding.Unicode.GetBytes(ToInsecureString(input)),
Entropy, DataProtectionScope.LocalMachine);
return(Convert.ToBase64String(encryptedData));
}
private static string EncryptString(System.Security.SecureString input)
{
byte[] encryptedData = System.Security.Cryptography.ProtectedData.Protect(
System.Text.Encoding.Unicode.GetBytes(ToInsecureString(input)),
entropy,
System.Security.Cryptography.DataProtectionScope.CurrentUser);
return(Convert.ToBase64String(encryptedData));
}
private SecureString SecurePassword()
{
System.Security.SecureString securePassword = new System.Security.SecureString();
foreach (char c in password)
{
securePassword.AppendChar(c);
}
return(securePassword);
}
/// <summary>
/// 密码加密
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static SecureString PasswordToSecureString(this string obj)
{
System.Security.SecureString ss = new System.Security.SecureString();
obj.ToStringExtension().ToArray().ToList().ForEach(x => {
ss.AppendChar(x);
});
ss.MakeReadOnly();
return(ss);
}
private void RunPowerShellCommand()
{
// the following is Myesha's sample:
string sUser = "";
string sPassword = "";
string sPowerShell_Url = txtURI.Text.Trim();
string sPowerShellUrl = ""; //this.cmboExchangePowerShellUrl.Text.Trim();
System.Security.SecureString securePassword = new System.Security.SecureString();
foreach (char c in sPassword)
{
securePassword.AppendChar(c);
}
PSCredential credential = new PSCredential(sUser, securePassword);
Uri oUri = new Uri(sPowerShellUrl);
WSManConnectionInfo connectionInfo = new WSManConnectionInfo(oUri, sPowerShellUrl, credential);
connectionInfo.SkipCACheck = this.chkSkipCACheck.Checked;
connectionInfo.SkipCNCheck = this.chkSkipCNCheck.Checked;
connectionInfo.SkipRevocationCheck = this.chkSkipRevocationCheck.Checked;
connectionInfo.AuthenticationMechanism = AuthenticationMechanism.Basic;
connectionInfo.MaximumConnectionRedirectionCount = 2;
using (Runspace runspace = RunspaceFactory.CreateRunspace(connectionInfo))
{
runspace.Open();
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = runspace;
//Create the command and add a parameter
powershell.AddCommand("Get-Mailbox");
powershell.AddParameter("RecipientTypeDetails", "UserMailbox");
//Invoke the command and store the results in a PSObject collection
Collection <PSObject> results = powershell.Invoke();
//Iterate through the results and write the DisplayName and PrimarySMTP address for each mailbox
foreach (PSObject result in results)
{
Console.WriteLine(result);
}
Console.Read();
runspace.Close();
}
}
}
static void Main(string[] args)
{
string username = "******";
string password = "******";
System.Security.SecureString securepassword = new
System.Security.SecureString();
foreach (char c in password)
{
securepassword.AppendChar(c);
}
PSCredential credential = new PSCredential(username,
securepassword);
WSManConnectionInfo connectioninfo = new
WSManConnectionInfo(new Uri(
"https://ps.outlook.com/powershell"),
"http://schemas.microsoft.com/powershell/Microsoft.Exchange",
credential);
connectioninfo.AuthenticationMechanism =
AuthenticationMechanism.Basic;
//connectioninfo.AuthenticationMechanism =
AuthenticationMechanism.Basic;
connectioninfo.MaximumConnectionRedirectionCount = 2;
//connectioninfo.MaximumConnectionRedirectionCount = 2;
using (Runspace runspace =
RunspaceFactory.CreateRunspace(connectioninfo))
{
runspace.Open();
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = runspace;
//Create the command and add a parameter
powershell.AddCommand("Get-Mailbox");
powershell.AddParameter("RecipientTypeDetails",
"UserMailbox");
//powershell.
//Invoke the command and store the results in a
PSObject collection
Collection <PSObject> results =
powershell.Invoke();
foreach (PSObject result in results)
{
string createText = string.Format("Name: {0}
Alias: {1} Mail: {2}", result.Properties[
"DisplayName"].Value.ToString(), result.
Properties["Alias"].Value.ToString(),
result.Properties["PrimarySMTPAddress"].
Value.ToString());
System.IO.File.WriteAllText("C:\\User.txt",
createText);
}
}
}
}
public static System.Security.SecureString ToSecureString(this string input)
{
System.Security.SecureString secureString = new System.Security.SecureString();
for (int i = 0; i < input.Length; i++)
{
char c = input[i];
secureString.AppendChar(c);
}
secureString.MakeReadOnly();
return(secureString);
}
//SecureString securedString = new SecureString();
//string plaintext = "";
//plaintext.ToCharArray().ToList().ForEach(securedString.AppendChar);
//string encryptedString = Encrypting.EncryptString(securedString);
public static string EncryptString(System.Security.SecureString input)
{
byte[] encryptedData = System.Security.Cryptography.ProtectedData.Protect(
System.Text.Encoding.Unicode.GetBytes(ToInsecureString(input)),
entropy,
System.Security.Cryptography.DataProtectionScope.LocalMachine);
string encrypted = Convert.ToBase64String(encryptedData);
Array.Clear(encryptedData, 0, encryptedData.Length);
return(encrypted);
}
private void LoginWithPwd(object parameter)
{
var passwordContainer = parameter as PasswordBox;
if (passwordContainer != null)
{
System.Security.SecureString secureString = passwordContainer.SecurePassword;
passwordContainer = null;
SecurePassword = secureString;//update secure string
// _password = ConvertToUnsecureString(secureString);//used only for testing will need to just use a secure string
}
}
internal static System.Security.SecureString BuildSecureStringFromPassword(string password)
{
var passwordSecureString = new System.Security.SecureString();
if (password != null)
{
foreach (char c in password)
{
passwordSecureString.AppendChar(c);
}
}
return(passwordSecureString);
}
public static SecureString ToSecureString(this string value)
{
unsafe
{
fixed(char *value3 = value)
{
SecureString ss = new System.Security.SecureString(value3, value.Length);
ss.MakeReadOnly();
return(ss);
}
}
}
/// <summary>
/// ////////////////////////////////////////////////////////////////////// Test run ////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="args"></param>
void r_u_n(string[] args)
{
Console.WriteLine("Running...");
if (args.Count() == 0)
{
return;
}
System.Security.SecureString a = new System.Security.SecureString();
a.AppendChar('P');
a.AppendChar('r');
a.AppendChar('i');
a.AppendChar('e');
a.AppendChar('s');
a.AppendChar('t'); a.AppendChar('1'); a.AppendChar('.'); a.AppendChar('*'); a.AppendChar('#');
// Configure the process using the StartInfo properties.
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.CreateNoWindow = false;
startInfo.FileName = "c:\\windows\\system32\\xcopy";
//startInfo.FileName = @"C:\TEMP\t.cmd";
string str1 = args[0];
string str2 = args[1];
startInfo.Arguments = "\"" + str1 + "\"" + " " + "\"" + str2 + "\"";
// startInfo.Arguments = @">c:\temp\test" ;
// process.StartInfo.WindowStyle = ProcessWindowStyle.Maximized;
startInfo.WorkingDirectory = @"c:\temp";
startInfo.LoadUserProfile = true;
startInfo.Password = a;
startInfo.Domain = "ctr-pr";
startInfo.UserName = "******";
startInfo.UseShellExecute = false;
using (Process exeProcess = Process.Start(startInfo))
{
exeProcess.WaitForExit(1000);
}
//Process.Start(@"c:\windows\system32\cmd.exe", "ilinks",a, "ctr-pr");
}
/// <summary>
/// Determines whether [the specified secure password] is null or empty
/// </summary>
/// <param name="securePassword">The secure password.</param>
/// <returns><c>true</c> if [is null or empty] [the specified secure password]; otherwise, <c>false</c>.</returns>
public static bool IsNullOrEmpty(this System.Security.SecureString securePassword)
{
if (securePassword == null)
{
return(true);
}
if (securePassword.Length < 1)
{
return(true);
}
return(false);
}
private static System.Security.SecureString ConvertToSecureString(string password)
{
if (password == null)
{
throw new ArgumentNullException("password");
}
System.Security.SecureString ClaveSec = new System.Security.SecureString();
for (int Y = 0; password.Length > Y; Y++)
{
ClaveSec.AppendChar(password[Y]);
}
return(ClaveSec);
}
/// <summary>
/// 密码解密
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static String SecureStringToPassword(this System.Security.SecureString obj)
{
string password = string.Empty;
IntPtr ptr = System.Runtime.InteropServices.Marshal.SecureStringToBSTR(obj);
try
{
password = System.Runtime.InteropServices.Marshal.PtrToStringBSTR(ptr);
}
finally
{
System.Runtime.InteropServices.Marshal.ZeroFreeBSTR(ptr);
}
return(password);
}
public static string ToInsecureString(this System.Security.SecureString input)
{
string result = string.Empty;
System.IntPtr intPtr = System.Runtime.InteropServices.Marshal.SecureStringToBSTR(input);
try
{
result = System.Runtime.InteropServices.Marshal.PtrToStringBSTR(intPtr);
}
finally
{
System.Runtime.InteropServices.Marshal.ZeroFreeBSTR(intPtr);
}
return(result);
}
public static string ShellExecuteWithPath(string ShellCommand, string Path, string Username = "", string Domain = "", string Password = "")
{
if (ShellCommand == null || ShellCommand == "")
{
return("");
}
string ShellCommandName = ShellCommand.Split(' ')[0];
string ShellCommandArguments = "";
if (ShellCommand.Contains(" "))
{
ShellCommandArguments = ShellCommand.Replace(ShellCommandName + " ", "");
}
System.Diagnostics.Process shellProcess = new System.Diagnostics.Process();
if (Username != "")
{
shellProcess.StartInfo.UserName = Username;
shellProcess.StartInfo.Domain = Domain;
System.Security.SecureString SecurePassword = new System.Security.SecureString();
foreach (char c in Password)
{
SecurePassword.AppendChar(c);
}
shellProcess.StartInfo.Password = SecurePassword;
}
shellProcess.StartInfo.FileName = ShellCommandName;
shellProcess.StartInfo.Arguments = ShellCommandArguments;
shellProcess.StartInfo.WorkingDirectory = Path;
shellProcess.StartInfo.UseShellExecute = false;
shellProcess.StartInfo.CreateNoWindow = true;
shellProcess.StartInfo.RedirectStandardOutput = true;
shellProcess.StartInfo.RedirectStandardError = true;
var output = new StringBuilder();
shellProcess.OutputDataReceived += (sender, args) => { output.AppendLine(args.Data); };
shellProcess.ErrorDataReceived += (sender, args) => { output.AppendLine(args.Data); };
shellProcess.Start();
shellProcess.BeginOutputReadLine();
shellProcess.BeginErrorReadLine();
shellProcess.WaitForExit();
return(output.ToString().TrimEnd());
}
/// <summary>
/// Setting The Credentials for Sql Servre Connection.
/// </summary>
/// <param name="strUserName">Sql Username</param>
/// <param name="objPassword">Sql Password</param>
/// <param name="blnIsWindowsAuth">Windows Authentication Active</param>
public void SetCridential(
string strUserName,
System.Security.SecureString objPassword,
bool blnIsWindowsAuth)
{
this.mstrUserName = strUserName;
this.mobjPassword = objPassword;
this.mblnIsWindowsAuth = blnIsWindowsAuth;
if (!mblnIsWindowsAuth)
{
this.mobjCredential = new SqlCredential(mstrUserName, mobjPassword);
}
this.mobjSqlConnectionStringBuilder.IntegratedSecurity = mblnIsWindowsAuth;
}
private string ConvertToUnsecureString(System.Security.SecureString securePassword)
{
if (securePassword == null)
{
return(string.Empty);
}
IntPtr unmanagedString = IntPtr.Zero;
try {
unmanagedString = System.Runtime.InteropServices.Marshal.SecureStringToGlobalAllocUnicode(securePassword);
return(System.Runtime.InteropServices.Marshal.PtrToStringUni(unmanagedString));
} finally {
System.Runtime.InteropServices.Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString);
}
}
static void Main(string[] args)
{
string username = "******";
string password = "******";
System.Security.SecureString securepassword = new System.Security.SecureString();
foreach (char c in password)
{
securepassword.AppendChar(c);
}
PSCredential credential = new PSCredential(username, securepassword);
WSManConnectionInfo connectioninfo = new WSManConnectionInfo(new Uri("https://RemoteServer/OcsPowershell"), "http://schemas.microsoft.com/powershell/Microsoft.PowerShell", credential);
connectioninfo.AuthenticationMechanism = AuthenticationMechanism.Default;
connectioninfo.SkipCACheck = true;
connectioninfo.SkipCNCheck = true;
//connectioninfo.AuthenticationMechanism = AuthenticationMechanism.Basic;
connectioninfo.MaximumConnectionRedirectionCount = 2;
//connectioninfo.MaximumConnectionRedirectionCount = 2;
using (Runspace runspace = RunspaceFactory.CreateRunspace(connectioninfo))
{
runspace.Open();
using (PowerShell powershell = PowerShell.Create())
{
powershell.Runspace = runspace;
//Create the command and add a parameter
powershell.AddCommand("Get-CsUser");
Collection <PSObject> results = powershell.Invoke();
foreach (PSObject result in results)
{
Console.WriteLine(result.Properties["SamaccountName"].Value.ToString());
Console.ReadLine();
}
}
}
}
public static System.Security.SecureString DecryptString(string encryptedData)
{
if (string.IsNullOrEmpty(encryptedData))
{
return(new System.Security.SecureString());
}
System.Security.SecureString result;
try
{
byte[] bytes = ProtectedData.Unprotect(System.Convert.FromBase64String(encryptedData), SettingsProvider.entropy, DataProtectionScope.CurrentUser);
result = System.Text.Encoding.Unicode.GetString(bytes).ToSecureString();
}
catch
{
result = new System.Security.SecureString();
}
return(result);
}
/// <summary>
/// Creates a Secure String
/// </summary>
/// <param name="data">string to be converted</param>
/// <returns>secure string instance</returns>
public static SecureString CreateSecureString(string data)
{
if (data == null || string.IsNullOrEmpty(data))
{
return(null);
}
System.Security.SecureString secureString = new System.Security.SecureString();
char[] charArray = data.ToCharArray();
foreach (char ch in charArray)
{
secureString.AppendChar(ch);
}
return(secureString);
}
public static string EncryptStringWithDPAPI(System.Security.SecureString input, byte[] aditionalEntropy, string scope)
{
byte[] encryptedData = null;
if (scope == "LocalMachine")
{
encryptedData = System.Security.Cryptography.ProtectedData.Protect(
System.Text.Encoding.Unicode.GetBytes(ToInsecureString(input)), aditionalEntropy,
System.Security.Cryptography.DataProtectionScope.LocalMachine);
}
else
{
encryptedData = System.Security.Cryptography.ProtectedData.Protect(
System.Text.Encoding.Unicode.GetBytes(ToInsecureString(input)), aditionalEntropy,
System.Security.Cryptography.DataProtectionScope.CurrentUser);
}
return(Convert.ToBase64String(encryptedData));
}
/// <summary>
/// To the secure string.
/// </summary>
/// <param name="password">The password.</param>
/// <returns>System.Security.SecureString.</returns>
/// <exception cref="ArgumentNullException">password</exception>
public static System.Security.SecureString ToSecureString(this string password)
{
if (password == null)
{
throw new ArgumentNullException("password");
}
unsafe
{
fixed(char *passwordChars = password)
{
var securePassword = new System.Security.SecureString(passwordChars, password.Length);
securePassword.MakeReadOnly();
return(securePassword);
}
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
bool auth;
if (string.IsNullOrEmpty(oAuthToken))
{
if (string.IsNullOrEmpty(AccountID))
{
Console.WriteLine("AccountID:"); AccountID = Console.ReadLine();
}
if (string.IsNullOrEmpty(Username))
{
Console.WriteLine("Username:"******"Paswsword:"); Password = ReadLineAsSecureString();
}
IntPtr stringPointer = Marshal.SecureStringToBSTR(Password);
string strPwd = Marshal.PtrToStringBSTR(stringPointer);
Marshal.ZeroFreeBSTR(stringPointer);
auth = APIClient.Instance.Authenticate(Username, strPwd, AccountID);
}
else
{
auth = APIClient.Instance.Authenticate(oAuthToken);
}
if (auth == true)
{
WriteObject("Connected to RightScale");
WriteObject(auth);
}
else
{
WriteObject("Error connecting to RightScale");
WriteObject(auth);
}
}
public Boolean AuthenticateUser(string username, System.Security.SecureString securePwd)
{//ToDo: implement comparing the SecureString userinput with a plaintext username string
//1)make sure that the username even exists
string TruePwd = null;
TruePwd = fetchtruepwd(username);
Comparepwd(securePwd, TruePwd);
//2)Once the username is confirmed that exists, then fetch the usernames true pwd
//check txt file or make a delta cache file
//3)compare true pwd with Secure String
//3a) if the true and entered credentials are correct then move to the HomeScreen view
return(true);//return true for debug purposes
}
/// <summary>
/// To the insecure string.
/// </summary>
/// <param name="securePassword">The secure password.</param>
/// <returns>System.String.</returns>
/// <exception cref="ArgumentNullException">securePassword</exception>
public static string ToInsecureString(this System.Security.SecureString securePassword)
{
if (securePassword == null)
{
throw new ArgumentNullException("securePassword");
}
IntPtr unmanagedString = IntPtr.Zero;
try
{
unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(securePassword);
return(Marshal.PtrToStringUni(unmanagedString));
}
finally
{
Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString);
}
}
public void ExecuteNonQueryProcedure(string procedureName, System.Collections.Specialized.NameValueCollection parametersCollection)
{
try
{
string password = "******";
var pwdarr = password.ToCharArray();
SecureString securePwd = new SecureString();
foreach (char c in pwdarr)
{
securePwd.AppendChar(c);
}
securePwd.MakeReadOnly();
using (
SqlConnection conn = new SqlConnection(this.db.Database.Connection.ConnectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = procedureName;
cmd.CommandType = CommandType.StoredProcedure;
foreach (var key in parametersCollection.AllKeys)
{
cmd.Parameters.AddWithValue(key, parametersCollection[key]);
}
var result = cmd.ExecuteNonQuery();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}