/// <summary>
/// Get credentials for updating datasource
/// </summary>
/// <param name="credentialType">Type of credential selected by user</param>
/// <param name="credentialsArray">Credentials entered by the user</param>
/// <returns>Credentials for updating the datasource</returns>
public CredentialsBase GetCredentials(string credentialType, string[] credentialsArray)
{
CredentialsBase credentials;
// Capture credentials based on credential type selected by the user
switch (credentialType)
{
case Constants.KeyCredentials:
credentials = new KeyCredentials(key: credentialsArray[0]);
break;
case Constants.BasicCredentials:
credentials = new BasicCredentials(username: credentialsArray[0], password: credentialsArray[1]);
break;
case Constants.OAuth2Credentials:
credentials = new OAuth2Credentials(accessToken: credentialsArray[0]);
break;
case Constants.WindowsCredentials:
credentials = new WindowsCredentials(username: credentialsArray[0], password: credentialsArray[1]);
break;
default:
Console.Error.WriteLine(Constants.InvalidCredType);
throw new Exception(Constants.InvalidCredType);
}
return(credentials);
}
public void Cloud_KeyCredentialsTest()
{
CredentialsBase credentials = new KeyCredentials("TestKey");
var credentialDetails = new CredentialDetails(credentials, PrivacyLevel.Private, EncryptedConnection.Encrypted);
Assert.IsNotNull(credentialDetails);
Assert.AreEqual("{\"credentialData\":[{\"name\":\"key\",\"value\":\"TestKey\"}]}", credentialDetails.Credentials);
Assert.AreEqual(CredentialType.Key, credentialDetails.CredentialType);
Assert.AreEqual(EncryptedConnection.Encrypted, credentialDetails.EncryptedConnection);
Assert.AreEqual(EncryptionAlgorithm.None, credentialDetails.EncryptionAlgorithm);
Assert.AreEqual(PrivacyLevel.Private, credentialDetails.PrivacyLevel);
Assert.AreEqual(false, credentialDetails.UseCallerAADIdentity);
}
public void OnPrem_KeyCredentialsTest()
{
CredentialsBase credentials = new KeyCredentials("TestKey");
var credentialsEncryptor = new AsymmetricKeyEncryptor(publicKey);
var credentialDetails = new CredentialDetails(credentials, PrivacyLevel.Private, EncryptedConnection.Encrypted, credentialsEncryptor);
Assert.IsNotNull(credentialDetails);
Assert.IsNotNull(credentialDetails.Credentials);
Assert.AreEqual(CredentialType.Key, credentialDetails.CredentialType);
Assert.AreEqual(EncryptedConnection.Encrypted, credentialDetails.EncryptedConnection);
Assert.AreEqual(EncryptionAlgorithm.RSAOAEP, credentialDetails.EncryptionAlgorithm);
Assert.AreEqual(PrivacyLevel.Private, credentialDetails.PrivacyLevel);
Assert.AreEqual(false, credentialDetails.UseCallerAADIdentity);
}
public void TestSaveLoad()
{
var encrypt = new MockEncrypter();
var options = new KeychainOptions();
options.Path = Path.Combine(directoryName, "testsave.json");
var uri = new Uri("http://www.morphic.org");
var wronguri = new Uri("http://www.gpii.net");
var username = new UsernameCredentials("passuser", "password");
var key = new KeyCredentials("key");
var logger = new LoggerFactory().CreateLogger <Keychain>();
//TEST SAVING
var keychain = new Keychain(options, encrypt, logger);
Assert.True(keychain.Save(username, uri));
Assert.Equal(1, encrypt.encryptCounter);
Assert.Equal(0, encrypt.decryptCounter);
Assert.True(keychain.Save(key, uri, "keyuser"));
Assert.Equal(2, encrypt.encryptCounter);
Assert.Equal(0, encrypt.decryptCounter);
//TEST LOADING
keychain = new Keychain(options, encrypt, logger);
Assert.Equal(2, encrypt.encryptCounter);
Assert.Equal(1, encrypt.decryptCounter);
//TEST RETRIEVAL
var newusername = keychain.LoadUsername(uri, "passuser");
Assert.Equal("passuser", newusername.Username);
Assert.Equal("password", newusername.Password);
var newkey = keychain.LoadKey(uri, "keyuser");
Assert.Equal("key", newkey.Key);
newusername = keychain.LoadUsername(uri, "notathing");
newkey = keychain.LoadKey(uri, "notathing");
Assert.Null(newusername);
Assert.Null(newkey);
//TODO: put any tests for switching usernames and keys here once that does something
newusername = keychain.LoadUsername(wronguri, "passuser");
newkey = keychain.LoadKey(wronguri, "keyuser");
Assert.Null(newusername);
Assert.Null(newkey);
}
/// <summary>
/// Send a request to create a new user with a secret key
/// </summary>
/// <param name="service"></param>
/// <param name="user">The user to create</param>
/// <param name="usernameCredentials">The user's key credentials</param>
/// <returns>An authentication token and user information, or <code>null</code> if the request failed</returns>
public static async Task <AuthResponse?> Register(this HttpService service, User user, KeyCredentials keyCredentials)
{
var registration = new KeyRegistration(keyCredentials, user);
return(await service.Session.Send <AuthResponse>(() => HttpRequestMessageExtensions.Create(service.Session, "v1/register/key", HttpMethod.Post, registration)));
}
/// <summary>
/// Send a request to authenticate with key based credentials
/// </summary>
/// <param name="service"></param>
/// <param name="keyCredentials">The key credentials</param>
/// <returns>An authentication token and user information, or <code>null</code> if the request failed</returns>
public static async Task <AuthResponse?> AuthenticateKey(this HttpService service, KeyCredentials keyCredentials)
{
var body = new AuthKeyRequest(keyCredentials.Key);
return(await service.Session.Send <AuthResponse>(() => HttpRequestMessageExtensions.Create(service.Session, "v1/auth/key", HttpMethod.Post, body)));
}
public KeyRegistration(KeyCredentials credentials, User user)
{
Key = credentials.Key;
FirstName = user.FirstName;
LastName = user.LastName;
}
