From cb0994a9294fca034d53424e1cee2f0d6963535c Mon Sep 17 00:00:00 2001 From: Bjarke Berg Date: Thu, 12 Mar 2020 14:36:25 +0100 Subject: [PATCH] Cleaned up config for Security settings --- src/Umbraco.Configuration/ConfigsFactory.cs | 10 +++-- .../MemberPasswordConfigurationSettings.cs | 16 +++++++ .../Implementations/SecuritySettings.cs | 14 +++++++ .../UserPasswordConfigurationSettings.cs | 15 +++++++ .../MemberPasswordConfigurationElement.cs | 2 +- .../UmbracoSettings/SecurityElement.cs | 18 ++++---- .../UmbracoSettings/UmbracoSettingsSection.cs | 2 - .../UserPasswordConfigurationElement.cs | 2 +- .../Configuration/ConfigsExtensions.cs | 27 ++++-------- .../MemberPasswordConfiguration.cs | 6 +-- .../Configuration/PasswordConfiguration.cs | 22 +++++----- .../IMemberPasswordConfigurationSection.cs | 6 --- ...ecuritySection.cs => ISecuritySettings.cs} | 8 +--- .../IUmbracoSettingsSection.cs | 2 - .../IUserPasswordConfigurationSection.cs | 6 --- .../UserPasswordConfiguration.cs | 6 +-- .../CompositionExtensions/Configuration.cs | 1 - .../Models/ContentEditing/UserInvite.cs | 2 +- .../UmbracoSettings/SecurityElementTests.cs | 42 +++++++++---------- .../UmbracoSettings/UmbracoSettingsTests.cs | 4 ++ .../TestHelpers/SettingsForTests.cs | 31 +++++++++----- src/Umbraco.Tests/Testing/UmbracoTestBase.cs | 3 ++ .../AuthenticationControllerTests.cs | 2 +- .../Web/Controllers/UsersControllerTests.cs | 12 ++++-- .../Umbraco/Views/AuthorizeUpgrade.cshtml | 2 +- .../Umbraco/Views/Default.cshtml | 2 +- .../Editors/AuthenticationController.cs | 8 ++-- .../Editors/BackOfficeController.cs | 13 +++--- src/Umbraco.Web/Editors/BackOfficeModel.cs | 7 +++- .../Editors/BackOfficePreviewModel.cs | 4 +- .../Editors/BackOfficeServerVariables.cs | 11 +++-- src/Umbraco.Web/Editors/PreviewController.cs | 7 +++- src/Umbraco.Web/Editors/UsersController.cs | 15 ++++--- .../HtmlHelperBackOfficeExtensions.cs | 4 +- .../Install/InstallSteps/NewInstallStep.cs | 8 ++-- .../Security/AppBuilderExtensions.cs | 35 ++++++++-------- .../Security/AuthenticationExtensions.cs | 6 +-- .../BackOfficeCookieAuthenticationProvider.cs | 8 ++-- .../Security/GetUserSecondsMiddleWare.cs | 4 +- .../UmbracoBackOfficeCookieAuthOptions.cs | 6 +-- src/Umbraco.Web/UmbracoDefaultOwinStartup.cs | 5 ++- 41 files changed, 228 insertions(+), 176 deletions(-) create mode 100644 src/Umbraco.Configuration/Implementations/MemberPasswordConfigurationSettings.cs create mode 100644 src/Umbraco.Configuration/Implementations/SecuritySettings.cs create mode 100644 src/Umbraco.Configuration/Implementations/UserPasswordConfigurationSettings.cs delete mode 100644 src/Umbraco.Core/Configuration/UmbracoSettings/IMemberPasswordConfigurationSection.cs rename src/Umbraco.Core/Configuration/UmbracoSettings/{ISecuritySection.cs => ISecuritySettings.cs} (78%) delete mode 100644 src/Umbraco.Core/Configuration/UmbracoSettings/IUserPasswordConfigurationSection.cs diff --git a/src/Umbraco.Configuration/ConfigsFactory.cs b/src/Umbraco.Configuration/ConfigsFactory.cs index 8930edf36b..d9305e0ee8 100644 --- a/src/Umbraco.Configuration/ConfigsFactory.cs +++ b/src/Umbraco.Configuration/ConfigsFactory.cs @@ -24,6 +24,9 @@ namespace Umbraco.Core.Configuration public IKeepAliveSettings KeepAliveSettings { get; } = new KeepAliveSettings(); public IWebRoutingSettings WebRoutingSettings { get; } = new WebRoutingSettings(); public IRequestHandlerSettings RequestHandlerSettings { get; } = new RequestHandlerSettings(); + public ISecuritySettings SecuritySettings { get; } = new SecuritySettings(); + public IUserPasswordConfiguration UserPasswordConfigurationSettings { get; } = new UserPasswordConfigurationSettings(); + public IMemberPasswordConfiguration MemberPasswordConfigurationSettings { get; } = new MemberPasswordConfigurationSettings(); public IUmbracoSettingsSection UmbracoSettings { get; } @@ -36,10 +39,6 @@ namespace Umbraco.Core.Configuration configs.Add("umbracoConfiguration/settings"); configs.Add("umbracoConfiguration/HealthChecks"); - // Password configuration is held within IUmbracoSettingsSection from umbracoConfiguration/settings but we'll add explicitly - // so it can be independently retrieved in classes that need it. - configs.AddPasswordConfigurations(); - configs.Add(() => CoreDebug); configs.Add(() => MachineKeyConfig); configs.Add(() => new ConnectionStrings(ioHelper)); @@ -58,6 +57,9 @@ namespace Umbraco.Core.Configuration configs.Add(() => KeepAliveSettings); configs.Add(() => WebRoutingSettings); configs.Add(() => RequestHandlerSettings); + configs.Add(() => SecuritySettings); + configs.Add(() => UserPasswordConfigurationSettings); + configs.Add(() => MemberPasswordConfigurationSettings); configs.AddCoreConfigs(ioHelper); return configs; diff --git a/src/Umbraco.Configuration/Implementations/MemberPasswordConfigurationSettings.cs b/src/Umbraco.Configuration/Implementations/MemberPasswordConfigurationSettings.cs new file mode 100644 index 0000000000..e42b02de73 --- /dev/null +++ b/src/Umbraco.Configuration/Implementations/MemberPasswordConfigurationSettings.cs @@ -0,0 +1,16 @@ +using Umbraco.Core.Configuration; + +namespace Umbraco.Configuration.Implementations +{ + internal class MemberPasswordConfigurationSettings : ConfigurationManagerConfigBase, IMemberPasswordConfiguration + { + public int RequiredLength => UmbracoSettingsSection.Security.UserPasswordConfiguration.RequiredLength; + public bool RequireNonLetterOrDigit => UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireNonLetterOrDigit; + public bool RequireDigit => UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireDigit; + public bool RequireLowercase=> UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireLowercase; + public bool RequireUppercase=> UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireUppercase; + public bool UseLegacyEncoding=> UmbracoSettingsSection.Security.UserPasswordConfiguration.UseLegacyEncoding; + public string HashAlgorithmType=> UmbracoSettingsSection.Security.UserPasswordConfiguration.HashAlgorithmType; + public int MaxFailedAccessAttemptsBeforeLockout => UmbracoSettingsSection.Security.UserPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout; + } +} diff --git a/src/Umbraco.Configuration/Implementations/SecuritySettings.cs b/src/Umbraco.Configuration/Implementations/SecuritySettings.cs new file mode 100644 index 0000000000..b7e39b0608 --- /dev/null +++ b/src/Umbraco.Configuration/Implementations/SecuritySettings.cs @@ -0,0 +1,14 @@ +using Umbraco.Core.Configuration.UmbracoSettings; + +namespace Umbraco.Configuration.Implementations +{ + internal class SecuritySettings : ConfigurationManagerConfigBase, ISecuritySettings + { + public bool KeepUserLoggedIn => UmbracoSettingsSection.Security.KeepUserLoggedIn; + public bool HideDisabledUsersInBackoffice => UmbracoSettingsSection.Security.HideDisabledUsersInBackoffice; + public bool AllowPasswordReset => UmbracoSettingsSection.Security.AllowPasswordReset; + public string AuthCookieName => UmbracoSettingsSection.Security.AuthCookieName; + public string AuthCookieDomain => UmbracoSettingsSection.Security.AuthCookieDomain; + public bool UsernameIsEmail => UmbracoSettingsSection.Security.UsernameIsEmail; + } +} diff --git a/src/Umbraco.Configuration/Implementations/UserPasswordConfigurationSettings.cs b/src/Umbraco.Configuration/Implementations/UserPasswordConfigurationSettings.cs new file mode 100644 index 0000000000..51dd645c42 --- /dev/null +++ b/src/Umbraco.Configuration/Implementations/UserPasswordConfigurationSettings.cs @@ -0,0 +1,15 @@ +using Umbraco.Core.Configuration; +namespace Umbraco.Configuration.Implementations +{ + internal class UserPasswordConfigurationSettings : ConfigurationManagerConfigBase, IUserPasswordConfiguration + { + public int RequiredLength => UmbracoSettingsSection.Security.UserPasswordConfiguration.RequiredLength; + public bool RequireNonLetterOrDigit => UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireNonLetterOrDigit; + public bool RequireDigit => UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireDigit; + public bool RequireLowercase=> UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireLowercase; + public bool RequireUppercase=> UmbracoSettingsSection.Security.UserPasswordConfiguration.RequireUppercase; + public bool UseLegacyEncoding=> UmbracoSettingsSection.Security.UserPasswordConfiguration.UseLegacyEncoding; + public string HashAlgorithmType=> UmbracoSettingsSection.Security.UserPasswordConfiguration.HashAlgorithmType; + public int MaxFailedAccessAttemptsBeforeLockout => UmbracoSettingsSection.Security.UserPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout; + } +} diff --git a/src/Umbraco.Configuration/UmbracoSettings/MemberPasswordConfigurationElement.cs b/src/Umbraco.Configuration/UmbracoSettings/MemberPasswordConfigurationElement.cs index 93c7c20159..92cd112630 100644 --- a/src/Umbraco.Configuration/UmbracoSettings/MemberPasswordConfigurationElement.cs +++ b/src/Umbraco.Configuration/UmbracoSettings/MemberPasswordConfigurationElement.cs @@ -1,6 +1,6 @@ namespace Umbraco.Core.Configuration.UmbracoSettings { - internal class MemberPasswordConfigurationElement : PasswordConfigurationElement, IMemberPasswordConfigurationSection + internal class MemberPasswordConfigurationElement : PasswordConfigurationElement, IMemberPasswordConfiguration { } } diff --git a/src/Umbraco.Configuration/UmbracoSettings/SecurityElement.cs b/src/Umbraco.Configuration/UmbracoSettings/SecurityElement.cs index 82012cfd0f..aec6809298 100644 --- a/src/Umbraco.Configuration/UmbracoSettings/SecurityElement.cs +++ b/src/Umbraco.Configuration/UmbracoSettings/SecurityElement.cs @@ -2,7 +2,7 @@ namespace Umbraco.Core.Configuration.UmbracoSettings { - internal class SecurityElement : UmbracoConfigurationElement, ISecuritySection + internal class SecurityElement : UmbracoConfigurationElement, ISecuritySettings { [ConfigurationProperty("keepUserLoggedIn")] internal InnerTextConfigurationElement KeepUserLoggedIn => GetOptionalTextElement("keepUserLoggedIn", true); @@ -38,14 +38,14 @@ namespace Umbraco.Core.Configuration.UmbracoSettings [ConfigurationProperty("memberPasswordConfiguration")] public MemberPasswordConfigurationElement MemberPasswordConfiguration => (MemberPasswordConfigurationElement)this["memberPasswordConfiguration"]; - bool ISecuritySection.KeepUserLoggedIn => KeepUserLoggedIn; + bool ISecuritySettings.KeepUserLoggedIn => KeepUserLoggedIn; - bool ISecuritySection.HideDisabledUsersInBackoffice => HideDisabledUsersInBackoffice; + bool ISecuritySettings.HideDisabledUsersInBackoffice => HideDisabledUsersInBackoffice; /// /// Used to enable/disable the forgot password functionality on the back office login screen /// - bool ISecuritySection.AllowPasswordReset => AllowPasswordReset; + bool ISecuritySettings.AllowPasswordReset => AllowPasswordReset; /// /// A boolean indicating that by default the email address will be the username @@ -54,14 +54,10 @@ namespace Umbraco.Core.Configuration.UmbracoSettings /// Even if this is true and the username is different from the email in the database, the username field will still be shown. /// When this is false, the username and email fields will be shown in the user section. /// - bool ISecuritySection.UsernameIsEmail => UsernameIsEmail; + bool ISecuritySettings.UsernameIsEmail => UsernameIsEmail; - string ISecuritySection.AuthCookieName => AuthCookieName; + string ISecuritySettings.AuthCookieName => AuthCookieName; - string ISecuritySection.AuthCookieDomain => AuthCookieDomain; - - IUserPasswordConfigurationSection ISecuritySection.UserPasswordConfiguration => UserPasswordConfiguration; - - IMemberPasswordConfigurationSection ISecuritySection.MemberPasswordConfiguration => MemberPasswordConfiguration; + string ISecuritySettings.AuthCookieDomain => AuthCookieDomain; } } diff --git a/src/Umbraco.Configuration/UmbracoSettings/UmbracoSettingsSection.cs b/src/Umbraco.Configuration/UmbracoSettings/UmbracoSettingsSection.cs index 2b980d133c..4860d3138e 100644 --- a/src/Umbraco.Configuration/UmbracoSettings/UmbracoSettingsSection.cs +++ b/src/Umbraco.Configuration/UmbracoSettings/UmbracoSettingsSection.cs @@ -26,7 +26,5 @@ namespace Umbraco.Core.Configuration.UmbracoSettings internal KeepAliveElement KeepAlive => (KeepAliveElement)this["keepAlive"]; IContentSection IUmbracoSettingsSection.Content => Content; - - ISecuritySection IUmbracoSettingsSection.Security => Security; } } diff --git a/src/Umbraco.Configuration/UmbracoSettings/UserPasswordConfigurationElement.cs b/src/Umbraco.Configuration/UmbracoSettings/UserPasswordConfigurationElement.cs index 8128f3d8e7..a1d2aa8842 100644 --- a/src/Umbraco.Configuration/UmbracoSettings/UserPasswordConfigurationElement.cs +++ b/src/Umbraco.Configuration/UmbracoSettings/UserPasswordConfigurationElement.cs @@ -1,6 +1,6 @@ namespace Umbraco.Core.Configuration.UmbracoSettings { - internal class UserPasswordConfigurationElement : PasswordConfigurationElement, IUserPasswordConfigurationSection + internal class UserPasswordConfigurationElement : PasswordConfigurationElement, IUserPasswordConfiguration { } } diff --git a/src/Umbraco.Core/Configuration/ConfigsExtensions.cs b/src/Umbraco.Core/Configuration/ConfigsExtensions.cs index b800b42454..6d4c8e1b91 100644 --- a/src/Umbraco.Core/Configuration/ConfigsExtensions.cs +++ b/src/Umbraco.Core/Configuration/ConfigsExtensions.cs @@ -28,6 +28,15 @@ namespace Umbraco.Core public static IUmbracoSettingsSection Settings(this Configs configs) => configs.GetConfig(); + public static ISecuritySettings Security(this Configs configs) + => configs.GetConfig(); + + + public static IUserPasswordConfiguration UserPasswordConfiguration(this Configs configs) + => configs.GetConfig(); + public static IMemberPasswordConfiguration MemberPasswordConfiguration(this Configs configs) + => configs.GetConfig(); + public static IRequestHandlerSettings RequestHandler(this Configs configs) => configs.GetConfig(); @@ -43,24 +52,6 @@ namespace Umbraco.Core public static ICoreDebug CoreDebug(this Configs configs) => configs.GetConfig(); - public static IUserPasswordConfiguration UserPasswordConfiguration(this Configs configs) - => configs.GetConfig(); - - public static IMemberPasswordConfiguration MemberPasswordConfiguration(this Configs configs) - => configs.GetConfig(); - - public static void AddPasswordConfigurations(this Configs configs) - { - configs.Add(() => - { - return new UserPasswordConfiguration(configs.Settings().Security.UserPasswordConfiguration); - }); - configs.Add(() => - { - return new MemberPasswordConfiguration(configs.Settings().Security.MemberPasswordConfiguration); - }); - } - public static void AddCoreConfigs(this Configs configs, IIOHelper ioHelper) { var configDir = new DirectoryInfo(ioHelper.MapPath(Constants.SystemDirectories.Config)); diff --git a/src/Umbraco.Core/Configuration/MemberPasswordConfiguration.cs b/src/Umbraco.Core/Configuration/MemberPasswordConfiguration.cs index 58c907c31f..8e7cd97f35 100644 --- a/src/Umbraco.Core/Configuration/MemberPasswordConfiguration.cs +++ b/src/Umbraco.Core/Configuration/MemberPasswordConfiguration.cs @@ -7,9 +7,9 @@ namespace Umbraco.Core.Configuration /// public class MemberPasswordConfiguration : PasswordConfiguration, IMemberPasswordConfiguration { - public MemberPasswordConfiguration(IMemberPasswordConfigurationSection configSection) - : base(configSection) - { + public MemberPasswordConfiguration(IMemberPasswordConfiguration configSettings) + : base(configSettings) + { } } } diff --git a/src/Umbraco.Core/Configuration/PasswordConfiguration.cs b/src/Umbraco.Core/Configuration/PasswordConfiguration.cs index 9edf1a462e..6827695b35 100644 --- a/src/Umbraco.Core/Configuration/PasswordConfiguration.cs +++ b/src/Umbraco.Core/Configuration/PasswordConfiguration.cs @@ -5,21 +5,21 @@ namespace Umbraco.Core.Configuration { public abstract class PasswordConfiguration : IPasswordConfiguration { - protected PasswordConfiguration(IPasswordConfigurationSection configSection) + protected PasswordConfiguration(IPasswordConfiguration configSettings) { - if (configSection == null) + if (configSettings == null) { - throw new ArgumentNullException(nameof(configSection)); + throw new ArgumentNullException(nameof(configSettings)); } - RequiredLength = configSection.RequiredLength; - RequireNonLetterOrDigit = configSection.RequireNonLetterOrDigit; - RequireDigit = configSection.RequireDigit; - RequireLowercase = configSection.RequireLowercase; - RequireUppercase = configSection.RequireUppercase; - UseLegacyEncoding = configSection.UseLegacyEncoding; - HashAlgorithmType = configSection.HashAlgorithmType; - MaxFailedAccessAttemptsBeforeLockout = configSection.MaxFailedAccessAttemptsBeforeLockout; + RequiredLength = configSettings.RequiredLength; + RequireNonLetterOrDigit = configSettings.RequireNonLetterOrDigit; + RequireDigit = configSettings.RequireDigit; + RequireLowercase = configSettings.RequireLowercase; + RequireUppercase = configSettings.RequireUppercase; + UseLegacyEncoding = configSettings.UseLegacyEncoding; + HashAlgorithmType = configSettings.HashAlgorithmType; + MaxFailedAccessAttemptsBeforeLockout = configSettings.MaxFailedAccessAttemptsBeforeLockout; } public int RequiredLength { get; } diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/IMemberPasswordConfigurationSection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/IMemberPasswordConfigurationSection.cs deleted file mode 100644 index cbbb933857..0000000000 --- a/src/Umbraco.Core/Configuration/UmbracoSettings/IMemberPasswordConfigurationSection.cs +++ /dev/null @@ -1,6 +0,0 @@ -namespace Umbraco.Core.Configuration.UmbracoSettings -{ - public interface IMemberPasswordConfigurationSection : IPasswordConfigurationSection - { - } -} diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/ISecuritySection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/ISecuritySettings.cs similarity index 78% rename from src/Umbraco.Core/Configuration/UmbracoSettings/ISecuritySection.cs rename to src/Umbraco.Core/Configuration/UmbracoSettings/ISecuritySettings.cs index a6ed188713..6ab520fefd 100644 --- a/src/Umbraco.Core/Configuration/UmbracoSettings/ISecuritySection.cs +++ b/src/Umbraco.Core/Configuration/UmbracoSettings/ISecuritySettings.cs @@ -1,9 +1,9 @@ namespace Umbraco.Core.Configuration.UmbracoSettings { - public interface ISecuritySection : IUmbracoConfigurationSection + public interface ISecuritySettings : IUmbracoConfigurationSection { bool KeepUserLoggedIn { get; } - + bool HideDisabledUsersInBackoffice { get; } /// @@ -23,9 +23,5 @@ /// When this is false, the username and email fields will be shown in the user section. /// bool UsernameIsEmail { get; } - - IUserPasswordConfigurationSection UserPasswordConfiguration { get; } - - IMemberPasswordConfigurationSection MemberPasswordConfiguration { get; } } } diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs index 69715f8e46..3db70e6d42 100644 --- a/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs +++ b/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs @@ -5,7 +5,5 @@ namespace Umbraco.Core.Configuration.UmbracoSettings public interface IUmbracoSettingsSection : IUmbracoConfigurationSection { IContentSection Content { get; } - - ISecuritySection Security { get; } } } diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/IUserPasswordConfigurationSection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/IUserPasswordConfigurationSection.cs deleted file mode 100644 index d80dd2b7e5..0000000000 --- a/src/Umbraco.Core/Configuration/UmbracoSettings/IUserPasswordConfigurationSection.cs +++ /dev/null @@ -1,6 +0,0 @@ -namespace Umbraco.Core.Configuration.UmbracoSettings -{ - public interface IUserPasswordConfigurationSection : IPasswordConfigurationSection - { - } -} diff --git a/src/Umbraco.Core/Configuration/UserPasswordConfiguration.cs b/src/Umbraco.Core/Configuration/UserPasswordConfiguration.cs index 4cfee5280b..07e6603cee 100644 --- a/src/Umbraco.Core/Configuration/UserPasswordConfiguration.cs +++ b/src/Umbraco.Core/Configuration/UserPasswordConfiguration.cs @@ -7,9 +7,9 @@ namespace Umbraco.Core.Configuration /// public class UserPasswordConfiguration : PasswordConfiguration, IUserPasswordConfiguration { - public UserPasswordConfiguration(IUserPasswordConfigurationSection configSection) - : base(configSection) - { + public UserPasswordConfiguration(IUserPasswordConfiguration configSettings) + : base(configSettings) + { } } } diff --git a/src/Umbraco.Infrastructure/Composing/CompositionExtensions/Configuration.cs b/src/Umbraco.Infrastructure/Composing/CompositionExtensions/Configuration.cs index 48e43156ae..e1bc079432 100644 --- a/src/Umbraco.Infrastructure/Composing/CompositionExtensions/Configuration.cs +++ b/src/Umbraco.Infrastructure/Composing/CompositionExtensions/Configuration.cs @@ -15,7 +15,6 @@ namespace Umbraco.Core.Composing.CompositionExtensions // register others composition.RegisterUnique(factory => factory.GetInstance().Content); - composition.RegisterUnique(factory => factory.GetInstance().Security); return composition; } diff --git a/src/Umbraco.Infrastructure/Models/ContentEditing/UserInvite.cs b/src/Umbraco.Infrastructure/Models/ContentEditing/UserInvite.cs index f1c6cf6c04..06e4d0748c 100644 --- a/src/Umbraco.Infrastructure/Models/ContentEditing/UserInvite.cs +++ b/src/Umbraco.Infrastructure/Models/ContentEditing/UserInvite.cs @@ -33,7 +33,7 @@ namespace Umbraco.Web.Models.ContentEditing if (UserGroups.Any() == false) yield return new ValidationResult("A user must be assigned to at least one group", new[] { nameof(UserGroups) }); - if (Current.Configs.Settings().Security.UsernameIsEmail == false && Username.IsNullOrWhiteSpace()) + if (Current.Configs.Security().UsernameIsEmail == false && Username.IsNullOrWhiteSpace()) yield return new ValidationResult("A username cannot be empty", new[] { nameof(Username) }); } } diff --git a/src/Umbraco.Tests/Configurations/UmbracoSettings/SecurityElementTests.cs b/src/Umbraco.Tests/Configurations/UmbracoSettings/SecurityElementTests.cs index 9300c88a67..93f37a1e35 100644 --- a/src/Umbraco.Tests/Configurations/UmbracoSettings/SecurityElementTests.cs +++ b/src/Umbraco.Tests/Configurations/UmbracoSettings/SecurityElementTests.cs @@ -9,127 +9,127 @@ namespace Umbraco.Tests.Configurations.UmbracoSettings [Test] public void KeepUserLoggedIn() { - Assert.IsTrue(SettingsSection.Security.KeepUserLoggedIn == true); + Assert.IsTrue(SecuritySettings.KeepUserLoggedIn == true); } [Test] public void HideDisabledUsersInBackoffice() { - Assert.IsTrue(SettingsSection.Security.HideDisabledUsersInBackoffice == false); + Assert.IsTrue(SecuritySettings.HideDisabledUsersInBackoffice == false); } [Test] public void AllowPasswordReset() { - Assert.IsTrue(SettingsSection.Security.AllowPasswordReset == true); + Assert.IsTrue(SecuritySettings.AllowPasswordReset == true); } [Test] public void AuthCookieDomain() { - Assert.IsTrue(SettingsSection.Security.AuthCookieDomain == null); + Assert.IsTrue(SecuritySettings.AuthCookieDomain == null); } [Test] public void AuthCookieName() { - Assert.IsTrue(SettingsSection.Security.AuthCookieName == "UMB_UCONTEXT"); + Assert.IsTrue(SecuritySettings.AuthCookieName == "UMB_UCONTEXT"); } [Test] public void UserPasswordConfiguration_RequiredLength() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.RequiredLength == 12); + Assert.IsTrue(UserPasswordConfiguration.RequiredLength == 12); } [Test] public void UserPasswordConfiguration_RequireNonLetterOrDigit() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.RequireNonLetterOrDigit == false); + Assert.IsTrue(UserPasswordConfiguration.RequireNonLetterOrDigit == false); } [Test] public void UserPasswordConfiguration_RequireDigit() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.RequireDigit == false); + Assert.IsTrue(UserPasswordConfiguration.RequireDigit == false); } [Test] public void UserPasswordConfiguration_RequireLowercase() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.RequireLowercase == false); + Assert.IsTrue(UserPasswordConfiguration.RequireLowercase == false); } [Test] public void UserPasswordConfiguration_RequireUppercase() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.RequireUppercase == false); + Assert.IsTrue(UserPasswordConfiguration.RequireUppercase == false); } [Test] public void UserPasswordConfiguration_UseLegacyEncoding() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.UseLegacyEncoding == false); + Assert.IsTrue(UserPasswordConfiguration.UseLegacyEncoding == false); } [Test] public void UserPasswordConfiguration_HashAlgorithmType() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.HashAlgorithmType == "HMACSHA256"); + Assert.IsTrue(UserPasswordConfiguration.HashAlgorithmType == "HMACSHA256"); } [Test] public void UserPasswordConfiguration_MaxFailedAccessAttemptsBeforeLockout() { - Assert.IsTrue(SettingsSection.Security.UserPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout == 5); + Assert.IsTrue(UserPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout == 5); } [Test] public void MemberPasswordConfiguration_RequiredLength() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.RequiredLength == 12); + Assert.IsTrue(MemberPasswordConfiguration.RequiredLength == 12); } [Test] public void MemberPasswordConfiguration_RequireNonLetterOrDigit() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.RequireNonLetterOrDigit == false); + Assert.IsTrue(MemberPasswordConfiguration.RequireNonLetterOrDigit == false); } [Test] public void MemberPasswordConfiguration_RequireDigit() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.RequireDigit == false); + Assert.IsTrue(MemberPasswordConfiguration.RequireDigit == false); } [Test] public void MemberPasswordConfiguration_RequireLowercase() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.RequireLowercase == false); + Assert.IsTrue(MemberPasswordConfiguration.RequireLowercase == false); } [Test] public void MemberPasswordConfiguration_RequireUppercase() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.RequireUppercase == false); + Assert.IsTrue(MemberPasswordConfiguration.RequireUppercase == false); } [Test] public void MemberPasswordConfiguration_UseLegacyEncoding() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.UseLegacyEncoding == false); + Assert.IsTrue(MemberPasswordConfiguration.UseLegacyEncoding == false); } [Test] public void MemberPasswordConfiguration_HashAlgorithmType() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.HashAlgorithmType == "HMACSHA256"); + Assert.IsTrue(MemberPasswordConfiguration.HashAlgorithmType == "HMACSHA256"); } [Test] public void MemberPasswordConfiguration_MaxFailedAccessAttemptsBeforeLockout() { - Assert.IsTrue(SettingsSection.Security.MemberPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout == 5); + Assert.IsTrue(MemberPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout == 5); } } } diff --git a/src/Umbraco.Tests/Configurations/UmbracoSettings/UmbracoSettingsTests.cs b/src/Umbraco.Tests/Configurations/UmbracoSettings/UmbracoSettingsTests.cs index b19e4d522a..364c30eecc 100644 --- a/src/Umbraco.Tests/Configurations/UmbracoSettings/UmbracoSettingsTests.cs +++ b/src/Umbraco.Tests/Configurations/UmbracoSettings/UmbracoSettingsTests.cs @@ -2,6 +2,7 @@ using System.Diagnostics; using System.IO; using NUnit.Framework; +using Umbraco.Core.Configuration; using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Tests.TestHelpers; @@ -38,5 +39,8 @@ namespace Umbraco.Tests.Configurations.UmbracoSettings protected ILoggingSettings LoggingSettings => Settings.Logging; protected IWebRoutingSettings WebRoutingSettings => Settings.WebRouting; protected IRequestHandlerSettings RequestHandlerSettings => Settings.RequestHandler; + protected ISecuritySettings SecuritySettings => Settings.Security; + protected IUserPasswordConfiguration UserPasswordConfiguration => Settings.Security.UserPasswordConfiguration; + protected IMemberPasswordConfiguration MemberPasswordConfiguration => Settings.Security.MemberPasswordConfiguration; } } diff --git a/src/Umbraco.Tests/TestHelpers/SettingsForTests.cs b/src/Umbraco.Tests/TestHelpers/SettingsForTests.cs index f3d03e1ea4..e3c9657b34 100644 --- a/src/Umbraco.Tests/TestHelpers/SettingsForTests.cs +++ b/src/Umbraco.Tests/TestHelpers/SettingsForTests.cs @@ -45,18 +45,8 @@ namespace Umbraco.Tests.TestHelpers var settings = new Mock(); var content = new Mock(); - var security = new Mock(); - var requestHandler = new Mock(); - var logging = new Mock(); - var routing = new Mock(); - - var userPasswordConfig = new Mock(); - var memberPasswordConfig = new Mock(); - security.Setup(x => x.UserPasswordConfiguration).Returns(userPasswordConfig.Object); - security.Setup(x => x.MemberPasswordConfiguration).Returns(memberPasswordConfig.Object); settings.Setup(x => x.Content).Returns(content.Object); - settings.Setup(x => x.Security).Returns(security.Object); //Now configure some defaults - the defaults in the config section classes do NOT pertain to the mocked data!! settings.Setup(x => x.Content.ImageAutoFillProperties).Returns(ContentImagingElement.GetDefaultImageAutoFillProperties()); @@ -185,5 +175,26 @@ namespace Umbraco.Tests.TestHelpers return mock.Object; } + + public static ISecuritySettings GenerateMockSecuritySettings() + { + var security = new Mock(); + + return security.Object; + } + + public static IUserPasswordConfiguration GenerateMockUserPasswordConfiguration() + { + var mock = new Mock(); + + return mock.Object; + } + + public static IMemberPasswordConfiguration GenerateMockMemberPasswordConfiguration() + { + var mock = new Mock(); + + return mock.Object; + } } } diff --git a/src/Umbraco.Tests/Testing/UmbracoTestBase.cs b/src/Umbraco.Tests/Testing/UmbracoTestBase.cs index 6b177c16cc..10449ac785 100644 --- a/src/Umbraco.Tests/Testing/UmbracoTestBase.cs +++ b/src/Umbraco.Tests/Testing/UmbracoTestBase.cs @@ -416,6 +416,9 @@ namespace Umbraco.Tests.Testing Composition.Configs.Add(SettingsForTests.GetDefaultHostingSettings); Composition.Configs.Add(SettingsForTests.GenerateMockRequestHandlerSettings); Composition.Configs.Add(SettingsForTests.GenerateMockWebRoutingSettings); + Composition.Configs.Add(SettingsForTests.GenerateMockSecuritySettings); + Composition.Configs.Add(SettingsForTests.GenerateMockUserPasswordConfiguration); + Composition.Configs.Add(SettingsForTests.GenerateMockMemberPasswordConfiguration); //Composition.Configs.Add(() => new DefaultUserPasswordConfig()); } diff --git a/src/Umbraco.Tests/Web/Controllers/AuthenticationControllerTests.cs b/src/Umbraco.Tests/Web/Controllers/AuthenticationControllerTests.cs index 9ecedee056..0e757bbc6d 100644 --- a/src/Umbraco.Tests/Web/Controllers/AuthenticationControllerTests.cs +++ b/src/Umbraco.Tests/Web/Controllers/AuthenticationControllerTests.cs @@ -88,7 +88,7 @@ namespace Umbraco.Tests.Web.Controllers Factory.GetInstance(), Factory.GetInstance(), Factory.GetInstance(), - Factory.GetInstance(), + Factory.GetInstance(), Factory.GetInstance(), Factory.GetInstance() ); diff --git a/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs b/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs index d914ef2c39..e23a4db1dc 100644 --- a/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs +++ b/src/Umbraco.Tests/Web/Controllers/UsersControllerTests.cs @@ -92,7 +92,8 @@ namespace Umbraco.Tests.Web.Controllers Factory.GetInstance(), Factory.GetInstance(), Factory.GetInstance(), - Factory.GetInstance() + Factory.GetInstance(), + Factory.GetInstance() ); return usersController; @@ -164,7 +165,8 @@ namespace Umbraco.Tests.Web.Controllers Factory.GetInstance(), Factory.GetInstance(), Factory.GetInstance(), - Factory.GetInstance() + Factory.GetInstance(), + Factory.GetInstance() ); return usersController; } @@ -206,7 +208,8 @@ namespace Umbraco.Tests.Web.Controllers Factory.GetInstance(), Factory.GetInstance(), Factory.GetInstance(), - Factory.GetInstance() + Factory.GetInstance(), + Factory.GetInstance() ); return usersController; } @@ -283,7 +286,8 @@ namespace Umbraco.Tests.Web.Controllers Factory.GetInstance(), Factory.GetInstance(), Factory.GetInstance(), - Factory.GetInstance() + Factory.GetInstance(), + Factory.GetInstance() ); return usersController; } diff --git a/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml b/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml index e41185d74b..35654e7a41 100644 --- a/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml +++ b/src/Umbraco.Web.UI/Umbraco/Views/AuthorizeUpgrade.cshtml @@ -48,7 +48,7 @@ redirectUrl = Url.Action("AuthorizeUpgrade", "BackOffice") }); } - @Html.BareMinimumServerVariablesScript(Url, externalLoginUrl, Model.Features, Model.GlobalSettings, Model.UmbracoVersion, Model.UmbracoSettingsSection, Model.IOHelper, Model.TreeCollection, Model.HttpContextAccessor, Model.HostingEnvironment, Model.RuntimeSettings) + @Html.BareMinimumServerVariablesScript(Url, externalLoginUrl, Model.Features, Model.GlobalSettings, Model.UmbracoVersion, Model.UmbracoSettingsSection, Model.IOHelper, Model.TreeCollection, Model.HttpContextAccessor, Model.HostingEnvironment, Model.RuntimeSettings, Model.SecuritySettings)