public void ManageabilityProviderGeneratesProperAdmContent()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
CryptographySettings cryptographySettings = new CryptographySettings();
configurationSource.Add("securityCryptographyConfiguration", cryptographySettings);
MockAdmContentBuilder contentBuilder = new MockAdmContentBuilder();
contentBuilder.StartCategory("category");
contentBuilder.StartPolicy("policy", "policy key");
provider.InvokeAddAdministrativeTemplateDirectives(contentBuilder, configurationObject, configurationSource, "TestApp");
contentBuilder.EndPolicy();
contentBuilder.EndCategory();
MockAdmContent content = contentBuilder.GetMockContent();
IEnumerator <AdmCategory> categoriesEnumerator = content.Categories.GetEnumerator();
categoriesEnumerator.MoveNext();
IEnumerator <AdmPolicy> policiesEnumerator = categoriesEnumerator.Current.Policies.GetEnumerator();
policiesEnumerator.MoveNext();
IEnumerator <AdmPart> partsEnumerator = policiesEnumerator.Current.Parts.GetEnumerator();
Assert.IsTrue(partsEnumerator.MoveNext());
Assert.AreSame(typeof(AdmDropDownListPart), partsEnumerator.Current.GetType());
Assert.IsNotNull(partsEnumerator.Current.KeyName);
Assert.AreEqual(SymmetricStorageEncryptionProviderDataManageabilityProvider.SymmetricInstancePropertyName,
partsEnumerator.Current.ValueName);
Assert.AreEqual(Resources.SymmetricStorageEncryptionProviderSymmetricInstancePartName,
partsEnumerator.Current.PartName);
Assert.IsFalse(partsEnumerator.MoveNext());
}
/// <summary>
/// <para>Saves the configuration settings created for the application.</para>
/// </summary>
/// <param name="serviceProvider">
/// <para>The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.</para>
/// </param>
public void Save(IServiceProvider serviceProvider)
{
ConfigurationContext configurationContext = ServiceHelper.GetCurrentConfigurationContext(serviceProvider);
if (configurationContext.IsValidSection(CryptographySettings.SectionName))
{
CryptographySettingsNode securitySettingsNode = null;
try
{
IUIHierarchy hierarchy = ServiceHelper.GetCurrentHierarchy(serviceProvider);
securitySettingsNode = hierarchy.FindNodeByType(typeof(CryptographySettingsNode)) as CryptographySettingsNode;
if (securitySettingsNode == null)
{
return;
}
CryptographySettings securitySettings = securitySettingsNode.CryptographySettings;
configurationContext.WriteConfiguration(CryptographySettings.SectionName, securitySettings);
}
catch (ConfigurationException e)
{
ServiceHelper.LogError(serviceProvider, securitySettingsNode, e);
}
catch (InvalidOperationException e)
{
ServiceHelper.LogError(serviceProvider, securitySettingsNode, e);
}
}
}
public void Given()
{
cryptographySettings = new CryptographySettings();
customHashProviderData = new CustomHashProviderData("custom", typeof(MockCustomHashProvider));
customHashProviderData.Attributes["foo"] = "bar";
cryptographySettings.HashProviders.Add(customHashProviderData);
}
private static CryptographySettings GenerateCryptographySettings()
{
CryptographySettings settings = new CryptographySettings();
settings.SymmetricCryptoProviders.Add(new DpapiSymmetricCryptoProviderData("dpapi1", DataProtectionScope.CurrentUser));
return(settings);
}
public void Given()
{
cryptographySettings = new CryptographySettings {
DefaultHashProviderName = "name"
};
cryptographySettings.HashProviders.Add(
new HashAlgorithmProviderData("name", typeof(RijndaelManaged), true));
}
public void FixtureSetup()
{
byte[] key = new byte[] { 0, 1, 2, 3, 4 };
CryptographySettings settings = (CryptographySettings)context.GetConfiguration(CryptographySettings.SectionName);
((KeyedHashAlgorithmProviderData)settings.HashProviders[hashInstance]).Key = key;
}
public void SetUp()
{
provider = new CryptographySettingsManageabilityProvider(new Dictionary<Type, ConfigurationElementManageabilityProvider>(0));
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
section = new CryptographySettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add("securityCryptographyConfiguration", section);
}
public void SetUp()
{
provider = new CryptographySettingsManageabilityProvider(new Dictionary <Type, ConfigurationElementManageabilityProvider>(0));
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
section = new CryptographySettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add("securityCryptographyConfiguration", section);
}
public void Given()
{
cryptographySettings = new CryptographySettings();
cryptographySettings.SymmetricCryptoProviders.Add(
new SymmetricAlgorithmProviderData(
"name",
typeof(RijndaelManaged),
"protected key",
DataProtectionScope.LocalMachine));
}
public void SetUp()
{
settings = new CryptographySettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(CryptographySettings.SectionName, settings);
configurationSource.Add(InstrumentationConfigurationSection.SectionName,
new InstrumentationConfigurationSection(false, false));
}
public void AddTo(IConfigurationSource configurationSource)
{
var section = new CryptographySettings();
foreach (var builder in hashProviderBuilders)
{
builder.AddTo(section);
}
configurationSource.Add(BlockSectionNames.Cryptography, section);
}
/// <summary>
/// <para>Adds to the dictionary configuration data for
/// the enterpriselibrary.configurationSettings configuration section.</para>
/// </summary>
/// <param name="serviceProvider">
/// <para>The a mechanism for retrieving a service object; that is, an object that provides custom support to other objects.</para>
/// </param>
/// <param name="configurationDictionary">
/// <para>A <see cref="ConfigurationDictionary"/> to add
/// configuration data to.</para></param>
public void BuildContext(IServiceProvider serviceProvider, ConfigurationDictionary configurationDictionary)
{
CryptographySettingsNode node = GetCryptographySettingsNode(serviceProvider);
if (node != null)
{
CryptographySettings settings = node.CryptographySettings;
configurationDictionary[CryptographySettings.SectionName] = settings;
}
}
/// <summary>
/// Test key needs to be >= 128 characters
/// </summary>
/// <returns></returns>
internal IOptions <CryptographySettings> BuildCryptographySettings()
{
CryptographySettings mySeTings = new CryptographySettings()
{
// 68+68 characters
JwtSecret = Guid.NewGuid().ToString("X") + Guid.NewGuid().ToString("X")
};
return(Options.Create <CryptographySettings>(mySeTings));
}
public void AddTo(CryptographySettings settings)
{
var providerSetting = new HashAlgorithmProviderData(providerSettings.Name, providerSettings.Type, true);
settings.HashProviders.Add(providerSetting);
if (isDefault)
{
settings.DefaultHashProviderName = providerSetting.Name;
}
}
IConfigurationSource CreateSource(string defaultName)
{
DictionaryConfigurationSource sections = new DictionaryConfigurationSource();
CryptographySettings settings = new CryptographySettings();
settings.DefaultHashProviderName = defaultName;
settings.HashProviders.Add(new KeyedHashAlgorithmProviderData(providerName, typeof(HMACSHA1), false, keyedHashKeyFile, DataProtectionScope.CurrentUser));
settings.HashProviders.Add(new HashAlgorithmProviderData(hashAlgorithm, typeof(SHA1Managed), false));
sections.Add(CryptographySettings.SectionName, settings);
return(sections);
}
public void Given()
{
cryptographySettings =
new CryptographySettings
{
DefaultSymmetricCryptoProviderName = "name"
};
cryptographySettings.SymmetricCryptoProviders.Add(
new SymmetricAlgorithmProviderData(
"name", typeof(RijndaelManaged), "protected key", DataProtectionScope.CurrentUser));
}
public void Given()
{
cryptographySettings = new CryptographySettings();
cryptographySettings.HashProviders.Add(
new KeyedHashAlgorithmProviderData(
"keyed",
typeof(RijndaelManaged),
true,
"protected key",
DataProtectionScope.LocalMachine));
}
IConfigurationSource CreateSource(string defaultName)
{
DictionaryConfigurationSource sections = new DictionaryConfigurationSource();
CryptographySettings settings = new CryptographySettings();
settings.DefaultSymmetricCryptoProviderName = defaultName;
settings.SymmetricCryptoProviders.Add(new DpapiSymmetricCryptoProviderData(providerName, DataProtectionScope.CurrentUser));
settings.SymmetricCryptoProviders.Add(new SymmetricAlgorithmProviderData(symmetricAlgorithm, typeof(RijndaelManaged), "ProtectedKey.file", DataProtectionScope.CurrentUser));
sections.Add(CryptographySettings.SectionName, settings);
return(sections);
}
public void FixtureSetup()
{
byte[] key = new byte[32];
CryptographyUtility.GetRandomBytes(key);
CryptographySettings settings = (CryptographySettings)context.GetConfiguration(CryptographySettings.SectionName);
((SymmetricAlgorithmProviderData)settings.SymmetricCryptoProviders[symmetricInstanceName]).Key = key;
SymmetricCryptoProviderFactory factory = new SymmetricCryptoProviderFactory(context);
symmProvider = factory.CreateSymmetricCryptoProvider(symmetricInstanceName);
}
public static void ModifProtectedKeyFilename(string keyFilePath)
{
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
if (config.HasFile)
{
ConfigurationSection configurationSection = config.Sections["securityCryptographyConfiguration"];
CryptographySettings cryptographySettings = configurationSection as CryptographySettings;
NameTypeConfigurationElementCollection <SymmetricProviderData, CustomSymmetricCryptoProviderData> elementCollection = cryptographySettings.SymmetricCryptoProviders;
SymmetricProviderData symmetricProviderData = elementCollection.Get("DESCryptoServiceProvider");
symmetricProviderData.ElementInformation.Properties["protectedKeyFilename"].Value = keyFilePath;
config.Save(ConfigurationSaveMode.Minimal);
}
}
public void SetUp()
{
cryptoSettings = new CryptographySettings();
settings = new CacheManagerSettings();
SymmetricStorageEncryptionProviderData encrytionProvider = new SymmetricStorageEncryptionProviderData(providerName, symmetricInstance);
settings.EncryptionProviders.Add(encrytionProvider);
cryptoSettings.SymmetricCryptoProviders.Add(new DpapiSymmetricCryptoProviderData(symmetricInstance, DataProtectionScope.CurrentUser));
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(CacheManagerSettings.SectionName, settings);
configurationSource.Add(CryptographySettings.SectionName, cryptoSettings);
}
/// <summary>
/// Get the named <see cref="HashProviderData"/> instance.
/// </summary>
/// <param name="hashProviderName">The name of the instance to retrieve.</param>
/// <returns>The named <see cref="HashProviderData"/> instance.</returns>
public HashProviderData GetHashProviderData(string hashProviderName)
{
if (string.IsNullOrEmpty(hashProviderName))
{
throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "hashProviderName");
}
CryptographySettings settings = this.CryptographySettings;
if (settings.HashProviders.Contains(hashProviderName))
{
return(settings.HashProviders.Get(hashProviderName));
}
throw new ConfigurationErrorsException(string.Format(Resources.Culture, Resources.ExceptionNoHashProviderDefined, hashProviderName));
}
/// <summary>
/// Get the named <see cref="SymmetricProviderData"/> instance.
/// </summary>
/// <param name="symetricCryptoProviderName">The name of the instance to retrieve.</param>
/// <returns>The named <see cref="SymmetricProviderData"/> instance.</returns>
public SymmetricProviderData GetSymetricCryptoProviderData(string symetricCryptoProviderName)
{
if (string.IsNullOrEmpty(symetricCryptoProviderName))
{
throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "symetricCryptoProviderName");
}
CryptographySettings settings = this.CryptographySettings;
if (settings.SymmetricCryptoProviders.Contains(symetricCryptoProviderName))
{
return(settings.SymmetricCryptoProviders.Get(symetricCryptoProviderName));
}
throw new ConfigurationErrorsException(string.Format(Resources.Culture, Resources.ExceptionNoSymmetricCrytoProviderDefined, symetricCryptoProviderName));
}
protected override void AddElementAdministrativeTemplateParts(AdmContentBuilder contentBuilder,
SymmetricStorageEncryptionProviderData configurationObject,
IConfigurationSource configurationSource,
String elementPolicyKeyName)
{
CryptographySettings cryptographySection
= configurationSource.GetSection("securityCryptographyConfiguration") as CryptographySettings;
contentBuilder.AddDropDownListPartForNamedElementCollection <SymmetricProviderData>(Resources.SymmetricStorageEncryptionProviderSymmetricInstancePartName,
elementPolicyKeyName,
SymmetricInstancePropertyName,
cryptographySection.SymmetricCryptoProviders,
configurationObject.SymmetricInstance,
false);
}
public void Properties()
{
Guid appID = Guid.NewGuid();
CryptographySettings settings = new CryptographySettings();
KeyedHashAlgorithmProviderData hashData = new KeyedHashAlgorithmProviderData();
hashData.Name = "name";
settings.HashProviders.Add(hashData);
Assert.AreEqual(1, settings.HashProviders.Count, "hash collection");
DpapiSymmetricCryptoProviderData symmData = new DpapiSymmetricCryptoProviderData();
symmData.Name = "name";
settings.SymmetricCryptoProviders.Add(symmData);
Assert.AreEqual(1, settings.SymmetricCryptoProviders.Count, "symmetric collection");
}
public void Properties()
{
Guid appID = Guid.NewGuid();
CryptographySettings settings = new CryptographySettings();
KeyedHashAlgorithmProviderData hashData = new KeyedHashAlgorithmProviderData();
hashData.Name = "name";
settings.HashProviders.Add(hashData);
Assert.AreEqual(1, settings.HashProviders.Count, "hash collection");
DpapiSymmetricCryptoProviderData symmData = new DpapiSymmetricCryptoProviderData();
symmData.Name = "name";
settings.SymmetricCryptoProviders.Add(symmData);
Assert.AreEqual(1, settings.SymmetricCryptoProviders.Count, "symmetric collection");
}
/// <summary>
/// <para>Gets the named <see cref="SymmetricCryptoProviderData"/> from the <see cref="CryptographySettings"/>.</para>
/// </summary>
/// <param name="symmetricProviderName">
/// <para>The name of the <see cref="SymmetricCryptoProviderData"/>.</para>
/// </param>
/// <returns>
/// <para>The named <see cref="SymmetricCryptoProviderData"/> from the <see cref="CryptographySettings"/>.</para>
/// </returns>
public virtual SymmetricCryptoProviderData GetSymmetricCryptoProviderData(string symmetricProviderName)
{
CryptographySettings settings = ConfigurationContext.GetConfiguration(CryptographySettings.SectionName) as CryptographySettings;
if (settings == null)
{
throw new ConfigurationException(SR.ExceptionCryptoSettingsMissing);
}
SymmetricCryptoProviderData symmetricCryptoProviderData = settings.SymmetricCryptoProviders[symmetricProviderName];
if (symmetricCryptoProviderData == null)
{
throw new ConfigurationException(SR.ExceptionNoCryptoProvider(symmetricProviderName));
}
return(symmetricCryptoProviderData);
}
public static void ModifProtectedKeyFilename()
{
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
if (config.HasFile)
{
ConfigurationSection configurationSection = config.Sections["securityCryptographyConfiguration"];
CryptographySettings cryptographySettings = configurationSection as CryptographySettings;
NameTypeConfigurationElementCollection <SymmetricProviderData, CustomSymmetricCryptoProviderData> elementCollection = cryptographySettings.SymmetricCryptoProviders;
SymmetricProviderData symmetricProviderData = elementCollection.Get("AesCryptoServiceProvider");
string keyFilePath = symmetricProviderData.ElementInformation.Properties["protectedKeyFilename"].Value.ToString();
if (keyFilePath.Split('\\').Length == 1)
{
symmetricProviderData.ElementInformation.Properties["protectedKeyFilename"].Value = AppDomain.CurrentDomain.BaseDirectory + "\\" + keyFilePath;
config.Save(ConfigurationSaveMode.Minimal);
}
}
}
private static CryptographySettings GenerateBlockSettings()
{
CryptographySettings settings = new CryptographySettings();
settings.HashProviders.Add(new CustomHashProviderData("mockHashProvider1", typeof(MockHashProvider).AssemblyQualifiedName));
settings.HashProviders.Add(new KeyedHashAlgorithmProviderData("hmac1", typeof(HMACSHA1).AssemblyQualifiedName, true, new byte[] {}));
settings.HashProviders.Add(new HashAlgorithmProviderData("hashAlgorithm1", typeof(SHA1Managed).AssemblyQualifiedName, false));
settings.HashProviders.Add(new CustomHashProviderData("provider1", typeof(MockHashProvider).AssemblyQualifiedName));
settings.HashProviders.Add(new CustomHashProviderData("provider2", typeof(MockHashProvider).AssemblyQualifiedName));
settings.SymmetricCryptoProviders.Add(new CustomSymmetricCryptoProviderData("mockSymmetric1", typeof(MockSymmetricCryptoProvider).AssemblyQualifiedName));
settings.SymmetricCryptoProviders.Add(new DpapiSymmetricCryptoProviderData("dpapiSymmetric1", new DpapiSettingsData(new byte[] {}, DpapiStorageMode.User)));
settings.SymmetricCryptoProviders.Add(new SymmetricAlgorithmProviderData("symmetricAlgorithm1", typeof(RijndaelManaged).AssemblyQualifiedName, Encoding.UTF8.GetBytes("TODO")));
settings.SymmetricCryptoProviders.Add(new CustomSymmetricCryptoProviderData("provider1", typeof(MockSymmetricCryptoProvider).AssemblyQualifiedName));
settings.SymmetricCryptoProviders.Add(new CustomSymmetricCryptoProviderData("provider2", typeof(MockSymmetricCryptoProvider).AssemblyQualifiedName));
return(settings);
}
protected override void Arrange()
{
updatableConfigurationSource = new ConfigurationSourceUpdatable();
cryptoSettings = new CryptographySettings();
hashProvider = new HashAlgorithmProviderData("hash provider", typeof(MD5), true);
cryptoSettings.HashProviders.Add(hashProvider);
cryptoSettings.DefaultHashProviderName = hashProvider.Name;
symmetricAlgorithmProvider = new CustomSymmetricCryptoProviderData("symm provider", typeof(MockCustomSymmetricProvider));
cryptoSettings.SymmetricCryptoProviders.Add(symmetricAlgorithmProvider);
cryptoSettings.DefaultSymmetricCryptoProviderName = symmetricAlgorithmProvider.Name;
updatableConfigurationSource.Add(CryptographySettings.SectionName, cryptoSettings);
container = new UnityContainer();
containerConfigurator = new UnityContainerConfigurator(container);
EnterpriseLibraryContainer.ConfigureContainer(containerConfigurator, updatableConfigurationSource);
}
public void CanDeserializeSerializedConfiguration()
{
string name1 = "name1";
string name2 = "name2";
string name3 = "name3";
CryptographySettings settings = new CryptographySettings();
settings.DefaultHashProviderName = name1;
settings.HashProviders.Add(new HashAlgorithmProviderData(name1, typeof(SHA1Managed), true));
settings.HashProviders.Add(new KeyedHashAlgorithmProviderData(name2, typeof(HMACSHA1), false, keyedHashKeyFile, DataProtectionScope.CurrentUser));
settings.HashProviders.Add(new CustomHashProviderData(name3, typeof(MockCustomHashProvider)));
IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>();
sections[CryptographySettings.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
CryptographySettings roSettings = (CryptographySettings)configurationSource.GetSection(CryptographySettings.SectionName);
Assert.IsNotNull(roSettings);
Assert.AreEqual(name1, roSettings.DefaultHashProviderName);
Assert.AreEqual(3, roSettings.HashProviders.Count);
Assert.IsNotNull(roSettings.HashProviders.Get(name1));
Assert.AreSame(typeof(HashAlgorithmProviderData), roSettings.HashProviders.Get(name1).GetType());
Assert.AreSame(typeof(HashAlgorithmProvider), roSettings.HashProviders.Get(name1).Type);
Assert.AreSame(typeof(SHA1Managed), ((HashAlgorithmProviderData)roSettings.HashProviders.Get(name1)).AlgorithmType);
Assert.AreEqual(true, ((HashAlgorithmProviderData)roSettings.HashProviders.Get(name1)).SaltEnabled);
Assert.IsNotNull(roSettings.HashProviders.Get(name2));
Assert.AreSame(typeof(KeyedHashAlgorithmProviderData), roSettings.HashProviders.Get(name2).GetType());
Assert.AreSame(typeof(KeyedHashAlgorithmProvider), roSettings.HashProviders.Get(name2).Type);
Assert.AreSame(typeof(HMACSHA1), ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).AlgorithmType);
Assert.AreEqual(false, ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).SaltEnabled);
Assert.AreEqual(keyedHashKeyFile, ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).ProtectedKeyFilename);
Assert.AreEqual(DataProtectionScope.CurrentUser, ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).ProtectedKeyProtectionScope);
Assert.IsNotNull(roSettings.HashProviders.Get(name3));
Assert.AreSame(typeof(CustomHashProviderData), roSettings.HashProviders.Get(name3).GetType());
Assert.AreSame(typeof(MockCustomHashProvider), roSettings.HashProviders.Get(name3).Type);
}
public void CanDeserializeSerializedConfiguration()
{
string name1 = "name1";
string name2 = "name2";
string name3 = "name3";
CryptographySettings settings = new CryptographySettings();
settings.DefaultHashProviderName = name1;
settings.HashProviders.Add(new HashAlgorithmProviderData(name1, typeof(SHA1Managed), true));
settings.HashProviders.Add(new KeyedHashAlgorithmProviderData(name2, typeof(HMACSHA1), false, keyedHashKeyFile, DataProtectionScope.CurrentUser));
settings.HashProviders.Add(new CustomHashProviderData(name3, typeof(MockCustomHashProvider)));
IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
sections[CryptographyConfigurationView.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
CryptographySettings roSettings = (CryptographySettings)configurationSource.GetSection(CryptographyConfigurationView.SectionName);
Assert.IsNotNull(roSettings);
Assert.AreEqual(name1, roSettings.DefaultHashProviderName);
Assert.AreEqual(3, roSettings.HashProviders.Count);
Assert.IsNotNull(roSettings.HashProviders.Get(name1));
Assert.AreSame(typeof(HashAlgorithmProviderData), roSettings.HashProviders.Get(name1).GetType());
Assert.AreSame(typeof(HashAlgorithmProvider), roSettings.HashProviders.Get(name1).Type);
Assert.AreSame(typeof(SHA1Managed), ((HashAlgorithmProviderData)roSettings.HashProviders.Get(name1)).AlgorithmType);
Assert.AreEqual(true, ((HashAlgorithmProviderData)roSettings.HashProviders.Get(name1)).SaltEnabled);
Assert.IsNotNull(roSettings.HashProviders.Get(name2));
Assert.AreSame(typeof(KeyedHashAlgorithmProviderData), roSettings.HashProviders.Get(name2).GetType());
Assert.AreSame(typeof(KeyedHashAlgorithmProvider), roSettings.HashProviders.Get(name2).Type);
Assert.AreSame(typeof(HMACSHA1), ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).AlgorithmType);
Assert.AreEqual(false, ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).SaltEnabled);
Assert.AreEqual(keyedHashKeyFile, ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).ProtectedKeyFilename);
Assert.AreEqual(DataProtectionScope.CurrentUser, ((KeyedHashAlgorithmProviderData)roSettings.HashProviders.Get(name2)).ProtectedKeyProtectionScope);
Assert.IsNotNull(roSettings.HashProviders.Get(name3));
Assert.AreSame(typeof(CustomHashProviderData), roSettings.HashProviders.Get(name3).GetType());
Assert.AreSame(typeof(MockCustomHashProvider), roSettings.HashProviders.Get(name3).Type);
}
public void CanBuildCustomHashProviderFromGivenConfiguration()
{
CustomHashProviderData customData
= new CustomHashProviderData("custom", typeof(MockCustomHashProvider));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
CryptographySettings settings = new CryptographySettings();
settings.HashProviders.Add(customData);
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(CryptographyConfigurationView.SectionName, settings);
IHashProvider custom
= EnterpriseLibraryFactory.BuildUp <IHashProvider>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomHashProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomHashProvider)custom).customValue);
}
public void CanDeserializeSerializedConfiguration()
{
byte[] key = new byte[] { 1, 2, 3, 4 };
string name1 = "name1";
string name2 = "name2";
string name3 = "name3";
CryptographySettings settings = new CryptographySettings();
settings.DefaultSymmetricCryptoProviderName = name1;
settings.SymmetricCryptoProviders.Add(new DpapiSymmetricCryptoProviderData(name1, DataProtectionScope.CurrentUser));
settings.SymmetricCryptoProviders.Add(new SymmetricAlgorithmProviderData(name2, typeof(RijndaelManaged), "ProtectedKey.file", DataProtectionScope.CurrentUser));
settings.SymmetricCryptoProviders.Add(new CustomSymmetricCryptoProviderData(name3, typeof(MockCustomSymmetricProvider)));
IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
sections[CryptographyConfigurationView.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
CryptographySettings roSettings = (CryptographySettings)configurationSource.GetSection(CryptographyConfigurationView.SectionName);
Assert.IsNotNull(roSettings);
Assert.AreEqual(name1, roSettings.DefaultSymmetricCryptoProviderName);
Assert.AreEqual(3, roSettings.SymmetricCryptoProviders.Count);
Assert.IsNotNull(roSettings.SymmetricCryptoProviders.Get(name1));
Assert.AreSame(typeof(DpapiSymmetricCryptoProviderData), roSettings.SymmetricCryptoProviders.Get(name1).GetType());
Assert.AreSame(typeof(DpapiSymmetricCryptoProvider), roSettings.SymmetricCryptoProviders.Get(name1).Type);
Assert.AreEqual(DataProtectionScope.CurrentUser, ((DpapiSymmetricCryptoProviderData)roSettings.SymmetricCryptoProviders.Get(name1)).Scope);
Assert.IsNotNull(roSettings.SymmetricCryptoProviders.Get(name2));
Assert.AreSame(typeof(SymmetricAlgorithmProviderData), roSettings.SymmetricCryptoProviders.Get(name2).GetType());
Assert.AreSame(typeof(SymmetricAlgorithmProvider), roSettings.SymmetricCryptoProviders.Get(name2).Type);
Assert.AreSame(typeof(RijndaelManaged), ((SymmetricAlgorithmProviderData)roSettings.SymmetricCryptoProviders.Get(name2)).AlgorithmType);
Assert.AreEqual("ProtectedKey.file", ((SymmetricAlgorithmProviderData)roSettings.SymmetricCryptoProviders.Get(name2)).ProtectedKeyFilename);
Assert.AreEqual(DataProtectionScope.CurrentUser, ((SymmetricAlgorithmProviderData)roSettings.SymmetricCryptoProviders.Get(name2)).ProtectedKeyProtectionScope);
Assert.IsNotNull(roSettings.SymmetricCryptoProviders.Get(name3));
Assert.AreSame(typeof(CustomSymmetricCryptoProviderData), roSettings.SymmetricCryptoProviders.Get(name3).GetType());
Assert.AreSame(typeof(MockCustomSymmetricProvider), roSettings.SymmetricCryptoProviders.Get(name3).Type);
}
/// <summary>
/// Constructs a new instance
/// with the corresponding runtime configuration data.
/// </summary>
/// <param name="data">The corresponding runtime configuration data.</param>
public CryptographySettingsNode(CryptographySettings data)
: base()
{
this.cryptographySettings = data;
}
public CryptographyManagerSettingsNodeBuilder(IServiceProvider serviceProvider, CryptographySettings cryptographySettings)
: base(serviceProvider)
{
this.cryptographySettings = cryptographySettings;
}
public CryptographyManagerSettingsBuilder(IServiceProvider serviceProvider, CryptographySettingsNode cryptographySettingsNode)
{
this.cryptographySettingsNode = cryptographySettingsNode;
hierarchy = ServiceHelper.GetCurrentHierarchy(serviceProvider);
cryptographySettings = new CryptographySettings();
}
