public static void SendAuthComplete(bool failed, AuthResult result, AuthSession session) { var complete = new AuthPacket(AuthServerMessage.Complete); complete.Write(failed, 1); if (failed) { complete.Write(false, 1); // false - disable optional modules complete.Write(1, 2); // 1 - enable AuthResults complete.Write(result, 16); // AuthResults (Error codes) complete.Write(0x80000000, 32); // Unknown } else { complete.Write(0, 3); complete.Write(0x80005000, 32); // Ping request, ~10 secs var hasOptionalData = true; complete.Write(hasOptionalData, 1); if (hasOptionalData) { var hasConnectionInfo = true; complete.Write(hasConnectionInfo, 1); if (hasConnectionInfo) { complete.Write(25000000, 32); complete.Write(1000, 32); } } complete.Write(false, 1); complete.WriteString("", 8, false); // FirstName not implemented complete.WriteString("", 8, false); // LastName not implemented complete.Write(session.Account.Id, 32); complete.Write(0, 8); complete.Write(0, 64); complete.Write(0, 8); complete.WriteString(session.Account.Email, 5, false, -1); complete.Write(0, 64); complete.Write(0, 32); complete.Write(0, 8); } session.Send(complete); }
public SamlDirector(IPrincipalBuilder principalBuilder, IAuthenticationSession session, IPrincipalContext context) { _principalBuilder = principalBuilder; _session = session; _context = context; _result = new AuthResult { Success = false, Continuation = FubuContinuation.RedirectTo(new LoginRequest { Message = SamlValidationKeys.UnableToValidationSamlResponse }, "GET") }; }
public ServerAuthProof(BinaryReader reader) : this() { command = AuthCommand.LOGON_PROOF; error = (AuthResult)reader.ReadByte(); if (error != AuthResult.SUCCESS) { reader.ReadUInt16(); return; } M2 = reader.ReadBytes(20); unk1 = reader.ReadUInt32(); unk2 = reader.ReadUInt32(); unk3 = reader.ReadUInt16(); }
public ServerAuthChallenge(BinaryReader reader) : this() { command = AuthCommand.LOGON_CHALLENGE; unk2 = reader.ReadByte(); error = (AuthResult)reader.ReadByte(); if (error != AuthResult.SUCCESS) return; B = reader.ReadBytes(32); gLen = reader.ReadByte(); g = reader.ReadBytes(1); nLen = reader.ReadByte(); N = reader.ReadBytes(32); salt = reader.ReadBytes(32); unk3 = reader.ReadBytes(16); securityFlags = reader.ReadByte(); }
public async Task<AuthResult> AuthAsync(string startUrl, string endUrlPrefix) { AuthResult result = new AuthResult(WebAuthenticationStatus.UserCancel); Uri start = null; OnlineIdServiceTicketRequest[] tickets = new OnlineIdServiceTicketRequest[] { new OnlineIdServiceTicketRequest( new Uri(startUrl).Host, String.IsNullOrEmpty(LiveIdAuthPolicy) ? ServiceDefinition.DefaultLiveIdAuthPolicy : LiveIdAuthPolicy) }; try { var onlineIdAuthenticator = new OnlineIdAuthenticator(); UserIdentity useridentity = await onlineIdAuthenticator.AuthenticateUserAsync(tickets, CredentialPromptType.PromptIfNeeded); if (useridentity != null && useridentity.Tickets != null && useridentity.Tickets.Count > 0) { OnlineIdServiceTicket ticket = useridentity.Tickets.First(); start = new Uri(startUrl + WebUtility.UrlEncode("&" + ticket.Value) + "&mobile=true"); } } catch (TaskCanceledException) { result.Status = WebAuthenticationStatus.UserCancel; } catch { start = new Uri(startUrl + "&mobile=true"); } if (start != null) { WebAuthenticationResult webAuthResult = (await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, start, new Uri(endUrlPrefix))); result = new AuthResult(webAuthResult); } return result; }
public AuthResult merge(AuthResult auth) { if (auth.result != null) { result = auth.result; game = null; player = null; } else { if (auth.game != null) { game = auth.game; } if (auth.player != null) { player = auth.player; } } return(this); }
public async Task <IActionResult> Auth(AuthRequest request) { AuthResult res = userService.Login( new LoginInfoDTO { Login = request.Login, Password = request.Password, Key = request.SecretKey, Browser = Request.Headers["User-Agent"], IP = Request.HttpContext.Connection.RemoteIpAddress.ToString() } ); if (res.Status == AuthStatus.Succsess) { await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(res.Identity)); } return(new JsonResult( new AuthResponse { AuthType = res.authType, KeyTime = res.KeyTime, Status = res.Status })); }
public AuthResult TryToApply() { AuthResult result = AuthResult.Failed(); _requestData.Value(SamlResponseKey, v => { try { var xml = v.RawValue as string; ProcessSamlResponseXml(xml); } catch (Exception e) { _logger.Error("Saml Response handling failed", e); _director.FailedUser(); } result = _director.Result(); }); return(result); }
public static AuthResult GetAuth <TKey>(System.Security.Claims.ClaimsIdentity claim, IUserDevice <TKey> model) { var now = DateTime.Now; var jwt = new JwtSecurityToken( issuer: AuthOption.ISSUER, audience: AuthOption.AUDINECE, notBefore: now, claims: claim.Claims, expires: now.Add(TimeSpan.FromMinutes(AuthOption.LifeTime)), signingCredentials: new SigningCredentials(State.GetSecurityKey(), SecurityAlgorithms.HmacSha256)); var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt); AuthResult result = new AuthResult() { AccessToken = encodedJwt, RefreshToken = ComputeSha256Hash(now.ToLongDateString() + now.ToLongTimeString() + RepositoryRule.State.State.RandomString(6)), AccessTime = now, }; return(result); }
public IAuthResult Login(ILoginModel model) { var result = new AuthResult { Message = Constants.MessageLoginFailUnknow, Success = false }; UserService = Container.Resolve <IUserService>(); var user = UserService.GetByLoginPassword(model.Login.ToLower(), model.Password); if (user != null) { result.Success = true; result.Message = Constants.MessageLoginSuccess; result.Login = user.Login; result.UserID = user.Id.ToString(); } return(result); }
public IActionResult CheckUser([FromForm] UserAuthRequest request) { var tags = new [] { "administrator", "management" }; try { var userlog = string.Format("user : {0}, password : {1}", request.UserName, request.Password); _logger.LogInformation(userlog); if (request.UserName == "authuser") //Sample check you can put your custom logic over here { return(AuthResult.Deny()); } } catch (Exception ex) { //check or log error } return(AuthResult.Allow(tags)); }
public AuthResult TryPassword(string userName, string password) { byte[] phash = Digest(password); var reply = Call(CmdTryPassword, userName, phash); var result = reply.ReadCString(); switch (result) { case ReplyOk: var sessionId = reply.ReadCString(); var sessionCookie = GetCookie(); return(AuthResult.Success(sessionId, sessionCookie)); case ReplyNo: var error = reply.ReadCString(); throw new AuthException(error); default: throw new AuthException($"Unexpected reply {result} from auth server"); } }
public async Task <AuthResult> AssignRoleToUserAsync(int userId, string[] roles) { var user = await _userManager.FindByIdAsync(userId.ToString()); var message = new AuthResult(); var existRoles = await _userManager.GetRolesAsync(user); //adding new roles var newRoles = roles.Where(p => !existRoles.Any(p2 => p2 == p)).ToList(); await _userManager.AddToRolesAsync(user, newRoles); //remove new roles var deletedRoles = existRoles.Where(ex => !roles.Any(p2 => p2 == ex)).ToList(); await _userManager.RemoveFromRolesAsync(user, deletedRoles); message = new AuthResult() { Suceess = true, Message = "Successfully add roles" }; return(message); }
public string ParseGameArguments(AuthResult authResult) { var mcArgumentsDic = new Dictionary <string, string> { { "${version_name}", LaunchSettings.Version }, { "${version_type}", GameProfile?.Type ?? $"\"{LaunchSettings.LauncherName}\"" }, { "${assets_root}", $"\"{AssetRoot}\"" }, { "${assets_index_name}", $"\"{VersionInfo.AssetInfo.Id}\"" }, { "${game_directory}", $"\"{(string.IsNullOrWhiteSpace(LaunchSettings.GamePath) ? "/" : LaunchSettings.GamePath)}\"" }, { "${auth_player_name}", authResult?.SelectedProfile?.Name }, { "${auth_uuid}", authResult?.SelectedProfile?.Id }, { "${auth_access_token}", authResult?.AccessToken }, { "${user_properties}", authResult?.User?.Properties.ResolveUserProperties() }, { "${user_type}", "Mojang" } // use default value as placeholder }; return(StringHelper.ReplaceByDic(VersionInfo.GameArguments, mcArgumentsDic)); }
public void RetriveToken(ref AuthResult authResult) { Debug.Assert(authResult.Status); if (!authResult.Status) { return; } var client = authResult.Client; var output = Exec.Run("-p " + server.Host + " -u " + client.Username + " tickets"); var match = Regex.Match(output, @"\b(.*)\s((.*))\b"); if (match.Success && match.Groups.Count == 4) { var token = match.Groups[3]; client.Token = token.Value; } else { authResult = new AuthResult(client, false); } }
public async Task <Launcher.Launcher> LaunchGame(string id, bool offline = true) { AuthResult authResult; if (offline) { authResult = new AuthResult(BmclCore.Config); } else { authResult = await BmclCore.AuthManager.Login(BmclCore.Config.Username, BmclCore.Config.GetPassword()); if (!authResult.IsSuccess) { var authname = "BMCL"; if (BmclCore.AuthManager.GetCurrectAuth() is IBmclAuthPlugin) { var plugin = BmclCore.AuthManager.GetCurrectAuth() as IBmclAuthPlugin; authname = plugin?.GetName(); } MessageBox.Show(BmclCore.MainWindow, authResult.Message, authname, MessageBoxButton.OK); return(null); } } if (_launcher != null) { throw new AnotherGameRunningException(_launcher); } var game = GetVersion(id); if (game == null) { throw new NoSuchVersionException(id); } _launcher = new Launcher.Launcher(game, authResult, BmclCore.Config); _launcher.OnLaunchError += (launcher, exception) => _launcher = null; _launcher.OnGameExit += (sender, info, exitcode) => _launcher = null; _launcher.OnGameStart += LauncherOnGameStart; return(_launcher); }
static async Task Main(string[] args) { OfflineAuthenticator mojangAuthenticator = new OfflineAuthenticator { Account = "*****@*****.**", }; AuthResult authResult = mojangAuthenticator.Auth(); Console.WriteLine(authResult.PlayerName); Global.AuthConfiguation = authResult; Global.LaunchConfiguation = new LaunchConfiguation { JavaSetting = new JavaSetting { MaxMemorySize = 10, MinMemorySize = 6, JavaPath = @"C:\Program Files\Java\jre1.8.0_241\bin\javaw.exe", }, MinecraftSetting = new MinecraftSetting { LauncherName = "Tets", MinecraftSource = @"D:\Minecraft\Solution1\.minecraft", VersionJson = JsonStorage.ParseVersionJson(@"D:\Minecraft\Solution1\.minecraft\versions\1.8.9") } }; foreach (var item in Libraries.GetExistLibraries()) { Console.WriteLine(item.DownloadUri); Console.WriteLine(item.FileName); } LaunchCore launchCore = new LaunchCore(); String argss = launchCore.GenerateLaunchArgs(); Console.WriteLine(argss); launchCore.ExtraNatives(); Console.ReadLine(); }
/// <summary> /// Valida um token. /// </summary> /// <returns></returns> internal static AuthResult ValidateToken() { if (_securityKey == null) { _securityKey = new InMemorySymmetricSecurityKey(Encoding.UTF8.GetBytes(ParameterCache.Get("TOKEN_SYMETRIC_KEY"))); } AuthResult result = new AuthResult(); string accessToken = ReadTokenFromRequest(); if (!string.IsNullOrWhiteSpace(accessToken)) { TokenValidationParameters validationParameters = new TokenValidationParameters() { ValidAudience = TOKEN_AUDIENCE, ValidIssuer = TOKEN_ISSUER, IssuerSigningKey = _securityKey }; SecurityToken jwtToken = null; try { result.TokenClaims = _tokenHandler.ValidateToken(accessToken, validationParameters, out jwtToken); } catch (SecurityTokenExpiredException) { result.AuthStatus = AuthStatus.TOKEN_EXPIRED; } catch { result.AuthStatus = AuthStatus.UNAUTHORIZED; } } else { result.AuthStatus = AuthStatus.ANONYMOUS; } return(result); }
static string ObtainAccessToken(string clientID, string clientSecret, string refreshToken) { const string AuthRequestBase = "https://auth.ischool.com.tw/oauth/token.php"; const string AuthGrantType = "grant_type=refresh_token"; string urlString = $"{AuthRequestBase}?{AuthGrantType}&client_id={clientID}&client_secret={clientSecret}&refresh_token={refreshToken}"; // 準備 Http request HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(urlString); req.Method = "GET"; req.Accept = "*/*"; req.ContentType = "application/json"; req.ContentLength = 0; ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls; // 呼叫並取得結果 HttpWebResponse rsp; rsp = (HttpWebResponse)req.GetResponse(); Stream dataStream = rsp.GetResponseStream(); StreamReader reader = new StreamReader(dataStream); string result = reader.ReadToEnd(); reader.Close(); dataStream.Close(); rsp.Close(); //Console.WriteLine(result); // 解析 JSON byte[] byteArray = Encoding.UTF8.GetBytes(result); MemoryStream authStream = new MemoryStream(byteArray); DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(AuthResult)); authStream.Position = 0; AuthResult authResult = (AuthResult)ser.ReadObject(authStream); return(authResult.accessToken); }
private static void MenuAuthHelper(AuthResult result, string menuName) { string str; if (result == null || !result.IsLicensed) { str = "licenseUnlicensed"; } else if (result.IsLifetime()) { str = "licenseLifetime"; } else { str = "licenseSubscription"; } var expiry = result.Expiry.ToString(CultureInfo.InvariantCulture); var item = Menu.GetMenu("license").Get <MenuText>(menuName); void Update(EventArgs _) { Menu.ResetTranslations("license", menuName); var inner = GetString(str).Replace("{expiry}", expiry); item.Text = item.Text.Replace("{status}", "\n" + inner); } if (MenuLicenseHandlers.TryGetValue(menuName, out var value)) { Menu.OnLanguageChanged -= value; } MenuLicenseHandlers[menuName] = Update; Menu.OnLanguageChanged += Update; Update(null); }
private void ShowAuthError(string email, AuthResult res, Mode mode, bool googleAuth = false) { DialogFragment dia = null; switch (res) { case AuthResult.InvalidCredentials: if (mode == Mode.Login && !googleAuth) { dia = new ErrorDialogFragment(LoginError.InvalidCredentials); } else if (mode == Mode.Signup) { dia = new ErrorDialogFragment(LoginError.SignupFailed); } else if (mode == Mode.Login && googleAuth) { dia = new ErrorDialogFragment(LoginError.NoAccount); } break; case AuthResult.NoDefaultWorkspace: dia = new NoWorkspaceDialogFragment(email); break; case AuthResult.NetworkError: dia = new ErrorDialogFragment(LoginError.NetworkError); break; default: dia = new ErrorDialogFragment(LoginError.SystemError); break; } if (dia != null) { dia.Show(FragmentManager, "auth_result_dialog"); } }
public async Task <IActionResult> Token([FromBody] Client.Auth.TokenCreationInfo tokenCreationInfo, CancellationToken cancellationToken) { string encodedJwt; try { encodedJwt = await authenticator.AuthenticateAsync(tokenCreationInfo.Email, tokenCreationInfo.Password, cancellationToken); } catch { return(BadRequest("Invalid login or password")); } var authResult = new AuthResult { Token = encodedJwt }; return(Ok(authResult)); }
public IActionResult Index(IndexViewModel model) { if (!ModelState.IsValid) { return(View(model)); } UserData user = _authentication.GetUserByAssociatedUser(User); if (user == null) { throw new ApplicationException($"Unable to load user with ID '{_authentication.GetUserId(User)}'."); } var email = user.Email; if (model.Email != email) { AuthResult setEmailResult = _authentication.SetUserEmail(User, model.Email); if (!setEmailResult.Succeded) { throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'."); } } var phoneNumber = user.PhoneNumber; if (model.PhoneNumber != phoneNumber) { AuthResult setPhoneResult = _authentication.SetUserPhoneNumber(User, model.PhoneNumber); if (!setPhoneResult.Succeded) { throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'."); } } StatusMessage = "Your profile has been updated"; return(RedirectToAction(nameof(Index))); }
public async Task <ApplicationActionResult <AuthResult> > Refresh(JwtTokenModel authToken) { AuthResult refreshResult = new AuthResult(); string userLogin = _tokenHelper.GetUserNameFromExpiredToken(authToken.AccessToken); ApplicationUser user = await _userManager.FindByNameAsync(userLogin); //Validate refresh token if (user.RefreshToken != authToken.RefreshToken) { refreshResult.InvalidRefreshToken(); return(new ApplicationActionResult <AuthResult>(refreshResult, (int)Core.Constants.ActionStatuses.Fail, "")); } //create access and refresh token var token = await _tokenHelper.CreateJwtTokens(user); //save user refresh token in database user.SetRefreshToken(token.RefreshToken); await _userManager.UpdateAsync(user); refreshResult.SuccessAuth(token); return(new ApplicationActionResult <AuthResult>(refreshResult, (int)Core.Constants.ActionStatuses.Success, "")); }
public async Task AddUser_Throws_Exception_When_Trying_To_Write_Different_User_Than_Specified_Credentials() { /* Test this rule * { * "rules": { * "users": { * "$userId": { * ".write": "auth.uid == $userId" * } * } * } * } */ AuthResult result = await _authService.LoginWithEmailAndPasswordAsync(_validatedUser, "testPassword"); Assert.IsNotNull(result.User); Assert.IsNotNull(result.User.UserId); Assert.IsTrue(result.User.IsEmailVerified); Assert.AreEqual("Success", result.Result); //check that preparation is successful Assert.ThrowsAsync <FirebaseException>(() => _sut.SaveUserAsync(_user)); }
/// <summary> /// Update the user's password /// </summary> /// <param name="oldpass">Old password to validate</param> /// <param name="newpass">Intended password to be changed</param> /// <returns>AuthResult Success if password is changed successfully</returns> internal AuthResult UpdatePassword(string oldpass, string newpass) { using (DataContext db = new DataContext()) { Users u = Users.FindByEmail(this.Email, db); if (u == null) { return(AuthResult.UserNotFound); } AuthResult oldpwres = ValidateLogin(oldpass); if (oldpwres != AuthResult.Success) { return(oldpwres); } db.Entry(u).Reference(usr => usr.UserKeyStore).Load(); // Get the user key store and decrypt their private key UserKeyStore uks = u.UserKeyStore; byte[] aesKey = Crypt.Instance.DeriveKey(oldpass, u.Salt, uks.DesIv); byte[] rsaPrivBytes = Crypt.Instance.DecryptAes(uks.RsaPriv, aesKey, uks.AesIv); // Do the password update u.UpdatePassword(newpass); // Encrypt the private key again byte[] newAesIv = Crypt.Instance.GenerateIv("AES"); uks.AesIv = newAesIv; byte[] newAesKey = Crypt.Instance.DeriveKey(newpass, u.Salt, uks.DesIv); byte[] newRsaPrivEnc = Crypt.Instance.EncryptAes(rsaPrivBytes, newAesKey, newAesIv); uks.RsaPriv = newRsaPrivEnc; db.SaveChanges(); AuthLogger.Instance.PasswordChanged(); return(AuthResult.Success); } }
public override void OnActionExecuting(HttpActionContext actionContext) { if (EFWCoreLib.WcfFrame.ServerController.WcfServerManage.IsDebug == false) { //登陆之外的请求验证token if (actionContext.Request.RequestUri.AbsolutePath.ToLower().IndexOf("/efwplusApi/coresys/login/userlogin".ToLower()) == -1) { string token = null; string[] qs = actionContext.Request.RequestUri.Query.ToLower().Split(new char[] { '?', '&' }); foreach (var s in qs) { string[] kv = s.Split(new char[] { '=' }); if (kv.Length == 2 && kv[0] == "token") { token = kv[1]; break; } } if (token == null) { throw new Exception("no token"); } AuthResult result = SsoHelper.ValidateToken(token); if (result.ErrorMsg != null) { throw new Exception(result.ErrorMsg); } SysLoginRight loginInfo = new SysLoginRight(); loginInfo.UserId = Convert.ToInt32(result.User.UserId); loginInfo.EmpName = result.User.UserName; actionContext.Request.Properties[Key] = loginInfo; } } }
private async Task <AuthResult> SingIn(string ID, string Password) { var result = new AuthResult(); if (ID == AppSettings.Auth.ID && Password == AppSettings.Auth.Password) { var identity = new ClaimsIdentity("Password"); identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, ID)); var principal = new ClaimsPrincipal(identity); var authenticationProperties = new AuthenticationProperties { IsPersistent = true }; await HttpContext.Authentication.SignInAsync("MyCookieAuth", principal, authenticationProperties); result.Succeeded = true; } else { result.Succeeded = false; } return(result); }
public async Task <AuthResult <Token> > SignUp(SignUpDTO signUpDto) { try { if (signUpDto == null || string.IsNullOrEmpty(signUpDto.Email) || string.IsNullOrEmpty(signUpDto.Password) || string.IsNullOrEmpty(signUpDto.ConfirmPassword) || string.IsNullOrEmpty(signUpDto.FirstName) || string.IsNullOrEmpty(signUpDto.LastName) || signUpDto.Password != signUpDto.ConfirmPassword ) { return(AuthResult <Token> .UnvalidatedResult); } var newUser = new TUser { SecondName = signUpDto.LastName, FirstName = signUpDto.FirstName, Email = signUpDto.Email, UserName = signUpDto.Email }; var result = await userManager.CreateAsync(newUser, signUpDto.Password); if (result.Succeeded) { //await userManager.AddToRoleAsync(newUser, "User"); var token = jwtManager.GenerateToken(newUser); return(AuthResult <Token> .TokenResult(token)); } return(AuthResult <Token> .UnauthorizedResult); } catch (Exception e) { Console.Write(e.Message); throw; } }
/// <summary> /// 登录 /// </summary> /// <param name="loginName"></param> /// <param name="password"></param> /// <param name="isRememberPassword"></param> /// <returns></returns> public AuthResult Login(string loginName, string password, bool isRememberPassword) { var status = new AuthResult() { IsSuccess = false }; // 这不会计入到为执行帐户锁定而统计的登录失败次数中 // 在多次输入错误密码的情况下触发帐户锁定 shouldLockout: true var result = SignInManager.PasswordSignIn(loginName, password, isRememberPassword, shouldLockout: true); switch (result) { case SignInStatus.Success: status.IsSuccess = true; status.Status = LoginStatus.Success; break; case SignInStatus.LockedOut: status.Message = "当前账户已被锁定!"; status.Status = LoginStatus.LockedOut; break; case SignInStatus.RequiresVerification: status.Message = "当前账户需要验证!"; status.Status = LoginStatus.RequiresVerification; break; case SignInStatus.Failure: status.Message = "您输入的用户名或密码不对,请重新输入!"; status.Status = LoginStatus.Failure; break; default: status.Message = "无效的登录尝试。"; status.Status = LoginStatus.Orthers; break; } return(status); }
public static async Task <string> SendResult(byte[] archiveData) { try { using (HttpClient client = new HttpClient()) { HttpResponseMessage authResponse = await client.PostAsync($"{ApiUrl}/login", new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("login", LogicSettings.Default.ApiUserName), new KeyValuePair <string, string>("password", LogicSettings.Default.ApiPassword) })); string authResponseContent = await authResponse.Content.ReadAsStringAsync(); AuthResult authResult = JsonConvert.DeserializeObject <AuthResult>(authResponseContent); if (authResult.ExpirationDate == null && authResult.Token == null) { return("Unable to login"); } MultipartFormDataContent content = new MultipartFormDataContent(); StreamContent archiveContent = new StreamContent(new MemoryStream(archiveData)); archiveContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/zip"); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authResult.Token); content.Add(archiveContent, "arc", "arc.zip"); HttpResponseMessage uploadResponse = await client.PostAsync($"{ApiUrl}/sendResult", content); string uploadResponseContent = await uploadResponse.Content.ReadAsStringAsync(); return(uploadResponseContent); } } catch (Exception ex) { return(ex.ToString()); } }
public async Task AddUser_Throws_Exception_When_Email_Not_Validated() { /* Test this rule * { * "rules": { * "users": { * "$userId": { * ".write": "auth.token.email_verified == true" * } * } * } * } */ AuthResult result = await _authService.LoginWithEmailAndPasswordAsync(_user, "testPassword", false); Assert.IsNotNull(result.User); Assert.IsNotNull(result.User.UserId); Assert.IsFalse(result.User.IsEmailVerified); Assert.AreEqual("Success", result.Result); //check that preparation is successful Assert.ThrowsAsync <FirebaseException>(() => _sut.SaveUserAsync(result.User)); }
protected override void beforeEach() { theDirectoryResult = new AuthResult(); MockFor <ISamlDirector>().Stub(x => x.Result()).Return(theDirectoryResult); theResponseXml = "<Response />"; theRequestData = new InMemoryRequestData(); theRequestData[SamlAuthenticationStrategy.SamlResponseKey] = theResponseXml; theRequestData.Value(SamlAuthenticationStrategy.SamlResponseKey).ShouldNotBeNull(); Services.Inject <IRequestData>(theRequestData); Services.PartialMockTheClassUnderTest(); theException = new NotImplementedException(); ClassUnderTest.Expect(x => x.ProcessSamlResponseXml(theResponseXml)).Throw(theException); theResult = ClassUnderTest.TryToApply(); }
public async Task <AuthResult> Login(AuthRequest request) { AuthResult r = new AuthResult(); await Task.Factory.StartNew(() => { LoginForm l = new LoginForm(request.Name, request.LoginUrl, request.ClientId, request.Scopes, request.RedirectUri); DialogResult dr = l.ShowDialog(); if (dr == DialogResult.OK) { r.Code = l.Code; r.Scopes = l.Scopes; r.HasError = false; } else { r.HasError = true; r.ErrorString = "Unable to login"; } }, new CancellationToken(), TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); return(r); }
public async Task ClientCredentialsReceived_WhenSent() { // Arrange: var mockMessaging = MockMessagingService.Setup(results => { var expectedResult = AuthResult.Authenticated().SetSignedToken("MOCK_TOKEN"); results.RegisterResponse <AuthenticateCaller, AuthResult>(expectedResult); }); var plugin = new MockAppHostPlugin(); var httpClient = TestHttpClient.Create(plugin, mockMessaging); // Act: var credentialModle = new AuthCredentialModel { Credentials = new Dictionary <string, string> { { "CertKey1", "CertValue1" }, { "CertKey2", "CertValue2" } } }; var result = await httpClient.AuthenticateAsync(credentialModle); // Assert: Assert.True(mockMessaging.ReceivedMessages.Count() == 1); var receivedCommand = (AuthenticateCaller)mockMessaging.ReceivedMessages.First(); Assert.NotNull(receivedCommand.Context); var receivedCredentials = receivedCommand.Context.Credentials; Assert.NotNull(receivedCredentials); Assert.True(receivedCredentials.ContainsKey("CertKey1")); Assert.True(receivedCredentials.ContainsKey("CertKey2")); Assert.Equal("CertValue1", receivedCredentials["CertKey1"]); Assert.Equal("CertValue2", receivedCredentials["CertKey2"]); }
public async Task<AuthResult> Login(AuthRequest request) { AuthResult r = new AuthResult(); await Application.Current.Dispatcher.InvokeAsync(() => { LoginForm l = new LoginForm(request.Name, request.LoginUrl, request.ClientId, request.Scopes, request.RedirectUri,request.ScopesCommaSeparated); l.Owner = _owner; bool? res = l.ShowDialog(); if (res.HasValue && res.Value) { r.Code = l.Code; r.Scopes = l.Scopes; r.HasError = false; } else { r.HasError = true; r.ErrorString = "Unable to login"; } }); return r; }
public static async Task SendAuthComplete(bool failed, AuthResult result, AuthSession session) { var authComplete = new Complete { AuthResult = result, Failed = failed }; if (!failed) { authComplete.PingTimeout = 0x80005000; authComplete.RegulatorInfo = new RegulatorInfo { Threshold = 25000000, Rate = 1000 }; authComplete.LogonInfo = new LogonInfo { Account = session.Account, GameAccount = session.GameAccount }; } await session.Send(authComplete); }
public void WriteError(AuthResult errorCode, int server = 0, int module = 0, int line = 0) { WriteString($"<Error code=\"{(int)errorCode}\" server=\"{server}\" module=\"{module}\" line=\"{line}\"/>\n"); }
public static void Show (UIViewController controller, string email, AuthResult res, Mode mode, bool googleAuth=false) { switch (res) { case AuthResult.InvalidCredentials: if (mode == Mode.Login && !googleAuth) { new UIAlertView ( "AuthErrorLoginTitle".Tr (), "AuthErrorLoginMessage".Tr (), null, "AuthErrorOk".Tr ()).Show (); } else if (mode == Mode.Login && googleAuth) { new UIAlertView ( "AuthErrorGoogleLoginTitle".Tr (), "AuthErrorGoogleLoginMessage".Tr (), null, "AuthErrorOk".Tr ()).Show (); } else if (mode == Mode.Signup) { new UIAlertView ( "AuthErrorSignupTitle".Tr (), "AuthErrorSignupMessage".Tr (), null, "AuthErrorOk".Tr ()).Show (); } break; case AuthResult.NoDefaultWorkspace: if (MFMailComposeViewController.CanSendMail) { var dia = new UIAlertView ( "AuthErrorNoWorkspaceTitle".Tr (), "AuthErrorNoWorkspaceMessage".Tr (), null, "AuthErrorNoWorkspaceCancel".Tr (), "AuthErrorNoWorkspaceOk".Tr ()); dia.Clicked += (sender, e) => { if (e.ButtonIndex == 1) { var mail = new MFMailComposeViewController (); mail.SetToRecipients (new[] { "AuthErrorNoWorkspaceEmail".Tr () }); mail.SetSubject ("AuthErrorNoWorkspaceSubject".Tr ()); mail.SetMessageBody (String.Format ("AuthErrorNoWorkspaceBody".Tr (), email), false); mail.Finished += delegate { controller.DismissViewController (true, null); }; controller.PresentViewController (mail, true, null); } }; dia.Show (); } else { new UIAlertView ( "AuthErrorNoWorkspaceTitle".Tr (), "AuthErrorNoWorkspaceMessage".Tr (), null, "AuthErrorOk".Tr ()).Show(); } break; case AuthResult.NetworkError: new UIAlertView ( "AuthErrorNetworkTitle".Tr (), "AuthErrorNetworkMessage".Tr (), null, "AuthErrorOk".Tr ()).Show (); break; default: new UIAlertView ( "AuthErrorSystemTitle".Tr (), "AuthErrorSystemMessage".Tr (), null, "AuthErrorOk".Tr ()).Show (); break; } }
public AuthFailedMessage (AuthManager manager, AuthResult result, Exception ex = null) : base (manager) { this.result = result; exception = ex; }
public static void SendAuthenticationLogOnProofFailure(IClient client, AuthResult result) { Contract.Requires(client != null); using (var packet = new OutgoingAuthPacket(GruntOpCode.AuthenticationLogOnProof, 3)) { packet.Write((byte)result); if (result == AuthResult.FailUnknownAccount) { // This is only read if the result == 4, and even then its not used. But it does need this to be here, as it does a length check before reading packet.Write((short) 0); } client.Send(packet); } }
public static void SendAuthenticationChallengeFailure(IClient client, AuthResult result) { Contract.Requires(client != null); Contract.Requires(result != AuthResult.Success); using (var packet = new OutgoingAuthPacket(GruntOpCode.AuthenticationLogOnChallenge, 2)) { packet.Write((byte)0x00); packet.Write((byte)result); client.Send(packet); } }
} //miche auch async void OneDrive_loginFinished(AuthResult result) { this.OneDrive.authForm.Close(); if (result.AuthorizeCode != null) { try { LiveConnectSession session = await this.OneDrive.LiveAuthClient.ExchangeAuthCodeAsync(result.AuthorizeCode); this.OneDrive.liveConnectClient = new LiveConnectClient(session); this.OneDrive.handler = new RefreshTokenHandler(); await this.OneDrive.handler.SaveRefreshTokenAsync(new RefreshTokenInfo(session.RefreshToken)); } catch (Exception) { } } this.setBindings(); this.Btn_LogInOutOneDrive.raiseCanExecuteChanged(); } //miche auch
private void ShowAuthError (string email, AuthResult res, bool googleAuth=false) { var dia = new ErrorDialogFragment (res); if (dia != null) { dia.Show (FragmentManager, "auth_result_dialog"); } }
public ErrorDialogFragment (AuthResult e) { switch (e) { case AuthResult.InvalidCredentials: title = Resource.String.LoginSignupFailedDialogTitle; message = Resource.String.LoginSignupFailedDialogText; buttonText =Resource.String.LoginSignupFailedDialogOk; break; case AuthResult.NetworkError: title = Resource.String.LoginNetworkErrorDialogTitle; message = Resource.String.LoginNetworkErrorDialogText; buttonText =Resource.String.LoginNetworkErrorDialogOk; break; default: title = Resource.String.LoginSystemErrorDialogTitle; message = Resource.String.LoginSystemErrorDialogText; buttonText =Resource.String.LoginSystemErrorDialogOk; break; } }
public static void HandleAuthResponse(AuthResult result, CharacterSession session) { var gameAccount = session.GameAccount; var realm = session.Realm; var authResponse = new Packet(ServerMessage.AuthResponse); var hasSuccessInfo = result == AuthResult.Ok; var hasWaitInfo = result == AuthResult.WaitQueue; authResponse.Write(result); authResponse.PutBit(hasSuccessInfo); authResponse.PutBit(hasWaitInfo); authResponse.Flush(); if (hasSuccessInfo) { var allowedRaces = Manager.GameAccount.GetAvailableRaces(gameAccount, realm); var allowedClasses = Manager.GameAccount.GetAvailableClasses(gameAccount, realm); var charTemplates = Manager.GameAccount.GetAvailableCharacterTemplates(gameAccount, realm); authResponse.Write<uint>(0); authResponse.Write<uint>(0); authResponse.Write<uint>(0); authResponse.Write<uint>(0); authResponse.Write<uint>(0); authResponse.Write(gameAccount.BoxLevel); authResponse.Write(gameAccount.BoxLevel); authResponse.Write<uint>(0); authResponse.Write(allowedRaces.Count); authResponse.Write(allowedClasses.Count); authResponse.Write(charTemplates.Count); authResponse.Write<uint>(0); foreach (var r in allowedRaces) { authResponse.Write(r.Key); authResponse.Write(r.Value); } foreach (var c in allowedClasses) { authResponse.Write(c.Key); authResponse.Write(c.Value); } foreach (var set in charTemplates) { authResponse.Write(set.Id); authResponse.Write(set.CharacterTemplateClasses.Count); foreach (var c in set.CharacterTemplateClasses) { authResponse.Write(c.ClassId); authResponse.Write(c.FactionGroup); } authResponse.PutBits(set.Name.Length, 7); authResponse.PutBits(set.Description.Length, 10); authResponse.Flush(); authResponse.Write(set.Name); authResponse.Write(set.Description); } authResponse.PutBit(0); authResponse.PutBit(0); authResponse.PutBit(0); authResponse.PutBit(0); authResponse.PutBit(0); authResponse.Flush(); } session.Send(authResponse); }
public static void SendAuthComplete(bool failed, AuthResult result, Client client) { client.Session.GameAccount.IsOnline = true; var complete = new AuthPacket(AuthServerMessage.Complete); complete.Write(failed, 1); if (failed) { complete.Write(false, 1); // false - disable optional modules complete.Write(1, 2); // 1 - enable AuthResults complete.Write(result, 16); // AuthResults (Error codes) complete.Write(0x80000000, 32); // Unknown } else { // No modules supported here. complete.Write(0, 3); var pingTimeout = 0x80005000; var hasRegulatorRules = true; complete.Write(pingTimeout, 32); complete.Write(hasRegulatorRules, 1); if (hasRegulatorRules) { var hasRegulatorInfo = true; complete.Write(hasRegulatorInfo, 1); if (hasRegulatorInfo) { var threshold = 25000000; var rate = 1000; complete.Write(threshold, 32); complete.Write(rate, 32); } } var haslogonInfo = true; var account = client.Session.Account; var gameAccount = client.Session.GameAccount; complete.Write(!haslogonInfo, 1); complete.WriteString(account.GivenName, 8, false); complete.WriteString(account.Surname, 8, false); complete.Write(account.Id, 32); complete.Write((byte)account.Region, 8); complete.Write((ulong)account.Flags, 64); complete.Write((byte)gameAccount.Region, 8); complete.WriteString(gameAccount.AccountId + "#" + gameAccount.Index, 5, false, -1); complete.Write((ulong)gameAccount.Flags, 64); complete.Write(account.LoginFailures, 32); complete.Write(0, 8); } client.SendPacket(complete); }
private void ShowAuthError (string email, AuthResult res, Mode mode, bool googleAuth=false) { DialogFragment dia = null; switch (res) { case AuthResult.InvalidCredentials: if (mode == Mode.Login && !googleAuth) { dia = new InvalidCredentialsDialogFragment (); } else if (mode == Mode.Signup && !googleAuth) { dia = new SignupFailedDialogFragment (); } else if (mode == Mode.Login && googleAuth) { dia = new NoAccountDialogFragment (); } else if (mode == Mode.Signup && googleAuth) { dia = new SignupFailedDialogFragment (); } break; case AuthResult.NoDefaultWorkspace: dia = new NoWorkspaceDialogFragment (email); break; case AuthResult.NetworkError: dia = new NetworkErrorDialogFragment (); break; default: dia = new SystemErrorDialogFragment (); break; } if (dia != null) { dia.Show (FragmentManager, "auth_result_dialog"); } }