Exemplo n.º 1
0
        internal Credential(NativeCode.NativeCredential ncred)
        {
            Flags      = ncred.Flags;
            TargetName = ncred.TargetName;
            Comment    = ncred.Comment;
            try
            {
#pragma warning disable CS0675 // Bitwise-or operator used on a sign-extended operand
                LastWritten = DateTime.FromFileTime((long)((ulong)ncred.LastWritten.dwHighDateTime << 32 | (uint)ncred.LastWritten.dwLowDateTime));
#pragma warning restore CS0675 // Bitwise-or operator used on a sign-extended operand
            }
            catch (ArgumentOutOfRangeException)
            { }


            var CredentialBlobSize = ncred.CredentialBlobSize;
            if (ncred.CredentialBlobSize >= 2)
            {
                CredentialBlob = Marshal.PtrToStringUni(ncred.CredentialBlob, (int)ncred.CredentialBlobSize / 2);
            }
            Persistance = (Persistance)ncred.Persist;
            var AttributeCount = ncred.AttributeCount;
            if (AttributeCount > 0)
            {
                try
                {
                    var formatter  = new BinaryFormatter();
                    var attribSize = Marshal.SizeOf(typeof(NativeCode.NativeCredentialAttribute));
                    Attributes = new Dictionary <string, Object>();
                    byte[] rawData = new byte[AttributeCount * attribSize];
                    var    buffer  = Marshal.AllocHGlobal(attribSize);
                    Marshal.Copy(ncred.Attributes, rawData, (int)0, (int)AttributeCount * attribSize);
                    for (int i = 0; i < AttributeCount; i++)
                    {
                        Marshal.Copy(rawData, i * attribSize, buffer, attribSize);
                        var attr = (NativeCode.NativeCredentialAttribute)Marshal.PtrToStructure(buffer,
                                                                                                typeof(NativeCode.NativeCredentialAttribute));
                        var key = attr.Keyword;
                        var val = new byte[attr.ValueSize];
                        Marshal.Copy(attr.Value, val, (int)0, (int)attr.ValueSize);
                        using var stream = new MemoryStream(val, false);
                        Attributes.Add(key, formatter.Deserialize(stream));
                    }
                    Marshal.FreeHGlobal(buffer);
                    rawData = null;
                }
                catch
                {
                }
            }
            TargetAlias = ncred.TargetAlias;
            UserName    = ncred.UserName;
            Type        = (CredentialType)ncred.Type;
        }
Exemplo n.º 2
0
 internal Credential(NativeCode.NativeCredential ncred)
 {
     CredentialBlobSize = ncred.CredentialBlobSize;
     CredentialBlob     = CredentialBlobSize > 0 ? Marshal.PtrToStringUni(ncred.CredentialBlob, (int)ncred.CredentialBlobSize / 2) : string.Empty;
     UserName           = Marshal.PtrToStringUni(ncred.UserName);
     TargetName         = Marshal.PtrToStringUni(ncred.TargetName);
     TargetAlias        = Marshal.PtrToStringUni(ncred.TargetAlias);
     Type    = ncred.Type;
     Flags   = ncred.Flags;
     Persist = (NativeCode.Persistance)ncred.Persist;
     try
     {
         LastWritten = DateTime.FromFileTime((long)((ulong)ncred.LastWritten.dwHighDateTime << 32 | (ulong)ncred.LastWritten.dwLowDateTime));
     }
     catch (ArgumentOutOfRangeException e)
     { }
 }
Exemplo n.º 3
0
        internal Credential GetCredential()
        {
            if (!IsInvalid)
            {
                // Get the Credential from the mem location
                NativeCode.NativeCredential ncred = (NativeCode.NativeCredential)Marshal.PtrToStructure(handle,
                                                                                                        typeof(NativeCode.NativeCredential));

                // Create a managed Credential type and fill it with data from the native counterpart.
                Credential cred = new Credential(ncred);

                return(cred);
            }
            else
            {
                throw new InvalidOperationException("Invalid CriticalHandle!");
            }
        }
Exemplo n.º 4
0
 /// <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 NativeCode.NativeCredential GetNativeCredential()
 {
     NativeCode.NativeCredential ncred = new NativeCode.NativeCredential();
     ncred.AttributeCount     = 0;
     ncred.Attributes         = IntPtr.Zero;
     ncred.Comment            = IntPtr.Zero;
     ncred.TargetAlias        = IntPtr.Zero;
     ncred.Type               = this.Type;
     ncred.Persist            = (UInt32)this.Persist;
     ncred.UserName           = Marshal.StringToCoTaskMemUni(this.UserName);
     ncred.TargetName         = Marshal.StringToCoTaskMemUni(this.TargetName);
     ncred.CredentialBlob     = Marshal.StringToCoTaskMemUni(this.CredentialBlob);
     ncred.CredentialBlobSize = (UInt32)this.CredentialBlobSize;
     if (this.LastWritten != DateTime.MinValue)
     {
         var fileTime = this.LastWritten.ToFileTimeUtc();
         ncred.LastWritten.dwLowDateTime  = (int)(fileTime & 0xFFFFFFFFL);
         ncred.LastWritten.dwHighDateTime = (int)((fileTime >> 32) & 0xFFFFFFFFL);
     }
     return(ncred);
 }
        /// <summary>
        /// Saves the given Network Credential into Windows Credential store
        /// </summary>
        /// <param name="target">Name of the application/Url where the credential is used for</param>
        /// <param name="credential">Credential to store</param>
        /// <returns>True:Success, throw if failed</returns>
        public static bool SaveCredentials(string target, NetworkCredential credential)
        {
            // Go ahead with what we have are stuff it into the CredMan structures.
            var cred = new Credential(credential)
            {
                TargetName = target, Persist = NativeCode.Persistance.Entrprise
            };

            NativeCode.NativeCredential ncred = cred.GetNativeCredential();

            // Write the info into the CredMan storage.
            if (NativeCode.CredWrite(ref ncred, 0))
            {
                return(true);
            }

            int    lastError = Marshal.GetLastWin32Error();
            string message   = String.Format("'CredWrite' call throw an error (Error code: {0})", lastError);

            throw new Win32Exception(lastError, message);
        }
        /// <summary>
        /// Saves the given Network Credential into Windows Credential store
        /// </summary>
        /// <param name="Target">Name of the application/Url where the credential is used for</param>
        /// <param name="credential">Credential to store</param>
        /// <returns>True:Success, False:Failure</returns>
        public static bool SaveCredentials(string Target, NetworkCredential credential)
        {
            // Go ahead with what we have are stuff it into the CredMan structures.
            Credential cred = new Credential(credential);

            cred.TargetName = Target;
            cred.Persist    = NativeCode.Persistance.Entrprise;
            NativeCode.NativeCredential ncred = cred.GetNativeCredential();
            // Write the info into the CredMan storage.
            bool written   = NativeCode.CredWrite(ref ncred, 0);
            int  lastError = Marshal.GetLastWin32Error();

            if (written)
            {
                return(true);
            }
            else
            {
                string message = string.Format("CredWrite failed with the error code {0}.", lastError);
                throw new Exception(message);
            }
        }
Exemplo n.º 7
0
        internal Credential(NativeCode.NativeCredential ncred)
        {
            CredentialBlobSize = ncred.CredentialBlobSize;
            if (ncred.CredentialBlobSize > 2)
            {
                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     = (NativeCode.Persistance)ncred.Persist;
            try
            {
#pragma warning disable CS0675 // Bitwise-or operator used on a sign-extended operand
                LastWritten = DateTime.FromFileTime((long)((ulong)ncred.LastWritten.dwHighDateTime << 32 | (uint)ncred.LastWritten.dwLowDateTime));
#pragma warning restore CS0675 // Bitwise-or operator used on a sign-extended operand
            }
            catch (ArgumentOutOfRangeException)
            { }
        }
Exemplo n.º 8
0
        public bool SaveCredential(bool AllowBlankPassword = false)
        {
            IntPtr   buffer = default(IntPtr);
            GCHandle pinned = default(GCHandle);

            if (!String.IsNullOrEmpty(this.Comment) && Encoding.Unicode.GetBytes(this.Comment).Length > 256)
            {
                throw new ArgumentException("Comment can't be more than 256 bytes long", "Comment");
            }

            if (String.IsNullOrEmpty(this.TargetName))
            {
                throw new ArgumentNullException("TargetName", "TargetName can't be Null or Empty");
            }
            else if (this.TargetName.Length > 32767)
            {
                throw new ArgumentNullException("TargetName can't be more than 32kB", "TargetName");
            }

            if (!AllowBlankPassword && String.IsNullOrEmpty(this.CredentialBlob))
            {
                throw new ArgumentNullException("CredentialBlob", "CredentialBlob can't be Null or Empty");
            }

            NativeCode.NativeCredential ncred = new NativeCode.NativeCredential
            {
                Comment            = this.Comment,
                TargetAlias        = null,
                Type               = (UInt32)this.Type,
                Persist            = (UInt32)this.Persistance,
                UserName           = this.UserName,
                TargetName         = this.TargetName,
                CredentialBlobSize = (UInt32)Encoding.Unicode.GetBytes(this.CredentialBlob).Length
            };
            if (ncred.CredentialBlobSize > MaxCredentialBlobSize)
            {
                throw new ArgumentException($"Credential can't be more than {MaxCredentialBlobSize} bytes long", "CredentialBlob");
            }

            ncred.CredentialBlob = Marshal.StringToCoTaskMemUni(this.CredentialBlob);
            if (this.LastWritten != DateTime.MinValue)
            {
                var fileTime = this.LastWritten.ToFileTimeUtc();
                ncred.LastWritten.dwLowDateTime  = (int)(fileTime & 0xFFFFFFFFL);
                ncred.LastWritten.dwHighDateTime = (int)((fileTime >> 32) & 0xFFFFFFFFL);
            }

            NativeCode.NativeCredentialAttribute[] nativeAttribs = null;
            try
            {
                if (Attributes == null || Attributes.Count == 0)
                {
                    ncred.AttributeCount = 0;
                    ncred.Attributes     = IntPtr.Zero;
                }
                else
                {
                    if (Attributes.Count > 64)
                    {
                        throw new ArgumentException("Credentials can't have more than 64 Attributes!!");
                    }

                    ncred.AttributeCount = (UInt32)Attributes.Count;
                    nativeAttribs        = new NativeCode.NativeCredentialAttribute[Attributes.Count];
                    var    attribSize = Marshal.SizeOf(typeof(NativeCode.NativeCredentialAttribute));
                    byte[] rawData    = new byte[Attributes.Count * attribSize];
                    buffer = Marshal.AllocHGlobal(attribSize);
                    var formatter = new BinaryFormatter();

                    var i = 0;
                    foreach (var a in Attributes)
                    {
                        if (a.Key.Length > 256)
                        {
                            throw new ArgumentException($"Attribute names can't be more than 256 bytes long. Error with key:{a.Key}", a.Key);
                        }
                        if (a.Value == null)
                        {
                            throw new ArgumentNullException(a.Key, $"Attribute value cant'be null. Error with key:{a.Key}");
                        }
                        if (!a.Value.GetType().IsSerializable)
                        {
                            throw new ArgumentException($"Attribute value must be Serializable. Error with key:{a.Key}", a.Key);
                        }

                        using var stream = new MemoryStream();
                        formatter.Serialize(stream, a.Value);
                        var value = stream.ToArray();

                        if (value.Length > 256)
                        {
                            throw new ArgumentException($"Attribute values can't be more than 256 bytes long after serialization. Error with Value for key:{a.Key}", a.Key);
                        }

                        var attrib = new NativeCode.NativeCredentialAttribute
                        {
                            Keyword   = a.Key,
                            ValueSize = (UInt32)value.Length
                        };

                        attrib.Value = Marshal.AllocHGlobal(value.Length);
                        Marshal.Copy(value, 0, attrib.Value, value.Length);
                        nativeAttribs[i] = attrib;

                        Marshal.StructureToPtr(attrib, buffer, false);
                        Marshal.Copy(buffer, rawData, i * attribSize, attribSize);
                        i++;
                    }
                    pinned           = GCHandle.Alloc(rawData, GCHandleType.Pinned);
                    ncred.Attributes = pinned.AddrOfPinnedObject();
                }
                // Write the info into the CredMan storage.

                if (NativeCode.CredWrite(ref ncred, 0))
                {
                    return(true);
                }
                else
                {
                    int lastError = Marshal.GetLastWin32Error();
                    throw new CredentialAPIException($"Unable to Save Credential", "CredWrite", lastError);
                }
            }

            finally
            {
                if (ncred.CredentialBlob != default(IntPtr))
                {
                    Marshal.FreeCoTaskMem(ncred.CredentialBlob);
                }
                if (nativeAttribs != null)
                {
                    foreach (var a in nativeAttribs)
                    {
                        if (a.Value != default(IntPtr))
                        {
                            Marshal.FreeHGlobal(a.Value);
                        }
                    }
                    if (pinned.IsAllocated)
                    {
                        pinned.Free();
                    }
                    if (buffer != default(IntPtr))
                    {
                        Marshal.FreeHGlobal(buffer);
                    }
                }
            }
        }