public void Configuration(IAppBuilder app)
{
app.Map("/idmgr", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("DefaultConnection");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
app.Map("/idsvr", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("DefaultConnection");
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - UserService-AspNetIdentity",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
AuthenticationOptions = new AuthenticationOptions
{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
core.UseIdentityServer(options);
});
}
public static void Configure(IAppBuilder app)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
app.UseAesDataProtectorProvider();
BasePath = AppDomain.CurrentDomain.BaseDirectory;
var certFile = Path.Combine(BasePath, "idsrv3test.pfx");
Console.WriteLine(certFile);
var options = ConfigureIdentityServer(certFile);
// var cpath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),"..", "..", "..", "src", "Janitor", "Content"));
// Console.WriteLine(cpath);
// app.UseStaticFiles (new StaticFileOptions {
// RequestPath = new PathString("/Content"),
// FileSystem = new PhysicalFileSystem(cpath)
// });
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
var adminOptions = new IdentityManagerOptions
{
Factory = factory,
};
adminOptions.SecurityConfiguration.RequireSsl = false;
adminApp.UseIdentityManager(adminOptions);
});
app.UseIdentityServer(options);
}
public static void UseIdentityServer(this IApplicationBuilder app, IdentityServerOptions options)
{
app.UseOwin(pipeline =>
{
pipeline(next =>
{
var builder = new Microsoft.Owin.Builder.AppBuilder();
var provider = app.ApplicationServices.GetService <DataProtection.IDataProtectionProvider>();
builder.Properties["security.DataProtectionProvider"] = new DataProtectionProviderDelegate(purposes =>
{
var dataProtection = provider.CreateProtector(String.Join(",", purposes));
return(new DataProtectionTuple(dataProtection.Protect, dataProtection.Unprotect));
});
builder.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
builder.UseIdentityServer(options);
builder.UseAesDataProtectorProvider();
var appFunc = builder.Build(typeof(Func <IDictionary <string, object>, Task>)) as Func <IDictionary <string, object>, Task>;
return(appFunc);
});
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
app.UseAesDataProtectorProvider();
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
var adminOptions = new IdentityManagerOptions(){
Factory = factory
};
adminOptions.SecurityConfiguration.RequireSsl = false;
adminApp.UseIdentityManager(adminOptions);
});
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("AspId");
var viewOptions = new ViewServiceOptions
{
TemplatePath = this.basePath.TrimEnd(new char[] { '/' })
};
idSvrFactory.ViewService = new IdentityServer3.Core.Configuration.Registration<IViewService>(new ViewService(viewOptions));
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - ViewSerive-AspNetIdentity",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
RequireSsl = false,
AuthenticationOptions = new AuthenticationOptions
{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
app.Map("/core", core =>
{
core.UseIdentityServer(options);
});
app.UseStaticFiles(new StaticFileOptions
{
RequestPath = new PathString("/Content"),
FileSystem = new PhysicalFileSystem(Path.Combine(this.basePath, "Content"))
});
var config = new HttpConfiguration();
// config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute("API", "api/{controller}/{action}", new { controller = "Home", action = "Get" });
app.UseWebApi(config);
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
// this configures IdentityManager
// we're using a Map just to test hosting not at the root
app.Map("/idm", idm =>
{
var factory = new IdentityManagerServiceFactory();
var rand = new System.Random();
var users = Users.Get(rand.Next(5000, 20000));
var roles = Roles.Get(rand.Next(15));
factory.Register(new Registration <ICollection <InMemoryUser> >(users));
factory.Register(new Registration <ICollection <InMemoryRole> >(roles));
factory.IdentityManagerService = new Registration <IIdentityManagerService, InMemoryIdentityManagerService>();
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory,
});
});
// used to redirect to the main admin page visiting the root of the host
app.Run(ctx =>
{
ctx.Response.Redirect("/idm/");
return(Task.FromResult(0));
});
}
public void Configuration(IAppBuilder app)
{
// Configuring logging
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
// Configuring thinktecture identity manager
app.Map("/admin", adminApp =>
{
var adminFactory = new IdentityManagerServiceFactory();
adminFactory.ConfigureSimpleIdentityManagerService();
adminApp.UseIdentityManager(new IdentityManagerOptions
{
Factory = adminFactory
});
});
// Configuring thinktecture auth server with Asp.Net identity
var factory = Factory.Configure();
factory.ConfigureCustomServices();
var options = new IdentityServerOptions
{
SiteName = "My Auth Server",
RequireSsl = false,
SigningCertificate = Certificate.Load(),
Factory = factory,
CorsPolicy = CorsPolicy.AllowAll
};
app.UseIdentityServer(options);
}
public ActionResult Index()
{
ViewBag.Title = "Home Page";
var factory = new IdentityManagerServiceFactory();
return(Redirect("Swagger/ui/index"));
}
public void Configuration(IAppBuilder app)
{
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
app.Map("/core", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("AspId");
var options = new IdentityServerOptions
{
SiteName = "Thinktecture IdentityServer3 - AspNetIdentity 2FA",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
};
core.UseIdentityServer(options);
});
}
public void Configuration(IAppBuilder app)
{
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("AspId");
//idSvrFactory.ConfigureCustomUserService("AspId_CustomPK");
var options = new IdentityServerOptions
{
SiteName = "Thinktecture IdentityServer3 - UserService-AspNetIdentity",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
CorsPolicy = CorsPolicy.AllowAll,
AuthenticationOptions = new AuthenticationOptions
{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
app.UseIdentityServer(options);
}
public static void UseIdentityServer(this IApplicationBuilder app, IdentityServerOptions options)
{
app.UseOwin(pipeline =>
{
pipeline(next =>
{
var builder = new Microsoft.Owin.Builder.AppBuilder();
var provider = app.ApplicationServices.GetService<DataProtection.IDataProtectionProvider>();
builder.Properties["security.DataProtectionProvider"] = new DataProtectionProviderDelegate(purposes =>
{
var dataProtection = provider.CreateProtector(String.Join(",", purposes));
return new DataProtectionTuple(dataProtection.Protect, dataProtection.Unprotect);
});
builder.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
builder.UseIdentityServer(options);
builder.UseAesDataProtectorProvider();
var appFunc = builder.Build(typeof(Func<IDictionary<string, object>, Task>)) as Func<IDictionary<string, object>, Task>;
return appFunc;
});
});
}
public void Configuration(IAppBuilder app)
{
var connectionString = "MembershipReboot";
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.Configure(connectionString);
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureCustomUserService(connectionString);
var options = new IdentityServerOptions
{
IssuerUri = "https://idsrv3.com",
SiteName = "Thinktecture IdentityServer3 - UserService-MembershipReboot",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
CorsPolicy = CorsPolicy.AllowAll,
AuthenticationOptions = new AuthenticationOptions {
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
app.UseIdentityServer(options);
}
public IdentityManagerOptions GetManagerOptions()
{
var factory = new IdentityManagerServiceFactory
{
IdentityManagerService = new Registration<IIdentityManagerService>(ctx => identityManagerService)
};
var rand = new Random();
var users = UserSeeder.Get(rand.Next(1000, 3000));
var roles = RoleSeeder.Get(rand.Next(15));
factory.Register(new Registration<ICollection<InMemoryUser>>(users));
factory.Register(new Registration<ICollection<InMemoryRole>>(roles));
return new IdentityManagerOptions
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration
{
HostAuthenticationType = "Cookies",
NameClaimType = "name",
RoleClaimType = "role",
AdminRoleName = "IdentityManagerAdmin"
}
};
}
public IdentityManagerOptions GetManagerOptions()
{
var factory = new IdentityManagerServiceFactory
{
IdentityManagerService = new Registration <IIdentityManagerService>(ctx => identityManagerService)
};
var rand = new Random();
var users = UserSeeder.Get(rand.Next(1000, 3000));
var roles = RoleSeeder.Get(rand.Next(15));
factory.Register(new Registration <ICollection <InMemoryUser> >(users));
factory.Register(new Registration <ICollection <InMemoryRole> >(roles));
return(new IdentityManagerOptions
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration
{
HostAuthenticationType = "Cookies",
NameClaimType = "name",
RoleClaimType = "role",
AdminRoleName = "IdentityManagerAdmin"
}
});
}
public void Configuration(IAppBuilder app)
{
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
app.Map("/core", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("AspId");
var options = new IdentityServerOptions
{
SiteName = "Thinktecture IdentityServer3 - AspNetIdentity 2FA",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
};
core.UseIdentityServer(options);
});
}
public void Configuration(IAppBuilder app)
{
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("AspId");
//idSvrFactory.ConfigureCustomUserService("AspId_CustomPK");
var options = new IdentityServerOptions
{
SiteName = "Thinktecture IdentityServer3 - UserService-AspNetIdentity",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
CorsPolicy = CorsPolicy.AllowAll,
AuthenticationOptions = new AuthenticationOptions
{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
app.UseIdentityServer(options);
}
public void Configuration(IAppBuilder app)
{
var connectionString = "MembershipReboot";
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.Configure(connectionString);
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureCustomUserService(connectionString);
var options = new IdentityServerOptions
{
IssuerUri = "https://idsrv3.com",
SiteName = "Thinktecture IdentityServer3 - UserService-MembershipReboot",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
CorsPolicy = CorsPolicy.AllowAll,
AuthenticationOptions = new AuthenticationOptions{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
app.UseIdentityServer(options);
}
public void Configuration(IAppBuilder app)
{
app.Map("/idmgr", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("DefaultConnection");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
app.Map("/idsvr", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("DefaultConnection");
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - UserService-AspNetIdentity",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
AuthenticationOptions = new AuthenticationOptions
{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
core.UseIdentityServer(options);
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
app.Map("/core", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("AspId");
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - AspNetIdentity 2FA",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
};
core.UseIdentityServer(options);
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
app.Map("/core", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService("AspId");
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - AspNetIdentity 2FA",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
};
core.UseIdentityServer(options);
});
}
public static void ConfigureManagerService(this IAppBuilder app)
{
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
//IdentityDbContext identityDbContext = new IdentityDbContext("AuthServer");
IdentityDbContext identityDbContext = new CustomIdentityDbContext("AuthServer");
UserManager <IdentityUser> userManager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(identityDbContext));
RoleManager <IdentityRole> roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(identityDbContext));
//var managerService = new AspNetIdentityManagerService<IdentityUser, string, IdentityRole, string>(userManager, roleManager);
var managerService = new CustomAspNetIdentityManagerService(userManager, roleManager);
factory.IdentityManagerService = new Registration <IIdentityManagerService>(managerService);
var managerOptions = new IdentityManagerOptions()
{
Factory = factory
};
managerOptions.SecurityConfiguration.RequireSsl = false;
managerOptions.SecurityConfiguration.AdminRoleName = "admin";//setup which role can manage the account
adminApp.UseIdentityManager(managerOptions);
});
}
public void Configuration(IAppBuilder app)
{
// this configures IdentityManager
// we're using a Map just to test hosting not at the root
app.Map("/idm", idm =>
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
var factory = new IdentityManagerServiceFactory();
var rand = new System.Random();
var users = Users.Get(rand.Next(5000, 20000));
var roles = Roles.Get(rand.Next(15));
factory.Register(new Registration <ICollection <InMemoryUser> >(users));
factory.Register(new Registration <ICollection <InMemoryRole> >(roles));
factory.IdentityManagerService = new Registration <IIdentityManagerService, InMemoryIdentityManagerService>();
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory,
SecurityMode = SecurityMode.LocalMachine,
OAuth2Configuration = new OAuth2Configuration
{
AuthorizationUrl = "http://localhost:17457/ids/connect/authorize",
Issuer = "https://idsrv3.com",
Audience = "https://idsrv3.com/resources",
ClientId = "idmgr",
SigningCert = Cert.Load(),
Scope = "idmgr",
ClaimsTransformation = user =>
{
if (user.IsInRole("Foo"))
{
((ClaimsIdentity)user.Identity).AddClaim(new Claim("role", "IdentityManagerAdministrator"));
}
return(user);
},
//PersistToken = true,
//AutomaticallyRenewToken = true
}
});
});
// this configures an embedded IdentityServer to act as an external authentication provider
// when using IdentityManager in Token security mode. normally you'd configure this elsewhere.
app.Map("/ids", ids =>
{
IdSvrConfig.Configure(ids);
});
// used to redirect to the main admin page visiting the root of the host
app.Run(ctx =>
{
ctx.Response.Redirect("/idm/");
return(System.Threading.Tasks.Task.FromResult(0));
});
}
public void Configuration(IAppBuilder app)
{
// this configures IdentityManager
// we're using a Map just to test hosting not at the root
app.Map("/idm", idm =>
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
var factory = new IdentityManagerServiceFactory();
var rand = new System.Random();
var users = Users.Get(rand.Next(5000, 20000));
var roles = Roles.Get(rand.Next(15));
factory.Register(new Registration<ICollection<InMemoryUser>>(users));
factory.Register(new Registration<ICollection<InMemoryRole>>(roles));
factory.IdentityManagerService = new Registration<IIdentityManagerService, InMemoryIdentityManagerService>();
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory,
SecurityMode = SecurityMode.LocalMachine,
OAuth2Configuration = new OAuth2Configuration
{
AuthorizationUrl = "http://localhost:17457/ids/connect/authorize",
Issuer = "https://idsrv3.com",
Audience = "https://idsrv3.com/resources",
ClientId = "idmgr",
SigningCert = Cert.Load(),
Scope = "idmgr",
ClaimsTransformation = user =>
{
if (user.IsInRole("Foo"))
{
((ClaimsIdentity)user.Identity).AddClaim(new Claim("role", "IdentityManagerAdministrator"));
}
return user;
},
//PersistToken = true,
//AutomaticallyRenewToken = true
}
});
});
// this configures an embedded IdentityServer to act as an external authentication provider
// when using IdentityManager in Token security mode. normally you'd configure this elsewhere.
app.Map("/ids", ids =>
{
IdSvrConfig.Configure(ids);
});
// used to redirect to the main admin page visiting the root of the host
app.Run(ctx =>
{
ctx.Response.Redirect("/idm/");
return System.Threading.Tasks.Task.FromResult(0);
});
}
public static void ConfigureCustomIdentityManagerServiceWithIntKeys(this IdentityManagerServiceFactory factory, string connectionString)
{
factory.Register(new Registration <CustomContext>(resolver => new CustomContext(connectionString)));
factory.Register(new Registration <CustomUserStore>());
factory.Register(new Registration <CustomRoleStore>());
factory.Register(new Registration <CustomUserManager>());
factory.Register(new Registration <CustomRoleManager>());
factory.IdentityManagerService = new Registration <IIdentityManagerService, CustomIdentityManagerServiceWithIntKeys>();
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary <string, string>();
app.UseCookieAuthentication(new Microsoft.Owin.Security.Cookies.CookieAuthenticationOptions
{
AuthenticationType = "Cookies"
});
app.UseOpenIdConnectAuthentication(new Microsoft.Owin.Security.OpenIdConnect.OpenIdConnectAuthenticationOptions
{
Authority = "https://localhost:44337/ids",
ClientId = "idmgr_client",
RedirectUri = "https://localhost:44337",
ResponseType = "id_token",
UseTokenLifetime = false,
Scope = "openid idmgr",
SignInAsAuthenticationType = "Cookies"
});
app.Map("/idm", idm =>
{
var factory = new IdentityManagerServiceFactory();
var rand = new System.Random();
var users = Users.Get(rand.Next(5000, 20000));
var roles = Roles.Get(rand.Next(15));
factory.Register(new Registration <ICollection <InMemoryUser> >(users));
factory.Register(new Registration <ICollection <InMemoryRole> >(roles));
factory.IdentityManagerService = new Registration <IIdentityManagerService, InMemoryIdentityManagerService>();
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration
{
HostAuthenticationType = "Cookies"
}
});
});
// this configures an embedded IdentityServer to act as an external authentication provider
// when using IdentityManager in Token security mode. normally you'd configure this elsewhere.
app.Map("/ids", ids =>
{
IdSvrConfig.Configure(ids);
});
// used to redirect to the main admin page visiting the root of the host
app.Run(ctx =>
{
ctx.Response.Redirect("/idm/");
return(Task.FromResult(0));
});
}
public static void ConfigureSimpleIdentityManagerService(this IdentityManagerServiceFactory factory)
{
factory.Register(new Registration <AuthDbContext>(resolver => new AuthDbContext()));
factory.Register(new Registration <UserStore>());
factory.Register(new Registration <RoleStore>());
factory.Register(new Registration <UserManager>());
factory.Register(new Registration <RoleManager>());
factory.IdentityManagerService = new Registration <IIdentityManagerService, IdentityManagerService>();
}
public static void ConfigureSimpleIdentityManagerService(this IdentityManagerServiceFactory factory, string connectionString)
{
factory.Register(new Registration <MacheteContext>(resolver => new MacheteContext(connectionString)));
factory.Register(new Registration <UserStore>());
factory.Register(new Registration <RoleStore>());
factory.Register(new Registration <UserManager>());
factory.Register(new Registration <RoleManager>());
factory.IdentityManagerService = new Registration <IIdentityManagerService, SimpleIdentityManagerService>();
}
public static void Configure(this IdentityManagerServiceFactory factory, string connectionString)
{
factory.IdentityManagerService = new Registration <IIdentityManagerService, CustomIdentityManagerService>();
factory.Register(new Registration <CustomUserAccountService>());
factory.Register(new Registration <CustomGroupService>());
factory.Register(new Registration <CustomUserRepository>());
factory.Register(new Registration <CustomGroupRepository>());
factory.Register(new Registration <CustomDatabase>(resolver => new CustomDatabase(connectionString)));
factory.Register(new Registration <CustomConfig>(CustomConfig.Config));
}
public void Configuration(IAppBuilder app)
{
var factory = new IdentityManagerServiceFactory();
factory.IdentityManagerService = new Registration <IIdentityManagerService>(Create());
app.UseIdentityManager(new IdentityManagerOptions {
Factory = factory
});
}
public void Configuration(IAppBuilder app)
{
// config identity server
var factory = new IdentityServerServiceFactory
{
CorsPolicyService = new IdentityServer3.Core.Configuration.Registration<ICorsPolicyService>(new DefaultCorsPolicyService {AllowAll = true}),
ScopeStore = new IdentityServer3.Core.Configuration.Registration<IScopeStore>(new InMemoryScopeStore(Scopes.Get())),
ClientStore = new IdentityServer3.Core.Configuration.Registration<IClientStore>(new InMemoryClientStore(Clients.Get()))
};
factory.ConfigureUserService(ConnectionString);
app.Map("/identity", idServer => idServer.UseIdentityServer(new IdentityServerOptions
{
SiteName = "Identity Server for 8sApp",
RequireSsl = false,
Factory = factory,
SigningCertificate = Certificate.Certificate.Get(),
AuthenticationOptions = new AuthenticationOptions()
{
LoginPageLinks = new[]
{
new LoginPageLink
{
Text = "Register",
Href = "register"
}
}
}
}));
// config identity manager
app.Map("/admin", adminApp =>
{
var identityManagerServiceFactory = new IdentityManagerServiceFactory();
identityManagerServiceFactory.ConfigureIdentityManagerService(ConnectionString);
var options = new IdentityManagerOptions
{
Factory = identityManagerServiceFactory,
SecurityConfiguration = {RequireSsl = false}
};
adminApp.UseIdentityManager(options);
});
// config web api
var config = new HttpConfiguration();
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
app.UseCors(CorsOptions.AllowAll);
app.UseWebApi(config);
}
public static void ConfigureIdentityManagerService(this IdentityManagerServiceFactory factory, string connectionString)
{
factory.Register(new Registration <CContext>(resolver => new CContext(connectionString)));
factory.Register(new Registration <CUserStore>());
factory.Register(new Registration <CRoleStore>());
factory.Register(new Registration <CUserManager>());
factory.Register(new Registration <CRoleManager>());
factory.IdentityManagerService = new Registration <IIdentityManagerService, CIdentityManagerService>();
ConfigureUser(Users.Get(), connectionString);
}
public void Configuration(IAppBuilder app)
{
var factory = new IdentityManagerServiceFactory();
factory.Configure("CustomMembershipReboot");
app.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
}
public void Configuration(IAppBuilder app)
{
//Log.Logger = new LoggerConfiguration()
// .WriteTo.RollingFile("log-{Date}.txt")
// .CreateLogger();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
var efConfig = new EntityFrameworkServiceOptions
{
ConnectionString = "DefaultConnection"
};
#if DEBUG
Database.SetInitializer(new DropCreateDatabaseIfModelChanges <ApplicationDbContext>());
#endif
app.Map("/admin", adminApp =>
{
var imgrFactory = new IdentityManagerServiceFactory();
imgrFactory.ConfigureSimpleIdentityManagerService();
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = imgrFactory
});
});
var factory = new IdentityServerServiceFactory();
factory.RegisterConfigurationServices(efConfig);
factory.RegisterOperationalServices(efConfig);
factory.ConfigureUserService();
#if DEBUG
// these two calls just pre-populate the test DB from the in-memory config
TestClients.ConfigureClients(TestClients.Get(), efConfig);
TestScopes.ConfigureScopes(TestScopes.Get(), efConfig);
#endif
var options = new IdentityServerOptions
{
SiteName = "MyIdentityServer - Server",
Factory = factory,
RequireSsl = false,
SigningCertificate = Certificate.Get(),
};
app.UseIdentityServer(options);
var cleanup = new TokenCleanup(efConfig, 10);
cleanup.Start();
}
public void Configuration(IAppBuilder app)
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
app.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
}
public static void ReConfigureDefaultFactory(IdentityManagerServiceFactory factory, string connectionStringName)
{
factory.IdentityManagerService = new Registration <IIdentityManagerService, CustomIdentityManagerService>();
factory.Register(new Registration <CustomUserAccountService>());
factory.Register(new Registration <CustomGroupService>());
factory.Register(new Registration <CustomUserRepository>());
factory.Register(new Registration <CustomGroupRepository>());
factory.Register(new Registration <CustomDatabase>(resolver => new CustomDatabase(connectionStringName)));
factory.Register(new Registration <CustomConfiguration>(CustomConfiguration.Data));
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
var factory = new IdentityManagerServiceFactory();
factory.Configure("CustomMembershipReboot");
app.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary<string, string>();
app.UseCookieAuthentication(new Microsoft.Owin.Security.Cookies.CookieAuthenticationOptions
{
AuthenticationType = "Cookies"
});
app.UseOpenIdConnectAuthentication(new Microsoft.Owin.Security.OpenIdConnect.OpenIdConnectAuthenticationOptions
{
AuthenticationType = "oidc",
Authority = "https://localhost:44337/ids",
ClientId = "idmgr_client",
RedirectUri = "https://localhost:44337",
ResponseType = "id_token",
UseTokenLifetime = false,
Scope = "openid idmgr",
SignInAsAuthenticationType = "Cookies"
});
app.Map("/idm", idm =>
{
var factory = new IdentityManagerServiceFactory();
var rand = new System.Random();
var users = Users.Get(rand.Next(5000, 20000));
var roles = Roles.Get(rand.Next(15));
factory.Register(new Registration<ICollection<InMemoryUser>>(users));
factory.Register(new Registration<ICollection<InMemoryRole>>(roles));
factory.IdentityManagerService = new Registration<IIdentityManagerService, InMemoryIdentityManagerService>();
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration
{
HostAuthenticationType = "Cookies",
//AdditionalSignOutType = "oidc"
}
});
});
// this configures an embedded IdentityServer to act as an external authentication provider
// when using IdentityManager in Token security mode. normally you'd configure this elsewhere.
app.Map("/ids", ids =>
{
IdSvrConfig.Configure(ids);
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
var factory = new IdentityManagerServiceFactory();
factory.Configure("CustomMembershipReboot");
app.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
}
public void Configuration(IAppBuilder app)
{
app.Map("/admin", adminApp =>
{
var factory = new IdentityAdminServiceFactory();
factory.Configure("AspId");
adminApp.UseIdentityAdmin(new IdentityAdminOptions
{
Factory = factory
});
});
app.Map("/manager", managerApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureIdentityManagerService("AspId");
managerApp.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory
});
});
app.Map("/core", core =>
{
var idSvrFactory = IdentityServer.Factory.Configure("AspId");
idSvrFactory.ConfigureUserService("AspId");
var options = new IdentityServerOptions
{
SiteName = "Cabroso Identity Server",
SigningCertificate = IdentityServer.Certificate.Get(),
Factory = idSvrFactory,
AuthenticationOptions = new AuthenticationOptions
{
LoginPageLinks = new List <LoginPageLink>
{
new LoginPageLink()
{
Href = "passwordReset",
Text = "Reset Your Password",
Type = "resetTestType"
}
}
}
};
core.UseIdentityServer(options);
});
}
void InitializeUserAdmin(IAppBuilder app)
{
// Users and Roles manager
app.Map("/useradmin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService(MyConstants.UserAdminConfig);
adminApp.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory
});
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
app.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
app.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
}
public static void ConfigureSimpleIdentityManagerService(this IdentityManagerServiceFactory factory)
{
factory.Register(new Registration <DbContext>(resolver => new ApplicationDbContext()));
factory.Register(new Registration <IUserStore <ApplicationUser>, UserStore <ApplicationUser> >());
factory.Register(new Registration <ApplicationUserManager>(
resolver => ApplicationUserManager.CreateUserManager(
new IdentityFactoryOptions <ApplicationUserManager>(),
resolver.Resolve <DbContext>(),
new EmailService(),
new SmsService())));
factory.Register(new Registration <IRoleStore <ApplicationRole, string>, RoleStore <ApplicationRole> >());
factory.Register(new Registration <ApplicationRoleManager>());
factory.IdentityManagerService = new Registration <IIdentityManagerService, ApplicationIdentityManagerService>();
}
public static IdentityManagerOptions CreateIdentityManagerOptions()
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureIdentityManagerService("IdentityManagerConfig");
return new IdentityManagerOptions
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration
{
HostAuthenticationType = "Cookies"
, AdminRoleName = "IdentityManagerAdministrator"
, RequireSsl = GlobalConfiguration.RequireSSL ?? true
}
};
}
public static IdentityManagerServiceFactory Configure(string connString)
{
var factory = new IdentityManagerServiceFactory();
ConfigureUsers(DefaultUsers.Get(), connString);
factory.IdentityManagerService = new Registration <IIdentityManagerService, CustomIdentityManagerService>();
factory.Register(new Registration <CustomUserAccountService>());
factory.Register(new Registration <CustomGroupService>());
factory.Register(new Registration <CustomUserRepository>());
factory.Register(new Registration <CustomGroupRepository>());
factory.Register(new Registration <CustomDatabase>(resolver => new CustomDatabase(connString)));
factory.Register(new Registration <CustomConfig>(CustomConfig.Config));
return(factory);
}
public static IdentityManagerServiceFactory Configure(string connString)
{
var factory = new IdentityManagerServiceFactory();
ConfigureUsers(DefaultUsers.Get(), connString);
factory.IdentityManagerService = new Registration<IIdentityManagerService, CustomIdentityManagerService>();
factory.Register(new Registration<CustomUserAccountService>());
factory.Register(new Registration<CustomGroupService>());
factory.Register(new Registration<CustomUserRepository>());
factory.Register(new Registration<CustomGroupRepository>());
factory.Register(new Registration<CustomDatabase>(resolver => new CustomDatabase(connString)));
factory.Register(new Registration<CustomConfig>(CustomConfig.Config));
return factory;
}
public static IdentityManagerServiceFactory Configure(this IdentityManagerServiceFactory factory,
string connectionString)
{
factory.Register(new Registration <Context>(resolver => new Context(connectionString)));
factory.Register(new Registration <UserStore>());
factory.Register(new Registration <RoleStore>());
factory.Register(new Registration <UserManager>());
factory.Register(new Registration <RoleManager>());
var clientstore = new ClientStore(new ClientsDbContext(connectionString));
factory.Register(new Registration <IClientStore>(clientstore));
factory.IdentityManagerService = new Registration <IIdentityManagerService, IdentityManagerService>();
return(factory);
}
public void Configuration(IAppBuilder app)
{
app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/home/login")
});
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService();
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration()
{
HostAuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
NameClaimType = "name",
RoleClaimType = "role",
AdminRoleName = "Admin"
}
});
});
app.Map("/core", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureUserService();
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - UserService-AspNetIdentity",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
AuthenticationOptions = new AuthenticationOptions
{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
core.UseIdentityServer(options);
});
ConfigureAuth(app);
}
public void Configure(IApplicationBuilder app, IApplicationEnvironment env)
{
Log.Logger = new LoggerConfiguration().MinimumLevel.Debug().WriteTo.Trace().CreateLogger();
BasePath = env.ApplicationBasePath;
var certFile = Path.Combine(BasePath, "idsrv3test.pfx");
var options = ConfigureIdentityServer(certFile);
app.UseOwin(pipeline =>
{
pipeline(next =>
{
var builder = new Microsoft.Owin.Builder.AppBuilder();
var provider = app.ApplicationServices.GetService<Microsoft.AspNet.DataProtection.IDataProtectionProvider>();
builder.Properties["security.DataProtectionProvider"] = new DataProtectionProviderDelegate(purposes =>
{
var dataProtection = provider.CreateProtector(String.Join(",", purposes));
return new DataProtectionTuple(dataProtection.Protect, dataProtection.Unprotect);
});
builder.UseAesDataProtectorProvider();
builder.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
//factory.ConfigureCustomIdentityManagerServiceWithIntKeys("AspId_CustomPK");
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
builder.UseIdentityServer(options);
var appFunc = builder.Build(typeof(Func<IDictionary<string, object>, Task>)) as Func<IDictionary<string, object>, Task>;
return appFunc;
});
});
app.UseIdentityServer(options);
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
var connectionString = "MembershipReboot";
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.Configure(connectionString);
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory
});
});
app.Map("/core", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureCustomUserService(connectionString);
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - UserService-MembershipReboot",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
AuthenticationOptions = new AuthenticationOptions{
IdentityProviders = ConfigureAdditionalIdentityProviders,
}
};
core.UseIdentityServer(options);
});
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
app.Map("/admin", admin =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService();
admin.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory
});
});
app.Map("/core", core =>
{
var factory = Factory.Configure();
var options = new IdentityServerOptions
{
SiteName = "Cardeal - Servidor de Identidade",
SigningCertificate = Certificate.Get(),
Factory = factory,
AuthenticationOptions = new AuthenticationOptions
{
EnablePostSignOutAutoRedirect = true,
EnableSignOutPrompt = false,
PostSignOutAutoRedirectDelay = 1
},
IssuerUri = "http://adsprev.com.br"
};
core.UseIdentityServer(options);
});
}
public IdentityManagerOptions GetManagerOptions()
{
var factory = new IdentityManagerServiceFactory();
factory.IdentityManagerService = new Registration<IIdentityManagerService, CustomIdentityManagerService>();
factory.Register(new Registration<CustomUserAccountService>());
factory.Register(new Registration<CustomGroupService>());
factory.Register(new Registration<CustomUserRepository>());
factory.Register(new Registration<CustomGroupRepository>());
factory.Register(new Registration<CustomDatabase>(resolver => new CustomDatabase("MembershipReboot")));
factory.Register(new Registration<CustomConfig>(CustomConfig.Config));
return new IdentityManagerOptions
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration
{
HostAuthenticationType = "Cookies",
NameClaimType = "name",
RoleClaimType = "role",
AdminRoleName = "IdentityManagerAdmin"
}
};
}
public void InitializeIdentityManager(IAppBuilder app, string nameOrConnStr, IdentityManagerServiceFactory factory)
{
#region CONFIGURAÇÃO DO IDENTITY MANAGER
app.Map("/admin", admin => {
var congig = new IdentityManagerOptions {
Factory = factory,
#region Configura a authenticação e o administrador do IdMgr
SecurityConfiguration = new HostSecurityConfiguration {
HostAuthenticationType = "Cookies",
AdditionalSignOutType = "oidc",
AdminRoleName = ConfigurationManager.AppSettings[Constantes.AppSettings.IdMgr.IdMgrAdminRoleName],
RequireSsl = true
#endregion
}
};
admin.UseIdentityManager(congig);
});
#endregion
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
// this configures IdentityManager
// we're using a Map just to test hosting not at the root
app.Map("/idm", idm =>
{
var factory = new IdentityManagerServiceFactory();
var rand = new System.Random();
var users = Users.Get(rand.Next(5000, 20000));
var roles = Roles.Get(rand.Next(15));
factory.Register(new Registration<ICollection<InMemoryUser>>(users));
factory.Register(new Registration<ICollection<InMemoryRole>>(roles));
factory.IdentityManagerService = new Registration<IIdentityManagerService, InMemoryIdentityManagerService>();
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory,
});
});
}
public void Configuration(IAppBuilder app)
{
AppStart();
ConfigureAuth(app);
app.Map("/idm", idm =>
{
var factory = new IdentityManagerServiceFactory();
factory.IdentityManagerService =
new Registration<IIdentityManagerService,
ApplicationIdentityManagerService>();
factory.Register(new Registration<ApplicationUserManager>());
factory.Register(new Registration<ApplicationUserStore>());
factory.Register(new Registration<ApplicationRoleManager>());
factory.Register(new Registration<ApplicationRoleStore>());
//factory.Register(new Registration<ApplicationDbContext>(resolver => new ApplicationDbContext("foo")));
factory.Register(new Registration<ApplicationDbContext>());
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory
});
});
}
public void Configuration(IAppBuilder appBuilder)
{
//var options = new IdentityServerOptions
//{
// SigningCertificate = Certificate.Load(),
// Factory = factory,
//};
//appBuilder.UseIdentityServer(options);
var connectionString = "MembershipReboot";
//------------------------------------------------
const string IdServBaseUri = @"https://*****:*****@"https://localhost:44333/admin/";
AntiForgeryConfig.UniqueClaimTypeIdentifier = "sub";
JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary<string, string>();
appBuilder.Map("/admin", adminApp =>
{
adminApp.UseCookieAuthentication(new CookieAuthenticationOptions { AuthenticationType = "Cookies" });
adminApp.UseOpenIdConnectAuthentication(
new OpenIdConnectAuthenticationOptions
{
AuthenticationType = "oidc",
ClientId = "hybridclient",
Authority = IdServBaseUri,
RedirectUri = ClientUri,
PostLogoutRedirectUri = @"https://*****:*****@"https://localhost:44333/connect/userinfo"),
n.ProtocolMessage.AccessToken);
var userInfo = await userInfoClient.GetAsync();
List<Tuple<string, string>> mn = userInfo.Claims as List<Tuple<string, string>>;
mn.ForEach(x => nIdentity.AddClaim(new Claim(x.Item1, x.Item2)));
//userInfo.Claims.ToList().ForEach(x => nIdentity.AddClaim(new Claim(x.Item1, x.Item2)));
/*var tokenClient = new OAuth2Client(new Uri(@"https://*****:*****@"https://localhost:44333/useraccount/",
ResponseType = "code id_token token",
Scope = "openid profile email roles all_claims", //offline_access
SignInAsAuthenticationType = "Cookies",
PostLogoutRedirectUri = @"https://*****:*****@"https://localhost:44333/connect/userinfo"),
n.ProtocolMessage.AccessToken);
var userInfo = await userInfoClient.GetAsync();
List<Tuple<string, string>> mn = userInfo.Claims as List<Tuple<string, string>>;
mn.ForEach(x => nIdentity.AddClaim(new Claim(x.Item1, x.Item2)));
nIdentity.AddClaim(new Claim("id_token", n.ProtocolMessage.IdToken));
n.Options.Caption += "id_token_hint=" + n.ProtocolMessage.IdToken;
n.AuthenticationTicket = new Microsoft.Owin.Security.AuthenticationTicket(
nIdentity,
n.AuthenticationTicket.Properties);
},
RedirectToIdentityProvider = async n =>
{
if (n.ProtocolMessage.RequestType == OpenIdConnectRequestType.LogoutRequest)
{
var idTokenHint = n.OwinContext.Authentication.User.FindFirst("id_token").Value;
n.ProtocolMessage.IdTokenHint = idTokenHint;
//var caption = n.Options.Caption;
//var indexOfTokenHint = caption.IndexOf("id_token_hint=");
//var idTokenHint = caption.Substring(indexOfTokenHint).Replace("id_token_hint=", "");
//n.Options.Caption = caption.Remove(indexOfTokenHint);
//n.ProtocolMessage.IdTokenHint = idTokenHint;
}
}
}
});
});
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureCustomUserService(connectionString);
idSvrFactory.ViewService = new Thinktecture.IdentityServer.Core.Configuration.Registration<IViewService>(typeof(CustomViewService));
var options = new IdentityServerOptions
{
IssuerUri = "https://localhost:44333/", //"https://localhost:44333/core"
SiteName = "SLEEK Auth System",
SigningCertificate = Certificate.Load(), //.Get(),
Factory = idSvrFactory,
CorsPolicy = CorsPolicy.AllowAll,
AuthenticationOptions = new AuthenticationOptions
{
IdentityProviders = ConfigureAdditionalIdentityProviders,
LoginPageLinks = new LoginPageLink[]
{
new LoginPageLink(){
Href = "UserAccount/PasswordReset",
Text = "I can't access my account"
},
new LoginPageLink(){
Href = "Registration",
Text = "Create account"
}
}
},
//EnableWelcomePage = false
};
appBuilder.UseIdentityServer(options);
}
public IdentityManagerOptions()
{
Factory = new IdentityManagerServiceFactory();
SecurityConfiguration = new LocalhostSecurityConfiguration();
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new DiagnosticsTraceLogProvider());
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
app.UseCookieAuthentication(new Microsoft.Owin.Security.Cookies.CookieAuthenticationOptions()
{
AuthenticationType = "Cookies",
LoginPath = new PathString("/Home/Login")
});
// Adding below stuff to secure identity manager
//JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary<string, string>();
//app.UseCookieAuthentication(new Microsoft.Owin.Security.Cookies.CookieAuthenticationOptions
//{
// AuthenticationType = "Cookies",
//});
//app.UseOpenIdConnectAuthentication(new Microsoft.Owin.Security.OpenIdConnect.OpenIdConnectAuthenticationOptions
//{
// AuthenticationType = "oidc",
// Authority = WebConfigurationManager.AppSettings["IdentityServerURL"], // https://localhost:44301/identity,
// ClientId = "WorksuiteThinClient",
// RedirectUri = WebConfigurationManager.AppSettings["IdentityServerAuthRedirectURL"], //"https://localhost:44301",
// ResponseType = "id_token",
// UseTokenLifetime = false,
// Scope = "openid idmgr",
// SignInAsAuthenticationType = "Cookies",
// Notifications = new Microsoft.Owin.Security.OpenIdConnect.OpenIdConnectAuthenticationNotifications
// {
// SecurityTokenValidated = n =>
// {
// n.AuthenticationTicket.Identity.AddClaim(new Claim("id_token", n.ProtocolMessage.IdToken));
// return Task.FromResult(0);
// },
// RedirectToIdentityProvider = async n =>
// {
// if (n.ProtocolMessage.RequestType == Microsoft.IdentityModel.Protocols.OpenIdConnectRequestType.LogoutRequest)
// {
// var result = await n.OwinContext.Authentication.AuthenticateAsync("Cookies");
// if (result != null)
// {
// var id_token = result.Identity.Claims.GetValue("id_token");
// if (id_token != null)
// {
// n.ProtocolMessage.IdTokenHint = id_token;
// n.ProtocolMessage.PostLogoutRedirectUri = WebConfigurationManager.AppSettings["IdentityManagerURL"]; //"https://localhost:44337/idm";
// }
// }
// }
// }
// }
//});
////////////////
var connectionString = "MembershipReboot";
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.Configure(connectionString);
adminApp.UseIdentityManager(new IdentityManagerOptions()
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration()
{
HostAuthenticationType = "Cookies",
NameClaimType = "name",
RoleClaimType = "role",
AdminRoleName = "UsersAdmin"
}
});
});
app.Map("/identity", core =>
{
var idSvrFactory = Factory.Configure();
idSvrFactory.ConfigureCustomUserService(connectionString);
var options = new IdentityServerOptions
{
SiteName = "IdentityServer3 - UserService-MembershipReboot",
SigningCertificate = Certificate.Get(),
Factory = idSvrFactory,
AuthenticationOptions = new AuthenticationOptions
{
}
};
core.UseIdentityServer(options);
});
}
public static void Configure(IAppBuilder app)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Trace()
.CreateLogger();
app.UseAesDataProtectorProvider();
BasePath = AppDomain.CurrentDomain.BaseDirectory;
var certFile = Path.Combine(BasePath, "idsrv3test.pfx");
Console.WriteLine(certFile);
var options = ConfigureIdentityServer(certFile);
// var cpath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),"..", "..", "..", "src", "Janitor", "Content"));
// Console.WriteLine(cpath);
// app.UseStaticFiles (new StaticFileOptions {
// RequestPath = new PathString("/Content"),
// FileSystem = new PhysicalFileSystem(cpath)
// });
app.Map("/admin", adminApp =>
{
var factory = new IdentityManagerServiceFactory();
factory.ConfigureSimpleIdentityManagerService("AspId");
var adminOptions = new IdentityManagerOptions
{
Factory = factory,
};
adminOptions.SecurityConfiguration.RequireSsl = false;
adminApp.UseIdentityManager(adminOptions);
});
app.UseIdentityServer(options);
}
public void Configuration(IAppBuilder app)
{
LogProvider.SetCurrentLogProvider(new TraceSourceLogProvider());
JwtSecurityTokenHandler.InboundClaimTypeMap = new Dictionary<string, string>();
app.UseCookieAuthentication(new Microsoft.Owin.Security.Cookies.CookieAuthenticationOptions
{
AuthenticationType = "Cookies",
});
app.UseOpenIdConnectAuthentication(new Microsoft.Owin.Security.OpenIdConnect.OpenIdConnectAuthenticationOptions
{
AuthenticationType = "oidc",
Authority = "https://localhost:44337/ids",
ClientId = "idmgr_client",
RedirectUri = "https://localhost:44337",
ResponseType = "id_token",
UseTokenLifetime = false,
Scope = "openid idmgr",
SignInAsAuthenticationType = "Cookies",
Notifications = new Microsoft.Owin.Security.OpenIdConnect.OpenIdConnectAuthenticationNotifications
{
SecurityTokenValidated = n =>
{
n.AuthenticationTicket.Identity.AddClaim(new Claim("id_token", n.ProtocolMessage.IdToken));
return Task.FromResult(0);
},
RedirectToIdentityProvider = async n =>
{
if (n.ProtocolMessage.RequestType == Microsoft.IdentityModel.Protocols.OpenIdConnectRequestType.LogoutRequest)
{
var result = await n.OwinContext.Authentication.AuthenticateAsync("Cookies");
if (result != null)
{
var id_token = result.Identity.Claims.GetValue("id_token");
if (id_token != null)
{
n.ProtocolMessage.IdTokenHint = id_token;
n.ProtocolMessage.PostLogoutRedirectUri = "https://localhost:44337/idm";
}
}
}
}
}
});
app.Map("/idm", idm =>
{
var factory = new IdentityManagerServiceFactory();
var rand = new System.Random();
var users = Users.Get(rand.Next(5000, 20000));
var roles = Roles.Get(rand.Next(15));
factory.Register(new Registration<ICollection<InMemoryUser>>(users));
factory.Register(new Registration<ICollection<InMemoryRole>>(roles));
factory.IdentityManagerService = new Registration<IIdentityManagerService, InMemoryIdentityManagerService>();
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory,
SecurityConfiguration = new HostSecurityConfiguration
{
HostAuthenticationType = "Cookies",
//AdditionalSignOutType = "oidc"
}
});
});
// this configures an embedded IdentityServer to act as an external authentication provider
// when using IdentityManager in Token security mode. normally you'd configure this elsewhere.
app.Map("/ids", ids =>
{
IdSvrConfig.Configure(ids);
});
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app)
{
// Configure the db context, user manager and signin manager to use a single instance per request
app.CreatePerOwinContext(ApplicationDbContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
// Enable the application to use a cookie to store information for the signed in user
// and to use a cookie to temporarily store information about a user logging in with a third party login provider
// Configure the sign in cookie
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login to your account.
OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(30),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
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);
// Uncomment the following lines to enable logging in with third party login providers
//app.UseMicrosoftAccountAuthentication(
// clientId: "",
// clientSecret: "");
//app.UseTwitterAuthentication(
// consumerKey: "",
// consumerSecret: "");
//app.UseFacebookAuthentication(
// appId: "",
// appSecret: "");
//app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
//{
// ClientId = "",
// ClientSecret = ""
//});
app.Map("/idm", idm =>
{
var factory = new IdentityManagerServiceFactory();
factory.IdentityManagerService = new Registration<IIdentityManagerService, ApplicationIdentityManagerService>();
factory.Register(new Registration<ApplicationUserManager>());
factory.Register(new Registration<ApplicationUserStore>());
factory.Register(new Registration<ApplicationRoleManager>());
factory.Register(new Registration<ApplicationRoleStore>());
factory.Register(new Registration<ApplicationDbContext>());
idm.UseIdentityManager(new IdentityManagerOptions
{
Factory = factory
});
});
}
