internal static ISecurityContext CreateFrom(ISecurityConfiguration configuration)
{
ISecurityContext context = null;
var securityConfiguration = configuration as SecurityConfiguration;
if (securityConfiguration != null)
{
var configurationExpression = securityConfiguration.Expression;
var externalServiceLocator = configurationExpression.ExternalServiceLocator;
if (externalServiceLocator != null)
context = externalServiceLocator.Resolve(typeof(ISecurityContext)) as ISecurityContext;
if (context == null)
{
if (CanCreateSecurityContextFromConfigurationExpression(configurationExpression) == false)
throw new ConfigurationErrorsException(
@"
The current configuration is invalid! Before using Fluent Security you must do one of the following.
1) Specify how to get the authentication status using GetAuthenticationStatusFrom().
2) Register an instance of ISecurityContext in your IoC-container and register your container using ResolveServicesUsing().
");
context = new SecurityContext(configurationExpression);
}
}
return context;
}
public static TabSection Create(ISecurityConfiguration configuration)
{
var section = new TabSection("Key", "Value");
var availableVersion = TryGetVersionFromGithub();
section.AddRow()
.Column("Latest version of Fluent Security").Strong()
.Column(availableVersion).Strong()
.Selected();
var loadedVersion = configuration.GetType().Assembly.FullName;
section.AddRow()
.Column("Loaded assembly")
.Column(loadedVersion);
section.AddRow()
.Column("Website")
.Column(@"<a href='http://fluentsecurity.net/'>http://fluentsecurity.net</a>").Raw();
section.AddRow()
.Column("Documentation")
.Column(@"<a href='http://fluentsecurity.net/wiki'>http://fluentsecurity.net/wiki</a>").Raw();
section.AddRow()
.Column("Twitter")
.Column(@"<a href='http://twitter.com/FluentSecurity'>@FluentSecurity</a>").Raw();
return section;
}
internal KeyEncryption(string containerName, [CanBeNull] ISecurityConfiguration securityConfiguration)
{
_securityConfiguration = securityConfiguration ?? new SecurityConfiguration();
_maxBytesServer = GetMaxKeySize() / 8;
var isTemporary = false;
if (!containerName.IsAssigned())
{
isTemporary = true;
containerName = "None";
}
Debug.WriteLine("Encryption: Utilhelper.ServerKeyEncryption(...) key - " + containerName);
if (isTemporary)
{
RsaProvider = TempKeyContainer;
}
else
{
GetKeyContainer(containerName);
}
Debug.WriteLine("Encryption: Utilhelper.ServerKeyEncryption(...) gotcontainer");
}
internal static ISecurityContext CreateFrom(ISecurityConfiguration configuration)
{
ISecurityContext context = null;
var securityConfiguration = configuration as SecurityConfiguration;
if (securityConfiguration != null)
{
var externalServiceLocator = securityConfiguration.Runtime.ExternalServiceLocator;
if (externalServiceLocator != null)
{
context = externalServiceLocator.Resolve(typeof(ISecurityContext)) as ISecurityContext;
}
if (context == null)
{
if (securityConfiguration.Runtime.IsAuthenticated == null)
{
throw new ConfigurationErrorsException(
@"
The current configuration is invalid! Before using Fluent Security you must do one of the following.
1) Specify how to get the authentication status using GetAuthenticationStatusFrom().
2) Register an instance of ISecurityContext in your IoC-container and register your container using ResolveServicesUsing().
" );
}
context = new SecurityContext(securityConfiguration.Runtime);
}
}
return(context);
}
internal static void Reset()
{
lock (LockObject)
{
_configuration = null;
}
}
internal static void Reset()
{
lock (LockObject)
{
_configuration = null;
}
}
public IEnumerable <ExpectationResult> VerifyAll(ISecurityConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
return(ExpectationVerifyerProvider(configuration, ExpectationViolationHandler).VerifyExpectationsOf(ExpectationGroups));
}
public ExpectationVerifyer(ISecurityConfiguration configuration, IExpectationViolationHandler expectationViolationHandler)
{
if (configuration == null) throw new ArgumentNullException("configuration");
if (expectationViolationHandler == null) throw new ArgumentNullException("expectationViolationHandler");
_configuration = configuration;
_expectationViolationHandler = expectationViolationHandler;
}
/// <summary>
/// The security configuration accessor.
/// </summary>
/// <returns> The security configuration implementation.
/// </returns>
public static ISecurityConfiguration SecurityConfiguration()
{
if (Esapi.securityConfiguration == null)
{
Esapi.securityConfiguration = new SecurityConfiguration();
}
return(Esapi.securityConfiguration);
}
public static ISecurityConfiguration SecurityConfiguration()
{
if (Owasp.Esapi.Esapi.securityConfiguration == null)
{
Owasp.Esapi.Esapi.securityConfiguration = (ISecurityConfiguration) new SecurityConfiguration();
}
return(Owasp.Esapi.Esapi.securityConfiguration);
}
public void Should_not_throw()
{
ISecurityConfiguration securityConfiguration = FluentSecurityFactory.CreateSecurityConfiguration();
Assert.DoesNotThrow(() =>
securityConfiguration.Verify <AdminController>(expectations => { })
);
}
public void Should_throw_when_expectations_are_null()
{
ISecurityConfiguration securityConfiguration = FluentSecurityFactory.CreateSecurityConfigurationWithTwoExpectations();
Assert.Throws <ArgumentNullException>(() =>
securityConfiguration.Verify <AdminController>(null)
);
}
public void Should_throw_when_configuration_is_null()
{
ISecurityConfiguration securityConfiguration = null;
Assert.Throws <ArgumentNullException>(() =>
securityConfiguration.Verify <AdminController>(expectations => { })
);
}
public PopulateClaimsMiddleware(ISecurityConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration), $"{nameof(configuration)} is null.");
}
_Configuration = configuration;
}
public SecurityController(ISecurityConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration), $"{nameof(configuration)} is null.");
}
_Configuration = configuration;
}
public void Should_throw_when_configuration_is_null()
{
// Arrange
ISecurityConfiguration configuration = null;
var policyExpectations = new PolicyExpectations();
// Act & assert
Assert.Throws <ArgumentNullException>(() => policyExpectations.VerifyAll(configuration));
}
public void Should_throw_ArgumentNullException_when_configuration_is_null()
{
// Arrange
SecurityConfigurator.Reset();
const ISecurityConfiguration nullConfiguration = null;
// Act & Assert
Assert.Throws <ArgumentNullException>(() => SecurityConfigurator.SetConfiguration(nullConfiguration));
}
public void Should_throw_when_configuration_is_null()
{
// Arrange
const ISecurityConfiguration configuration = null;
var expectationViolationHandler = new Mock <IExpectationViolationHandler>().Object;
// Act & assert
Assert.Throws <ArgumentNullException>(() => new ExpectationVerifyer(configuration, expectationViolationHandler));
}
private static EducationSecurityPrincipal CreateTarget(string adminEmailAddress, User user)
{
ISecurityConfiguration config = MockRepository.GenerateMock <ISecurityConfiguration>();
config.Expect(m => m.AdministratorEmailAddresses).Return(new string[] { adminEmailAddress });
EducationSecurityPrincipal target = new EducationSecurityPrincipal(user);
target.Configuration = config;
return(target);
}
public UsuarioService(IBaseRepository <Usuario> userRepository,
IMapper mapper,
ISecurityConfiguration appSettings,
IMailClient mailClient)
{
_userRepository = userRepository;
_mapper = mapper;
_appSettings = appSettings;
_mailClient = mailClient;
}
internal static void SetConfiguration(ISecurityConfiguration configuration)
{
if (configuration == null)
throw new ArgumentNullException("configuration");
lock (LockObject)
{
_configuration = configuration;
}
}
public static void SetConfiguration(ISecurityConfiguration configuration)
{
if (configuration == null)
throw new ArgumentNullException("configuration");
Reset();
lock (LockObject)
{
SecurityConfiguration.SetConfiguration(configuration);
}
}
public WebDavPlugin(IStorageAccountService accountService,
ICryptoService cryptoService,
ISecurityConfiguration securityConfiguration)
{
AccountService = accountService;
CryptoService = cryptoService;
SecurityConfiguration = securityConfiguration;
ConfigurationProviderReference = new WeakRefHolder<ConfigurationProvider>(() => new ConfigurationProvider(AccountService, CryptoService, SecurityConfiguration));
FolderQueryReference = new WeakRefHolder<FolderQuery>(() => new FolderQuery());
FileStreamQueryReference = new WeakRefHolder<FileStreamQuery>(() => new FileStreamQuery());
}
public JwtTokenRequestClient(
ISecurityConfiguration securityConfiguration,
IInternalLogger internalLogger,
IUserProfileId userProfileId,
IJwtTokenCache jwtTokenCache)
{
_securityConfiguration = securityConfiguration;
_internalLogger = internalLogger;
_userProfileId = userProfileId;
_jwtTokenCache = jwtTokenCache;
}
public PopulateClaimsMiddleware(ISecurityConfiguration configuration,
IEasyAuthDemoDbContext context)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration), $"{nameof(configuration)} is null.");
}
_Configuration = configuration;
_DbContext = context ?? throw new ArgumentNullException(nameof(context));
}
public WebDavPlugin(IStorageAccountService accountService,
ICryptoService cryptoService,
ISecurityConfiguration securityConfiguration)
{
AccountService = accountService;
CryptoService = cryptoService;
SecurityConfiguration = securityConfiguration;
ConfigurationProviderReference = new WeakRefHolder <ConfigurationProvider>(() => new ConfigurationProvider(AccountService, CryptoService, SecurityConfiguration));
FolderQueryReference = new WeakRefHolder <FolderQuery>(() => new FolderQuery());
FileStreamQueryReference = new WeakRefHolder <FileStreamQuery>(() => new FileStreamQuery());
}
public static bool IsAdministrator(User userEntity, ISecurityConfiguration configuration)
{
if (userEntity == null)
{
throw new ArgumentNullException("userEntity");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
return configuration.AdministratorEmailAddresses.Contains(userEntity.EmailAddress, StringComparer.OrdinalIgnoreCase);
}
internal static void SetConfiguration(ISecurityConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
lock (LockObject)
{
_configuration = configuration;
}
}
public AccountService(
IAccountManager accountManager,
IEmailManager emailManager,
IAppConfiguration appConfiguration,
ISecurityConfiguration securityConfiguration,
IMapper mapper) : base(mapper)
{
this.accountManager = accountManager;
this.emailManager = emailManager;
this.appConfiguration = appConfiguration;
this.securityConfiguration = securityConfiguration;
}
public static bool IsAdministrator(User userEntity, ISecurityConfiguration configuration)
{
if (userEntity == null)
{
throw new ArgumentNullException("userEntity");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
return(configuration.AdministratorEmailAddresses.Contains(userEntity.EmailAddress, StringComparer.OrdinalIgnoreCase));
}
public AuthenticationService(IBaseRepository <Usuario> userRepository,
IMapper mapper,
IBaseRepository <Permiso> permisoRepository, IBaseRepository <PermisoRol> permisoRolRepository,
IBaseRepository <PermisoControladorAccion> permisoControladorRepository,
ISecurityConfiguration appSettings)
{
_userRepository = userRepository;
_mapper = mapper;
_appSettings = appSettings;
_permisoRolRepository = permisoRolRepository;
_permisoRepository = permisoRepository;
_permisoControladorRepository = permisoControladorRepository;
}
public UserController(IAccountManager logicManager, ISecurityConfiguration securityConfiguration)
{
if (logicManager == null)
{
throw new ArgumentNullException("logicManager");
}
if (securityConfiguration == null)
{
throw new ArgumentNullException("securityConfiguration");
}
LogicManager = logicManager;
SecurityConfiguration = securityConfiguration;
}
public static void SetConfiguration(ISecurityConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
Reset();
lock (LockObject)
{
SecurityConfiguration.SetConfiguration(configuration);
}
}
public UserController(IAccountManager logicManager, ISecurityConfiguration securityConfiguration)
{
if (logicManager == null)
{
throw new ArgumentNullException("logicManager");
}
if (securityConfiguration == null)
{
throw new ArgumentNullException("securityConfiguration");
}
LogicManager = logicManager;
SecurityConfiguration = securityConfiguration;
}
public ExpectationVerifyer(ISecurityConfiguration configuration, IExpectationViolationHandler expectationViolationHandler)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (expectationViolationHandler == null)
{
throw new ArgumentNullException("expectationViolationHandler");
}
_configuration = configuration;
_expectationViolationHandler = expectationViolationHandler;
}
public UserClientDataTable(HttpRequestBase request, ISecurityConfiguration securityConfiguration)
: base(request)
{
if (securityConfiguration == null)
{
throw new ArgumentNullException("securityConfiguration");
}
SecurityConfiguration = securityConfiguration;
FirstName = ExtractFilterValue("firstName");
LastName = ExtractFilterValue("lastName");
Email = ExtractFilterValue("email");
Schools = ExtractFilterList("schools");
Statuses = ExtractFilterList("status");
Roles = ExtractFilterList("roles");
}
public void Should_verify_expectations()
{
ISecurityConfiguration securityConfiguration = FluentSecurityFactory.CreateSecurityConfiguration();
var results = securityConfiguration.Verify <AdminController>(expectations =>
{
expectations.Expect().Has <DenyAnonymousAccessPolicy>();
expectations.Expect(x => x.Login()).DoesNotHave <DenyAnonymousAccessPolicy>().Has <DenyAuthenticatedAccessPolicy>();
expectations.Expect(x => x.NewUser())
.DoesNotHave <DenyAnonymousAccessPolicy>()
.DoesNotHave <RequireRolePolicy>(p => p.RolesRequired.Contains(UserRole.UserViewer))
.Has <RequireRolePolicy>(p => p.RolesRequired.Contains(UserRole.UserEditor));
});
Assert.That(results.All(x => x.ExpectationsMet), results.ErrorMessages());
}
public static IEnumerable <ExpectationResult> Verify(this ISecurityConfiguration configuration, Action <PolicyExpectationsExpression> expectationExpression)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (expectationExpression == null)
{
throw new ArgumentNullException("expectationExpression");
}
var policyExpectationsExpression = new PolicyExpectationsExpression();
expectationExpression(policyExpectationsExpression);
var policyExpectations = policyExpectationsExpression.Expectations;
return(policyExpectations.VerifyAll(configuration));
}
public static TabSection Create(ISecurityConfiguration configuration)
{
var section = new TabSection("Controller", "Action", "Policies");
var sortedPolicyContainers = configuration.PolicyContainers.OrderBy(x => x.ActionName).OrderBy(x => x.ControllerName);
foreach (var policyContainer in sortedPolicyContainers)
{
var policySectionData = new TabSection("Policy", "Type");
var securityPolicies = policyContainer.GetPolicies().OrderBy(x => x.GetType().FullName).Select(x => x.GetPolicyType());
AddPoliciesToPolicySection(policySectionData, securityPolicies);
section.AddRow()
.Column(policyContainer.ControllerName)
.Column(policyContainer.ActionName)
.Column(policySectionData);
}
return section;
}
public string WhatDoIHave(ISecurityConfiguration configuration)
{
var builder = new StringBuilder();
builder.AppendFormat("Ignore missing configuration: {0}", configuration.Runtime.ShouldIgnoreMissingConfiguration);
builder.AppendLine().AppendLine().AppendLine("------------------------------------------------------------------------------------").AppendLine();
foreach (var policyContainer in configuration.PolicyContainers.OrderBy(x => x.ActionName).OrderBy(x => x.ControllerName))
{
builder.AppendFormat(
"{0} > {1}{2}",
policyContainer.ControllerName,
policyContainer.ActionName,
policyContainer.GetPolicies().ToText()
);
builder.AppendLine().AppendLine();
}
builder.Append("------------------------------------------------------------------------------------");
return(builder.ToString());
}
public string WhatDoIHave(ISecurityConfiguration configuration)
{
var builder = new StringBuilder();
builder.AppendFormat("Ignore missing configuration: {0}", configuration.Runtime.ShouldIgnoreMissingConfiguration);
builder.AppendLine().AppendLine().AppendLine("------------------------------------------------------------------------------------").AppendLine();
foreach (var policyContainer in configuration.PolicyContainers.OrderBy(x => x.ActionName).OrderBy(x => x.ControllerName))
{
builder.AppendFormat(
"{0} > {1}{2}",
policyContainer.ControllerName,
policyContainer.ActionName,
policyContainer.GetPolicies().ToText()
);
builder.AppendLine().AppendLine();
}
builder.Append("------------------------------------------------------------------------------------");
return builder.ToString();
}
public ConfigurationProvider(IStorageAccountService accountService, ICryptoService cryptoService, ISecurityConfiguration securityConfiguration)
{
_accountService = accountService;
_cryptoService = cryptoService;
_securityConfiguration = securityConfiguration;
}
/// <summary>
/// The security configuration accessor.
/// </summary>
/// <returns> The security configuration implementation.
/// </returns>
public static ISecurityConfiguration SecurityConfiguration()
{
if (Esapi.securityConfiguration == null)
Esapi.securityConfiguration = new SecurityConfiguration();
return Esapi.securityConfiguration;
}
public YandexDiskPlugin(IStorageAccountService accountService, ICryptoService cryptoService, ISecurityConfiguration securityConfiguration)
: base(accountService, cryptoService, securityConfiguration)
{
}
