internal static SecureString GetSecureStringPassword(this PasswordString pwdString)
{
var secure = new SecureString();
foreach (char c in pwdString.GetClearTextPassword())
{
secure.AppendChar(c);
}
return(secure);
}
internal static PasswordString GetPassword(string prompt)
{
if (!StandardInputIsAllowed())
{
throw new NotSupportedException("Password request is not supported.");
}
var inputReq = new InputRequest(prompt, password: true);
var password = JupyterRequestContext.Current.JupyterMessageSender.Send(inputReq);
var result = new PasswordString(password);
return(result);
}
public void DeserializeGivesPlainTextPriorityOverEncodedPasswordRegardlessOfPosition()
{
var passwordInPlainText = "Password-in-plain-text";
var anotherPassword = new PasswordString()
{
Password = "******"
};
var json = $@"{{ ""{nameof(PasswordString.Password)}"": ""{passwordInPlainText}""
,""{nameof(PasswordString.PasswordEncoded)}"": ""{anotherPassword.PasswordEncoded}""
}}" ;
var result = JsonSerializer.Deserialize <PasswordString>(json);
result.Password.Should().Be(passwordInPlainText);
}
public void WriteJsonShouldWriteEncryptedPassword()
{
// Arrange
var sut = new PasswordStringConverter();
var writer = Substitute.For <JsonWriter>();
var plainText = "plain";
var value = PasswordString.FromPlainText(plainText);
// Act
sut.WriteJson(writer, value, JsonSerializer.CreateDefault());
// Assert
writer.Received(1).WriteValue(Arg.Is <string>(arg => new PasswordString(arg).PlainText() == plainText));
}
public void ReadJsonShouldReturnValidPasswordString()
{
// Arrange
var sut = new PasswordStringConverter();
var reader = Substitute.For <JsonReader>();
const string expected = "foobar";
reader.Value.Returns(PasswordString.FromPlainText(expected).Encrypted());
// Act
var actual = sut.ReadJson(reader, typeof(PasswordString), new PasswordString(), false, JsonSerializer.CreateDefault());
// Assert
Assert.Equal(expected, actual.PlainText());
}
public void EqualsTest()
{
PasswordString passwd1 = new PasswordString();
Assert.IsFalse(passwd1.Equals(null));
Assert.IsTrue(passwd1.Equals(passwd1));
PasswordString passwd2 = new PasswordString();
Assert.IsTrue(passwd1.Equals(passwd2));
SecureString secureString = new SecureString();
foreach (char c in validPassword.ToCharArray())
{
secureString.AppendChar(c);
}
passwd1.Password = secureString;
Assert.IsFalse(passwd1.Equals(passwd2));
SecureString secureString1 = new SecureString();
foreach (char c in wrongPassword1.ToCharArray())
{
secureString1.AppendChar(c);
}
passwd2.Password = secureString1;
Assert.IsFalse(passwd1.Equals(passwd2));
SecureString secureString2 = new SecureString();
foreach (char c in wrongPassword2.ToCharArray())
{
secureString2.AppendChar(c);
}
passwd2.Password = secureString2;
Assert.IsFalse(passwd1.Equals(passwd2));
SecureString secureString3 = new SecureString();
foreach (char c in validPassword.ToCharArray())
{
secureString3.AppendChar(c);
}
passwd2.Password = secureString3;
Assert.IsTrue(passwd1.Equals(passwd2));
}
private PasswordStringModel AddPasswordString(PasswordStringModel model)
{
PasswordString ps = new PasswordString();
PasswordStringViewModel psContext = new PasswordStringViewModel(model);
model.FieldChanged += (s) =>
{
using (SQLiteConnection connection = DBContext.GetConnection())
{
connection.InsertOrReplace(s);
}
};
psContext.OnDeletePressed += RemovePasswordString;
ps.BindingContext = psContext;
PasswordStringVMs.Add(psContext);
PasswordStack.Children.Add(ps);
return(model);
}
public void CanDeserializeASerializedObject(PasswordStringConverter.PasswordStringConverterOptions option)
{
var passwordInPlainText = "Password-in-plain-text";
var passwordString = new PasswordString()
{
Password = passwordInPlainText,
};
var jsonSerializerOptions = new JsonSerializerOptions {
WriteIndented = true,
Converters =
{
new PasswordStringConverter(option)
},
};
string json = JsonSerializer.Serialize(passwordString, jsonSerializerOptions);
var result = JsonSerializer.Deserialize <PasswordString>(json);
result.Password.Should().Be(passwordInPlainText);
}
public void SerializesBothEncodedAndPlainTextPassword_WhenConfigured()
{
var passwordInPlainText = "Password-in-plain-text";
var passwordString = new PasswordString()
{
Password = passwordInPlainText,
};
var jsonSerializerOptions = new JsonSerializerOptions {
WriteIndented = true,
Converters =
{
new PasswordStringConverter(PasswordStringConverter.PasswordStringConverterOptions.PlainTextAndEncodedBase64)
},
};
string result = JsonSerializer.Serialize(passwordString, jsonSerializerOptions);
result.Should().Contain(passwordString.PasswordEncoded);
result.Should().Contain(passwordInPlainText);
result.Should().Contain($@"""{nameof(PasswordString.Password)}""");
result.Should().Contain($@"""{nameof(PasswordString.PasswordEncoded)}""");
}
public bool PasswordStringIsValid()
{
var charCount = PasswordString.Count(x => x == Character);
return(charCount >= MinOccurences && charCount <= MaxOccurences);
}
public NewPasswordViewModel()
{
NewPassword = new PasswordString();
NewPasswordReEnter = new PasswordString();
}
/// <inheritdoc />
public EncryptedTextOption(string plainValue, string nameTextId, string descriptionTextId)
: base(PasswordString.FromPlainText(plainValue), nameTextId, descriptionTextId)
{
}
public UpdatePasswordViewModel()
{
CheckPassword = new PasswordString();
NewPassword = new PasswordString();
NewPasswordReEnter = new PasswordString();
}
