public static void ExecuteEdit(IWin32Window owner, PasswordTypes passwordTypes) { using (var form = new ViewTypesForm()) { form.Init(passwordTypes, true); form.ShowDialog(owner); } }
public PasswordDocument() { IsLoaded = false; _fileName = string.Empty; DocumentPassword = string.Empty; _passwordFields = new Fields(this); _passwordTypes = new PasswordTypes(this); _passwords = new Passwords(this); }
public static PasswordType Execute(IWin32Window owner, PasswordTypes passwordTypes, PasswordType passwordType) { using (var form = new EditPasswordTypeForm()) { form.Init(passwordTypes, passwordType); if (form.ShowDialog(owner) == DialogResult.OK) return form.SelectedPasswordType; return null; } }
public static PasswordType ExecuteSelect(IWin32Window owner, PasswordTypes passwordTypes) { using (var form = new ViewTypesForm()) { form.Init(passwordTypes, false); if (form.ShowDialog(owner) == DialogResult.OK) return form.GetSelectedPasswordType(); return null; } }
private void Init(PasswordTypes passwordTypes, PasswordType passwordType) { _passwordTypes = passwordTypes; _passwordType = passwordType; if (_passwordType == null) Text = "Добавление"; else { Text = "Редактирование"; tbName.Text = _passwordType.Name; Fill(); } RefreshUI(); }
/// <summary> /// Decrypt a string sequence using the selected encryption types /// </summary> /// <param name="data">hex coded string sequence to decrypt</param> /// <param name="encryptedTypes">Encryption types</param> /// <param name="password">optional password</param> /// <param name="yubidata">optional yubi data</param> /// <param name="decode"></param> /// <returns>decrypted string sequence</returns> private static string DecryptSequenceNoHash(string data, PasswordTypes encryptedTypes, string password, YubiKey yubi, bool decode = false) { try { // reverse order they were encrypted if ((encryptedTypes & PasswordTypes.Machine) != 0) { // we are going to decrypt with the Windows local machine key byte[] cipher = Authenticator.StringToByteArray(data); byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.LocalMachine); if (decode == true) { data = Encoding.UTF8.GetString(plain, 0, plain.Length); } else { data = ByteArrayToString(plain); } } if ((encryptedTypes & PasswordTypes.User) != 0) { // we are going to decrypt with the Windows User account key byte[] cipher = StringToByteArray(data); byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.CurrentUser); if (decode == true) { data = Encoding.UTF8.GetString(plain, 0, plain.Length); } else { data = ByteArrayToString(plain); } } if ((encryptedTypes & PasswordTypes.Explicit) != 0) { // we use an explicit password to encrypt data if (string.IsNullOrEmpty(password) == true) { throw new EncrpytedSecretDataException(); } data = Authenticator.Decrypt(data, password, true); if (decode == true) { byte[] plain = Authenticator.StringToByteArray(data); data = Encoding.UTF8.GetString(plain, 0, plain.Length); } } if ((encryptedTypes & PasswordTypes.YubiKeySlot1) != 0 || (encryptedTypes & PasswordTypes.YubiKeySlot2) != 0) { if (string.IsNullOrEmpty(yubi.Info.Error) == false) { throw new BadYubiKeyException("Unable to detect YubiKey"); } if (yubi.Info.Status.VersionMajor == 0) { throw new BadYubiKeyException("Please insert your YubiKey"); } int slot = ((encryptedTypes & PasswordTypes.YubiKeySlot1) != 0 ? 1 : 2); string seed = data.Substring(0, SALT_LENGTH * 2); data = data.Substring(seed.Length); byte[] key = yubi.ChallengeResponse(slot, StringToByteArray(seed)); data = Authenticator.Decrypt(data, key); if (decode == true) { byte[] plain = Authenticator.StringToByteArray(data); data = Encoding.UTF8.GetString(plain, 0, plain.Length); } yubi.YubiData.Seed = seed; yubi.YubiData.Data = key; } } catch (EncrpytedSecretDataException) { throw; } catch (BadYubiKeyException ) { throw; } catch (ChallengeResponseException ex) { throw new BadYubiKeyException("Please check your YubiKey or touch the flashing button", ex); } catch (Exception ex) { throw new BadPasswordException(ex.Message, ex); } return data; }
/// <summary> /// Decrypt a string sequence using the selected encryption types /// </summary> /// <param name="data">hex coded string sequence to decrypt</param> /// <param name="encryptedTypes">Encryption types</param> /// <param name="password">optional password</param> /// <param name="yubidata">optional yubi data</param> /// <param name="decode"></param> /// <returns>decrypted string sequence</returns> public static string DecryptSequence(string data, PasswordTypes encryptedTypes, string password, YubiKey yubi, bool decode = false) { // check for encrpytion header if (data.Length < ENCRYPTION_HEADER.Length || data.IndexOf(ENCRYPTION_HEADER) != 0) { return DecryptSequenceNoHash(data, encryptedTypes, password, yubi, decode); } // extract salt and hash using (var sha = new SHA256Managed()) { // jump header int datastart = ENCRYPTION_HEADER.Length; string salt = data.Substring(datastart, Math.Min(SALT_LENGTH * 2, data.Length - datastart)); datastart += salt.Length; string hash = data.Substring(datastart, Math.Min(sha.HashSize / 8 * 2, data.Length - datastart)); datastart += hash.Length; data = data.Substring(datastart); data = DecryptSequenceNoHash(data, encryptedTypes, password, yubi); // check the hash byte[] compareplain = StringToByteArray(salt + data); string comparehash = ByteArrayToString(sha.ComputeHash(compareplain)); if (string.Compare(comparehash, hash) != 0) { throw new BadPasswordException(); } } return data; }
public void SetEncryption(PasswordTypes passwordType, string password = null) { // check if still encrpyted if (this.RequiresPassword == true) { // have to decrypt to be able to re-encrypt throw new EncrpytedSecretDataException(); } if (passwordType == PasswordTypes.None) { this.RequiresPassword = false; this.EncryptedData = null; this.PasswordType = passwordType; } else { using (MemoryStream ms = new MemoryStream()) { // get the plain version XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.Encoding = Encoding.UTF8; using (XmlWriter encryptedwriter = XmlWriter.Create(ms, settings)) { string encrpytedData = this.EncryptedData; Authenticator.PasswordTypes savedpasswordType = PasswordType; try { PasswordType = Authenticator.PasswordTypes.None; EncryptedData = null; WriteToWriter(encryptedwriter); } finally { this.PasswordType = savedpasswordType; this.EncryptedData = encrpytedData; } } string data = Authenticator.ByteArrayToString(ms.ToArray()); // update secret hash using (SHA1 sha1 = SHA1.Create()) { this.SecretHash = sha1.ComputeHash(Encoding.UTF8.GetBytes(this.SecretData)); } // encrypt this.EncryptedData = Authenticator.EncryptSequence(data, passwordType, password, null); this.PasswordType = passwordType; if (this.PasswordType == PasswordTypes.Explicit) { this.SecretData = null; this.RequiresPassword = true; } } } }
/// <summary> /// Encode the PasswordTypes type into a string for storing in config /// </summary> /// <param name="passwordType">PasswordTypes value</param> /// <returns>string version</returns> public static string EncodePasswordTypes(PasswordTypes passwordType) { StringBuilder encryptedTypes = new StringBuilder(); if ((passwordType & PasswordTypes.Explicit) != 0) { encryptedTypes.Append("y"); } if ((passwordType & PasswordTypes.User) != 0) { encryptedTypes.Append("u"); } if ((passwordType & PasswordTypes.Machine) != 0) { encryptedTypes.Append("m"); } return encryptedTypes.ToString(); }
public static string EncryptSequence(string data, PasswordTypes passwordType, string password, YubiKey yubi) { // get hash of original var random = new RNGCryptoServiceProvider(); byte[] saltbytes = new byte[SALT_LENGTH]; random.GetBytes(saltbytes); string salt = ByteArrayToString(saltbytes); string hash; using (var sha = new SHA256Managed()) { byte[] plain = StringToByteArray(salt + data); hash = ByteArrayToString(sha.ComputeHash(plain)); } if ((passwordType & PasswordTypes.YubiKeySlot1) != 0 || (passwordType & PasswordTypes.YubiKeySlot2) != 0) { if (yubi.YubiData.Length == 0) { byte[] seed = new byte[SALT_LENGTH]; random = new RNGCryptoServiceProvider(); random.GetBytes(seed); // we encrypt the data using the hash of a random string from the YubiKey int slot = ((passwordType & PasswordTypes.YubiKeySlot1) != 0 ? 1 : 2); yubi.YubiData.Data = yubi.ChallengeResponse(slot, seed); yubi.YubiData.Seed = Authenticator.ByteArrayToString(seed); } byte[] key = yubi.YubiData.Data; string encrypted = Encrypt(data, key); // test the encryption string decrypted = Decrypt(encrypted, key); if (string.Compare(data, decrypted) != 0) { throw new InvalidEncryptionException(data, password, encrypted, decrypted); } data = yubi.YubiData.Seed + encrypted; } if ((passwordType & PasswordTypes.Explicit) != 0) { string encrypted = Encrypt(data, password); // test the encryption string decrypted = Decrypt(encrypted, password, true); if (string.Compare(data, decrypted) != 0) { throw new InvalidEncryptionException(data, password, encrypted, decrypted); } data = encrypted; } if ((passwordType & PasswordTypes.User) != 0) { // we encrypt the data using the Windows User account key byte[] plain = StringToByteArray(data); byte[] cipher = ProtectedData.Protect(plain, null, DataProtectionScope.CurrentUser); data = ByteArrayToString(cipher); } if ((passwordType & PasswordTypes.Machine) != 0) { // we encrypt the data using the Local Machine account key byte[] plain = StringToByteArray(data); byte[] cipher = ProtectedData.Protect(plain, null, DataProtectionScope.LocalMachine); data = ByteArrayToString(cipher); } // prepend the salt + hash return ENCRYPTION_HEADER + salt + hash + data; }
/// <summary> /// Load an authenticator from a Stream with an explicit password for this current version /// </summary> /// <param name="stream">Stream to read</param> /// <param name="password">explicit password if requried</param> /// <param name="version">expected version of authenticator</param> /// <returns>loaded Authenticator</returns> public static Authenticator ReadFromStream(Stream stream, string password, decimal version) { using (XmlReader xr = XmlReader.Create(stream)) { XmlDocument doc = new XmlDocument(); doc.Load(xr); XmlNode rootnode = doc.DocumentElement; XmlNode node; Authenticator authenticator = null; // get the type is we have it, else use the default XmlAttribute authenticatorType = rootnode.Attributes["type"]; if (authenticatorType != null) { Type type = System.Reflection.Assembly.GetExecutingAssembly().GetType(authenticatorType.Value, false, true); authenticator = Activator.CreateInstance(type) as Authenticator; } if (authenticator == null) { authenticator = new BattleNetAuthenticator(); } // is the Mobile Authenticator file? <xml.../><map>...</map> node = rootnode.SelectSingleNode("/map/string[@name='" + BMA_HASH_NAME + "']"); if (node != null) { string data = node.InnerText; // extract the secret key and serial byte[] bytes = StringToByteArray(data); // decrpyt with the fixed key for (int i = bytes.Length - 1; i >= 0; i--) { bytes[i] ^= MOBILE_AUTHENTICATOR_KEY[i]; } // decode and set members string full = Encoding.UTF8.GetString(bytes, 0, bytes.Length); authenticator.SecretData = full; // get offset value long offset = 0; node = rootnode.SelectSingleNode("/map/long[@name='" + BMA_OFFSET_NAME + "']"); if (node != null && LongTryParse(node.Attributes["value"].InnerText, out offset) /* long.TryParse(node.Attributes["value"].InnerText, out offset) == true */) { authenticator.ServerTimeDiff = offset; } return(authenticator); } // read <= 1.6 config if (version <= (decimal)1.6 && (node = rootnode.SelectSingleNode("secretdata")) != null) { // save off the processed decryptions so we can send bug report List <string> datas = new List <string>(); string data = node.InnerText; datas.Add(data); XmlAttribute attr = node.Attributes["encrypted"]; if (attr != null && attr.InnerText.Length != 0) { string encryptedType = attr.InnerText; if (encryptedType == "u") { // we are going to decrypt with the Windows User account key authenticator.PasswordType = PasswordTypes.User; byte[] cipher = StringToByteArray(data); byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.CurrentUser); data = ByteArrayToString(plain); datas.Add(data); } else if (encryptedType == "m") { // we are going to decrypt with the Windows local machine key authenticator.PasswordType = PasswordTypes.Machine; byte[] cipher = StringToByteArray(data); byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.LocalMachine); data = ByteArrayToString(plain); datas.Add(data); } else if (encryptedType == "y") { // we use an explicit password to encrypt data if (string.IsNullOrEmpty(password) == true) { throw new EncrpytedSecretDataException(); } authenticator.PasswordType = PasswordTypes.Explicit; authenticator.Password = password; data = Decrypt(data, password, false); datas.Add(data); } } try { authenticator.SecretData = ConvertAndriodSecretData(data); } catch (Exception ex) { // we get a decode error if the data decrypted but isn't valid throw new InvalidSecretDataException(ex, password, (attr != null ? attr.InnerText : null), datas); } long offset = 0; node = rootnode.SelectSingleNode("servertimediff"); if (node != null && LongTryParse(node.InnerText, out offset) == true /* long.TryParse(node.InnerText, out offset) == true */) { authenticator.ServerTimeDiff = offset; } node = rootnode.SelectSingleNode("restorecodeverified"); if (node != null && string.Compare(node.InnerText, bool.TrueString.ToLower(), true) == 0) { authenticator.RestoreCodeVerified = true; } return(authenticator); } // read current config if ((node = rootnode.SelectSingleNode("secretdata")) != null) { // save off the processed decryptions so we can send bug report string data = node.InnerText; XmlAttribute attr = node.Attributes["encrypted"]; List <string> datas = new List <string>(); datas.Add(data); PasswordTypes passwordType = PasswordTypes.None; if (attr != null && attr.InnerText.Length != 0) { char[] encTypes = attr.InnerText.ToCharArray(); // we read the string in reverse order (the order they were encrypted) for (int i = encTypes.Length - 1; i >= 0; i--) { char encryptedType = encTypes[i]; switch (encryptedType) { case 'u': { // we are going to decrypt with the Windows User account key try { passwordType |= PasswordTypes.User; byte[] cipher = StringToByteArray(data); byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.CurrentUser); data = ByteArrayToString(plain); datas.Add(data); } catch (System.Security.Cryptography.CryptographicException) { throw new InvalidUserDecryptionException(); } break; } case 'm': { // we are going to decrypt with the Windows local machine key try { passwordType |= PasswordTypes.Machine; byte[] cipher = StringToByteArray(data); byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.LocalMachine); data = ByteArrayToString(plain); datas.Add(data); } catch (System.Security.Cryptography.CryptographicException) { throw new InvalidMachineDecryptionException(); } break; } case 'y': { // we use an explicit password to encrypt data if (string.IsNullOrEmpty(password) == true) { throw new EncrpytedSecretDataException(); } passwordType |= PasswordTypes.Explicit; authenticator.Password = password; data = Decrypt(data, password, true); datas.Add(data); break; } default: break; } } authenticator.PasswordType = passwordType; } try { // pre-version 2 we kept compatability with the Android file if (version < (decimal)2) { data = ConvertAndriodSecretData(data); } authenticator.SecretData = data; } catch (Exception ex) { throw new InvalidSecretDataException(ex, password, (attr != null ? attr.InnerText : null), datas); } long offset = 0; node = rootnode.SelectSingleNode("servertimediff"); if (node != null && LongTryParse(node.InnerText, out offset) == true /* long.TryParse(node.InnerText, out offset) == true */) { authenticator.ServerTimeDiff = offset; } node = rootnode.SelectSingleNode("restorecodeverified"); if (node != null && string.Compare(node.InnerText, bool.TrueString.ToLower(), true) == 0) { authenticator.RestoreCodeVerified = true; } return(authenticator); } throw new InvalidOperationException(); } }
/// <summary> /// Decrypt a string sequence using the selected encryption types /// </summary> /// <param name="data">hex coded string sequence to decrypt</param> /// <param name="encryptedTypes">Encryption types</param> /// <param name="password">optional password</param> /// <param name="decode"></param> /// <returns>decrypted string sequence</returns> private static string DecryptSequenceNoHash(string data, PasswordTypes encryptedTypes, string?password, bool decode = false) { try { // reverse order they were encrypted if ((encryptedTypes & PasswordTypes.Machine) != 0) { // we are going to decrypt with the Windows local machine key var cipher = StringToByteArray(data); var plain = IProtectedData.Instance.Unprotect(cipher, null, IProtectedData.DataProtectionScope.LocalMachine); if (decode == true) { data = Encoding.UTF8.GetString(plain, 0, plain.Length); } else { data = ByteArrayToString(plain); } } if ((encryptedTypes & PasswordTypes.User) != 0) { // we are going to decrypt with the Windows User account key var cipher = StringToByteArray(data); var plain = IProtectedData.Instance.Unprotect(cipher, null, IProtectedData.DataProtectionScope.CurrentUser); if (decode == true) { data = Encoding.UTF8.GetString(plain, 0, plain.Length); } else { data = ByteArrayToString(plain); } } if ((encryptedTypes & PasswordTypes.Explicit) != 0) { // we use an explicit password to encrypt data if (string.IsNullOrEmpty(password) == true) { throw new WinAuthEncryptedSecretDataException(); } data = Decrypt(data, password, true); if (decode == true) { var plain = StringToByteArray(data); data = Encoding.UTF8.GetString(plain, 0, plain.Length); } } if ((encryptedTypes & PasswordTypes.YubiKeySlot1) != 0 || (encryptedTypes & PasswordTypes.YubiKeySlot2) != 0) { throw new NotSupportedException(); } } catch (WinAuthEncryptedSecretDataException) { throw; } catch (Exception ex) { throw new WinAuthBadPasswordException(ex.Message, ex); } return(data); }
private void Init(PasswordTypes passwordTypes, bool isEdit) { _passwordTypes = passwordTypes; if (isEdit) { Text = "Редактировать тип"; btnSelect.Visible = false; btnClose.Text = "Закрыть"; } else { Text = "Выбрать тип"; dgvItems.DoubleClick -= BtnEditClick; dgvItems.DoubleClick += BtnSelectClick; } Fill(); RefreshUI(); }
public static string EncryptSequence(string data, PasswordTypes passwordType, string password) { // get hash of original string salt; using (var random = new RNGCryptoServiceProvider()) { byte[] saltbytes = new byte[SALT_LENGTH]; random.GetBytes(saltbytes); salt = ByteArrayToString(saltbytes); } string hash; using (var sha = new SHA256Managed()) { byte[] plain = StringToByteArray(salt + data); hash = ByteArrayToString(sha.ComputeHash(plain)); } if ((passwordType & PasswordTypes.Explicit) != 0) { string encrypted = Encrypt(data, password); // test the encryption string decrypted = Decrypt(encrypted, password, true); if (string.Compare(data, decrypted) != 0) { throw new InvalidEncryptionException(data, password, encrypted, decrypted); } data = encrypted; } if ((passwordType & PasswordTypes.User) != 0) { // we encrypt the data using the Windows User account key byte[] plain = StringToByteArray(data); byte[] cipher = ProtectedData.Protect(plain, null, DataProtectionScope.CurrentUser); data = ByteArrayToString(cipher); } if ((passwordType & PasswordTypes.Machine) != 0) { // we encrypt the data using the Local Machine account key byte[] plain = StringToByteArray(data); byte[] cipher = ProtectedData.Protect(plain, null, DataProtectionScope.LocalMachine); data = ByteArrayToString(cipher); } // prepend the salt + hash return ENCRYPTION_HEADER + salt + hash + data; }
//public static void Log(string message) //{ // try // { // string dir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); // File.AppendAllText(Path.Combine(dir, "winauth.log"), message); // } // catch (Exception) { } //} private static string DecryptSequenceNoHash( string data, PasswordTypes encryptedTypes, string password, bool decode = false) { try { // reverse order they were encrypted if ((encryptedTypes & PasswordTypes.Machine) != 0) { // we are going to decrypt with the Windows local machine key byte[] cipher = StringToByteArray(data); //Log("Decrypt Machine: " + data + Environment.NewLine); byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.LocalMachine); if (decode == true) { //Log("Decode Machine: " + ByteArrayToString(plain) + Environment.NewLine); data = Encoding.UTF8.GetString(plain, 0, plain.Length); } else { data = ByteArrayToString(plain); } //Log("Decrypted Machine: " + data + Environment.NewLine); } if ((encryptedTypes & PasswordTypes.User) != 0) { // we are going to decrypt with the Windows User account key byte[] cipher = StringToByteArray(data); //Log("Decrypt User: "******"Decode User: "******"Decrypted User: "******"Decrypt Explicit: " + password + " " + data + Environment.NewLine); data = Decrypt(data, password, true); //Log("Decrypted Explicit: " + data + Environment.NewLine); if (decode == true) { byte[] plain = StringToByteArray(data); data = Encoding.UTF8.GetString(plain, 0, plain.Length); //Log("Decode Explicit: " + data + Environment.NewLine); } } } catch (EncrpytedSecretDataException) { throw; } catch (Exception ex) { throw new BadPasswordException(ex.Message, ex); } return data; }
public bool ReadXml(XmlReader reader, string password = null) { // decode the password type string encrypted = reader.GetAttribute("encrypted"); PasswordTypes passwordType = DecodePasswordTypes(encrypted); PasswordType = passwordType; if (passwordType != PasswordTypes.None) { // read the encrypted text from the node EncryptedData = reader.ReadElementContentAsString(); return(Unprotect(password)); //// decrypt //try //{ // string data = Authenticator.DecryptSequence(this.EncryptedData, passwordType, password); // using (MemoryStream ms = new MemoryStream(Authenticator.StringToByteArray(data))) // { // reader = XmlReader.Create(ms); // this.ReadXml(reader, password); // } //} //catch (EncrpytedSecretDataException) //{ // this.RequiresPassword = true; // throw; //} //finally //{ // this.PasswordType = passwordType; //} } reader.MoveToContent(); if (reader.IsEmptyElement) { reader.Read(); return(false); } reader.Read(); while (reader.EOF == false) { if (reader.IsStartElement()) { switch (reader.Name) { case "lastservertime": LastServerTime = reader.ReadElementContentAsLong(); break; case "servertimediff": ServerTimeDiff = reader.ReadElementContentAsLong(); break; case "secretdata": SecretData = reader.ReadElementContentAsString(); break; default: if (ReadExtraXml(reader, reader.Name) == false) { reader.Skip(); } break; } } else { reader.Read(); break; } } // check if we need to sync, or if it's been a day if (ServerTimeDiff == 0 || LastServerTime == 0 || LastServerTime < DateTime.Now.AddHours(-24).Ticks) { Sync(); return(true); } else { return(false); } }
public bool Unprotect(string password) { PasswordTypes passwordType = PasswordType; if (passwordType == PasswordTypes.None) { throw new InvalidOperationException("Cannot Unprotect a non-encrypted authenticator"); } // decrypt bool changed = false; try { string data = DecryptSequence(EncryptedData, PasswordType, password); using (MemoryStream ms = new MemoryStream(StringToByteArray(data))) { XmlReader reader = XmlReader.Create(ms); changed = ReadXml(reader, password) || changed; } RequiresPassword = false; // calculate hash of current secretdata using (SHA1 sha1 = SHA1.Create()) { SecretHash = sha1.ComputeHash(Encoding.UTF8.GetBytes(SecretData)); } // keep the password until we reprotect in case data changes Password = password; if (changed == true) { // we need to encrypt changed secret data using (MemoryStream ms = new MemoryStream()) { // get the plain version XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.Encoding = Encoding.UTF8; using (XmlWriter encryptedwriter = XmlWriter.Create(ms, settings)) { WriteToWriter(encryptedwriter); } string encrypteddata = ByteArrayToString(ms.ToArray()); // update secret hash using (SHA1 sha1 = SHA1.Create()) { SecretHash = sha1.ComputeHash(Encoding.UTF8.GetBytes(SecretData)); } // encrypt EncryptedData = EncryptSequence(encrypteddata, passwordType, password); } } return(changed); } catch (EncrpytedSecretDataException) { RequiresPassword = true; throw; } finally { PasswordType = passwordType; } }
public static Authenticator ReadXmlv2(XmlReader reader, string password = null) { Authenticator authenticator = null; string authenticatorType = reader.GetAttribute("type"); if (string.IsNullOrEmpty(authenticatorType) == false) { authenticatorType = authenticatorType.Replace("WindowsAuthenticator.", "WinAuth."); Type type = Assembly.GetExecutingAssembly().GetType(authenticatorType, false, true); authenticator = Activator.CreateInstance(type) as Authenticator; } if (authenticator == null) { authenticator = new BattleNetAuthenticator(); } reader.MoveToContent(); if (reader.IsEmptyElement) { reader.Read(); return(null); } reader.Read(); while (reader.EOF == false) { if (reader.IsStartElement()) { switch (reader.Name) { case "servertimediff": authenticator.ServerTimeDiff = reader.ReadElementContentAsLong(); break; //case "restorecodeverified": // authenticator.RestoreCodeVerified = reader.ReadElementContentAsBoolean(); // break; case "secretdata": string encrypted = reader.GetAttribute("encrypted"); string data = reader.ReadElementContentAsString(); PasswordTypes passwordType = DecodePasswordTypes(encrypted); if (passwordType != PasswordTypes.None) { // this is an old version so there is no hash data = DecryptSequence(data, passwordType, password); } authenticator.PasswordType = PasswordTypes.None; authenticator.SecretData = data; break; default: if (authenticator.ReadExtraXml(reader, reader.Name) == false) { reader.Skip(); } break; } } else { reader.Read(); break; } } return(authenticator); }
public MsgShowConfirmPassword(System.Security.SecureString password, PasswordTypes type) { this.OriginalPassword = password; this.PasswordType = type; }
public void SetUsernameToken(string username, string password, PasswordTypes type = PasswordTypes.PasswordText) { _usernameToken = new UsernameToken { Username = username, Password = password, Type = type }; }