/// <summary> /// Send username and password authorisation /// supports only AUTH=PLAIN for now /// </summary> /// <param name="user">email account username</param> /// <param name="pass">email account password</param> /// <param name="authType">Authorisation type to use</param> public void SendAuthUserPass(String user, String pass, AuthTypes authType = AuthTypes.Plain) { string response = ""; if (authType == AuthTypes.Plain) { Write(". AUTHENTICATE PLAIN"); response = Response(); if (!response.StartsWith("+")) { throw new Imap4Exception(response); } byte[] authBytes = { 0 }; authBytes = authBytes.Concat(Encoding.ASCII.GetBytes(user)).Concat(new byte[] { 0 }).Concat(Encoding.ASCII.GetBytes(pass)).ToArray(); Write(Convert.ToBase64String(authBytes)); response = Response(); } while (!response.StartsWith(".")) { response = Response(); } if (response.Substring(0, 4) != ". OK") { throw new Imap4Exception(response); } }
internal void InvokeLink(AuthTypes linkType, PlayFabError error = null) { if (OnPlayFabLink != null) { OnPlayFabLink.Invoke(linkType, error); } }
internal void InvokeUnlink(AuthTypes unlinkType, PlayFabError error = null) { if (OnPlayFabUnlink != null) { OnPlayFabUnlink.Invoke(unlinkType, error); } }
public User(int id, string name, string description, bool loggedIn, AuthTypes authType, int loginFailedCount, string password) { Id = id; Name = name; Description = description; LoggedIn = loggedIn; AuthType = authType; LoginFailedCount = loginFailedCount; Password = password; }
public HeadBarViewModel() { _breadcrumbBarViewModel = new BreadcrumbBarViewModel(); _userName = "******"; _role = AuthTypes.Other; var dispatcherTimer = new DispatcherTimer(); dispatcherTimer.Tick += DateTimeUpdater; dispatcherTimer.Interval = TimeSpan.FromSeconds(1); dispatcherTimer.Start(); }
protected override void HandleAssembly(Assembly assembly) { assembly.GetTypes() .Where(type => !type.IsInterface) .Where(type => !type.IsAbstract) .Where(type => BaseParameterType.IsAssignableFrom(type)) .ToList() .ForEach(type => { var result = HandleType(type); AuthTypes.AddOrUpdate(type, result, (t, b) => result); }); }
/// <summary> /// OAuth2 客戶端,使用 Client Credential 認證 /// </summary> /// <param name="clientId">Client Id</param> /// <param name="clientSecret">Client Secret</param> /// <param name="baseUri">OAuth2 Server 網址, 範例 http://{root}/oauth2/</param> public OAuth2Client(Uri baseUri, string clientId, string clientSecret) { _authType = AuthTypes.ClientCredential; _baseUri = baseUri; _clientId = clientId; _clientSecret = clientSecret; _httpClient = new HttpClient { BaseAddress = _baseUri }; // We want the response to be JSON. _httpClient.DefaultRequestHeaders.Accept.Clear(); _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); }
protected static string GetAuthType(AuthTypes authType) { switch (authType) { case AuthTypes.PIN: return("PIN"); case AuthTypes.VBVSECURECODE: return("VBVSECURECODE"); case AuthTypes.AVS_VBVSECURECODE: return("AVS_VBVSECURECODE"); default: return("PIN"); } }
/// <summary> /// Add Authorization header to the <see cref="HttpRequest" /> /// </summary> /// <param name="parameter">The parameter for the request</param> /// <param name="request">The http request</param> public async Task HandleRequest(HttpParameter parameter, HttpRequest request) { try { var requireAuth = AuthTypes.GetOrAdd(parameter.GetType(), HandleType); if (requireAuth) { var accessToken = await AuthorizationService.GetAccessToken(); request.AddHeader("Authorization", $"Bearer {accessToken}"); } } catch (Exception e) { Error(e); } }
protected async Task Auth(string code = null, List <ShyftConstants.AuthScopes> scopes = null) { JObject authData; if (string.IsNullOrEmpty(code)) { authData = JObject.FromObject(new { grant_type = "client_credentials" }); if (scopes == null || scopes.Count == 0) { authData["scope"] = "public"; } else { authData["scope"] = GetScopesString(scopes); } AuthType = AuthTypes.TwoLeg; } else { authData = JObject.FromObject(new { grant_type = "authorization_code", code = code }); AuthType = AuthTypes.ThreeLeg; } httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", GetBasicAuth()); JObject responseObject = await PostLyftAuth(new Url(ShyftConstants.BaseUrl).AppendPathSegments("oauth", "token"), authData); ExpiresAt = DateTime.Now + TimeSpan.FromSeconds((int)responseObject["expires_in"]); AccessToken = (string)responseObject["access_token"]; httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken); if (AuthType == AuthTypes.ThreeLeg) { RefreshToken = (string)responseObject["refresh_token"]; } }
public ServerAuthenticator(NetServer netServer, string serverName, string serverDescription, AuthTypes authType) { this.netServer = netServer; this.serverName = serverName; this.serverDescription = serverDescription; this.authType = authType; this.credentialStore = new CredentialStore(); this.sessions = new Dictionary <string, Session>(); this.sessionCleanupTimer = new Timer { Interval = 10000.00, // 10 seconds AutoReset = true }; this.sessionCleanupTimer.Elapsed += onSessionCleanup; this.sessionCleanupTimer.Start(); netServer.RegisterPacketHandler(MODULE_NAME, packetHandler); netServer.OnConnectionEstablished += ConnectionEstablishedHandler; netServer.OnConnectionClosed += ConnectionClosedHandler; }
public override void OnAuthorization(HttpActionContext actionContext) { if (actionContext.RequestContext.Principal.Identity.IsAuthenticated) { bool result = AuthorizeRequest(actionContext); if (result) { return; } else { authType = AuthTypes.Authorize; HandleUnauthorizedRequest(actionContext); } } else { authType = AuthTypes.Authenticate; HandleUnauthorizedRequest(actionContext); } }
/// <summary> /// OAuth2 客戶端,使用 Authorization Code認證 /// </summary> /// <param name="clientId">Client Id</param> /// <param name="clientSecret">Client Secret</param> /// <param name="userName">水文開放資料平台帳號</param> /// <param name="password">水文開放資料平台密碼</param> /// <param name="baseUri">OAuth2 Server 網址, 範例 http://{root}/oauth2/ </param> public OAuth2Client(Uri baseUri, Uri redirectUri, string clientId, string clientSecret, string userName, string password) { ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; if (!baseUri.AbsoluteUri.StartsWith("https")) { throw new Exception("Only support https protocol"); } _authType = AuthTypes.AuthorizationCode; _baseUri = baseUri; _clientId = clientId; _clientSecret = clientSecret; _redirectUri = redirectUri; _password = password; _userName = userName; _httpClient = new HttpClient(); _httpClient.BaseAddress = _baseUri; //http://{root}/oauth2/ // We want the response to be JSON. _httpClient.DefaultRequestHeaders.Accept.Clear(); _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); }
public Host() { AuthType = AuthTypes.WINDOWS; Databases = new List <string>(); }
public ServerAuthenticator(NetServer netServer, string serverName, string serverDescription, AuthTypes authType, string credentialStorePath) : this(netServer, serverName, serverDescription, authType) { Load(credentialStorePath); }
public AuthToken(string username, AuthTypes authType, DateTimeOffset expires) { this.Username = username; this.AuthType = authType; this.Expire = (DateTime.UtcNow.AddTicks(expires.Ticks)).Ticks; }
/// <summary> /// Create auth filter with custom authentication type and roles. Use this constructor /// for global filter registration /// </summary> /// <param name="expectedAuthScheme"></param> /// <param name="roles"></param> public AuthFilter(AuthTypes expectedAuthScheme, params string[] roles) :base() { this.roles = roles; this.expectedAuthScheme = expectedAuthScheme; }
public async Task AuthWithRefreshToken(string refreshToken) { AuthType = AuthTypes.ThreeLeg; RefreshToken = refreshToken; await RefreshAccessToken(); }
public void SetType(AuthTypes k) { auth = k; }
public NetworkCredential GetCredential(Uri uri, string authType) { return(authType == null || !AuthTypes.Any() || AuthTypes.Any(x => StringComparer.OrdinalIgnoreCase.Equals(x, authType)) ? InnerCredential.GetCredential(uri, authType) : null); }
public void SetType(AuthTypes k) { auth = k; }
/// <summary> /// Kick off the authentication process by specific authType. /// </summary> /// <param name="authType"></param> /// <param name="authKeys"></param> public void Authenticate(AuthTypes authType, AuthKeys authKeys = null) { AuthType = authType; Authenticate(authKeys); }
/// <summary> /// Send the Authentication challenge request /// </summary> /// <param name="message"></param> /// <param name="actionContext"></param> private void challenge(HttpActionContext actionContext, string message, AuthTypes scheme) { var body = new { error = message }; actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.Unauthorized, body); actionContext.Response.Headers.Add("WWW-Authenticate", scheme.ToString()); }
public static bool DoSocksAuth(Socks5Client p, string Username, string Password) { AuthTypes auth = Socks.Greet(p.Client); if (auth == AuthTypes.Unsupported) { p.Client.Disconnect(); return(false); } if (auth != AuthTypes.None) { p.enc = new Encryption.SocksEncryption(); switch (auth) { case AuthTypes.Login: //logged in. p.enc.SetType(AuthTypes.Login); //just reqeust login? break; case AuthTypes.SocksBoth: //socksboth. p.enc.SetType(AuthTypes.SocksBoth); p.enc.GenerateKeys(); //send public key. p.Client.Send(p.enc.GetPublicKey()); //now receive key. byte[] buffer = new byte[4096]; int keysize = p.Client.Receive(buffer, 0, buffer.Length); p.enc.SetKey(buffer, 0, keysize); //let them know we got it //now receive our encryption key. int enckeysize = p.Client.Receive(buffer, 0, buffer.Length); //decrypt with our public key. byte[] newkey = new byte[enckeysize]; Buffer.BlockCopy(buffer, 0, newkey, 0, enckeysize); p.enc.SetEncKey(p.enc.key.Decrypt(newkey, false)); //now we share our encryption key. p.Client.Send(p.enc.ShareEncryptionKey()); break; case AuthTypes.SocksEncrypt: p.enc.SetType(AuthTypes.SocksEncrypt); p.enc.GenerateKeys(); //send public key. p.Client.Send(p.enc.GetPublicKey()); //now receive key. buffer = new byte[4096]; keysize = p.Client.Receive(buffer, 0, buffer.Length); p.enc.SetKey(buffer, 0, keysize); //let them know we got it p.Client.Send(new byte[] { (byte)HeaderTypes.Socks5, (byte)HeaderTypes.Zero }); //now receive our encryption key. enckeysize = p.Client.Receive(buffer, 0, buffer.Length); //decrypt with our public key. newkey = new byte[enckeysize]; Buffer.BlockCopy(buffer, 0, newkey, 0, enckeysize); p.enc.SetEncKey(p.enc.key.Decrypt(newkey, false)); //wait for server to confirm we got it. p.Client.Receive(buffer, 0, buffer.Length); //now we share our encryption key. p.Client.Send(p.enc.ShareEncryptionKey()); //socksencrypt. break; case AuthTypes.SocksCompress: p.enc.SetType(AuthTypes.SocksCompress); //sockscompress. break; default: p.Client.Disconnect(); return(false); } if (p.enc.GetAuthType() != AuthTypes.Login) { //now receive login params. byte[] buff = new byte[1024]; int recv = p.Client.Receive(buff, 0, buff.Length); //check for if (recv > 0) { //check if socks5 version is 5 if (buff[0] == 0x05) { //good. if (buff[1] == (byte)AuthTypes.Login) { if (Username == null || Password == null) { p.Client.Sock.Close(); return(false); } int ret = Socks.SendLogin(p.Client, Username, Password); if (ret != 1) { p.Client.Sock.Close(); return(false); } } else { //idk? close for now. p.Client.Disconnect(); return(false); } } } else { p.Client.Disconnect(); return(false); } } else { if (Username == null || Password == null) { p.Client.Sock.Close(); return(false); } int ret = Socks.SendLogin(p.Client, Username, Password); if (ret != 1) { p.Client.Sock.Close(); return(false); } } } return(true); }
public Host() { AuthType = AuthTypes.Windows; Databases = new List <string>(); }