public void CreateDefaultProviderWithNoneDefinedThrows()
{
SymmetricCryptoProviderFactory factory = new SymmetricCryptoProviderFactory(CreateSource(string.Empty));
ISymmetricCryptoProvider provider = factory.CreateDefault();
Assert.IsNotNull(provider);
}
public void SetUp()
{
hashProviders = new Dictionary<string, IHashProvider>();
symmetricCrytoProviders = new Dictionary<string, ISymmetricCryptoProvider>();
CreateKeyFile(symmetricKeyFile);
CreateKeyFile(keyedHashKeyFile);
configSource = ConfigurationSourceFactory.Create();
HashProviderFactory factory = new HashProviderFactory(configSource);
defaultHashProvider = factory.Create(hashInstance);
hashProviders.Add(hashInstance, defaultHashProvider);
SymmetricCryptoProviderFactory symmfactory = new SymmetricCryptoProviderFactory(configSource);
defaultSymmetricCryptoProvider = symmfactory.Create(symmInstance);
algorithSymmetricCryptoProvider = symmfactory.Create(symmetricAlgorithm1);
symmetricCrytoProviders.Add(symmInstance, defaultSymmetricCryptoProvider);
symmetricCrytoProviders.Add(symmetricAlgorithm1, algorithSymmetricCryptoProvider);
var container = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
cryptographyManager = container.GetInstance<CryptographyManager>();
}
public void SetUp()
{
hashProviders = new Dictionary <string, IHashProvider>();
symmetricCrytoProviders = new Dictionary <string, ISymmetricCryptoProvider>();
CreateKeyFile(symmetricKeyFile);
CreateKeyFile(keyedHashKeyFile);
configSource = ConfigurationSourceFactory.Create();
HashProviderFactory factory = new HashProviderFactory(configSource);
defaultHashProvider = factory.Create(hashInstance);
hashProviders.Add(hashInstance, defaultHashProvider);
SymmetricCryptoProviderFactory symmfactory = new SymmetricCryptoProviderFactory(configSource);
defaultSymmetricCryptoProvider = symmfactory.Create(symmInstance);
algorithSymmetricCryptoProvider = symmfactory.Create(symmetricAlgorithm1);
symmetricCrytoProviders.Add(symmInstance, defaultSymmetricCryptoProvider);
symmetricCrytoProviders.Add(symmetricAlgorithm1, algorithSymmetricCryptoProvider);
var container = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
cryptographyManager = container.GetInstance <CryptographyManager>();
}
public void CanCreateDefaultCustomSymmetricEncryptionProvider()
{
CustomSymmetricCryptoProviderData data1
= new CustomSymmetricCryptoProviderData("provider1", typeof(MockCustomSymmetricProvider).AssemblyQualifiedName);
data1.Attributes.Add(MockCustomSymmetricProvider.AttributeKey, "value1");
settings.SymmetricCryptoProviders.Add(data1);
CustomSymmetricCryptoProviderData data2
= new CustomSymmetricCryptoProviderData("provider2", typeof(MockCustomSymmetricProvider).AssemblyQualifiedName);
data2.Attributes.Add(MockCustomSymmetricProvider.AttributeKey, "value2");
settings.SymmetricCryptoProviders.Add(data2);
settings.DefaultSymmetricCryptoProviderName = "provider1";
using (var container = CreateContainer())
{
ISymmetricCryptoProvider provider = container.Resolve <ISymmetricCryptoProvider>();
Assert.IsNotNull(provider);
Assert.IsInstanceOfType(provider, typeof(MockCustomSymmetricProvider));
Assert.AreEqual("value1", ((MockCustomSymmetricProvider)provider).customValue);
}
}
public void CreateDefaultProvider()
{
SymmetricCryptoProviderFactory factory = new SymmetricCryptoProviderFactory(CreateSource(providerName));
ISymmetricCryptoProvider provider = factory.CreateDefault();
Assert.AreEqual(typeof(DpapiSymmetricCryptoProvider), provider.GetType());
}
public AuthenticationService(ISymmetricCryptoProvider cryptoService, IGadgetKeysService gadgetKeysService, IUserService userService, IUserSessionService userSessionService)
{
this.SymmetricCryptoService = cryptoService;
this.GadgetKeysService = gadgetKeysService;
this.UserService = userService;
this.UserSessionService = userSessionService;
}
public EntitiesEncryptionService(ISymmetricCryptoProvider cryptoProvider)
{
if (cryptoProvider == null)
{
throw new ArgumentNullException(nameof(cryptoProvider));
}
_cryptoProvider = cryptoProvider;
}
public void CanResolveCryptoProvider()
{
IServiceLocator container = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource);
ISymmetricCryptoProvider provider = container.GetInstance <ISymmetricCryptoProvider>(symmetricInstance);
Assert.IsNotNull(provider);
Assert.AreSame(typeof(DpapiSymmetricCryptoProvider), provider.GetType());
}
/// <summary>
/// ''' Creates an instance with a specified key.
/// '''
/// </summary>
/// '''
/// <param name="key">The key used for cryptographic functions, required 16 chars in length.</param>
public EncryptionUtility(string key)
{
var keyValue = key.Left(16);
_key = Encoding.UTF8.GetBytes(keyValue);
_mSymmetricCryptoProvider = new SymmetricAlgorithmProvider(_key);
_mHashProvider = new HashAlgorithmProvider();
}
public void GetByNameTest()
{
SymmetricCryptoProviderFactory factory = new SymmetricCryptoProviderFactory(context);
ISymmetricCryptoProvider provider = factory.CreateSymmetricCryptoProvider("provider1");
Assert.IsNotNull(provider);
Assert.IsTrue(provider is MockSymmetricCryptoProvider);
}
public HttpContentService(ISymmetricCryptoProvider cryptoProvider)
{
if (cryptoProvider == null)
{
throw new ArgumentNullException(nameof(cryptoProvider));
}
this.CryptoProvider = cryptoProvider;
}
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);
}
internal static byte[] DecryptSymmetric(string symmetricInstance, byte[] ciphertext, ConfigurationContext context)
{
ArgumentValidation.CheckForNullReference(symmetricInstance, "symmetricInstance");
ArgumentValidation.CheckForEmptyString(symmetricInstance, "symmetricInstance");
SymmetricCryptoProviderFactory factory = new SymmetricCryptoProviderFactory(context);
ISymmetricCryptoProvider symmetricProvider = factory.CreateSymmetricCryptoProvider(symmetricInstance);
return(symmetricProvider.Decrypt(ciphertext));
}
internal static string EncryptSymmetric(ISymmetricCryptoProvider provider, string plaintext)
{
if (string.IsNullOrEmpty(plaintext))
{
throw new ArgumentException("The value can not be a null or empty string.", "plaintext");
}
byte[] bytes = Encoding.Unicode.GetBytes(plaintext);
byte[] inArray = provider.Encrypt(bytes);
CryptographyUtility.GetRandomBytes(bytes);
return(Convert.ToBase64String(inArray));
}
public RequestCoordinator(
ISymmetricCryptoProvider symmetricCryptoProvider,
IAsymmetricCryptoProvider asymmetricCryptoProvider,
IRequestProcessorBuilder requestProcessorBuilder)
{
this.SymmetricCryptoProvider = symmetricCryptoProvider;
this.AsymmetricCryptoProvider = asymmetricCryptoProvider;
this.RequestProcessorBuilder = requestProcessorBuilder;
this.ClientState = new ClientStateModel();
}
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);
}
internal static string EncryptSymmetric(ISymmetricCryptoProvider provider, string plaintext)
{
if (string.IsNullOrEmpty(plaintext))
{
throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "plaintext");
}
byte[] plainTextBytes = UnicodeEncoding.Unicode.GetBytes(plaintext);
byte[] cipherTextBytes = provider.Encrypt(plainTextBytes);
CryptographyUtility.GetRandomBytes(plainTextBytes);
return(Convert.ToBase64String(cipherTextBytes));
}
internal static string DecryptSymmetric(ISymmetricCryptoProvider provider, string ciphertextBase64)
{
if (string.IsNullOrEmpty(ciphertextBase64))
{
throw new ArgumentException("The value can not be a null or empty string.", "ciphertextBase64");
}
byte[] ciphertext = Convert.FromBase64String(ciphertextBase64);
byte[] bytes = provider.Decrypt(ciphertext);
string str = Encoding.Unicode.GetString(bytes);
CryptographyUtility.GetRandomBytes(bytes);
return(str);
}
/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Builds an <see cref="SymmetricStorageEncryptionProvider"/> based on an instance of <see cref="StorageEncryptionProviderData"/>.
/// </summary>
/// <seealso cref="StorageEncryptionProviderCustomFactory"/>
/// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
/// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="SymmetricStorageEncryptionProviderData"/>.</param>
/// <param name="configurationSource">The source for configuration objects.</param>
/// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
/// <returns>A fully initialized instance of <see cref="SymmetricStorageEncryptionProvider"/>.</returns>
public IStorageEncryptionProvider Assemble(IBuilderContext context, StorageEncryptionProviderData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
SymmetricStorageEncryptionProviderData castedObjectConfiguration
= (SymmetricStorageEncryptionProviderData)objectConfiguration;
ISymmetricCryptoProvider symmetricCrytoProvider
= (ISymmetricCryptoProvider)context.HeadOfChain.BuildUp(context, typeof(ISymmetricCryptoProvider), null, castedObjectConfiguration.SymmetricInstance);
IStorageEncryptionProvider createdObject
= new SymmetricStorageEncryptionProvider(symmetricCrytoProvider);
return(createdObject);
}
public void GetDefaultTest()
{
SymmetricCryptoProviderFactory factory = new SymmetricCryptoProviderFactory(context);
ISymmetricCryptoProvider provider = factory.CreateSymmetricCryptoProvider("provider1");
Assert.IsNotNull(provider);
MockSymmetricCryptoProvider mockProvider = provider as MockSymmetricCryptoProvider;
Assert.IsNotNull(mockProvider);
Assert.IsTrue(mockProvider.Initialized);
}
public static async Task <string> DecryptUtf8ToBase64Async(
this ISymmetricCryptoProvider provider,
string message,
byte[] key,
byte[] iv)
{
if (string.IsNullOrEmpty(message))
{
return(string.Empty);
}
return(Convert.ToBase64String(await provider.DecryptBytesAsync(Encoding.UTF8.GetBytes(message), key, iv)));
}
public void Store(IMessage msg, ISymmetricCryptoProvider cryptoProvider, ProtocolId protocol)
{
using (var src = new MemoryStream())
{
var srcWrap = src.AsUnclosable();
msg.Save(srcWrap, protocol);
srcWrap.Seek(0, SeekOrigin.Begin);
cdataWrap.Seek(0, SeekOrigin.Begin);
cdataWrap.SetLength(0);
cryptoProvider.Encrypt(cdataWrap, srcWrap, (int)src.Length);
iv = cryptoProvider.IV;
}
}
static ClientConfig()
{
Aes = CryptoProviderFactory.Instance.CreateSymmetric(SdmSymmetricAlgorithm.AES);
Aes.KeySize = 256;
var salt = new byte[] { 0x10, 0x77, 0x16, 0x18, 0xf7, 0x6a, 0x8d, 0x0f };
var tsm = new Rfc2898DeriveBytes("octoc@t", salt);
var keySize = Aes.KeySize / 8;
Aes.Key = tsm.GetBytes(keySize);
var blockSize = Aes.IV.Length;
Aes.IV = tsm.GetBytes(blockSize);
}
public static async Task <string> EncryptBase64ToBase64Async(
this ISymmetricCryptoProvider provider,
string message,
byte[] key,
byte[] iv)
{
if (string.IsNullOrEmpty(message))
{
return(string.Empty);
}
return(Convert.ToBase64String(await provider.EncryptBytesAsync(Convert.FromBase64String(message), key, iv)));
}
public IMessage Extract(MessageId id, ISymmetricCryptoProvider cryptoProvider, ProtocolId protocol)
{
using (var dst = new MemoryStream())
{
var dstWrap = dst.AsUnclosable();
cdataWrap.Seek(0, SeekOrigin.Begin);
cryptoProvider.IV = iv;
cryptoProvider.Decrypt(dstWrap, cdataWrap, (int)cdata.Length);
dstWrap.Seek(0, SeekOrigin.Begin);
var msg = MessageFactory.CreateMessage(id);
msg.Load(dstWrap, protocol);
return(msg);
}
}
internal static string DecryptSymmetric(ISymmetricCryptoProvider provider, string ciphertextBase64)
{
if (string.IsNullOrEmpty(ciphertextBase64))
{
throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "ciphertextBase64");
}
byte[] cipherTextBytes = Convert.FromBase64String(ciphertextBase64);
byte[] decryptedBytes = provider.Decrypt(cipherTextBytes);
string decryptedString = UnicodeEncoding.Unicode.GetString(decryptedBytes);
CryptographyUtility.GetRandomBytes(decryptedBytes);
return(decryptedString);
}
public void AptcaIsPresentInCachingCryptography()
{
try
{
ZoneIdentityPermission zoneIdentityPermission = new ZoneIdentityPermission(PermissionState.None);
zoneIdentityPermission.Deny();
ISymmetricCryptoProvider symmetricCryptoProvider = null;
Type type = typeof(SymmetricStorageEncryptionProvider);
object createdObject = Activator.CreateInstance(type, symmetricCryptoProvider);
}
finally
{
ZoneIdentityPermission.RevertDeny();
}
}
public void CanBuildCustomSymmetricProviderFromGivenConfiguration()
{
CustomSymmetricCryptoProviderData customData
= new CustomSymmetricCryptoProviderData("custom", typeof(MockCustomSymmetricProvider));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
CryptographySettings settings = new CryptographySettings();
settings.SymmetricCryptoProviders.Add(customData);
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(CryptographyConfigurationView.SectionName, settings);
ISymmetricCryptoProvider custom
= EnterpriseLibraryFactory.BuildUp <ISymmetricCryptoProvider>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomSymmetricProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomSymmetricProvider)custom).customValue);
}
/// <summary>
/// Decrypts a cipher text using a specified symmetric cryptography provider.
/// </summary>
/// <param name="symmetricInstance">A symmetric instance from configuration.</param>
/// <param name="ciphertext">The cipher text for which you want to decrypt.</param>
/// <returns>The resulting plain text.</returns>
public static byte[] DecryptSymmetric(string symmetricInstance, byte[] ciphertext)
{
if (string.IsNullOrEmpty(symmetricInstance))
{
throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "symmetricInstance");
}
try
{
SymmetricCryptoProviderFactory factory = new SymmetricCryptoProviderFactory(ConfigurationSourceFactory.Create());
ISymmetricCryptoProvider symmetricProvider = factory.Create(symmetricInstance);
return(symmetricProvider.Decrypt(ciphertext));
}
catch (ConfigurationErrorsException configurationException)
{
TryLogSymmetricConfigurationError(configurationException, symmetricInstance);
throw;
}
}
public void CanBuildCustomSymmetricProviderFromSavedConfiguration()
{
CustomSymmetricCryptoProviderData customData
= new CustomSymmetricCryptoProviderData("custom", typeof(MockCustomSymmetricProvider));
customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
CryptographySettings settings = new CryptographySettings();
settings.SymmetricCryptoProviders.Add(customData);
IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>(1);
sections[CryptographyConfigurationView.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
ISymmetricCryptoProvider custom
= EnterpriseLibraryFactory.BuildUp <ISymmetricCryptoProvider>("custom", configurationSource);
Assert.IsNotNull(custom);
Assert.AreSame(typeof(MockCustomSymmetricProvider), custom.GetType());
Assert.AreEqual("value1", ((MockCustomSymmetricProvider)custom).customValue);
}
public Server(ServerConfig cfg)
{
this.cfg = cfg;
users = new UserList();
users.Load();
clients = new SortedList <ClientId, SocketClientBase>();
newClients = new ConcurrentQueue <SocketClientBase>();
delClients = new ConcurrentQueue <SocketClientBase>();
iclients = new List <IClient>();
roClients = iclients.AsReadOnly();
nameToClient = new Dictionary <string, SocketClientBase>();
ftsContainer = new FileTransferSessionContainer();
int minBufSize = Math.Min(cfg.SocketReceiveBufferSize, cfg.SocketSendBufferSize);
MaxBlockSize = minBufSize / 2;
svcMessages = new ConcurrentQueue <IMessage>();
semAcceptingThread = new SemaphoreSlim(0, 1);
Protocol = cfg.Protocol;
asymCp = CryptoProviderFactory.Instance.CreateAsymmetric(cfg.AsymAlgorithm);
asymCp.KeySize = cfg.AsymAlgorithmKeySize;
symCp = CryptoProviderFactory.Instance.CreateSymmetric(cfg.SymAlgorithm);
symCp.KeySize = cfg.SymAlgorithmKeySize;
rng = new RNGCryptoServiceProvider();
}
public KeysController(
IGadgetKeysService keysService,
ISymmetricCryptoProvider symmetricCryptoProvider,
IAsymmetricCryptoProvider asymmetricCryptoProvider)
{
if (keysService == null)
{
throw new ArgumentNullException(nameof(keysService));
}
if (symmetricCryptoProvider == null)
{
throw new ArgumentNullException(nameof(symmetricCryptoProvider));
}
if (asymmetricCryptoProvider == null)
{
throw new ArgumentNullException(nameof(asymmetricCryptoProvider));
}
this.GadgetKeysService = keysService;
this.SymmetricCryptoProvider = symmetricCryptoProvider;
this.AsymmetricCryptoProvider = asymmetricCryptoProvider;
}
internal static string DecryptSymmetric(ISymmetricCryptoProvider provider, string ciphertextBase64)
{
if (string.IsNullOrEmpty(ciphertextBase64)) throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "ciphertextBase64");
byte[] cipherTextBytes = Convert.FromBase64String(ciphertextBase64);
byte[] decryptedBytes = provider.Decrypt(cipherTextBytes);
string decryptedString = UnicodeEncoding.Unicode.GetString(decryptedBytes);
CryptographyUtility.GetRandomBytes(decryptedBytes);
return decryptedString;
}
/// <summary>
/// Creates an instance with a specified key.
/// </summary>
/// <param name="key">The key used for cryptographic functions.</param>
public SecureQueryString(byte[] key)
: base()
{
// If no key is provided then use the default key...
if ((key == null) || (key.Length == 0))
{
UTF8Encoding encoder = new UTF8Encoding();
key = encoder.GetBytes(defaultKey);
}
// Convert key to 16-byte hash...
System.Security.Cryptography.MD5CryptoServiceProvider hasher = new System.Security.Cryptography.MD5CryptoServiceProvider();
symmetricCryptoProvider = new SymmetricAlgorithmProvider(hasher.ComputeHash(key));
hashProvider = new HashAlgorithmProvider();
this.key = hasher.ComputeHash(key);
}
/// <summary>
/// Creates an instance with a specified key.
/// </summary>
/// <param name="key">The key used for cryptographic functions.</param>
public SecureQueryString(string key)
: base()
{
// If no key is provided then use the default key...
if ((key == String.Empty) || (key == "") || (key == null))
key = defaultKey;
// Convert key to 16-byte hash...
UTF8Encoding encoder = new UTF8Encoding();
System.Security.Cryptography.MD5CryptoServiceProvider hasher = new System.Security.Cryptography.MD5CryptoServiceProvider();
symmetricCryptoProvider = new SymmetricAlgorithmProvider(hasher.ComputeHash(encoder.GetBytes(key)));
hashProvider = new HashAlgorithmProvider();
this.key = hasher.ComputeHash(encoder.GetBytes(key));
}
/// <summary>
/// <para>Initialize a new instance of the <see cref="SymmetricAlgorithmProvider"/> class.</para>
/// </summary>
public SymmetricStorageEncryptionProvider(ISymmetricCryptoProvider symmetricCrytoProvider)
{
this.symmetricCrytoProvider = symmetricCrytoProvider;
}
internal static string EncryptSymmetric(ISymmetricCryptoProvider provider, string plaintext)
{
if (string.IsNullOrEmpty(plaintext))
{
throw new ArgumentException("The value can not be a null or empty string.", "plaintext");
}
byte[] bytes = Encoding.Unicode.GetBytes(plaintext);
byte[] inArray = provider.Encrypt(bytes);
CryptographyUtility.GetRandomBytes(bytes);
return Convert.ToBase64String(inArray);
}
internal static string EncryptSymmetric(ISymmetricCryptoProvider provider, string plaintext)
{
if (string.IsNullOrEmpty(plaintext)) throw new ArgumentException(Resources.ExceptionNullOrEmptyString, "plaintext");
byte[] plainTextBytes = UnicodeEncoding.Unicode.GetBytes(plaintext);
byte[] cipherTextBytes = provider.Encrypt(plainTextBytes);
CryptographyUtility.GetRandomBytes(plainTextBytes);
return Convert.ToBase64String(cipherTextBytes);
}
public SymmetricProviderHelper(ISymmetricCryptoProvider symmProvider)
{
this.symmProvider = symmProvider;
}
internal static string DecryptSymmetric(ISymmetricCryptoProvider provider, string ciphertextBase64)
{
if (string.IsNullOrEmpty(ciphertextBase64))
{
throw new ArgumentException("The value can not be a null or empty string.", "ciphertextBase64");
}
byte[] ciphertext = Convert.FromBase64String(ciphertextBase64);
byte[] bytes = provider.Decrypt(ciphertext);
string str = Encoding.Unicode.GetString(bytes);
CryptographyUtility.GetRandomBytes(bytes);
return str;
}
