Esempio n. 1
0
        }         // func PasswordCompare

        public static bool PasswordCompare(string testPassword, byte[] passwordHash)
        {
            if (passwordHash == null)
            {
                return(String.IsNullOrEmpty(testPassword));
            }
            if (passwordHash.Length < 6)
            {
                throw new ArgumentException("invalid hash-length", nameof(passwordHash));
            }

            if (BitConverter.ToInt16(passwordHash, 0) != 2)
            {
                throw new ArgumentException("invalid hash-version", nameof(passwordHash));
            }

            var testPasswordBytes = Encoding.Unicode.GetBytes(testPassword);

            // create the SHA256 hash (Password + Salt)
            var sha = SHA512Managed.Create();

            sha.TransformBlock(testPasswordBytes, 0, testPasswordBytes.Length, testPasswordBytes, 0);
            sha.TransformFinalBlock(passwordHash, 2, 4);

            return(Procs.CompareBytes(sha.Hash, 0, passwordHash, 6, sha.HashSize / 8));
        }         // func PasswordCompare
Esempio n. 2
0
        }         // func TryGetProperty

        /// <summary>Versucht einen Paremter zurückzugeben.</summary>
        /// <typeparam name="T">Rückgabewert.</typeparam>
        /// <param name="name">Parametername.</param>
        /// <param name="value">Wert der abgelegt wurde.</param>
        /// <returns><c>true</c>, wenn ein Wert gefunden wurde.</returns>
        public static bool TryGetProperty <T>(this IPropertyReadOnlyDictionary propertyDictionary, string name, out T value)
        {
            object ret;

            if (propertyDictionary.TryGetProperty(name, out ret) && ret != null)
            {
                try
                {
                    if (ret is T)
                    {
                        value = (T)ret;
                    }
                    else
                    {
                        value = (T)Procs.ChangeType(ret, typeof(T));
                    }
                    return(true);
                }
                catch (FormatException)
                {
                }
            }
            value = default(T);
            return(false);
        }         // func TryGetProperty
Esempio n. 3
0
        }         // func EncodeWindowsPassword

        public static SecureString DecodePassword(string passwordValue)
        {
            if (String.IsNullOrEmpty(passwordValue))
            {
                return(null);
            }
            if (passwordValue.Length > 5 && passwordValue[5] == ':')
            {
                var pwdType = passwordValue.Substring(0, 5);
                switch (pwdType)
                {
                case "win0x":
                    return(DecodeWindowsPassword(Procs.ConvertToBytes(passwordValue, 6, passwordValue.Length - 6), true));

                case "win64":
                    return(DecodeWindowsPassword(Convert.FromBase64String(passwordValue.Substring(6, passwordValue.Length - 6)), true));

                case "usr0x":
                    return(DecodeWindowsPassword(Procs.ConvertToBytes(passwordValue, 6, passwordValue.Length - 6), false));

                case "usr64":
                    return(DecodeWindowsPassword(Convert.FromBase64String(passwordValue.Substring(6, passwordValue.Length - 6)), false));

                case "plain":
                    return(passwordValue.CreateSecureString(6, passwordValue.Length - 6));

                default:
                    throw new ArgumentOutOfRangeException("passwordType", pwdType, "Invalid password type.");
                }
            }
            else
            {
                return(passwordValue.CreateSecureString());
            }
        }         // func DecodePassword
Esempio n. 4
0
        }         // ctor

        public PropertyValue(string name, Type type, object value)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }

            this.name  = name;
            this.type  = type ?? typeof(object);
            this.value = Procs.ChangeType(value, this.type);
        }         // ctor
Esempio n. 5
0
        }         // func ToXml

        private static object GetValue(XElement x)
        {
            var type = LuaType.GetType(x.Attribute("t")?.Value ?? "string", lateAllowed: false).Type;

            if (type == typeof(LuaTable))
            {
                return(CreateLuaTable(x));
            }
            else
            {
                return(Procs.ChangeType(x.Value, type));
            }
        }         // func GetValue
Esempio n. 6
0
        }         // func EncodePassword

        #endregion

        #region -- Password Hash ------------------------------------------------------

        public static byte[] ParsePasswordHash(string passwordHash)
        {
            if (String.IsNullOrEmpty(passwordHash))
            {
                return(null);
            }

            if (passwordHash.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
            {
                return(Procs.ConvertToBytes(passwordHash, 2, passwordHash.Length - 2));
            }
            else
            {
                return(Convert.FromBase64String(passwordHash));
            }
        }         // func ParsePasswordHash
Esempio n. 7
0
        }         // func GetAttribute

        /// <summary>Gibt den Inhalt eines Attributes typiriesiert zurück.</summary>
        /// <typeparam name="T">Datentyp der erwartet wird.</typeparam>
        /// <param name="x">XElement, an dem das Attribut erwartet wird.</param>
        /// <param name="attributeName">Name des Attributes.</param>
        /// <param name="default">Defaultwert, falls das Attribut nicht vorhanden ist oder der Wert nicht in den Typ konvertiert werden konnte.</param>
        /// <returns>Wert oder der default-Wert.</returns>
        public static T GetAttribute <T>(this XElement x, XName attributeName, T @default)
        {
            try
            {
                string sValue = GetAttribute(x, attributeName, (string)null);
                if (sValue == null)
                {
                    return(@default);
                }

                return(Procs.ChangeType <T>(sValue));
            }
            catch
            {
                return(@default);
            }
        }         // func GetAttribute
Esempio n. 8
0
        }         // func DecodePassword

        public static string EncodePassword(SecureString password, string passwordType = null)
        {
            if (passwordType == null)
            {
                passwordType = "win64";
            }

            var passwordPtr  = Marshal.SecureStringToGlobalAllocUnicode(password);
            var passwordSize = password.Length * 2;

            try
            {
                switch (passwordType)
                {
                case "win0x":
                    return("win0x:" + Procs.ConvertToString(EncodeWindowsPassword(passwordPtr, passwordSize, true)));

                case "win64":
                    return("win64:" + Convert.ToBase64String(EncodeWindowsPassword(passwordPtr, passwordSize, true)));

                case "usr0x":
                    return("usr0x:" + Procs.ConvertToString(EncodeWindowsPassword(passwordPtr, passwordSize, false)));

                case "usr64":
                    return("usr64:" + Convert.ToBase64String(EncodeWindowsPassword(passwordPtr, passwordSize, false)));

                case "plain":
                    return("plain:" + Marshal.PtrToStringUni(passwordPtr, password.Length));

                default:
                    throw new ArgumentOutOfRangeException(nameof(passwordType), passwordType, "Invalid password type.");
                }
            }
            finally
            {
                Marshal.ZeroFreeGlobalAllocUnicode(passwordPtr);
            }
        }         // func EncodePassword
Esempio n. 9
0
        }         // ctor

        /// <summary>Erzeugt ein Dictionary.</summary>
        /// <param name="sParameterList">Parameterliste als Zeichenfolge konvertiert.</param>
        public PropertyDictionary(string parameterList)
        {
            AddRange(Procs.SplitPropertyList(parameterList));
        }         // ctor
Esempio n. 10
0
        }         // func ChangeType

        /// <summary>Generische Implementierung von <c>ChangeType</c>.</summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        public static T ChangeType <T>(this object value)
        => (T)Procs.ChangeType(value, typeof(T));
Esempio n. 11
0
 public void Except(string message, Exception e) => Procs.LogMsg(logger, LogMsgType.Error, message, e);
Esempio n. 12
0
 public void Except(Exception e) => Procs.LogMsg(logger, LogMsgType.Error, e);
Esempio n. 13
0
 public void Warn(string message, Exception e) => Procs.LogMsg(logger, LogMsgType.Warning, message, e);
Esempio n. 14
0
 public void Warn(Exception e) => Procs.LogMsg(logger, LogMsgType.Warning, e);