public Credential GetCredential() { if (!IsInvalid) { NativeCredential ncred = (NativeCredential)Marshal.PtrToStructure(handle, typeof(NativeCredential)); Credential cred = new Credential { CredentialBlobSize = ncred.CredentialBlobSize, CredentialBlob = Marshal.PtrToStringUni(ncred.CredentialBlob, (int)ncred.CredentialBlobSize / 2), UserName = Marshal.PtrToStringUni(ncred.UserName), TargetName = Marshal.PtrToStringUni(ncred.TargetName), TargetAlias = Marshal.PtrToStringUni(ncred.TargetAlias), Type = ncred.Type, Flags = ncred.Flags, Persist = ncred.Persist }; return(cred); } else { throw new InvalidOperationException("Invalid CriticalHandle!"); } }
internal static NativeCredential GetNativeCredential(Credential cred) { NativeCredential ncred = new NativeCredential(); ncred.AttributeCount = 0; ncred.AttributeCount = 0; ncred.Attributes = IntPtr.Zero; ncred.Comment = IntPtr.Zero; ncred.TargetAlias = IntPtr.Zero; ncred.Type = cred.Type; ncred.Persist = (UInt32)cred.Persist; ncred.CredentialBlobSize = (UInt32)cred.CredentialBlobSize; ncred.TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName); ncred.CredentialBlob = Marshal.StringToCoTaskMemUni(cred.CredentialBlob); ncred.UserName = Marshal.StringToCoTaskMemUni(cred.UserName); // var ncred = new NativeCredential // { // AttributeCount = 0, // Attributes = IntPtr.Zero, // Comment = IntPtr.Zero, // TargetAlias = IntPtr.Zero, // //Type = CRED_TYPE.DOMAIN_PASSWORD, // Type = cred.Type, // Persist = (UInt32)cred.Persist, // CredentialBlobSize = (UInt32)cred.CredentialBlobSize, // TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName), // CredentialBlob = Marshal.StringToCoTaskMemUni(cred.CredentialBlob), // UserName = Marshal.StringToCoTaskMemUni(cred.UserName) // }; return(ncred); }
/// <summary> /// Query the credential cache, get the first one and return username. /// </summary> /// <returns>user name</returns> internal static string FetchDefaultUsername(string headNodeName) { //TODO: SF: headnodeName is a gateway string IntPtr ptr = IntPtr.Zero; try { int count; string filter = string.Format(@"{0}\*", headNodeName); if (CredentialHelper.CredEnumerate(filter, 0, out count, out ptr)) { NativeCredential c = (NativeCredential)Marshal.PtrToStructure(Marshal.ReadIntPtr(ptr), typeof(NativeCredential)); string target = Marshal.PtrToStringUni(c.TargetName); string[] tmp = target.Split(new char[] { '\\' }, 2, StringSplitOptions.RemoveEmptyEntries); return(tmp[1]); } } finally { if (ptr != IntPtr.Zero) { CredFree(ptr); } } return(null); }
public static Credential ToCredential(this NativeCredential nativeCredential) { Credential credential; try { credential = new Credential() { Type = nativeCredential.Type, Flags = nativeCredential.Flags, Persist = (CredPersist)nativeCredential.Persist, UserName = Marshal.PtrToStringUni(nativeCredential.UserName), TargetName = Marshal.PtrToStringUni(nativeCredential.TargetName), TargetAlias = Marshal.PtrToStringUni(nativeCredential.TargetAlias), Comment = Marshal.PtrToStringUni(nativeCredential.Comment), PaswordSize = nativeCredential.CredentialBlobSize, LastWritten = nativeCredential.LastWritten.ToDateTime() }; if (0 < nativeCredential.CredentialBlobSize) { credential.Password = Marshal.PtrToStringUni(nativeCredential.CredentialBlob, (int)nativeCredential.CredentialBlobSize / 2); } } catch (Exception ex) { throw new Exception("PSCredentialManager.Api.CredentialUtility.ConvertToCredential Unable to convert native credential to credential.", ex); } return(credential); }
/// <summary> /// This method derives a NativeCredential instance from a given Credential instance. /// </summary> /// <param name="cred">The managed Credential counterpart containing data to be stored.</param> /// <returns>A NativeCredential instance that is derived from the given Credential /// instance.</returns> internal static NativeCredential GetNativeCredential(Credential cred) { var ncred = new NativeCredential(); ncred.AttributeCount = 0; ncred.Attributes = IntPtr.Zero; ncred.Comment = IntPtr.Zero; ncred.TargetAlias = IntPtr.Zero; ncred.Type = CredTypes.CRED_TYPE_GENERIC; ncred.Persist = (UInt32)cred.Persist; ncred.TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName); var encryptedPassword = EncryptPassword(cred.CredentialBlob); try { ncred.CredentialBlob = Marshal.AllocHGlobal(encryptedPassword.Length); Marshal.Copy(encryptedPassword, 0, ncred.CredentialBlob, encryptedPassword.Length); ncred.CredentialBlobSize = (uint)encryptedPassword.Length; ncred.Type = CredTypes.CRED_TYPE_GENERIC; } finally { Marshal.FreeCoTaskMem(ncred.CredentialBlob); } ncred.UserName = Marshal.StringToCoTaskMemUni(cred.UserName); return(ncred); }
public static NativeCredential ToNativeCredential(this Credential credential) { NativeCredential nativeCredential; try { nativeCredential = new NativeCredential() { AttributeCount = 0, Attributes = IntPtr.Zero, Comment = Marshal.StringToCoTaskMemUni(credential.Comment), TargetAlias = IntPtr.Zero, Type = credential.Type, Persist = (uint)credential.Persist, CredentialBlobSize = credential.PaswordSize, TargetName = Marshal.StringToCoTaskMemUni(credential.TargetName), CredentialBlob = Marshal.StringToCoTaskMemUni(credential.Password), UserName = Marshal.StringToCoTaskMemUni(credential.UserName), LastWritten = credential.LastWritten.ToComFileTime() }; } catch (Exception ex) { throw new Exception("PSCredentialManager.Api.CredentialUtility.ConvertToNativeCredential Unable to convert credential to native credential.", ex); } return(nativeCredential); }
public void Store(string resource, PasswordCredential credential) { // Validations. byte[] byteArray = Encoding.Unicode.GetBytes(credential.Password); // Go ahead with what we have are stuff it into the CredMan structures. Credential cred = new Credential { TargetName = resource, UserName = credential.UserName, CredentialBlob = credential.Password, CredentialBlobSize = (uint)byteArray.Length, AttributeCount = 0, Attributes = IntPtr.Zero, Comment = null, TargetAlias = null, Type = CRED_TYPE.GENERIC, Persist = CRED_PERSIST.LOCAL_MACHINE }; NativeCredential ncred = NativeCredential.GetNativeCredential(cred); // Write the info into the CredMan storage. bool written = CredWrite(ref ncred, 0); int lastError = Marshal.GetLastWin32Error(); if (!written) { string message = "CredWrite failed with the error code " + lastError.ToString(); throw new InvalidOperationException(message); } }
internal Credential GetCredential() { if (!IsInvalid) { // Get the Credential from the mem location NativeCredential nativeCredential = (NativeCredential)Marshal.PtrToStructure(handle, typeof(NativeCredential)); // Create a managed Credential type and fill it with data from the native counterpart. return(new Credential { CredentialBlobSize = nativeCredential.CredentialBlobSize, CredentialBlob = Marshal.PtrToStringUni(nativeCredential.CredentialBlob, (int)nativeCredential.CredentialBlobSize / 2), UserName = Marshal.PtrToStringUni(nativeCredential.UserName), TargetName = Marshal.PtrToStringUni(nativeCredential.TargetName), TargetAlias = Marshal.PtrToStringUni(nativeCredential.TargetAlias), Type = nativeCredential.Type, Flags = nativeCredential.Flags, Persist = (CRED_PERSIST)nativeCredential.Persist }); } else { throw new InvalidOperationException("Invalid CriticalHandle!"); } }
private Credential XlateNativeCred(IntPtr pCred) { NativeCredential ncred = (NativeCredential)Marshal.PtrToStructure(pCred, typeof(NativeCredential)); Credential cred = new Credential(); cred.Type = ncred.Type; cred.Flags = ncred.Flags; cred.Persist = (CRED_PERSIST)ncred.Persist; long LastWritten = ncred.LastWritten.dwHighDateTime; LastWritten = (LastWritten << 32) + ncred.LastWritten.dwLowDateTime; cred.LastWritten = DateTime.FromFileTime(LastWritten); cred.UserName = Marshal.PtrToStringUni(ncred.UserName); cred.TargetName = Marshal.PtrToStringUni(ncred.TargetName); cred.TargetAlias = Marshal.PtrToStringUni(ncred.TargetAlias); cred.Comment = Marshal.PtrToStringUni(ncred.Comment); cred.CredentialBlobSize = ncred.CredentialBlobSize; if (0 < ncred.CredentialBlobSize) { cred.CredentialBlob = Marshal.PtrToStringUni(ncred.CredentialBlob, (int)ncred.CredentialBlobSize / 2); } return(cred); }
internal Credential GetCredential() { if (!IsInvalid) { // Get the Credential from the mem location NativeCredential ncred = (NativeCredential)Marshal.PtrToStructure(handle, typeof(NativeCredential)); // Create a managed Credential type and fill it with data from the native counterpart. Credential cred = new Credential(); cred.CredentialBlobSize = ncred.CredentialBlobSize; cred.CredentialBlob = Marshal.PtrToStringUni(ncred.CredentialBlob, (int)ncred.CredentialBlobSize / 2); cred.UserName = Marshal.PtrToStringUni(ncred.UserName); cred.TargetName = Marshal.PtrToStringUni(ncred.TargetName); cred.TargetAlias = Marshal.PtrToStringUni(ncred.TargetAlias); cred.Type = ncred.Type; cred.Flags = ncred.Flags; cred.Persist = (Persistence)ncred.Persist; return(cred); } else { throw new InvalidOperationException("Invalid CriticalHandle!"); } }
/// <summary> /// 向添加计算机的凭据管理其中添加凭据 /// </summary> /// <param name="key">internet地址或者网络地址</param> /// <param name="userName">用户名</param> /// <param name="secret">密码</param> /// <param name="type">密码类型</param> /// <param name="credPersist"></param> /// <returns></returns> public static int WriteCred(string key, string userName, string secret, CRED_TYPE type, CRED_PERSIST credPersist) { byte[] byteArray = Encoding.Unicode.GetBytes(secret); if (byteArray.Length > 512) { throw new ArgumentOutOfRangeException("The secret message has exceeded 512 bytes."); } Credential cred = new Credential(); cred.TargetName = key; cred.CredentialBlob = secret; cred.CredentialBlobSize = (UInt32)Encoding.Unicode.GetBytes(secret).Length; cred.AttributeCount = 0; cred.Attributes = IntPtr.Zero; cred.UserName = userName; cred.Comment = null; cred.TargetAlias = null; cred.Type = type; cred.Persist = credPersist; #region // var cred = new Credential // { // TargetName = key, // CredentialBlob = secret, // CredentialBlobSize = (UInt32)Encoding.Unicode.GetBytes(secret).Length, // AttributeCount = 0, // Attributes = IntPtr.Zero, // UserName = userName, // Comment = null, // TargetAlias = null, // Type = type, // Persist = credPersist // }; #endregion NativeCredential ncred = NativeCredential.GetNativeCredential(cred); bool written = CredWrite(ref ncred, 0); int lastError = Marshal.GetLastWin32Error(); if (written) { return(0); } string message = ""; if (lastError == 1312) { message = (string.Format(String.Format("Failed to save {0} with error code {{0}}.", key), lastError) + " This error typically occurrs on home editions of Windows XP and Vista. Verify the version of Windows is Pro/Business or higher."); } else { message = string.Format(String.Format("Failed to save {0} with error code {{0}}.", key), lastError); } return(1); }
public void TestSerialize() { //Arrange var nativeCredential = new NativeCredential(userName, properties); // Act var result = nativeCredential.Serialize(); //Assert Assert.AreEqual(serializedNativeCredential, result); }
public void WriteCred(NativeCredential credential) { // Write the info into the CredMan storage. bool written = Imports.CredWrite(ref credential, 0); int lastError = Marshal.GetLastWin32Error(); if (!written) { string message = $"CredWrite failed with the error code {lastError}."; throw new Exception(message); } }
public void TestDeserialize() { //Arrange var nativeCredential = new NativeCredential(); // Act var result = NativeCredential.Deserialize(serializedNativeCredential); //Assert Assert.AreEqual(userName, result.UserID); Assert.AreEqual(properties.Count, result.Properties.Count); Assert.AreEqual(properties[key], result.Properties[key]); }
static private NativeCredential ConvertFrom(string credentialsName, NetworkCredential networkCredential) { var nativeCred = new NativeCredential() { TargetName = credentialsName, UserName = networkCredential.UserName, CredentialBlob = Marshal.StringToCoTaskMemUni(networkCredential.Password), CredentialBlobSize = (UInt32)Encoding.Unicode.GetBytes(networkCredential.Password).Length, Type = 1, //1 - GENERIC Persist = 2 //2 - LOCAL_MACHINE }; return(nativeCred); }
public static void WriteCredential(string credentialName, NetworkCredential credential) { var nativeCred = new NativeCredential { TargetName = credentialName, UserName = credential.UserName, CredentialBlob = Marshal.StringToCoTaskMemUni(credential.Password), CredentialBlobSize = (uint)Encoding.Unicode.GetByteCount(credential.Password), Type = GenericCredential, Persistence = CredentialPersistence.LocalMachine }; CredWrite(ref nativeCred, 0); }
internal static NativeCredential GetNativeCredential(Credential cred) { var ncred = new NativeCredential(); ncred.AttributeCount = 0; ncred.Attributes = IntPtr.Zero; ncred.Comment = IntPtr.Zero; ncred.TargetAlias = IntPtr.Zero; ncred.Type = CRED_TYPE.GENERIC; ncred.Persist = (UInt32)1; ncred.CredentialBlobSize = (UInt32)cred.CredentialBlobSize; ncred.TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName); ncred.CredentialBlob = Marshal.StringToCoTaskMemUni(cred.CredentialBlob); ncred.UserName = Marshal.StringToCoTaskMemUni(Environment.UserName); return ncred; }
internal Credential GetCredential() { if (!IsInvalid) { // Get the Credential from the mem location NativeCredential nativeCredential = (NativeCredential)Marshal.PtrToStructure(handle, typeof(NativeCredential)); // Create a managed Credential type and fill it with data from the native counterpart. Credential credential = nativeCredential.ToCredential(); return(credential); } else { throw new InvalidOperationException("Invalid CriticalHandle!"); } }
internal static NativeCredential GetNativeCredential(Credential cred) { NativeCredential ncred = new NativeCredential(); ncred.AttributeCount = 0; ncred.Attributes = IntPtr.Zero; ncred.Comment = IntPtr.Zero; ncred.TargetAlias = IntPtr.Zero; ncred.Type = CRED_TYPE.GENERIC; ncred.Persist = (UInt32)1; ncred.CredentialBlobSize = (UInt32)cred.CredentialBlobSize; ncred.TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName); ncred.CredentialBlob = Marshal.StringToCoTaskMemUni(cred.CredentialBlob); ncred.UserName = Marshal.StringToCoTaskMemUni(Environment.UserName); return(ncred); }
public Credential[] GetCredentials(int count) { if (IsInvalid) { throw new InvalidOperationException("Invalid CriticalHandle!"); } Credential[] credentials = new Credential[count]; for (int inx = 0; inx < count; inx++) { IntPtr pCred = Marshal.ReadIntPtr(handle, inx * IntPtr.Size); NativeCredential nativeCredential = (NativeCredential)Marshal.PtrToStructure(pCred, typeof(NativeCredential)); Credential credential = nativeCredential.ToCredential(); credentials[inx] = credential; } return(credentials); }
private static void WriteWindowsCredentialManagerEntry(string applicationName, string userName, SecureString securePassword) { var password = SecureStringToString(securePassword); byte[] byteArray = password == null ? null : Encoding.Unicode.GetBytes(password); if (Environment.OSVersion.Version < new Version(6, 1)) { if (byteArray != null && byteArray.Length > 512) { throw new ArgumentOutOfRangeException("password", "The password has exceeded 512 bytes."); } } else { if (byteArray != null && byteArray.Length > 512 * 5) { throw new ArgumentOutOfRangeException("password", "The password has exceeded 2560 bytes."); } } NativeCredential credential = new NativeCredential { AttributeCount = 0, Attributes = IntPtr.Zero, Comment = IntPtr.Zero, TargetAlias = IntPtr.Zero, Type = CRED_TYPE.GENERIC, Persist = (uint)3, CredentialBlobSize = (uint)(byteArray == null ? 0 : byteArray.Length), TargetName = Marshal.StringToCoTaskMemUni(applicationName), CredentialBlob = Marshal.StringToCoTaskMemUni(password), UserName = Marshal.StringToCoTaskMemUni(userName ?? Environment.UserName) }; bool written = CredWrite(ref credential, 0); Marshal.FreeCoTaskMem(credential.TargetName); Marshal.FreeCoTaskMem(credential.CredentialBlob); Marshal.FreeCoTaskMem(credential.UserName); if (!written) { int lastError = Marshal.GetLastWin32Error(); throw new Exception($"CredWrite failed with the error code {lastError}"); } }
internal static NativeCredential GetNativeCredential(Credential cred) { var ncred = new NativeCredential { AttributeCount = 0, Attributes = IntPtr.Zero, Comment = IntPtr.Zero, TargetAlias = IntPtr.Zero, //Type = CRED_TYPE.DOMAIN_PASSWORD,Type=cred.Type, Persist = (UInt32)cred.Persist, CredentialBlobSize = (UInt32)cred.CredentialBlobSize, TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName), CredentialBlob = Marshal.StringToCoTaskMemUni(cred.CredentialBlob), UserName = Marshal.StringToCoTaskMemUni(cred.UserName) }; return(ncred); }
internal static NativeCredential GetNativeCredential(Credential cred) { NativeCredential ncred = new NativeCredential { AttributeCount = 0, Attributes = IntPtr.Zero, Comment = IntPtr.Zero, TargetAlias = IntPtr.Zero, Type = CRED_TYPE.GENERIC, Persist = (UInt32)1, CredentialBlobSize = (UInt32)cred.CredentialBlobSize, TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName), CredentialBlob = Marshal.StringToCoTaskMemUni(cred.CredentialBlob), UserName = Marshal.StringToCoTaskMemUni(Environment.UserName) }; return(ncred); }
internal static void WriteUnformattedCred(string serverName, string userName, SecureString password) { NativeCredential ncred = new NativeCredential(); try { ncred.TargetName = Marshal.StringToCoTaskMemUni(serverName); ncred.UserName = Marshal.StringToCoTaskMemUni(userName); ncred.CredentialBlobSize = (uint)password.Length * 2; ncred.CredentialBlob = Marshal.SecureStringToCoTaskMemUnicode(password); ncred.Persist = (uint)CRED_PERSIST.LOCAL_MACHINE; ncred.Type = CRED_TYPE.GENERIC; ncred.TargetAlias = IntPtr.Zero; ncred.AttributeCount = 0; ncred.Attributes = IntPtr.Zero; ncred.Comment = IntPtr.Zero; if (!CredWrite(ref ncred, 0)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } } finally { if (ncred.UserName != IntPtr.Zero) { Marshal.FreeCoTaskMem(ncred.UserName); } if (ncred.TargetName != IntPtr.Zero) { Marshal.FreeCoTaskMem(ncred.TargetName); } if (ncred.CredentialBlob != IntPtr.Zero) { Marshal.ZeroFreeCoTaskMemUnicode(ncred.CredentialBlob); } } }
/// <summary> /// 向添加计算机的凭据管理其中添加凭据 /// </summary> /// <param name="key">internet地址或者网络地址</param> /// <param name="userName">用户名</param> /// <param name="secret">密码</param> /// <param name="type">密码类型</param> /// <param name="credPersist"></param> /// <returns></returns> public static int WriteCred(string key, string userName, string secret, CRED_TYPE type, CRED_PERSIST credPersist) { var byteArray = Encoding.Unicode.GetBytes(secret); if (byteArray.Length > 512) { throw new ArgumentOutOfRangeException("The secret message has exceeded 512 bytes."); } var cred = new Credential { TargetName = key, CredentialBlob = secret, CredentialBlobSize = (UInt32)Encoding.Unicode.GetBytes(secret).Length, AttributeCount = 0, Attributes = IntPtr.Zero, UserName = userName, Comment = null, TargetAlias = null, Type = type, Persist = credPersist }; var ncred = NativeCredential.GetNativeCredential(cred); var written = CredWrite(ref ncred, 0); var lastError = Marshal.GetLastWin32Error(); if (written) { return(0); } var message = ""; if (lastError == 1312) { message = (string.Format("Failed to save " + key + " with error code {0}.", lastError) + " This error typically occurrs on home editions of Windows XP and Vista. Verify the version of Windows is Pro/Business or higher."); } else { message = string.Format("Failed to save " + key + " with error code {0}.", lastError); } MessageBox.Show(message); return(1); }
protected override void ProcessRecord() { if (MyInvocation.BoundParameters.ContainsKey("Credentials")) { UserName = Credentials.UserName; Password = Credentials.GetNetworkCredential().Password; } //Create credential object Credential credential = new Credential() { TargetName = Target, Password = Password, PaswordSize = (UInt32)Encoding.Unicode.GetBytes(Password).Length, AttributeCount = 0, Attributes = IntPtr.Zero, Comment = Comment, TargetAlias = null, Type = Type, Persist = Persist, UserName = UserName, LastWritten = DateTime.Now, }; //Convert credential to native credential NativeCredential nativeCredential = credential.ToNativeCredential(); CredentialManager credentialManager = new CredentialManager(); try { //Write credential to Windows Credential manager WriteVerbose("Writing credential to Windows Credential Manager"); credentialManager.WriteCred(nativeCredential); WriteObject(credential); } catch (Exception exception) { ErrorRecord errorRecord = new ErrorRecord(exception, "1", ErrorCategory.InvalidOperation, credential); WriteError(errorRecord); } }
/// <summary> /// This method derives a NativeCredential instance from a given Credential instance. /// </summary> /// <param name="cred"> /// The managed Credential counterpart containing data to be stored. /// </param> /// <returns> /// A NativeCredential instance that is derived from the given Credential instance. /// </returns> internal static NativeCredential GetNativeCredential(Credential cred, string target, string passwordAsString) { var ncred = new NativeCredential { AttributeCount = 0, Attributes = IntPtr.Zero, Comment = IntPtr.Zero, TargetAlias = IntPtr.Zero, Type = (uint)CredentialType.CredTypeGeneric, Persist = (uint)Persistance.CredPersistSession, CredentialBlobSize = (uint)Encoding.Unicode.GetBytes(passwordAsString).Length, TargetName = Marshal.StringToCoTaskMemUni(target), CredentialBlob = Marshal.StringToCoTaskMemUni(passwordAsString) }; ncred.UserName = cred.UserName != IntPtr.Zero ? cred.UserName : Marshal.StringToCoTaskMemUni(Environment.UserName); return(ncred); }
/// <summary> /// Write credential to the win cedential set /// </summary> private static void WriteCred(string key, byte[] byteArray) { NativeCredential ncred = new NativeCredential(); GCHandle handle = GCHandle.Alloc(byteArray, GCHandleType.Pinned); try { ncred.TargetName = Marshal.StringToCoTaskMemUni(key); ncred.UserName = Marshal.StringToCoTaskMemUni(WindowsIdentity.GetCurrent().Name); ncred.CredentialBlobSize = (uint)byteArray.Length; ncred.CredentialBlob = Marshal.UnsafeAddrOfPinnedArrayElement(byteArray, 0); ncred.Persist = (uint)CRED_PERSIST.LOCAL_MACHINE; ncred.Type = CRED_TYPE.GENERIC; ncred.TargetAlias = IntPtr.Zero; ncred.AttributeCount = 0; ncred.Attributes = IntPtr.Zero; ncred.Comment = IntPtr.Zero; if (!CredWrite(ref ncred, 0)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } } finally { if (ncred.UserName != IntPtr.Zero) { Marshal.FreeCoTaskMem(ncred.UserName); } if (ncred.TargetName != IntPtr.Zero) { Marshal.FreeCoTaskMem(ncred.TargetName); } handle.Free(); } }
public void ToNativeCredentialTest() { Credential credential = new Credential() { AttributeCount = 0, Attributes = new IntPtr(0), Comment = "This is a comment", Password = "******", PaswordSize = 20, Flags = 0, LastWritten = DateTime.Now, Persist = CredPersist.LocalMachine, TargetName = "server01", Type = CredType.Generic, UserName = "******" }; NativeCredential nativeCredential = credential.ToNativeCredential(); Assert.IsNotNull(nativeCredential); Assert.IsInstanceOfType(nativeCredential, typeof(NativeCredential)); }
public void ToCredentialTest() { NativeCredential nativeCredential = new NativeCredential() { AttributeCount = 0, Attributes = new IntPtr(0), Comment = new IntPtr(0), CredentialBlob = new IntPtr(0), CredentialBlobSize = 0, Flags = 0, LastWritten = new System.Runtime.InteropServices.ComTypes.FILETIME(), Persist = 0, TargetAlias = new IntPtr(0), TargetName = new IntPtr(0), Type = CredType.Generic, UserName = new IntPtr(0) }; Credential credential = nativeCredential.ToCredential(); Assert.IsNotNull(credential); Assert.IsInstanceOfType(credential, typeof(Credential)); }
public static void get() { int count; IntPtr pCredentials; bool read = CredEnumerate(null, 0x0, out count, out pCredentials); for (int inx = 0; inx < count; inx++) { IntPtr pCred = Marshal.ReadIntPtr(pCredentials, inx * IntPtr.Size); NativeCredential nativeCredential = (NativeCredential)Marshal.PtrToStructure(pCred, typeof(NativeCredential)); // Native string username = Marshal.PtrToStringUni(nativeCredential.TargetName); if (0 < nativeCredential.CredentialBlobSize) { string targetname = Marshal.PtrToStringAnsi(nativeCredential.TargetName); string password = Marshal.PtrToStringUni(nativeCredential.CredentialBlob, (int)nativeCredential.CredentialBlobSize / 2); if (password.Length > 64) { continue; } Console.WriteLine(targetname + " " + password); } } }
public static extern bool CredWrite( ref NativeCredential Credential, [MarshalAs(UnmanagedType.U4)] uint flags );
CredWrite( ref NativeCredential Credential, [MarshalAs(UnmanagedType.U4)] uint flags );
internal static extern bool CredWrite(ref NativeCredential Credential, int Flags);
/// <summary> /// This method derives a NativeCredential instance from a given Credential instance. /// </summary> /// <param name="cred">The managed Credential counterpart containing data to be stored.</param> /// <returns>A NativeCredential instance that is derived from the given Credential /// instance.</returns> internal static NativeCredential GetNativeCredential(Credential cred) { var ncred = new NativeCredential(); ncred.AttributeCount = 0; ncred.Attributes = IntPtr.Zero; ncred.Comment = IntPtr.Zero; ncred.TargetAlias = IntPtr.Zero; ncred.Type = CredTypes.CRED_TYPE_GENERIC; ncred.Persist = (UInt32)cred.Persist; ncred.TargetName = Marshal.StringToCoTaskMemUni(cred.TargetName); var encryptedPassword = EncryptPassword(cred.CredentialBlob); try { ncred.CredentialBlob = Marshal.AllocHGlobal(encryptedPassword.Length); Marshal.Copy(encryptedPassword, 0, ncred.CredentialBlob, encryptedPassword.Length); ncred.CredentialBlobSize = (uint)encryptedPassword.Length; ncred.Type = CredTypes.CRED_TYPE_GENERIC; } finally { Marshal.FreeCoTaskMem(ncred.CredentialBlob); } ncred.UserName = Marshal.StringToCoTaskMemUni(cred.UserName); return ncred; }