public void AESEncryptStringNoKeyIV()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
byte[] keyBytes;
byte[] ivBytes;
byte[] hashBytes = f.Encrypt("Hello world", out keyBytes, out ivBytes);
string keyBytes64 = Convert.ToBase64String(keyBytes);
string ivBytes64 = Convert.ToBase64String(ivBytes);
string hashBytes64 = Convert.ToBase64String(hashBytes);
//Console.WriteLine("KeyBytes[{0}]", keyBytes64);
//Console.WriteLine("IVBytes[{0}]", ivBytes64);
//Console.WriteLine("HashBytes[{0}]", hashBytes64);
//Assert.Fail();
// Assert
//Assert.AreEqual("ZOyIygCyaOW6GjVnihtTFtIS9PNmskdyMlNKiuyjfzw=", result);
Assert.NotZero(keyBytes64.Length);
Assert.NotZero(ivBytes64.Length);
Assert.NotZero(hashBytes64.Length);
}
public void PbkdfStringWithSaltIteration()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
int iterationCount = 3050;
byte[] saltBytes = Convert.FromBase64String("cPpP4ISgNAIuMZGncgwlCHvE0bf0JQdWrZPXoH+g4e8=");
byte[] resultBytes = f.PasswordBasedKey(10, "Hello world", saltBytes, iterationCount);
string saltBase64 = Convert.ToBase64String(saltBytes);
string resultBase64 = Convert.ToBase64String(resultBytes);
//Console.WriteLine("salt Base64[{0}]", saltBase64);
//Console.WriteLine("resultBase64[{0}]", resultBase64);
//Console.WriteLine("iterationCount[{0}]", iterationCount);
//Assert.Fail();
// Assert
//Assert.AreEqual("ZOyIygCyaOW6GjVnihtTFtIS9PNmskdyMlNKiuyjfzw=", result);
//Assert.NotZero(saltBase64.Length);
//Assert.NotZero(resultBase64.Length);
Assert.AreEqual("sMYk7SkvF9PElA==", resultBase64);
}
public void TestSHA512()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.SHA512);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("zdRjlmz3FE4LLBlcsaOBrPwTDQ4SBnbIlTXfTiSlB16+GDegxsq9xpNUgwv9oetpnmOWUjs+7vWWupEXNmfkXQ==", Convert.ToBase64String(bytes));
}
public void RSAParametersXmlSerialization()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
System.Security.Cryptography.RSAParameters rsaParameters;
using (System.Security.Cryptography.RSACryptoServiceProvider csp = new System.Security.Cryptography.RSACryptoServiceProvider())
{
rsaParameters = csp.ExportParameters(true);
}
// Act
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(System.Security.Cryptography.RSAParameters));
System.IO.MemoryStream ms;
using (ms = new System.IO.MemoryStream())
{
serializer.Serialize(ms, rsaParameters);
}
byte[] serializedBytes = ms.ToArray();
string xml = System.Text.Encoding.UTF8.GetString(serializedBytes);
Console.WriteLine(xml);
// Assert
Assert.NotZero(serializedBytes.Length);
}
public void PbkdfStringNoSaltIteration()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
int iterationCount;
byte[] saltBytes;
byte[] resultBytes = f.PasswordBasedKey(10, "Hello world", out saltBytes, out iterationCount);
string saltBase64 = Convert.ToBase64String(saltBytes);
string resultBase64 = Convert.ToBase64String(resultBytes);
//Console.WriteLine("salt Base64[{0}]", saltBase64);
//Console.WriteLine("resultBase64[{0}]", resultBase64);
//Console.WriteLine("iterationCount[{0}]", iterationCount);
//Assert.Fail();
// Assert
//Assert.AreEqual("ZOyIygCyaOW6GjVnihtTFtIS9PNmskdyMlNKiuyjfzw=", result);
Assert.NotZero(saltBase64.Length);
Assert.NotZero(resultBase64.Length);
}
public void TestAES()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.AES);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("LA+IcPGDn5F1/e5oHXfRBw==", Convert.ToBase64String(bytes));
}
public void TestSHA256()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.SHA256);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("ajYzysdQ8Dt4CGBSHAQVf0jSO62d8A8rsUEXAYkWhA8=", Convert.ToBase64String(bytes));
}
public void TestSHA384()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.SHA384);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("JIojBzlQO8t8h/BmKwHHbKhV5l1it/tRuPnRvJC2KMXBv8rvTSpiQLSOc63zJ4vW", Convert.ToBase64String(bytes));
}
public void TestTDES()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.TripleDES);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("whjkbt+wvN8=", Convert.ToBase64String(bytes));
}
public void TestSHA1()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.SHA1);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("Ce+S8twtqAqw3IunLaJwGJsbA0k=", Convert.ToBase64String(bytes));
}
public void BinaryCryptoSerializerTest()
{
var crypt = CryptographyFactory.Create("des");
var serializer = new BinaryCryptoSerializer(crypt);
Assert.IsNotNull(serializer);
}
public void TestMD5()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.MD5);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("P2OjkZ/a9Oe0Yss1rRnlzw==", Convert.ToBase64String(bytes));
}
public void DeserializeUseMd5Test()
{
var crypt = CryptographyFactory.Create("md5");
var serializer = new BinaryCryptoSerializer(crypt);
#region
var bytes = new byte[] {
64,
110,
111,
194,
121,
248,
123,
58,
12,
137,
116,
110,
166,
232,
5,
110
};
#endregion
var obj = serializer.Deserialize <BinaryCryptoData>(bytes);
Assert.IsNotNull(obj);
}
public void RsaDecryptBytesWithKey()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
byte[] inputDataBytes = Convert.FromBase64String("uZj8Rm8xW0ISZICUKeQnvNGTMaG81zyhMG8f8DmThs4uTegvWYI0q6JPg1jj0Y+IsQSZHkv/XGLNUJSKrrwnkQYuS90a3OkCoqFiLw8HQnni07bp9TkzDIRQWN+RkZC+7yhIHpQvdQZYl6CSjs3/LaD+LIXHObyXvjMwXLl803I=");
System.Security.Cryptography.RSAParameters rsaParameters = new System.Security.Cryptography.RSAParameters
{
D = Convert.FromBase64String("fJY0+ECA7KN+RYl0qNsN/mwW2mVndFUTgXZ+CIfGleayMq2R5Y5TzngExcwHaYv9m99s6n9M9c+aDP33RB542z4q2OFgrucbeTKAwRhJlbOYNuLGDuCPmcejPy51JNginjkOtw31+Pn7QinMpgwNG+5n7aQrQwTi2jLI5KUoEpU="),
DP = Convert.FromBase64String("EJGDjg0DYMTwU8EGNztrqOriZWFvHKidBZj6C0PUo6nx54DzBG9TdNaGj+o0zkUA6cXzf4x1jHYqV+yzG5Njmw=="),
DQ = Convert.FromBase64String("GiRgLL/RiYS793OD5u/rcw6mYUXIw5bW42krYR2gV7JVrVOi2r7nHNV65StGwmfhwPNnDqwHDefVVFXSxu+O6Q=="),
Exponent = Convert.FromBase64String("AQAB"),
InverseQ = Convert.FromBase64String("N/6gNxkobfLf5MaqWwX9Y7hu4UT+urVWC6CASgYwmqsTxBZGGsizVZ3ocq1A814Lo9S+REgKYFYdqh6agXEYOQ=="),
Modulus = Convert.FromBase64String("wmkOrKR16oKeDz+9mUqCUOw9jdwDDusrzHH7CEtuWt2XmC6Yu5fG+fh5QquLLF1aC9fyKbr126NsJ2zPbSkejI7grUghDC71D25PCz8sY3bpbMhzXDr8XxM4WSvg3edsSsOhvYzkRa+yZkhWxiaQ+Z0Vb0tTYNyRPi34YLmQZCU="),
P = Convert.FromBase64String("zvIZ1lx6Qa++2cQVrNguqNbWMziSRrtWUcWISBrtYuzm8aYOm10JbKdq0oRBZspwDyrAyvajGbLBmi2FvwlHZw=="),
Q = Convert.FromBase64String("8H5JWPl4W6THX5Fw7HHta7x+fOpeV6q1MU4Bzpb6ld9rphD3v6r5F06dojdWTdujv8o94ezx1tm84TWVOpX8kw==")
};
byte[] plainTextBytes = f.Decrypt(inputDataBytes, rsaParameters);
string resultBase64 = System.Text.Encoding.UTF8.GetString(plainTextBytes);
Console.WriteLine("Result = [{0}]", resultBase64);
// Assert
Assert.AreEqual("Hello world", resultBase64);
}
public void TestDSAGenerateKey()
{
var encrypt = CryptographyFactory.Create(CryptoAlgorithm.DSA) as AsymmetricCrypto;
Console.WriteLine(encrypt.GeneratePrivateKey());
Console.WriteLine(encrypt.GeneratePublicKey());
}
public void TestDES()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.DES);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("NcnuOjI/5dI=", Convert.ToBase64String(bytes));
}
public void TestRC4()
{
var c = CryptographyFactory.Create(CryptoAlgorithm.RC4);
var bytes = c.Encrypt("fireasy", Encoding.UTF8);
Assert.AreEqual("hUWUuUSlmg==", Convert.ToBase64String(bytes));
}
protected override byte[] EncodeDataToBytes(CodedData data)
{
var des = CryptographyFactory.Create(CryptoAlgorithm.DES) as SymmetricCrypto;
des.SetKey(KEY);
return(des.Encrypt(data.Data));
}
private ICryptoProvider CreateCryptoProvider()
{
var keybuffer = new byte[] { 45, 66, 124, 187, 22, 56, 90, 242 };
var crypt = CryptographyFactory.Create(CryptoAlgorithm.DES);
(crypt as SymmetricCrypto).CryptKey = keybuffer;
return(crypt);
}
/// <summary>
/// 验证授权码是否正确。
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public bool VerifyLicenseKey(LicenceVerifyOption option)
{
Guard.ArgumentNull(option.PublicKey, nameof(option.PublicKey));
Guard.ArgumentNull(option.LicenseKey, nameof(option.LicenseKey));
if (option.VerifyLocalKey)
{
Guard.ArgumentNull(option.AppKey, nameof(option.AppKey));
Guard.ArgumentNull(option.LocalKey, nameof(option.LocalKey));
}
var crypt = CryptographyFactory.Create(option.EncryptKind.ToString()) as AsymmetricCrypto;
crypt.PublicKey = option.PublicKey;
if (option.VerifyLocalKey)
{
var bytes = FromBase64String(option.LocalKey);
if (bytes == null)
{
return(false);
}
var data = new byte[bytes.Length - 2];
Array.Copy(bytes, 2, data, 0, data.Length);
if (!Enum.IsDefined(typeof(MachineKeyKinds), (int)bytes[0]) ||
!Enum.IsDefined(typeof(LocalKeyEncryptKinds), (int)bytes[1]))
{
return(false);
}
var mkKind = (MachineKeyKinds)bytes[0];
var mkEncryptKind = (LocalKeyEncryptKinds)bytes[1];
var localKey = GetLocalKey(new LocalKeyOption
{
AppKey = option.AppKey,
MachineKeyKind = mkKind,
EncryptKind = mkEncryptKind
});
if (localKey != option.LocalKey)
{
return(false);
}
}
var licenseBytes = FromBase64String(option.LicenseKey);
if (licenseBytes == null)
{
return(false);
}
return(crypt.VerifySignature(Encoding.ASCII.GetBytes(option.LocalKey), licenseBytes));
}
/// <summary>
/// 获取授权码。
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public string GetLicenseKey(LicenceGenerateOption option)
{
Guard.ArgumentNull(option.PrivateKey, nameof(option.PrivateKey));
Guard.ArgumentNull(option.LocalKey, nameof(option.LocalKey));
var crypt = CryptographyFactory.Create(option.EncryptKind.ToString()) as AsymmetricCrypto;
crypt.PrivateKey = option.PrivateKey;
return(Convert.ToBase64String(crypt.CreateSignature(Encoding.ASCII.GetBytes(option.LocalKey))));
}
public void TestDSA()
{
var c = CryptographyFactory.CreateAsymmetric(CryptoAlgorithm.DSA);
c.PublicKey = c.GeneratePublicKey();
c.PrivateKey = c.GeneratePrivateKey();
var bytes = c.CreateSignature(Encoding.UTF8.GetBytes("fireasy"));
Assert.IsTrue(c.VerifySignature(Encoding.UTF8.GetBytes("fireasy"), bytes));
}
public void TestDSASign()
{
var encrypt = CryptographyFactory.Create(CryptoAlgorithm.DSA) as AsymmetricCrypto;
encrypt.PublicKey = DSA_publicKey;
encrypt.PrivateKey = DSA_privateKey;
var bytes = encrypt.CreateSignature(Encoding.GetEncoding(0).GetBytes("1234"));
var ver = encrypt.VerifySignature(Encoding.GetEncoding(0).GetBytes("1234"), bytes);
Assert.IsTrue(ver);
}
public void MD5TestString()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
byte[] hashBytes = f.Hash(HashAlgorithmName.MD5, "Hello world");
string result = System.Convert.ToBase64String(hashBytes);
// Assert
Assert.AreEqual("PiWWCnnbxptnTNTsZ6csYg==", result);
}
public void TestRijndaelEncrypt()
{
var encrypt = CryptographyFactory.Create(CryptoAlgorithm.Rijndael) as SymmetricCrypto;
encrypt.SetKey("faib studio");
var bytes = encrypt.Encrypt("1234", Encoding.GetEncoding(0));
Console.WriteLine(bytes.Length);
var s = encrypt.Decrypt(bytes, Encoding.GetEncoding(0));
Assert.AreEqual("1234", s);
}
public void SHA512TestBytes()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
byte[] inputBytes = System.Text.Encoding.UTF8.GetBytes("Hello world");
byte[] hashBytes = f.Hash(HashAlgorithmName.SHA512, inputBytes);
string result = System.Convert.ToBase64String(hashBytes);
// Assert
Assert.AreEqual("t/eDuu2Cl/DbkXRiGE/08I5pwtXl95qUJgD5cl9Yzh8pwYE5v4CwbA//K900c4RS7PQMSIwip+PYDN9vnBwNRw==", result);
}
public void SHA256TestBytes()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
byte[] inputBytes = System.Text.Encoding.UTF8.GetBytes("Hello world");
byte[] hashBytes = f.Hash(inputBytes);
string result = System.Convert.ToBase64String(hashBytes);
// Assert
Assert.AreEqual("ZOyIygCyaOW6GjVnihtTFtIS9PNmskdyMlNKiuyjfzw=", result);
}
protected override CodedData DecodeDataFromBytes(byte[] data)
{
if (data.Length == 0)
{
return(null);
}
var des = CryptographyFactory.Create(CryptoAlgorithm.DES) as SymmetricCrypto;
des.SetKey(KEY);
return(new CodedData(des.Decrypt(data)));
}
public void TestRSAEncrypt()
{
var encrypt = CryptographyFactory.Create(CryptoAlgorithm.RSA) as AsymmetricCrypto;
encrypt.PublicKey = RSA_publicKey;
encrypt.PrivateKey = RSA_privateKey;
var bytes = encrypt.Encrypt("1234", Encoding.GetEncoding(0));
Console.WriteLine(bytes.Length);
var s = encrypt.Decrypt(bytes, Encoding.GetEncoding(0));
Assert.AreEqual("1234", s);
}
public void SHA256TestString()
{
// Arrange
CryptographyFactory f = new CryptographyFactory();
// Act
byte[] hashBytes = f.Hash("Hello world");
string result = System.Convert.ToBase64String(hashBytes);
//System.Console.WriteLine(base64Result);
// Assert
Assert.AreEqual("ZOyIygCyaOW6GjVnihtTFtIS9PNmskdyMlNKiuyjfzw=", result);
}
