/*
* API Calls
*/
IEnumerator SendDeviceCodeCreateRequest()
{
if (!String.IsNullOrEmpty(clientId))
{
authenticationStatus = AuthenticationStatus.Waiting;
string payload = String.Format(
@"{{""client_id"":""{0}"",""scope"":""chat chat_dm""}}",
clientId);
yield return(HandleAPIRequest <DeviceCodeCreateResponse>(
APIHttpHost,
deviceCodeCreateEndpointPath,
payload,
null,
(DeviceCodeCreateResponse r) =>
{
if (r != null &&
!String.IsNullOrEmpty(r.user_code) &&
!String.IsNullOrEmpty(r.device_code) &&
!String.IsNullOrEmpty(r.associate_url) &&
r.interval > 0)
{
authCode = r.user_code;
authUrl = "https://" + r.associate_url + "?user_code=" + r.user_code;
deviceCode = r.device_code;
deviceCodeCheckInterval = r.interval;
StartCoroutine(CheckDeviceCode());
}
},
(APIResponse r) =>
{
authenticationStatus = AuthenticationStatus.NotAuthenticated;
error = "Authentication failed. Error: " + r.error;
}));
}
}
public App()
: base()
{
model = SpotifyViewModel.Instance;
client = new ServiceReference.SpotifyClient(new InstanceContext(model));
MainWindow = new MainWindow(model);
AuthenticationStatus ok = AuthenticationStatus.Bad;
try { ok = client.Authenticate(""); }
catch { throw; }
if (ok == AuthenticationStatus.Bad)
{
Shutdown();
}
else if (ok == AuthenticationStatus.RequireLogin)
{
bool loggedIn = false;
while (!loggedIn)
{
SpotifyLogin login = new SpotifyLogin();
login.ShowDialog();
if (login.Username.Text != "")
{
loggedIn = client.Login(login.Username.Text, login.Password.Password);
}
}
}
model.Client = client;
MainWindow.Show();
MainWindow.Closed += new EventHandler(MainWindow_Closed);
}
async public Task <bool> InitializeAsync(object ctx)
{
this.context = ctx as Context;
if (this.context == null)
{
throw new InvalidOperationException("Context cannot be null and must be Android.Content.Context instance ");
}
Platform.FetchAuthCode += Platform_FetchAuthCode;
authStatus = AuthenticationStatus.InProgress;
try
{
var result = await Platform.InitializeAsync(context, RomeClientId);
if (authStatus == AuthenticationStatus.InProgress && result)
{
AuthStatus = AuthenticationStatus.Authenticated;
}
return(result);
}
catch (Exception ex)
{
//TODO: Error handling
System.Diagnostics.Debug.WriteLine(ex.Message);
}
return(false);
}
/// <summary>
/// Converte a situação vinda do serviço para a do sistema.
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
private static AuthenticationStatus Convert(AuthenticationHost.AuthenticationStatus status)
{
AuthenticationStatus result = AuthenticationStatus.ErrorInValidate;
Enum.TryParse <AuthenticationStatus>(status.ToString(), out result);
return(result);
}
public async Task AuthenticateLdapUserAsync_SearchLdapReturnsTrueAndBindThrowsException_CallsSearchDirectory()
{
// Arrange
var loginInfo = LoginInfo.Parse("domain\\login");
loginInfo.LdapUrl = "DC=domain";
string password = "******";
var settingsRepository = new Mock <ISqlSettingsRepository>();
var settings = new[] { new LdapSettings {
LdapAuthenticationUrl = loginInfo.LdapUrl, AuthenticationType = AuthenticationTypes.Encryption
} };
settingsRepository.Setup(r => r.GetLdapSettingsAsync()).ReturnsAsync((IEnumerable <LdapSettings>)settings).Verifiable();
var authenticator = new Mock <IAuthenticator>();
var logMock = new Mock <IServiceLogRepository>();
authenticator.Setup(a => a.SearchLdap(settings[0], "(&(objectCategory=user)(samaccountname=" + loginInfo.UserName + "))")).Returns(true).Verifiable();
authenticator.Setup(a => a.Bind(loginInfo, password, AuthenticationTypes.Encryption)).Throws <Exception>().Verifiable();
authenticator.Setup(a => a.SearchDirectory(loginInfo, password)).Returns(false).Verifiable();
var repository = new LdapRepository(settingsRepository.Object, logMock.Object, authenticator.Object);
// Act
AuthenticationStatus status = await repository.AuthenticateLdapUserAsync(loginInfo.Login, password, false);
// Assert
settingsRepository.Verify();
authenticator.Verify();
Assert.AreEqual(AuthenticationStatus.Error, status);
}
public SecurityIdentity(AuthenticationStatus status)
{
_status = status;
_identityUnit = null;
_lastLoginDateUtc = DateTime.MinValue;
Name = null;
}
public async Task AuthenticateLdapUserAsync_SearchLdapReturnsFalse_ReturnsError()
{
// Arrange
var loginInfo = LoginInfo.Parse("domain\\login\\*()\u0000/"); // Covers LdapHelper.EscapeLdapSearchFilter()
string password = "******";
var settingsRepository = new Mock <ISqlSettingsRepository>();
var settings = new[] { new LdapSettings {
LdapAuthenticationUrl = "DC= domain ", EnableCustomSettings = true, AccountNameAttribute = "account"
} }; // Covers LdapHelper.GetEffectiveAccountNameAttribute()
settingsRepository.Setup(r => r.GetLdapSettingsAsync()).ReturnsAsync((IEnumerable <LdapSettings>)settings).Verifiable();
var authenticator = new Mock <IAuthenticator>();
var logMock = new Mock <IServiceLogRepository>();
authenticator.Setup(a => a.SearchLdap(settings[0], @"(&(objectCategory=user)(account=login\5c\2a\28\29\00\2f))")).Returns(false).Verifiable();
var repository = new LdapRepository(settingsRepository.Object, logMock.Object, authenticator.Object);
// Act
AuthenticationStatus status = await repository.AuthenticateLdapUserAsync(loginInfo.Login, password, false);
// Assert
settingsRepository.Verify();
authenticator.Verify();
Assert.AreEqual(AuthenticationStatus.Error, status);
}
void parameterizedProgrammaticOPIdentifierTest(Identifier opIdentifier, ProtocolVersion version,
Identifier claimedUrl, AuthenticationRequestMode requestMode,
AuthenticationStatus expectedResult, bool provideStore)
{
var rp = TestSupport.CreateRelyingParty(provideStore ? TestSupport.RelyingPartyStore : null, null, null);
var returnTo = TestSupport.GetFullUrl(TestSupport.ConsumerPage);
var realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);
var request = rp.CreateRequest(opIdentifier, realm, returnTo);
request.Mode = requestMode;
var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(request,
opReq => {
opReq.IsAuthenticated = expectedResult == AuthenticationStatus.Authenticated;
if (opReq.IsAuthenticated.Value)
{
opReq.ClaimedIdentifier = claimedUrl;
}
});
Assert.AreEqual(expectedResult, rpResponse.Status);
if (rpResponse.Status == AuthenticationStatus.Authenticated)
{
Assert.AreEqual(claimedUrl, rpResponse.ClaimedIdentifier);
}
else if (rpResponse.Status == AuthenticationStatus.SetupRequired)
{
Assert.IsNull(rpResponse.ClaimedIdentifier);
Assert.IsNull(rpResponse.FriendlyIdentifierForDisplay);
Assert.IsNull(rpResponse.Exception);
Assert.IsInstanceOfType(typeof(ISetupRequiredAuthenticationResponse), rpResponse);
Assert.AreEqual(opIdentifier.ToString(), ((ISetupRequiredAuthenticationResponse)rpResponse).ClaimedOrProviderIdentifier.ToString());
}
}
public async Task AuthenticateLdapUserAsync_NoMatchingSettings_ReturnsError()
{
// Arrange
var loginInfo = new LoginInfo();
string password = "******";
var settingsRepository = new Mock <ISqlSettingsRepository>();
var settings = new[]
{
new LdapSettings {
LdapAuthenticationUrl = "CD=domain", AuthenticationType = AuthenticationTypes.Encryption
},
new LdapSettings {
LdapAuthenticationUrl = "DC=wrongdomain", AuthenticationType = AuthenticationTypes.Encryption
}
}; // Covers LdapHelper.MatchesDomain()
settingsRepository.Setup(r => r.GetLdapSettingsAsync()).ReturnsAsync((IEnumerable <LdapSettings>)settings).Verifiable();
var authenticator = new Mock <IAuthenticator>();
var logMock = new Mock <IServiceLogRepository>();
var repository = new LdapRepository(settingsRepository.Object, logMock.Object, authenticator.Object);
// Act
AuthenticationStatus status = await repository.AuthenticateLdapUserAsync(loginInfo.Login, password, false);
// Assert
settingsRepository.Verify();
Assert.AreEqual(AuthenticationStatus.Error, status);
}
public async Task <AuthenticationResult> Login()
{
try
{
var authUser = await _client.LoginAsync(AppDelegate.RootViewController, Auth0Settings.AdfsConnection, true, "openid email name nickname given_name family_name");
var authToken = authUser.Profile.ToObject <AuthToken>();
authToken.IdToken = authUser.IdToken;
authToken.AccessToken = authUser.Auth0AccessToken;
authToken.RefreshToken = authUser.RefreshToken;
Insights.Identify(authToken);
return(new AuthenticationResult(authToken, AuthenticationStatus.Succeded));
}
catch (TaskCanceledException cancelException)
{
AuthenticationStatus authenticationStatus = AuthenticationStatus.Failed;
if (cancelException.Task != null && cancelException.Task.Status == TaskStatus.Canceled)
{
authenticationStatus = AuthenticationStatus.Canceled;
}
return(new AuthenticationResult(null, authenticationStatus, cancelException));
}
catch (Exception exception)
{
Insights.Report(exception);
return(new AuthenticationResult(null, AuthenticationStatus.Failed, exception));
}
}
public async Task <AuthenticationResult> Login()
{
try
{
var authUser = await _client.LoginAsync(new AndroidLoginPage().Context, Auth0Settings.AdfsConnection, true);
var authToken = authUser.Profile.ToObject <AuthToken>();
authToken.IdToken = authUser.IdToken;
authToken.AccessToken = authUser.Auth0AccessToken;
authToken.RefreshToken = authUser.RefreshToken;
Insights.Identify(authToken);
return(new AuthenticationResult(authToken, AuthenticationStatus.Succeded));
}
catch (TaskCanceledException cancelException)
{
AuthenticationStatus authenticationStatus = AuthenticationStatus.Failed;
if (cancelException.Task != null && cancelException.Task.Status == TaskStatus.Canceled)
{
authenticationStatus = AuthenticationStatus.Canceled;
}
return(new AuthenticationResult(null, authenticationStatus, cancelException));
}
catch (Exception exception)
{
return(new AuthenticationResult(null, AuthenticationStatus.Failed, exception));
}
}
void parameterizedProgrammaticOPIdentifierTest(Identifier opIdentifier, ProtocolVersion version,
Identifier claimedUrl, AuthenticationRequestMode requestMode,
AuthenticationStatus expectedResult, bool provideStore) {
var rp = TestSupport.CreateRelyingParty(provideStore ? TestSupport.RelyingPartyStore : null, null, null);
var returnTo = TestSupport.GetFullUrl(TestSupport.ConsumerPage);
var realm = new Realm(TestSupport.GetFullUrl(TestSupport.ConsumerPage).AbsoluteUri);
var request = rp.CreateRequest(opIdentifier, realm, returnTo);
request.Mode = requestMode;
var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(request,
opReq => {
opReq.IsAuthenticated = expectedResult == AuthenticationStatus.Authenticated;
if (opReq.IsAuthenticated.Value) {
opReq.ClaimedIdentifier = claimedUrl;
}
});
Assert.AreEqual(expectedResult, rpResponse.Status);
if (rpResponse.Status == AuthenticationStatus.Authenticated) {
Assert.AreEqual(claimedUrl, rpResponse.ClaimedIdentifier);
} else if (rpResponse.Status == AuthenticationStatus.SetupRequired) {
Assert.IsNull(rpResponse.ClaimedIdentifier);
Assert.IsNull(rpResponse.FriendlyIdentifierForDisplay);
Assert.IsNull(rpResponse.Exception);
Assert.IsInstanceOfType(typeof(ISetupRequiredAuthenticationResponse), rpResponse);
Assert.AreEqual(opIdentifier.ToString(), ((ISetupRequiredAuthenticationResponse)rpResponse).ClaimedOrProviderIdentifier.ToString());
}
}
private static void LoginToPlayfabWithDeviceID(System.Action OnSuccess = null, System.Action OnFailure = null)
{
PlayFabClientAPI.LoginWithAndroidDeviceID(new LoginWithAndroidDeviceIDRequest()
{
AndroidDeviceId = SystemInfo.deviceUniqueIdentifier,
CreateAccount = true
},
success =>
{
authenticationStatus = AuthenticationStatus.LoggedIn;
PlayFabClientAPI.GetPlayerProfile(new GetPlayerProfileRequest()
{
ProfileConstraints = new PlayerProfileViewConstraints()
{
ShowDisplayName = true
}
},
success2 =>
{
playerName = success2.PlayerProfile.DisplayName;
},
error2 =>
{
});
m_newlyCreated = success.NewlyCreated;
OnSuccess?.Invoke();
},
error =>
{
authenticationStatus = AuthenticationStatus.ErrorLoggingIn;
OnFailure?.Invoke();
});
}
public async Task AuthenticateLdapUserAsync_SearchLdapThrowsException_ReturnsError()
{
// Arrange
var loginInfo = new LoginInfo(); // Covers LdapHelper.EscapeLdapSearchFilter()
string password = "******";
var settingsRepository = new Mock <ISqlSettingsRepository>();
var settings = new[] { new LdapSettings {
LdapAuthenticationUrl = "DC=", EnableCustomSettings = true
} }; // Covers LdapHelper.GetEffectiveAccountNameAttribute()
settingsRepository.Setup(r => r.GetLdapSettingsAsync()).ReturnsAsync((IEnumerable <LdapSettings>)settings).Verifiable();
var authenticator = new Mock <IAuthenticator>();
var logMock = new Mock <IServiceLogRepository>();
authenticator.Setup(a => a.SearchLdap(settings[0], @"(&(objectCategory=user)(samaccountname=" + loginInfo.UserName + "))")).Throws <Exception>().Verifiable();
var repository = new LdapRepository(settingsRepository.Object, logMock.Object, authenticator.Object);
// Act
AuthenticationStatus status = await repository.AuthenticateLdapUserAsync(loginInfo.Login, password, false);
// Assert
settingsRepository.Verify();
authenticator.Verify();
Assert.AreEqual(AuthenticationStatus.Error, status);
}
public AuthenticationResult(AuthenticationStatus status, String ip, int port, byte[] token)
{
Status = status;
Ip = ip;
Port = port;
Token = token;
}
void parameterizedTest(TestSupport.Scenarios scenario, ProtocolVersion version,
AuthenticationRequestMode requestMode, AuthenticationStatus expectedResult)
{
Identifier claimedId = TestSupport.GetMockIdentifier(scenario, version);
parameterizedProgrammaticTest(scenario, version, claimedId, requestMode, expectedResult, true);
parameterizedProgrammaticTest(scenario, version, claimedId, requestMode, expectedResult, false);
}
private AuthenResult GetResult(AuthenticationStatus status, string message)
{
return(new AuthenResult()
{
Status = status,
ErrorMessage = message
});
}
private static AuthenticationResult CreateResult(IRegisteredUser user, AuthenticationStatus status)
{
return(new AuthenticationResult
{
User = user,
Status = status,
});
}
private void UpdateAuthStatus(AuthenticationStatus status)
{
_authenticationStatus = status;
if (AuthenticationStatusChanged != null)
{
AuthenticationStatusChanged(this, new AuthenticationStatusChangedEventArgs(status));
}
}
void parameterizedOPIdentifierTest(TestSupport.Scenarios scenario,
AuthenticationRequestMode requestMode, AuthenticationStatus expectedResult) {
ProtocolVersion version = ProtocolVersion.V20; // only this version supports directed identity
UriIdentifier claimedIdentifier = TestSupport.GetDirectedIdentityUrl(TestSupport.Scenarios.ApproveOnSetup, version);
Identifier opIdentifier = TestSupport.GetMockOPIdentifier(TestSupport.Scenarios.ApproveOnSetup, claimedIdentifier);
parameterizedProgrammaticOPIdentifierTest(opIdentifier, version, claimedIdentifier, requestMode, expectedResult, true);
parameterizedProgrammaticOPIdentifierTest(opIdentifier, version, claimedIdentifier, requestMode, expectedResult, false);
}
/// <summary>
/// Initializes a new instance of the AuthenticateResponseModel class.
/// </summary>
/// <param name="status">Possible values include: 'Ok', 'Error'</param>
public AuthenticateResponseModel(AuthenticationStatus status, string errorMessage = default(string), string notificationsId = default(string), string token = default(string), ClientAccountInformationModel account = default(ClientAccountInformationModel))
{
Status = status;
ErrorMessage = errorMessage;
NotificationsId = notificationsId;
Token = token;
Account = account;
CustomInit();
}
/// <summary>
/// On Authentication progress
/// </summary>
/// <param name="step"></param>
static void _manager_OnAuthenticationStep(AuthenticationStatus step)
{
Console.WriteLine("---- authentication step: {0} ----", step);
if (step == AuthenticationStatus.NoServerFound)
{
_manager.Connect(new System.Net.IPEndPoint(System.Net.IPAddress.Loopback, 15812));
Console.WriteLine(">> Trying loopback:15812 <<");
}
}
/// <summary>
/// Sets authentication setp
/// </summary>
/// <param name="status"></param>
private void SetStep(AuthenticationStatus status)
{
if (_authenticationStep == status)
{
return;
}
_authenticationStep = status;
OnAuthenticationStep.Invoke(status);
}
void parameterizedOPIdentifierTest(TestSupport.Scenarios scenario,
AuthenticationRequestMode requestMode, AuthenticationStatus expectedResult)
{
ProtocolVersion version = ProtocolVersion.V20; // only this version supports directed identity
UriIdentifier claimedIdentifier = TestSupport.GetDirectedIdentityUrl(TestSupport.Scenarios.ApproveOnSetup, version);
Identifier opIdentifier = TestSupport.GetMockOPIdentifier(TestSupport.Scenarios.ApproveOnSetup, claimedIdentifier);
parameterizedProgrammaticOPIdentifierTest(opIdentifier, version, claimedIdentifier, requestMode, expectedResult, true);
parameterizedProgrammaticOPIdentifierTest(opIdentifier, version, claimedIdentifier, requestMode, expectedResult, false);
}
public string GetRedirectUrl(AuthenticationStatus status, string returnUrl = null)
{
var redirectUrl = this.GetDefaultRedirectUrl(status);
if (!string.IsNullOrEmpty(returnUrl))
{
redirectUrl = this.AddReturnUrl(redirectUrl, returnUrl);
}
return(redirectUrl);
}
public static void Unauthenticate()
{
authLayer?.Unauthenticate();
_sAuthenticationStatus = AuthenticationStatus.NotAuthenticated;
authLayer = null;
//Raise event.
unauthenticated?.Invoke();
}
static IEnumerator AuthenticateRoutine(Completer completer)
{
void FailInitialization(Completer aCompleter, Exception reason)
{
Unauthenticate();
Debug.LogWarning($"{nameof(GameAuthSdk)} failed to authenticate: {reason}");
_sAuthenticationStatus = AuthenticationStatus.Failed;
aCompleter.Reject(reason);
//Raise event.
authenticatedFailed?.Invoke(reason);
}
Promises.GetHandles(out var dalInitDeferred, out var dalInitCompleter);
try
{
authLayer.Authenticate(dalInitCompleter);
}
catch (Exception e)
{
dalInitCompleter.Reject(e);
}
if (!dalInitDeferred.isDone)
{
yield return(dalInitDeferred.Wait());
}
var isFulfilled = dalInitDeferred.isFulfilled;
var error = dalInitDeferred.error;
dalInitDeferred.Release();
if (!isFulfilled)
{
FailInitialization(completer, error);
yield break;
}
_sAuthenticationStatus = AuthenticationStatus.Authenticated;
Debug.Log($"Successfully authenticated Game Auth version {currentVersion}");
completer.Resolve();
//Raise event.
authenticated?.Invoke();
}
public static AuthenticationResult Authenticate(string userName, string password, out Account account, bool passwordIsHashed = false)
{
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentNullException("userName");
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentNullException("password");
}
int authenticationAttemptID = 0;
AuthenticationStatus result = AuthenticationStatus.Failure_Unknown;
using (ICoreRepositoryManager repository = CoreServiceLocator.GetRepositoryManager())
{
CoreEntities ctx = repository.DataModel;
account = null;
//lets patch up the username and remove any leading or trailing spaces.
userName = userName.Trim();
//lets look and see if the userName is an email address.
account = ctx.Accounts.SingleOrDefault(p => p.UserName == userName && !p.Voided);
if (account != null)
{
//check account approved/disabled
result = account.Approved ? AuthenticationStatus.Success : AuthenticationStatus.Failure_AccountNotApproved;
result = account.Disabled ? AuthenticationStatus.Failure_AccountDisabled : AuthenticationStatus.Success;
result = account.Password == null ? AuthenticationStatus.Failure_NoPassword : AuthenticationStatus.Success;
//if so far we are approved and not disabled, and password is not null, then lets check the password against the input.
if (result == AuthenticationStatus.Success && !VerifyPasswordMatch(password, account.Password, passwordIsHashed))
{
result = AuthenticationStatus.Failure_IncorrectPassword;
}
}
else
{
result = AuthenticationStatus.Failure_AccountNotExist;
}
if (account != null)
{
//detach the contact so we don't have to worry about duplicates being committed into the database since this context is going out of scope *very* soon.
ctx.Detach(account);
}
}
return(new AuthenticationResult(result, authenticationAttemptID));
}
public static Guid?GetUserGuid(string userName, string userPassword)
{
ECXSecurityAccess sec = new ECXSecurityAccess();
Guid userGuid = Guid.Empty;
AuthenticationStatus s = sec.IsAuthenticated(userName, userPassword, "ECXCD", out userGuid);
if (userGuid == Guid.Empty)
{
return(null);
}
return(userGuid);
}
void parameterizedProgrammaticTest(TestSupport.Scenarios scenario, ProtocolVersion version,
Identifier claimedUrl, AuthenticationRequestMode requestMode,
AuthenticationStatus expectedResult, bool provideStore) {
var request = TestSupport.CreateRelyingPartyRequest(!provideStore, scenario, version);
request.Mode = requestMode;
var rpResponse = TestSupport.CreateRelyingPartyResponseThroughProvider(request,
opReq => opReq.IsAuthenticated = expectedResult == AuthenticationStatus.Authenticated);
Assert.AreEqual(expectedResult, rpResponse.Status);
Assert.AreEqual(claimedUrl, rpResponse.ClaimedIdentifier);
}
internal static string ToSerializedValue(this AuthenticationStatus value)
{
switch (value)
{
case AuthenticationStatus.Ok:
return("Ok");
case AuthenticationStatus.Error:
return("Error");
}
return(null);
}
APIResponse GetAPIResponseWithAuthCheck(APIRequest req)
{
Assert.IsTrue(req.Completed);
var resp = new APIResponse(req);
if (req.authenticated && resp.authFailed)
{
authenticationStatus = AuthenticationStatus.NotAuthenticated;
error = "Authentication failed. Error: " + resp.error;
Disconnect();
}
return resp;
}
/// <summary>
/// Override GetAuthenticationStatus for complex access check.
/// </summary>
protected override AuthenticationStatus GetAuthenticationStatus()
{
// Make sure we don't fail basic auth checks
AuthenticationStatus status = base.GetAuthenticationStatus();
if (status != AuthenticationStatus.Authenticated)
{
return(status);
}
// Default to not authorized
status = AuthenticationStatus.InsufficientRights;
// Admin
if (AngelSession.CurrentAngelSession.SystemRights >= SystemRights.SystemEditor)
{
// Admins have access to everything
status = AuthenticationStatus.Authenticated;
}
// If non-admin, and admin rights are not required, check course editor rights requirement
else if (!RequireSystemAdminRights)
{
// Course editor rights not required
if (!RequireCourseEditorRights)
{
status = AuthenticationStatus.Authenticated;
}
// Check course editor rights
else
{
// Check roster entry for course rights
CourseRoster currentCourseRosterEntry = AngelSession.CurrentAngelSession.RosterEntry;
if (currentCourseRosterEntry != null)
{
if (currentCourseRosterEntry.UserRights >= CourseRights.CourseEditor)
{
// Has course editor rights
status = AuthenticationStatus.Authenticated;
}
}
// Failed to get roster entry
else
{
// Log
new FrameworkException("Error getting roster entry for course.", ExceptionSeverity.Warning);
}
}
}
return(status);
}
public static void BeginLogin()
{
authenticationStatus = AuthenticationStatus.LoggingIn;
LoginToGPG(
OnSuccess: () =>
{
LoginToPlayFab();
},
OnFailure: (reason) =>
{
LoginToPlayfabWithDeviceID();
}
);
}
public bool Authenticate(string username, string password, out AuthenticationStatus status, out User usr)
{
var user = Find(u => u.Username == username).FirstOrDefault();
usr = null;
if (user == null)
{
status = AuthenticationStatus.InvalidUsername;
return false;
}
if (user.Password == password)
{
if (user.IsLockedOut)
{
status = AuthenticationStatus.UserLockedOut;
return false;
}
if (!user.IsApproved)
{
status = AuthenticationStatus.UserLockedOut;
return false;
}
user.LastLoginDate = DateTime.UtcNow;
usr = user;
var result = SaveOrUpdate(user);
status = AuthenticationStatus.Authenticated;
return true;
}
status = AuthenticationStatus.InvalidPassword;
return false;
//if (user.TemporaryPassword == password)
//{
// user.ResetPassword = true;
// user.Password = user.TemporaryPassword;
// SaveOrUpdate(user);
// return AuthenticationStatus.ResetPassword;
//}
//user.LastPasswordFailureDate = DateTime.UtcNow;
//SaveOrUpdate(user);
//return AuthenticationStatus.InvalidPassword;
}
public bool Authenticate(string username, string hashedPassword, out AuthenticationStatus authenticationStatus, out string email)
{
var authenticationRequest = new AuthenticateRequest();
var server = GetIPConvergeServer(authenticationRequest);
authenticationRequest.email_address = String.Empty; // "*****@*****.**";
authenticationRequest.md5_once_password = hashedPassword.ToLower();
authenticationRequest.username = username;
AuthenticateResponse response = server.Authenticate(authenticationRequest);
authenticationStatus = response.AuthenticationStatus;
email = response.email;
return response.AuthenticationStatus == AuthenticationStatus.Success;
}
public static AuthenticationStatus Authenticate(string email, string password)
{
Email = email;
Password = password;
var authRequest = new HttpHelper(
Settings.Default.API_URL,
new Dictionary<string, string>
{
{ PostItemParameters.Email, Email },
{ PostItemParameters.Password, Password },
{ PostItemParameters.Action, "authenticate" }
});
var result = authRequest.Post();
ParseRequest(result.Message);
Status = result.PostStatus == PostStatus.Created
? Status = AuthenticationStatus.Valid
: Status = AuthenticationStatus.Invalid;
return Status;
}
public bool Authenticate(string username, string hashedPassword, out AuthenticationStatus authenticationStatus, out string email)
{
var ipConverge = GetIPConverge();
IIPConvergeServer server = XmlRpcProxyGen.Create<IIPConvergeServer>();
server.Url = ipConverge.Url + "/converge_master/converge_server.php";
server.NonStandard = XmlRpcNonStandard.All;
var authenticationRequest = new AuthenticateRequest();
authenticationRequest.auth_key = ipConverge.ApiCode;
authenticationRequest.email_address = String.Empty; // "*****@*****.**";
authenticationRequest.md5_once_password = hashedPassword;
authenticationRequest.product_id = ipConverge.ProductId.ToString();
authenticationRequest.username = username;
AuthenticateResponse response = server.Authenticate(authenticationRequest);
authenticationStatus = response.AuthenticationStatus;
email = response.email;
return response.AuthenticationStatus == AuthenticationStatus.Success;
}
public AuthenticationResult(AuthToken authToken, AuthenticationStatus authenticationStatus, Exception error = null)
{
_authenticationStatus = authenticationStatus;
_error = error;
AuthToken = authToken;
}
public static void SetStatus( int portalID, AuthenticationStatus status )
{
string authCookies = Configuration.AUTHENTICATION_STATUS_KEY + "." + portalID;
HttpRequest Request = HttpContext.Current.Request;
HttpResponse Response = HttpContext.Current.Response;
FormsAuthenticationTicket AuthenticationTicket = new FormsAuthenticationTicket( 1, authCookies, DateTime.Now, DateTime.Now.AddHours( 1 ), false, status.ToString() );
// encrypt the ticket
string strAuthentication = FormsAuthentication.Encrypt( AuthenticationTicket );
if( Request.Cookies[authCookies] != null )
{
// expire
Request.Cookies[authCookies].Value = null;
Request.Cookies[authCookies].Path = "/";
Request.Cookies[authCookies].Expires = DateTime.Now.AddYears( -1 );
}
Response.Cookies[authCookies].Value = strAuthentication;
Response.Cookies[authCookies].Path = "/";
Response.Cookies[authCookies].Expires = DateTime.Now.AddHours( 1 );
}
void parameterizedTest(TestSupport.Scenarios scenario, ProtocolVersion version,
AuthenticationRequestMode requestMode, AuthenticationStatus expectedResult) {
Identifier claimedId = TestSupport.GetMockIdentifier(scenario, version);
parameterizedProgrammaticTest(scenario, version, claimedId, requestMode, expectedResult, true);
parameterizedProgrammaticTest(scenario, version, claimedId, requestMode, expectedResult, false);
}
public void AttachTransmissionSide(ISSHConnection con, AuthenticationStatus authStatus)
{
_sshSocket.SetSSHConnection(con);
if (authStatus == AuthenticationStatus.Success) {
SSHSocket ss = (SSHSocket)_sshSocket;
ss.OpenShell();
}
else if (authStatus == AuthenticationStatus.NeedKeyboardInput) {
SSHSocket ss = (SSHSocket)_sshSocket;
ss.OpenKeyboardInteractiveShell();
}
}
void parameterizedWebClientTest(Identifier identityUrl,
AuthenticationRequestMode requestMode, AuthenticationStatus expectedResult)
{
Uri redirectToProviderUrl;
HttpWebRequest rpRequest = (HttpWebRequest)WebRequest.Create(TestSupport.GetFullUrl(TestSupport.ConsumerPage));
NameValueCollection query = new NameValueCollection();
using (HttpWebResponse response = (HttpWebResponse)rpRequest.GetResponse()) {
using (StreamReader sr = new StreamReader(response.GetResponseStream())) {
Regex regex = new Regex(@"\<input\b.*\bname=""(\w+)"".*\bvalue=""([^""]+)""", RegexOptions.IgnoreCase);
while (!sr.EndOfStream) {
string line = sr.ReadLine();
Match m = regex.Match(line);
if (m.Success) {
query[m.Groups[1].Value] = m.Groups[2].Value;
}
}
}
}
query["OpenIdTextBox1$wrappedTextBox"] = identityUrl;
rpRequest = (HttpWebRequest)WebRequest.Create(TestSupport.GetFullUrl(TestSupport.ConsumerPage));
rpRequest.Method = "POST";
rpRequest.AllowAutoRedirect = false;
string queryString = UriUtil.CreateQueryString(query);
rpRequest.ContentLength = queryString.Length;
rpRequest.ContentType = "application/x-www-form-urlencoded";
using (StreamWriter sw = new StreamWriter(rpRequest.GetRequestStream())) {
sw.Write(queryString);
}
using (HttpWebResponse response = (HttpWebResponse)rpRequest.GetResponse()) {
using (StreamReader sr = new StreamReader(response.GetResponseStream())) {
string doc = sr.ReadToEnd();
Debug.WriteLine(doc);
}
redirectToProviderUrl = new Uri(response.Headers[HttpResponseHeader.Location]);
}
HttpWebRequest providerRequest = (HttpWebRequest)WebRequest.Create(redirectToProviderUrl);
providerRequest.AllowAutoRedirect = false;
Uri redirectUrl;
try {
using (HttpWebResponse providerResponse = (HttpWebResponse)providerRequest.GetResponse()) {
Assert.AreEqual(HttpStatusCode.Redirect, providerResponse.StatusCode);
redirectUrl = new Uri(providerResponse.Headers[HttpResponseHeader.Location]);
}
} catch (WebException ex) {
TestSupport.Logger.Error("WebException", ex);
if (ex.Response != null) {
using (StreamReader sr = new StreamReader(ex.Response.GetResponseStream())) {
TestSupport.Logger.ErrorFormat("Response stream follows: {0}", sr.ReadToEnd());
}
}
throw;
}
rpRequest = (HttpWebRequest)WebRequest.Create(redirectUrl);
rpRequest.AllowAutoRedirect = false;
using (HttpWebResponse response = (HttpWebResponse)rpRequest.GetResponse()) {
Assert.AreEqual(HttpStatusCode.Redirect, response.StatusCode); // redirect on login
}
// Try replay attack
if (expectedResult == AuthenticationStatus.Authenticated) {
// This simulates a network sniffing user who caught the
// authenticating query en route to either the user agent or
// the consumer, and tries the same query to the consumer in an
// attempt to spoof the identity of the authenticating user.
rpRequest = (HttpWebRequest)WebRequest.Create(redirectUrl);
rpRequest.AllowAutoRedirect = false;
using (HttpWebResponse response = (HttpWebResponse)rpRequest.GetResponse()) {
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); // error message
}
}
}
public void Authenticate([System.Xml.Serialization.XmlElementAttribute(IsNullable=true)] User user, out AuthenticationStatus AuthenticateResult, [System.Xml.Serialization.XmlIgnoreAttribute()] out bool AuthenticateResultSpecified) {
object[] results = this.Invoke("Authenticate", new object[] {
user});
AuthenticateResult = ((AuthenticationStatus)(results[0]));
AuthenticateResultSpecified = ((bool)(results[1]));
}
public AuthenticationResult(AuthenticationStatus Status, User User)
{
this.Status = Status;
this.User = User;
}
public AuthenticationStatusChangedEventArgs(AuthenticationStatus authenticationStatus)
{
AuthenticationStatus = authenticationStatus;
}
public AuthenticationResult(AuthenticationStatus status, object data)
{
Status = status;
Data = data;
}
/// <summary>
/// Sets authentication setp
/// </summary>
/// <param name="status"></param>
private void SetStep(AuthenticationStatus status)
{
if (_authenticationStep == status)
return;
_authenticationStep = status;
OnAuthenticationStep.Invoke(status);
}
/// <summary>
/// On Authentication progress
/// </summary>
/// <param name="step"></param>
static void _manager_OnAuthenticationStep(AuthenticationStatus step)
{
Console.WriteLine("---- authentication step: {0} ----", step);
if (step == AuthenticationStatus.NoServerFound)
{
_manager.Connect(new System.Net.IPEndPoint(System.Net.IPAddress.Loopback, 15812));
Console.WriteLine(">> Trying loopback:15812 <<");
}
}
