public async Task AuthenticateRequestAsync(HttpRequestMessage requestMessage) { var accessToken = await AcquireTokenAsync(); requestMessage.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); if (accessToken != null) { AuthenticationSuccessful?.Invoke(); } }
/// <summary> /// Hooks into EAC checks and exposes events for it; /// MUST be called after in GameStartDone or later /// </summary> public static void Init() { //if (_isInitialized) // throw new InvalidOperationException(nameof(EacTools) + "." + nameof(Init) + " may only be called once."); Log.Debug("Hooking into the EAC response callbacks ..."); if (EACServer.Instance == null) { throw new ApplicationException("Cannot activate EAC monitoring because EAC server is not (yet) started."); } var successDelegate = EACServer.Instance.GetSuccessDelegate(); var kickDelegate = EACServer.Instance.GetKickDelegate(); if (successDelegate == null || kickDelegate == null) { throw new ApplicationException("Cannot activate EAC monitoring because success and kick delegates are not (yet) set."); } var kickDelegateNew = new KickPlayerDelegate(delegate(ClientInfo info, GameUtils.KickPlayerData data) { if (PersistentData.Instance.EacWhitelist.Contains(info.playerId)) { Log.Out($"EAC check failed but player \"{info.playerName}\" ({info.playerId}) is exempt from EAC kicks."); // Call success delegate instead successDelegate(info); } else { // Let original kick delegate handle it kickDelegate(info, data); PlayerKicked?.Invoke(info, data); } }); // Replace original kick delegate with our new modified one EACServer.Instance.SetKickDelegate(kickDelegateNew); var successDelegateNew = new AuthenticationSuccessfulCallbackDelegate(delegate(ClientInfo info) { // Let original kick delegate handle it successDelegate(info); AuthenticationSuccessful?.Invoke(info); }); // Replace original success delegate with our new modified one EACServer.Instance.SetSuccessDelegate(successDelegateNew); //_isInitialized = true; Log.Debug("EAC monitoring activated."); }
/// <summary> /// Handles the response to the <see cref="US.OpenServer.Protocols.WinAuth.WinAuthProtocolCommands.AUTHENTICATE"/> /// command packet. /// </summary> /// <remarks> /// <para> /// When an <see cref="US.OpenServer.Protocols.WinAuth.WinAuthProtocolCommands.AUTHENTICATED"/> /// response is received, notifies the <see cref="US.OpenServer.SessionBase"/> the /// client is authenticated enabling the session to allow execution of higher /// protocol layers. Finally, signals the <see cref="Authenticate(String, String, String)" /> /// function to unblock the calling thread. /// </para> /// <para> /// When an <see cref="US.OpenServer.Protocols.WinAuth.WinAuthProtocolCommands.ACCESS_DENIED"/> /// response is received, logs the error then signals the <see cref="Authenticate(String, String, String)" /> /// function to unblock the calling thread. /// </para> /// <para> /// When an <see cref="US.OpenServer.Protocols.WinAuth.WinAuthProtocolCommands.ERROR"/> /// response is received, logs the error then signals the <see cref="Authenticate(String, String, String)" /> /// function to unblock the calling thread. /// </para> /// <para> /// Prior to authentication the session disallows all protocols commands. /// </para> /// </remarks> /// <param name="br">A BinaryReader that contains the command packet.</param> public override void OnPacketReceived(BinaryReader br) { lock (this) { if (Session == null) { return; } WinAuthProtocolCommands command = (WinAuthProtocolCommands)br.ReadByte(); switch (command) { case WinAuthProtocolCommands.AUTHENTICATED: IsAuthenticated = true; Session.IsAuthenticated = true; AuthenticationSuccessful?.Invoke(Session.Address, Session.UserName); Log(Level.Info, "Authenticated."); Monitor.PulseAll(this); break; case WinAuthProtocolCommands.ACCESS_DENIED: AuthenticationFailed?.Invoke(Session.Address, Session.UserName); Log(Level.Notice, "Access denied."); Monitor.PulseAll(this); break; case WinAuthProtocolCommands.ERROR: { string errorMessage = br.ReadString(); AuthenticationError?.Invoke(Session.Address, Session.UserName, errorMessage); Log(Level.Notice, errorMessage); Monitor.PulseAll(this); break; } default: Log(Level.Error, string.Format("Invalid or unsupported command. Command: {0}", command)); break; } } }
/// <summary> /// Handles the <see cref="US.OpenServer.Protocols.WinAuth.WinAuthProtocolCommands.AUTHENTICATE"/> /// command packet request. /// </summary> /// <param name="br">A BinaryReader that contains the command packet.</param> public override void OnPacketReceived(BinaryReader br) { lock (this) { if (Session == null) { return; } WinAuthProtocolCommands command = (WinAuthProtocolCommands)br.ReadByte(); try { switch (command) { case WinAuthProtocolCommands.AUTHENTICATE: string userName = br.ReadString(); string password = br.ReadString(); string domain = br.ReadString(); try { // I commented ou this line because it constantly hindered my // Authentication no matter what. //wp = GetPrincipal(userName, password, domain); if (!Authenticate(userName, password)) { throw new Exception("Insufficient privileges."); } UserId = userName; UserName = userName; IsAuthenticated = true; Session.UserName = userName; Session.IsAuthenticated = true; Session.AuthenticationProtocol = this; Log(Level.Info, string.Format(@"Authenticated {0}\{1}.", domain, userName)); MemoryStream ms = new MemoryStream(); GetBinaryWriter(ms, WinAuthProtocolCommands.AUTHENTICATED); //Fires the authentication succefull event AuthenticationSuccessful?.Invoke(Session.Address, Session.UserName); Session.Send(ms); } catch (Exception ex) { Log(Level.Notice, string.Format(@"Access denied. {0}. User: {1}\{2}", ex.Message, domain, userName)); MemoryStream ms = new MemoryStream(); GetBinaryWriter(ms, WinAuthProtocolCommands.ACCESS_DENIED); Session.Send(ms); } break; default: throw new Exception("Invalid or unsupported command."); } } catch (Exception ex) { Log(Level.Error, string.Format("{0} Command: {1}", ex.Message, command)); MemoryStream ms = new MemoryStream(); BinaryWriter bw = GetBinaryWriter(ms, WinAuthProtocolCommands.ERROR); bw.Write(ex.Message); Session.Send(ms); } } }
public Task AuthenticateRequestAsync(HttpRequestMessage request) { AuthenticationSuccessful?.Invoke(); return(Task.CompletedTask); }