public SecretDecryptionContext(
IKeyGenerator keyGenerator,
ISecretStore secretStore,
ISymmetricEncryptor secretEncryptor,
ISecretValidator secretValidator,
IServiceProvider serviceProvider,
PassawordContext context,
DecryptionEventArgs decryptEventArgs,
DecryptionFailedEventArgs decryptFailedEventArgs,
ILogger <SecretDecryptionContext> logger)
{
_secretStore = secretStore;
_secretEncryptor = secretEncryptor;
_secretValidator = secretValidator;
_serviceProvider = serviceProvider;
_context = context;
_decryptEventArgs = decryptEventArgs;
_decryptFailedEventArgs = decryptFailedEventArgs;
_logger = logger;
_decryptEventArgs.Context = this;
_decryptFailedEventArgs.Context = this;
EncryptionKey = keyGenerator.GetDefaultEncryptionKey();
DecryptionKeys = keyGenerator.GetDecryptionKeys();
}
public EncryptSerializer(ISerializer serializer, ISymmetricEncryptor encryptor)
{
serializer.ShouldNotBeNull("serializer");
Serializer = serializer;
Encryptor = encryptor ?? new RC2SymmetricEncryptor();
}
protected static void ValidateSymmetricEncryptor(ISymmetricEncryptor encryptor) {
var cipherKR = encryptor.Encrypt(Encoding.Unicode.GetBytes(PlainTextKR));
var clearKR = Encoding.Unicode.GetString(encryptor.Decrypt(cipherKR));
Assert.AreEqual(PlainTextKR, clearKR);
var cipherUS = encryptor.Encrypt(Encoding.Unicode.GetBytes(PlainTextUS));
var clearUS = Encoding.Unicode.GetString(encryptor.Decrypt(cipherUS));
Assert.AreEqual(PlainTextUS, clearUS);
}
/// <summary>
/// 문자열을 암호화합니다.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="text"></param>
/// <returns></returns>
public static string EncryptString(this ISymmetricEncryptor encryptor, string text)
{
if (text.IsEmpty())
{
return(string.Empty);
}
return(encryptor.Encrypt(text.ToBytes(StringTool.DefaultEncoding)).Base64Encode());
}
/// <summary>
/// 암호화된 문자열을 복원합니다.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="encryptedText"></param>
/// <returns></returns>
public static string DecryptString(this ISymmetricEncryptor encryptor, string encryptedText)
{
if (encryptedText.IsEmpty())
{
return(string.Empty);
}
return(encryptor.Decrypt(encryptedText.Base64Decode()).ToText(StringTool.DefaultEncoding));
}
/// <summary>
/// 대칭형 암호화 알고리즘을 이용하여, <paramref name="format"/>형태의 <paramref name="cipherText"/>를 복호화합니다.
/// </summary>
/// <param name="encryptor">대칭형 암호화 인스턴스</param>
/// <param name="cipherText">암호화된 정보</param>
/// <param name="format">암호화된 정보의 문자열 형식(Base64|HexDecimal)</param>
/// <returns>복화화된 원본 문자열</returns>
public static string DecryptString(this ISymmetricEncryptor encryptor, string cipherText,
EncryptionStringFormat format = EncryptionStringFormat.HexDecimal)
{
if (cipherText.IsEmpty())
{
return(cipherText);
}
var plainBytes = encryptor.Decrypt(cipherText.StringToBytes(format));
return(Encoding.Unicode.GetString(plainBytes).Trim('\0'));
}
protected static void ValidateSymmetricEncryptor(ISymmetricEncryptor encryptor)
{
var cipherKR = encryptor.Encrypt(Encoding.Unicode.GetBytes(PlainTextKR));
var clearKR = Encoding.Unicode.GetString(encryptor.Decrypt(cipherKR));
Assert.AreEqual(PlainTextKR, clearKR);
var cipherUS = encryptor.Encrypt(Encoding.Unicode.GetBytes(PlainTextUS));
var clearUS = Encoding.Unicode.GetString(encryptor.Decrypt(cipherUS));
Assert.AreEqual(PlainTextUS, clearUS);
}
/// <summary>
/// 대칭형 암호화 알고리즘을 이용하여 <paramref name="plainText"/>를 암호화하여, <paramref name="format"/> 형태의 문자열로 반환합니다.
/// </summary>
/// <param name="encryptor">대칭형 암호화 인스턴스</param>
/// <param name="plainText">원본 문자열</param>
/// <param name="format">암호화된 정보의 문자열 형식(Base64|HexDecimal)</param>
/// <returns>암호화된 문자열</returns>
public static string EncryptString(this ISymmetricEncryptor encryptor, string plainText,
EncryptionStringFormat format = EncryptionStringFormat.HexDecimal)
{
if (plainText.IsEmpty())
{
return(plainText);
}
return
(encryptor
.EncryptBytes(Encoding.Unicode.GetBytes(plainText))
.BytesToString(format)
.Trim('\0'));
}
public SecretEncryptionContext(
IKeyGenerator keyGenerator,
ISymmetricEncryptor secretEncryptor,
ISecretStore secretStore,
PassawordContext context,
EncryptionEventArgs eventArgs,
ILogger <SecretEncryptionContext> logger)
{
_secretEncryptor = secretEncryptor;
_secretStore = secretStore;
_context = context;
_eventArgs = eventArgs;
_logger = logger;
_eventArgs.Context = this;
EncryptionKey = keyGenerator.GetDefaultEncryptionKey();
}
internal FileEncryptor(
ISymmetricEncryptor symmetricEncryptor,
IEncryptionKeyGenerator encryptionKeyGenerator,
IConfigurationProvider configurationProvider,
IFileNameManager fileNameManager,
EncryptionKeyInput encryptionKeyInput,
string vaultName)
{
var key = encryptionKeyGenerator.Generate(encryptionKeyInput);
this.parameters = new SymmetricEncryptionParameters
{
Algorithm = AlgorithmType.Aes,
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7,
Key = key
};
this.symmetricEncryptor = symmetricEncryptor;
this.configurationProvider = configurationProvider;
this.fileNameManager = fileNameManager;
this.vaultName = vaultName;
}
/// <summary>
/// 대칭형 암호화 알고르즘을 이용하여 <paramref name="cipherBytes"/>를 복호화 합니다.
/// </summary>
/// <param name="encryptor">대칭형 암호화 인스턴스</param>
/// <param name="cipherBytes">암호화된 정보</param>
/// <returns>복호화된 정보</returns>
public static byte[] DecryptBytes(this ISymmetricEncryptor encryptor, byte[] cipherBytes)
{
return(encryptor.Decrypt(cipherBytes));
}
public Aes256EncryptorShould()
{
_context.ConfigureAndBuild();
_encryptor = _context.ServiceProvider.GetService <ISymmetricEncryptor>();
}
/// <summary>
/// 비동기 방식으로 암호화된 문자열을 복원합니다.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="encryptedText"></param>
/// <returns></returns>
public static Task <string> DecryptStringAsync(this ISymmetricEncryptor encryptor, string encryptedText)
{
return(Task.Factory.StartNew(() => DecryptString(encryptor, encryptedText)));
}
/// <summary>
/// 스트림을 암호화 합니다.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="stream"></param>
/// <returns></returns>
public static Stream EncryptStream(this ISymmetricEncryptor encryptor, Stream stream)
{
return(new MemoryStream(encryptor.Encrypt(stream.ToBytes())));
}
public CryptographyController(IHasher hasher, ISymmetricEncryptor encryptor)
{
_hasher = hasher;
_encryptor = encryptor;
}
public EncryptSerializer(ISerializer <T> serializer, ISymmetricEncryptor encryptor)
: base(serializer)
{
Encryptor = encryptor;
}
/// <summary>
/// 비동기 방식으로 데이터를 암호화 합니다.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="plainBytes"></param>
/// <returns></returns>
public static Task <byte[]> EncryptAsync(this ISymmetricEncryptor encryptor, byte[] plainBytes)
{
return(Task.Factory.StartNew(() => encryptor.Encrypt(plainBytes)));
}
/// <summary>
/// 비동기 방식으로 암호화된 데이터를 복원합니다.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="cipher"></param>
/// <returns></returns>
public static Task <byte[]> DecriptAsync(this ISymmetricEncryptor encryptor, byte[] cipher)
{
return(Task.Factory.StartNew(() => encryptor.Decrypt(cipher)));
}
public SymmetricEncryptors()
{
SystemCryptography = new SystemCryptographySymmetric();
BounceCastle = new BouncyCastleSymmetric();
}
/// <summary>
/// 비동기 방식으로 암호화된 스트림을 복원합니다.
/// </summary>
/// <param name="encryptor"></param>
/// <param name="stream"></param>
/// <returns></returns>
public static Task <Stream> DecryptStreamAsync(this ISymmetricEncryptor encryptor, Stream stream)
{
return(Task.Factory.StartNew(() => encryptor.DecryptStream(stream)));
}
public CryptoStoreSimulator(PiiDbContext dbContext, ISymmetricEncryptor symmetricEncryptor)
{
_piiContext = dbContext;
_symmetricEncryptor = symmetricEncryptor;
}
public EncryptSerializer(ISerializer serializer, ISymmetricEncryptor encryptor) {
serializer.ShouldNotBeNull("serializer");
Serializer = serializer;
Encryptor = encryptor ?? new RC2SymmetricEncryptor();
}
/// <summary>
/// 대칭형 암호화 알고리즘을 이용하여 <paramref name="plainBytes"/>를 암호화 합니다.
/// </summary>
/// <param name="encryptor">대칭형 암호화 인스턴스</param>
/// <param name="plainBytes">원본 정보</param>
/// <returns>암호화된 정보</returns>
public static byte[] EncryptBytes(this ISymmetricEncryptor encryptor, byte[] plainBytes)
{
return(encryptor.Encrypt(plainBytes));
}
/// <summary>
/// 대칭형 암호화 알고리즘을 이용하여, <paramref name="cipherStream"/>을 복호화한 스트림을 반환합니다.
/// </summary>
/// <param name="encryptor">대칭형 암호화 인스턴스</param>
/// <param name="cipherStream">암호화된 정보를 가진 스트림</param>
/// <returns>복호화된 정보를 가진 스트림</returns>
public static Stream DecryptString(this ISymmetricEncryptor encryptor, Stream cipherStream)
{
cipherStream.ShouldNotBeNull("cipherStream");
return(new MemoryStream(encryptor.Decrypt(cipherStream.ToBytes())));
}
/// <summary>
/// 대칭형 암호화 알고리즘을 이용하여, <paramref name="plainStream"/>을 암호화하여 스트림으로 반환합니다.
/// </summary>
/// <param name="encryptor">대칭형 암호화 인스턴스</param>
/// <param name="plainStream">원본 스트림</param>
/// <returns>암호화된 스트림</returns>
public static Stream EncryptStream(this ISymmetricEncryptor encryptor, Stream plainStream)
{
plainStream.ShouldNotBeNull("plainStream");
return(new MemoryStream(encryptor.Encrypt(plainStream.ToBytes())));
}
