C# IAppBuilder.UseBasicAuthentication方法代码示例

 public void ConfigureAuth( IAppBuilder app )
 {
     basicUsers = new Dictionary<string, string>();
     string appSet = System.Configuration.ConfigurationManager.AppSettings["BasicAuthUsers"];
     if ( !string.IsNullOrWhiteSpace( appSet ) ) {
         foreach ( string ident in appSet.Split( ';' ) ) {
             if ( !string.IsNullOrWhiteSpace( ident ) ) {
                 string[] login = ident.Split( ',' );
                 basicUsers.Add( login[0].Trim().ToLower(), login[1].Trim() );
             }
         }
     }
     Func<string, string, Task<IEnumerable<Claim>>> validateUser = ( string uname, string password ) => {
         IEnumerable<Claim> toReturn = null;
         if ( basicUsers.ContainsKey( uname.ToLower() ) ) {
             if ( basicUsers[uname.ToLower()] == password ) {
                 toReturn = new List<Claim>() { new Claim( "authed", "true" ) };
             }
         }
         return Task.FromResult( toReturn );
     };
     Thinktecture.IdentityModel.Owin.BasicAuthenticationOptions opts = new Thinktecture.IdentityModel.Owin.BasicAuthenticationOptions( "BloodGulch",
         new Thinktecture.IdentityModel.Owin.BasicAuthenticationMiddleware.CredentialValidationFunction( validateUser ) );
     app.UseBasicAuthentication( opts );
 }

        public void Configuration(IAppBuilder app)
        {
            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();

            app.UseBasicAuthentication(new BasicAuthenticationOptions("SecureApi",
                async (username, password) => await Authenticate(username, password)));

            app.UseWebApi(config);
        }

        public void Configuration(IAppBuilder app)
        {
            var configuration = new HttpConfiguration();
            configuration.Routes.MapHttpRoute(
                "default",
                "api/{controller}"
                );

            app.Use(typeof(TestMiddleware));

            app.UseBasicAuthentication("Demo", ValidateUser);

            app.UseWebApi(configuration);
        }

        public void Configuration(IAppBuilder app)
        {
            // require SSL and client certificates
            app.RequireSsl(requireClientCertificate: true);

            // basic authentication
            app.UseBasicAuthentication("katanademo", ValidateUser);
            
            // client certificates
            app.UseClientCertificateAuthentication(X509RevocationMode.NoCheck);

            // transform claims to application identity
            app.UseClaimsTransformation(TransformClaims);

            app.UseWebApi(WebApiConfig.Register());
        }

        public void Configuration(IAppBuilder app)
        {
            // Use basic authentication middleware
            app.UseBasicAuthentication("KatanaBasicAuth", Validator);

            // Configure web api routing
            var config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
                "DefaultApi",
                "api/{controller}/{id}",
                new { id = RouteParameter.Optional });
            app.UseWebApi(config);

            // Add error, welcome pages
            app.UseErrorPage();
            app.UseWelcomePage();
        }

        public void ConfigureAuth(IAppBuilder app)
        {
            app.CreatePerOwinContext(MyCtx.Create);
            app.CreatePerOwinContext(() => new MyUserManager(new MyUserStore(new MyCtx())));

            var basicAuthOptions = new BasicAuthenticationOptions("KMailWebManager", validationCallback);
            app.UseBasicAuthentication(basicAuthOptions);

            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Enables the application to remember the second login verification factor such as phone or email.
            // Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
            // This is similar to the RememberMe option when you log in.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
        }

        // This method is auto-detected by the OWIN pipeline. DO NOT RENAME IT!
        public static void Configuration(IAppBuilder app)
        {
            // Get config
            var config = Container.Kernel.Get<ConfigurationService>();
            var auth = Container.Kernel.Get<AuthenticationService>();

            // Configure logging
            app.SetLoggerFactory(new DiagnosticsLoggerFactory());

            if (config.Current.RequireSSL)
            {
                // Put a middleware at the top of the stack to force the user over to SSL
                // if authenticated.
                //app.UseForceSslWhenAuthenticated(config.Current.SSLPort);

                // Put a middleware at the top of the stack to force the user over to SSL always
                app.UseForceSslAlways(config.Current.SSLPort);
            }

            app.UseBasicAuthentication(new BasicAuthenticationOptions()
            {
                AuthenticationMode = AuthenticationMode.Active,
                AuthenticationType = AuthenticationTypes.LocalUser,
            });
            app.SetDefaultSignInAsAuthenticationType(AuthenticationTypes.LocalUser);

            if (config.Current.ForceAuth)
            {
                app.Authorize();
            }

            //// Get the local user auth provider, if present and attach it first
            //Authenticator localUserAuther;
            //if (auth.Authenticators.TryGetValue(Authenticator.GetName(typeof(LocalUserAuthenticator)), out localUserAuther))
            //{
            //    // Configure cookie auth now
            //    localUserAuther.Startup(config, app);
            //}

            //// Attach external sign-in cookie middleware
            //app.SetDefaultSignInAsAuthenticationType(AuthenticationTypes.External);
            //app.UseCookieAuthentication(new CookieAuthenticationOptions()
            //{
            //    AuthenticationType = AuthenticationTypes.External,
            //    AuthenticationMode = AuthenticationMode.Passive,
            //    CookieName = ".AspNet." + AuthenticationTypes.External,
            //    ExpireTimeSpan = TimeSpan.FromMinutes(5)
            //});

            //// Attach non-cookie auth providers
            //var nonCookieAuthers = auth
            //    .Authenticators
            //    .Where(p => !String.Equals(
            //        p.Key,
            //        Authenticator.GetName(typeof(LocalUserAuthenticator)),
            //        StringComparison.OrdinalIgnoreCase))
            //    .Select(p => p.Value);
            //foreach (var auther in nonCookieAuthers)
            //{
            //    auther.Startup(config, app);
            //}
        }

 // For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
 public void ConfigureAuth(IAppBuilder app)
 {
     app.UseBasicAuthentication(new Thinktecture.IdentityModel.Owin.BasicAuthenticationOptions(string.Empty,
         new Thinktecture.IdentityModel.Owin.BasicAuthenticationMiddleware.CredentialValidationFunction(BasicAuthenticate)));
 }

        public void ConfigureOAuth(IAppBuilder app)
        {
           app.UseBasicAuthentication(new BasicAuthenticationOptions("demo", ValidateBasicUser));

            var oAuthServerOptions = new OAuthAuthorizationServerOptions()
            {
                AllowInsecureHttp = true,
                TokenEndpointPath = new PathString("/token"),
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
                Provider = new SimpleAuthorizationServerProvider(),
                ApplicationCanDisplayErrors = true
            };

            // Token Generation
            app.UseOAuthAuthorizationServer(oAuthServerOptions);
            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
 
        }

 public void Configuration(IAppBuilder app)
 {
     app.UseBasicAuthentication("Demo", this.ValidateUsers);
 }