async Task IAuthenticationFilter.AuthenticateAsync(
			HttpAuthenticationContext context,
			CancellationToken cancellationToken
		) {
			HttpRequestMessage request = context.Request;

			ID2LPrincipal principal;

			try {
				principal = await AuthenticateAsync( context ).SafeAsync();
			} catch( ValidationException e ) {
				m_log.Warn( "Authentication failed", e );
				context.ErrorResult = new AuthenticationFailureResult( e );
				return;
			} catch( Exception e ) {
				m_log.Error( "Unexpected exception during authentication", e );
				throw;
			}

			// Note: the principal at this point may be anonymous if no credentials
			// were sent. This can be guarded against with the authorization attributes
			// and is by DefaultAuthorizationAttribute.

			// Add to request context so things that can't use DI (e.g. extension
			// methods) can get the principal.
			context.Principal = new D2LPrincipalToIPrincipalAdaptor( principal );

			// We're using a callback here to avoid coupling to Unity (for example)
			m_principalDependencyRegistry.Register( context, principal );
		}
		public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
		{
			HttpRequestMessage request = context.Request;
			AuthenticationHeaderValue authorization = request.Headers.Authorization;

			if (authorization == null || authorization.Scheme != AuthorizationScheme)
			{
				context.Principal = _anonymousPrincipal;
				return;
			}

			string user;
			string password;

			if (!ExtractUserNameAndPassword(authorization.Parameter, out user, out password))
			{
				context.ErrorResult = new AuthenticationFailureResult("Invalid credentials", request);
				return;
			}

			context.Principal = await Authenticate(user, password);

			if (context.Principal == null)
				context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
		}
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var req = context.Request;
            if (req.Headers.Authorization != null &&
                req.Headers.Authorization.Scheme.Equals("basic", StringComparison.OrdinalIgnoreCase))
            {
                var encoding = Encoding.GetEncoding("iso-8859-1");
                var credentials = encoding.GetString(Convert.FromBase64String(req.Headers.Authorization.Parameter));
                var parts = credentials.Split(':');
                var user = parts[0].Trim();
                var password = parts[1].Trim();

                //TODO: User/ password
                if (user.Equals(GetUserName()) && password.Equals(GetPassword()))
                {
                    var claims = new List<Claim>()
                    {
                        new Claim(ClaimTypes.Name, "Miguel Angel Martín Hrdez")
                    };
                    var identity = new ClaimsIdentity(claims, "Basic");
                    var principal = new ClaimsPrincipal(new[] { identity });
                    context.Principal = principal;
                }
                else
                {
                    context.ErrorResult = new UnauthorizedResult(new AuthenticationHeaderValue[0], context.Request);
                }
            }
            else
            {
                context.ErrorResult = new UnauthorizedResult(new AuthenticationHeaderValue[0], context.Request);
            }

            return Task.FromResult(0);
        }
예제 #4
0
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            if (CurrentFilter == null) return Task.FromResult(0);

            context.Principal = Principal;
            return CurrentFilter.AuthenticateAsync(context, cancellationToken);
        }
		private async Task<ID2LPrincipal> AuthenticateAsync( HttpAuthenticationContext context ) {
			ID2LPrincipal principal = await m_requestAuthenticator
				.AuthenticateAsync( context.Request )
				.SafeAsync();

			return principal;
		}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
		public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
		{
			HttpRequestMessage request = context.Request;

			var workContext = context.ActionContext.ControllerContext.GetWorkContext();
			var authenticator = workContext.Resolve<IBasicAuthenticationService>();
			var credentials = authenticator.GetCredentials(request.Headers.Authorization);

			if ( credentials == null )
			{
				this.Logger.Warning(
					"Basic authentication failed: missing credentials {0} for {1}",
					request.Method,
					request.RequestUri);
				context.ErrorResult = new AuthenticationFailureResult("Missing credentials", request);
				return;
			}

			var user = authenticator.GetUserForCredentials(credentials);
			if ( user == null )
			{
				this.Logger.Warning(
					"Basic authentication failed: invalid credentials {0} {1} for {2}",
					credentials.Username,
					request.Method,
					request.RequestUri);
				context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
			}
			else
			{
				authenticator.SetAuthenticatedUserForRequest(user);
			}
		}
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var tokenString = context?.Request?.Headers?.Authorization?.Parameter;
            if (string.IsNullOrEmpty(tokenString))
            {
                SetupUnauthenticated();
                return;
            }

            var tokenInfo = _authorizer.GetTokenInfo(tokenString);
            if (tokenInfo == null)
            {
                context.ErrorResult = new UnauthorizedResult(
                    new AuthenticationHeaderValue[] {},
                    context.Request);
                await context.ErrorResult.ExecuteAsync(cancellationToken);
                SetupUnauthenticated();
                return;
            }

            var identity = new LodIdentity(tokenInfo.UserId, true);
            var principal = new LodPrincipal(tokenInfo.Role, identity);

            Thread.CurrentPrincipal = principal;
            context.Principal = principal;
        }
예제 #8
0
        public void Authenticate(HttpAuthenticationContext context)
        {
            if (context == null)
                return;

            if (context.Principal != null && context.Principal.Identity.IsAuthenticated)
                return;

            var queryString = HttpUtility.ParseQueryString(context.Request.RequestUri.Query.ToString());

            if (queryString != null)
            {
                var apiKeyValues = queryString.GetValues("ApiKey");

                if (apiKeyValues != null)
                {
                    var apiKey = apiKeyValues.GetValue(0);

                    IPrincipal principal = null;
                    if (Auth.Validate(apiKey, out principal))
                    {
                        context.Principal = principal;
                        Thread.CurrentPrincipal = principal;
                    }
                }
            }
        }
        /// <inheritdoc />
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpRequestMessage request = context.Request;

            if (request == null)
            {
                throw new InvalidOperationException(OwinResources.HttpAuthenticationContext_RequestMustNotBeNull);
            }

            IAuthenticationManager authenticationManager = GetAuthenticationManagerOrThrow(request);

            cancellationToken.ThrowIfCancellationRequested();
            AuthenticateResult result = await authenticationManager.AuthenticateAsync(_authenticationType);

            if (result != null)
            {
                IIdentity identity = result.Identity;

                if (identity != null)
                {
                    context.Principal = new ClaimsPrincipal(identity);
                }
            }
        }
        public System.Threading.Tasks.Task AuthenticateAsync(HttpAuthenticationContext context, System.Threading.CancellationToken cancellationToken)
        {
            var request = context.Request;
            var authorization = request.Headers.Authorization;

            var validation = Task.FromResult(Validate(request, authorization, context));
            var authentication = validation.ContinueWith(
                tupleTask =>
                {
                    if (tupleTask.Result != null)
                    {
                        var tuple = tupleTask.Result;
                        var username = tuple.Item2.Item1;
                        var password = tuple.Item2.Item2;

                        var principal = Authenticate(username, password, cancellationToken);
                        if (principal == null)
                        {
                            context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
                        }
                        else
                        {
                            context.Principal = principal;
                        }
                    }
                    else
                    {
                        context.ErrorResult = new AuthenticationFailureResult("Authorization required", request);
                    }

                }
                );

            return authentication;
        }
 public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
 {
     IPrincipal user = null;
     AuthenticationHeaderValue headerValue = context.Request.Headers.Authorization;
     if (null != headerValue && headerValue.Scheme == "Basic")
     {
         string credential = Encoding.Default.GetString(Convert.FromBase64String(headerValue.Parameter));
         string[] split = credential.Split(':');
         if (split.Length == 2)
         {
             string userName = split[0];
             string password;
             if (userAccounters.TryGetValue(userName, out password))
             {
                 if (password == split[1])
                 {
                     GenericIdentity identity = new GenericIdentity(userName);
                     user = new GenericPrincipal(identity, new string[0]);
                 }
             }
         }
     }
     context.Principal = user;
     return Task.FromResult<object>(null);
 }
예제 #12
0
        public System.Threading.Tasks.Task AuthenticateAsync(System.Web.Http.Filters.HttpAuthenticationContext context, System.Threading.CancellationToken cancellationToken)
        {
            IPrincipal user = null;
            AuthenticationHeaderValue headerValue = context.Request.Headers.Authorization;

            if (headerValue != null && headerValue.Scheme == "Basic")
            {
                string   credential = Encoding.Default.GetString(Convert.FromBase64String(headerValue.Parameter));
                string[] split      = credential.Split(':');
                if (split.Length == 2)
                {
                    string userName = split[0];
                    string password;
                    if (_userAccounts.TryGetValue(userName, out password))
                    {
                        if (password == split[1])
                        {
                            GenericIdentity identity = new GenericIdentity(userName, "Basic");
                            user = new GenericPrincipal(identity, new string[0]);
                        }
                    }
                }
            }
            context.Principal = user;
            return(Task.FromResult <object>(null));
        }
예제 #13
0
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var credentials = ParseAuthentication(context.Request.Headers.Authorization);
            if (credentials != null)
            {
                var user = _config.Users.OfType<User>().FirstOrDefault(x =>
                    x.Username.Equals(credentials.UserName, StringComparison.InvariantCultureIgnoreCase));
                if (user != null)
                {
                    if (string.IsNullOrEmpty(user.HashAlgorithm))
                    {
                        if (credentials.Password == user.Password)
                            context.Principal = BuildPrincipal(user);
                    }
                    else
                    {
                        var algo = HashAlgorithm.Create(user.HashAlgorithm);
                        if (algo == null)
                            throw new ConfigurationErrorsException($"No known hash algorithm called {user.HashAlgorithm}.");

                        string hashedPassword = BitConverter.ToString(algo.ComputeHash(Encoding.UTF8.GetBytes(credentials.Password))).Replace("-", "");
                        if (hashedPassword == user.Password.ToUpperInvariant())
                            context.Principal = BuildPrincipal(user);
                    }
                }
            }

            return Task.FromResult(true);
        }
예제 #14
0
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var request = context.Request;
            var authorization = request.Headers.Authorization;

            // No credentials where supplied
            if (authorization == null)
                return;

            // The server does not recognize the authorization scheme.
            if (authorization.Scheme != "Basic")
                return;

            // The credentials were bad.
            if (String.IsNullOrEmpty(authorization.Parameter))
            {
                context.ErrorResult = new AuthenticationFailureResult("Missing credentials", request);
                return;
            }

            // Credentials were invalid
            var credentials = GetCredentialsFromRequest(authorization.Parameter);            
            if(credentials == null)
            {
                context.ErrorResult = new AuthenticationFailureResult("Invalid credentials", request);
                return;
            }

            // Credentials were supplied and were either correct or not.
            var principal = await AuthenticateAsync(credentials, cancellationToken);
            if (principal == null)
                context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
            else
                context.Principal = principal;
        }
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            HttpRequestMessage request = context.Request;
            AuthenticationHeaderValue authorization = request.Headers.Authorization;

            if (authorization == null) return;
            if (authorization.Scheme != "Basic") return;

            if (String.IsNullOrEmpty(authorization.Parameter))
            {
                context.ErrorResult = new AuthenticationFailureResult("Missing credentials", request);
                return;
            }

            Tuple<string, string> usernameAndPassword = ExtractUsernameAndPassword(authorization.Parameter);

            if(usernameAndPassword== null)
            {
                context.ErrorResult = new AuthenticationFailureResult("Invalid Credentials", request);
                return;
            }

            string username = usernameAndPassword.Item1;
            string password = usernameAndPassword.Item2;

            IPrincipal principal = await AuthenticateAsync(username, password, cancellationToken);

            if (principal == null)
                context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
            else context.Principal = principal;
        }
        /// <inheritdoc />
        public async Task<IAuthenticationResult> AuthenticateAsync(HttpAuthenticationContext context,
            CancellationToken cancellationToken)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpRequestMessage request = context.Request;

            if (request == null)
            {
                throw new InvalidOperationException(OwinResources.HttpAuthenticationContext_RequestMustNotBeNull);
            }

            OwinRequest owinRequest = request.GetOwinRequest();

            cancellationToken.ThrowIfCancellationRequested();
            IIdentity identity = await owinRequest.AuthenticateAsync(_authenticationType);

            if (identity == null)
            {
                return null;
            }

            return new SucceededAuthenticationResult(new ClaimsPrincipal(identity));
        }
 public override void OnAuthentication(HttpAuthenticationContext context)
 {
     if (!Authenticate(context))
     {
         context.ErrorResult = new StatusCodeResult(HttpStatusCode.Unauthorized, context.Request);
     }
 }
        public void WrapperResolvesAuthenticationFilterFromDependencyScope()
        {
            var builder = new ContainerBuilder();
            builder.Register<ILogger>(c => new Logger()).InstancePerDependency();
            var activationCount = 0;
            builder.Register<IAutofacAuthenticationFilter>(c => new TestAuthenticationFilter(c.Resolve<ILogger>()))
                .AsWebApiAuthenticationFilterFor<TestController>(c => c.Get())
                .InstancePerRequest()
                .OnActivated(e => activationCount++);
            var container = builder.Build();

            var resolver = new AutofacWebApiDependencyResolver(container);
            var configuration = new HttpConfiguration { DependencyResolver = resolver };
            var requestMessage = new HttpRequestMessage();
            requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration);
            var contollerContext = new HttpControllerContext { Request = requestMessage };
            var controllerDescriptor = new HttpControllerDescriptor { ControllerType = typeof(TestController) };
            var methodInfo = typeof(TestController).GetMethod("Get");
            var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
            var actionContext = new HttpActionContext(contollerContext, actionDescriptor);
            var context = new HttpAuthenticationContext(actionContext, Thread.CurrentPrincipal);
            var metadata = new FilterMetadata
            {
                ControllerType = typeof(TestController),
                FilterScope = FilterScope.Action,
                MethodInfo = methodInfo
            };
            var wrapper = new AuthenticationFilterWrapper(metadata);

            wrapper.OnAuthenticate(context);
            Assert.That(activationCount, Is.EqualTo(1));
        }
예제 #19
0
        private bool GetAuthParameter(HttpAuthenticationContext context, out string parameter)
        {
            var request = context.Request;
            var auth = request.Headers.Authorization;
            parameter = String.Empty;
            if (auth == null)
            {
                context.ErrorResult = new AuthFailedResult("Not authentificated request. Provide auth data.", request);
                return false;
            }

            if (auth.Scheme != _container.Scheme)
            {
                context.ErrorResult = new AuthFailedResult("Unknown scheme", request);
                return false;
            }

            if (string.IsNullOrEmpty(auth.Parameter))
            {
                context.ErrorResult = new AuthFailedResult("Missing credentials", request);
                return false;
            }

            parameter = auth.Parameter;
            //TODO: Parse parameters if needed

            //TODO: Check token not to be outdated

            return true;
        }
예제 #20
0
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            string parameter;
            if (!GetAuthParameter(context, out parameter))
            {
                return Task.FromResult(0);
            }
            var data = _container.Get(parameter);

            if (data == null)
            {
                context.ErrorResult = new AuthFailedResult("Unauthorized access", context.Request);
                return Task.FromResult(0);
            }
            var claims = new List<Claim>()
            {
                new Claim(ClaimTypes.Name, data.Item1.FirstName),
                new Claim("Permission", data.Item2.Permissions.ToString())
            };

            var id = new ClaimsIdentity(claims, "Token");
            var principal = new ClaimsPrincipal(new[] { id });

            context.Principal = principal;
            return Task.FromResult(0);
        }
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var token = string.Empty;

            IEnumerable<String> values;
            if (context.Request.Headers.TryGetValues("X-zvsToken", out values))
                token = values.FirstOrDefault();

            var authorizedTokens = new List<string>(_webApi2Plugin.TokensSettings.Split(','));

            if (token == null || !authorizedTokens.Any(o => o.Trim().Equals(token)))
            {
                context.ErrorResult = new UnauthorizedResult(new AuthenticationHeaderValue[0], context.Request);
                return Task.FromResult(0);
            }

            var claims = new List<Claim>
                {
                    new Claim(ClaimTypes.Name, "ZvsApi User"),
                    new Claim(ClaimTypes.Role, "All Access")
                };
            var id = new ClaimsIdentity(claims, "StaticToken");
            var principal = new ClaimsPrincipal(new[] { id });
            context.Principal = principal;

            return Task.FromResult(0);
        }
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var request = context.Request;
            var authorization = request.Headers.Authorization;

            if (authorization == null || authorization.Scheme != "Basic")
            {
                return;
            }

            if (string.IsNullOrEmpty(authorization.Parameter))
            {
                context.ErrorResult = new AuthenticationFailureResult("Missing credentials", request);
                return;
            }

            var credentials = ExtractCredentials(authorization.Parameter);
            if (credentials == null)
            {
                context.ErrorResult = new AuthenticationFailureResult("Invalid credentials", request);
                return;
            }

            var principal = await AuthenticateAsync(credentials, cancellationToken);
            if (principal == null)
            {
                context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
            }
            else
            {
                context.Principal = principal;
            }
        }
예제 #23
0
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var request = context.Request;
            if (string.IsNullOrEmpty(context.Principal.Identity.Name))
                context.ErrorResult = new AuthenticationFailureResult("Not Authenticated", request);

            return Task.FromResult(0);
        }
        public async Task AuthenticateAsync ( HttpAuthenticationContext context, System.Threading.CancellationToken cancellationToken )
        {
            //// set
            //context.Principal
            //use context.ActionContext.RequestContext.Principal to get what already in the pipeline
            Helper.Write("Authentication", context.ActionContext.RequestContext.Principal);

        }
 public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
 {
     string userName = context.Request.Headers.GetValues("X-Identity").Single();
     string[] roles = context.Request.Headers.GetValues("X-Roles").Single()
         .Split(new[] { ",", " " }, StringSplitOptions.RemoveEmptyEntries);
     context.Principal = new GenericPrincipal(new GenericIdentity(userName), roles);
     return _done;
 }
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            HttpRequestMessage request = context.Request;
            var scopeToken = request.Headers.FirstOrDefault(k => k.Key == "x-api-scope");
            var token = scopeToken.Value.First().Split(' ');

            //Token is not in the Bearer XXXX format
            if (token == null || token.Length != 2)
            {
                return;
            }
            AuthenticationHeaderValue authorization = new AuthenticationHeaderValue(token[0], token[1]);

            // 2. If there are no credentials, do nothing.
            if (authorization == null)
            {
                return;
            }

            // 3. If there are credentials but the filter does not recognize the 
            //    authentication scheme, do nothing.
            if (authorization.Scheme != "Scope")
            {
                context.ErrorResult = new AuthenticationFailureResult("Unrecognized credentials.", request);
                return;
            }

            // 4. If there are credentials that the filter understands, try to validate them.
            // 5. If the credentials are bad, set the error result.
            if (String.IsNullOrEmpty(authorization.Parameter))
            {
                context.ErrorResult = new AuthenticationFailureResult("Missing credentials", request);
                return;
            }

            var claimsList = await ValidateToken(authorization.Parameter);

            if(claimsList == null)
            {
                context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
            }
            else
            {
                ClaimsIdentity ident = new ClaimsIdentity(claimsList);
                IPrincipal principal = new ClaimsPrincipal(ident);

                if (principal == null)
                {
                    context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
                }
                else
                {
                    context.Principal = principal;
                }
            }

        }
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            HttpRequestMessage request = context.Request;
            AuthenticationHeaderValue authorization = request.Headers.Authorization;


            if (authorization == null)
            {
                // No authentication was attempted (for this authentication method).
                // Do not set either Principal (which would indicate success) or ErrorResult (indicating an error).
                return;
            }

            if (authorization.Scheme != "Basic")
            {
                // No authentication was attempted (for this authentication method).
                // Do not set either Principal (which would indicate success) or ErrorResult (indicating an error).
                return;
            }

            if (String.IsNullOrEmpty(authorization.Parameter))
            {
                // Authentication was attempted but failed. Set ErrorResult to indicate an error.
                context.ErrorResult = new AuthenticationFailureResult("Missing credentials", request);
                return;
            }


            Tuple<string, string> userNameAndPasword = ExtractUserNameAndPassword(authorization.Parameter);

            if (userNameAndPasword == null)
            {
                // Authentication was attempted but failed. Set ErrorResult to indicate an error.
                context.ErrorResult = new AuthenticationFailureResult("Invalid credentials", request);
                return;
            }


            string userName = userNameAndPasword.Item1;
            string password = userNameAndPasword.Item2;


            IPrincipal principal = await AuthenticateAsync(userName, password, cancellationToken);

            if (principal == null)
            {
                // Authentication was attempted but failed. Set ErrorResult to indicate an error.
                context.ErrorResult = new AuthenticationFailureResult("Invalid username or password", request);
            }
            else
            {
                // Authentication was attempted and succeeded. Set Principal to the authenticated user.
                context.Principal = principal;
            }
            
        }
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            var identity = context.Principal.Identity;

            if (identity.IsAuthenticated)
            {
            }

            return Task.CompletedTask;
        }
		public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
		{
			await Task.Run(() =>
			{
				IPrincipal incomingPrincipal = context.ActionContext.RequestContext.Principal;
				Debug.WriteLine(String.Format("Incoming principal in custom auth filter AuthenticateAsync method is authenticated: {0}", incomingPrincipal.Identity.IsAuthenticated));
				IPrincipal genericPrincipal = new GenericPrincipal(new GenericIdentity("Andras", "CustomIdentification"), new string[] { "Admin", "PowerUser" });
				context.Principal = genericPrincipal;
			});		
		}
예제 #30
0
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            AuthenticationHeaderValue authorization = context.Request.Headers.Authorization;
            if (string.Equals(authorization.Scheme, "Bearer", StringComparison.OrdinalIgnoreCase) &&
                authorization.Parameter == Settings.BearerToken)
            {
                context.Principal = new ClientRolePrincipal(new SocialIdentity("Bearer"));
            }

            return Task.FromResult(0);
        }
예제 #31
0
        /// <summary>
        /// Authenticates the request.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            Guard.NotNull(context, nameof(context));

            if (context.ActionContext.RequestContext.IsLocal == false)
            {
                throw new OnlyLocalException();
            }

            return Task.CompletedTask;
        }