/// <summary>
/// Export RSA public key
/// </summary>
/// <param name="rsa"></param>
/// <param name="format"></param>
/// <param name="usePemFormat"></param>
/// <returns></returns>
public static string ExportPublicKey(this MsRSA rsa, RsaKeyFormat format, bool usePemFormat = false)
{
var key = format switch
{
RsaKeyFormat.XML => rsa.ExportKeyInLvccXml(false),
RsaKeyFormat.JSON => rsa.ExportKeyInJson(false),
#if NETCOREAPP3_1 || NETSTANDARD2_1
RsaKeyFormat.Pkcs1 => BaseConv.ToBase64(rsa.ExportRSAPublicKey()),
RsaKeyFormat.Pkcs8 => BaseConv.ToBase64(rsa.ExportRSAPublicKey()),
#else
RsaKeyFormat.Pkcs1 => rsa.GetPublicKeyInPkcs1(),
RsaKeyFormat.Pkcs8 => rsa.GetPublicKeyInPkcs8(),
#endif
_ => throw new NotSupportedException("Unknown RSA key type.")
};
if (usePemFormat)
{
key = format switch
{
RsaKeyFormat.XML => key,
RsaKeyFormat.JSON => key,
RsaKeyFormat.Pkcs1 => key.RemovePkcs1PublicKeyFormat(),
RsaKeyFormat.Pkcs8 => key.RemovePkcs8PublicKeyFormat(),
_ => throw new NotSupportedException("Unknown RSA key type.")
};
}
return(key);
}
public void ZBase32StringTest()
{
var baseVal = BaseConv.ToZBase32String("Alex LEWIS");
var originalVal = BaseConv.FromZBase32String(baseVal);
Assert.Equal("Alex LEWIS", originalVal);
}
public static string PrivateKeyPkcs8ToXml(string privateKey)
{
var privateKeyBytes = BaseConv.FromBase64(privateKey.RemovePkcs8PrivateKeyFormat());
var privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(privateKeyBytes);
//Key
var element = new XElement("RSAKeyValue");
var privateModulus = new XElement("Modulus", Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()));
var privateExponent = new XElement("Exponent", Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()));
var privateP = new XElement("P", Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()));
var privateQ = new XElement("Q", Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()));
var privateDp = new XElement("DP", Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()));
var privateDq = new XElement("DQ", Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()));
var privateInverseQ = new XElement("InverseQ", Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()));
var privateD = new XElement("D", Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
element.Add(privateModulus);
element.Add(privateExponent);
element.Add(privateP);
element.Add(privateQ);
element.Add(privateDp);
element.Add(privateDq);
element.Add(privateInverseQ);
element.Add(privateD);
return(element.ToString());
}
public void Encrypt_ThreeRCX()
{
var key = RcFactory.GenerateKey("alexinea", Encoding.UTF8);
var function = RcFactory.Create(RcTypes.ThreeRCX, key);
var cryptoVal0 = function.Encrypt("ABCDDDDDDDDDDDDDDDDDDDDDD");
BaseConv.ToBase64(cryptoVal0.CipherData).ShouldBe("JPTCrl2N6xae4GCEXfzUiSa9YrwSa80HDg==");
}
public string GetBase64String()
{
if (!IncludeData())
{
return(string.Empty);
}
return(BaseConv.ToBase64(_data));
}
public void Encrypt()
{
var key = RcFactory.GenerateKey("alexinea", Encoding.UTF8);
var function = RcFactory.Create(RcTypes.RC4, key);
var cryptoVal0 = function.Encrypt("image");
BaseConv.ToBase64(cryptoVal0.CipherData).ShouldBe("I2YRaZo=");
}
public void Encrypt()
{
var key = RcFactory.GenerateKey("alexinea", Encoding.UTF8);
var function = RcFactory.Create(RcTypes.RCX, key);
var cryptoVal0 = function.Encrypt("ABCDDDDDDDDDDDDDDDDDDDDDD");
BaseConv.ToBase64(cryptoVal0.CipherData).ShouldBe("C+YxcfWRWMVCIjbX21qXcG9OXq25jJTHmw==");
}
public void ZBase32BytesTest()
{
var byteArray = Encoding.UTF8.GetBytes("Alex LEWIS");
var baseVal = BaseConv.ToZBase32(byteArray);
var originalByteArray = BaseConv.FromZBase32(baseVal);
var originalVal = Encoding.UTF8.GetString(originalByteArray);
Assert.Equal("Alex LEWIS", originalVal);
}
public byte[] Hash(ReadOnlySpan <byte> buff)
{
using var algorithm = MD5.Create();
var hashVal = algorithm.ComputeHash(buff.ToArray());
return(_type switch
{
MdTypes.Md5 => hashVal,
MdTypes.Md5Bit16 => hashVal.AsSpan(4, 8).ToArray(),
MdTypes.Md5Bit32 => hashVal,
MdTypes.Md5Bit64 => Encoding.UTF8.GetBytes(BaseConv.ToBase64(hashVal)),
_ => hashVal
});
public static void TouchFromPublicKeyInPkcs8(this MsRSA rsa, string publicKey, out RSAParameters parameters)
{
var publicKeyBytes = BaseConv.FromBase64(publicKey.RemovePkcs8PublicKeyFormat());
var publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(publicKeyBytes);
parameters = new RSAParameters
{
Modulus = publicKeyParam.Modulus.ToByteArrayUnsigned(),
Exponent = publicKeyParam.Exponent.ToByteArrayUnsigned()
};
rsa.ImportParameters(parameters);
}
public void Encrypt_L256_WithSalt_Test()
{
var key = AesFactory.GenerateKey(AesTypes.Aes256);
var function = AesFactory.Create(AesTypes.Aes256, key);
var cryptoVal0 = function.Encrypt("实现中华民族伟大复兴的中国梦", "12345678");
var cryptoVal1 = function.Decrypt(cryptoVal0.CipherData, "12345678");
cryptoVal1.GetOriginalDataDescriptor().GetString().ShouldBe("实现中华民族伟大复兴的中国梦");
var cryptoVal2 = function.Decrypt(BaseConv.ToBase64(cryptoVal0.CipherData), "12345678", CipherTextTypes.Base64Text);
cryptoVal2.GetOriginalDataDescriptor().GetString().ShouldBe("实现中华民族伟大复兴的中国梦");
}
public void EncryptDecrypt_WithSalt_WithAutoCreateKey_L128_Test()
{
var key = DesFactory.GenerateKey(DesTypes.TripleDES128);
var function = DesFactory.Create(DesTypes.TripleDES128, key);
var cryptoVal0 = function.Encrypt("实现中华民族伟大复兴的中国梦", "123412341234");
var cryptoVal1 = function.Decrypt(cryptoVal0.CipherData, "123412341234");
cryptoVal1.GetOriginalDataDescriptor().GetString().ShouldBe("实现中华民族伟大复兴的中国梦");
var cryptoVal2 = function.Decrypt(BaseConv.ToBase64(cryptoVal0.CipherData), "123412341234", CipherTextTypes.Base64Text);
cryptoVal2.GetOriginalDataDescriptor().GetString().ShouldBe("实现中华民族伟大复兴的中国梦");
}
public void TEATest()
{
var key = TeaFactory.GenerateKey("alexinea", Encoding.UTF8);
var function = TeaFactory.Create(TeaTypes.TEA, key);
var cryptoVal0 = function.Encrypt("AlexLEWIS ");
var cryptoVal1 = function.Decrypt(cryptoVal0.CipherData);
cryptoVal1.GetOriginalDataDescriptor().GetString().ShouldBe("AlexLEWIS ");
var cryptoVal2 = function.Decrypt(BaseConv.ToBase64(cryptoVal0.CipherData), CipherTextTypes.Base64Text);
cryptoVal2.GetOriginalDataDescriptor().GetString().ShouldBe("AlexLEWIS ");
}
public void EncryptDecrypt_WithAutoCreateKey_Test()
{
var key = DesFactory.GenerateKey();
var function = DesFactory.Create(DesTypes.DES, key);
var cryptoVal0 = function.Encrypt("image");
var cryptoVal1 = function.Decrypt(cryptoVal0.CipherData);
cryptoVal1.GetOriginalDataDescriptor().GetString().ShouldBe("image");
var cryptoVal2 = function.Decrypt(BaseConv.ToBase64(cryptoVal0.CipherData), CipherTextTypes.Base64Text);
cryptoVal2.GetOriginalDataDescriptor().GetString().ShouldBe("image");
}
public static byte[] GetBytes(this CipherTextTypes signatureTextType, string signature, Encoding encoding = default, Func <string, byte[]> customCipherTextConverter = null)
{
encoding = encoding.SafeEncodingValue();
return(signatureTextType switch
{
CipherTextTypes.PlainText => encoding.GetBytes(signature),
CipherTextTypes.Base32Text => BaseConv.FromBase32(signature),
CipherTextTypes.Base64Text => BaseConv.FromBase64(signature),
CipherTextTypes.Base91Text => BaseConv.FromBase91(signature),
CipherTextTypes.Base256Text => BaseConv.FromBase256(signature),
CipherTextTypes.ZBase32Text => BaseConv.FromZBase32(signature),
CipherTextTypes.Hex => Org.BouncyCastle.Utilities.Encoders.Hex.Decode(signature),
_ => customCipherTextConverter is null?encoding.GetBytes(signature) : customCipherTextConverter(signature)
});
public void EncryptDecrypt_WithSalt_Test()
{
var key = DesFactory.GenerateKey(DesTypes.DES, "alexinea", "forerunner", Encoding.UTF8);
var function = DesFactory.Create(DesTypes.DES, key);
var cryptoVal0 = function.Encrypt("image", "123412341234");
BaseConv.ToBase64(cryptoVal0.CipherData).ShouldBe("s4h5u8hA/2Y=");
var cryptoVal1 = function.Decrypt(cryptoVal0.CipherData, "123412341234");
cryptoVal1.GetOriginalDataDescriptor().GetString().ShouldBe("image");
var cryptoVal2 = function.Decrypt(BaseConv.ToBase64(cryptoVal0.CipherData), "123412341234", CipherTextTypes.Base64Text);
cryptoVal2.GetOriginalDataDescriptor().GetString().ShouldBe("image");
}
public void EncryptDecrypt_L192_Test()
{
var key = DesFactory.GenerateKey(DesTypes.TripleDES192, "alexinea&#%12!", "forerunner", Encoding.UTF8);
var function = DesFactory.Create(DesTypes.TripleDES192, key);
var cryptoVal0 = function.Encrypt("image");
BaseConv.ToBase64(cryptoVal0.CipherData).ShouldBe("Y6tAf/GrLx8=");
var cryptoVal1 = function.Decrypt(cryptoVal0.CipherData);
cryptoVal1.GetOriginalDataDescriptor().GetString().ShouldBe("image");
var cryptoVal2 = function.Decrypt(BaseConv.ToBase64(cryptoVal0.CipherData), CipherTextTypes.Base64Text);
cryptoVal2.GetOriginalDataDescriptor().GetString().ShouldBe("image");
}
public static void TouchFromPrivateKeyInPkcs8(this MsRSA rsa, string privateKey, out RSAParameters parameters)
{
var privateKeyBytes = BaseConv.FromBase64(privateKey.RemovePkcs8PrivateKeyFormat());
var privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(privateKeyBytes);
parameters = new RSAParameters
{
Modulus = privateKeyParam.Modulus.ToByteArrayUnsigned(),
Exponent = privateKeyParam.PublicExponent.ToByteArrayUnsigned(),
P = privateKeyParam.P.ToByteArrayUnsigned(),
Q = privateKeyParam.Q.ToByteArrayUnsigned(),
DP = privateKeyParam.DP.ToByteArrayUnsigned(),
DQ = privateKeyParam.DQ.ToByteArrayUnsigned(),
InverseQ = privateKeyParam.QInv.ToByteArrayUnsigned(),
D = privateKeyParam.Exponent.ToByteArrayUnsigned()
};
rsa.ImportParameters(parameters);
}
/// <summary>
/// Import RSA public key
/// </summary>
/// <param name="rsa"></param>
/// <param name="format"></param>
/// <param name="publicKey"></param>
/// <param name="isPem"></param>
public static void ImportPublicKey(this MsRSA rsa, RsaKeyFormat format, string publicKey, bool isPem = false)
{
if (isPem)
{
publicKey = format switch
{
RsaKeyFormat.XML => publicKey,
RsaKeyFormat.JSON => publicKey,
RsaKeyFormat.Pkcs1 => publicKey.RemovePkcs1PublicKeyFormat(),
RsaKeyFormat.Pkcs8 => publicKey.RemovePkcs8PublicKeyFormat(),
_ => throw new NotSupportedException("Unknown RSA key type.")
};
}
switch (format)
{
case RsaKeyFormat.XML:
rsa.ImportKeyInLvccXml(publicKey);
break;
case RsaKeyFormat.JSON:
rsa.ImportKeyInJson(publicKey);
break;
case RsaKeyFormat.Pkcs1:
#if NETCOREAPP3_1 || NETSTANDARD2_1
rsa.ImportRSAPublicKey(BaseConv.FromBase64(publicKey), out _);
#else
rsa.TouchFromPublicKeyInPkcs1(publicKey, out _);
#endif
break;
case RsaKeyFormat.Pkcs8:
#if NETCOREAPP3_1 || NETSTANDARD2_1
rsa.ImportRSAPublicKey(BaseConv.FromBase64(publicKey), out _);
#else
rsa.TouchFromPublicKeyInPkcs8(publicKey, out _);
#endif
break;
}
}
}
internal Sm2Key(ECPoint publicKey, BigInteger privateKey)
{
PublicKey = BaseConv.ToBase64(publicKey.GetEncoded()); //Hex.Encode(publicKey.GetEncoded()).GetString(encoding.SafeEncodingValue()).ToUpper();
PrivateKey = BaseConv.ToBase64(privateKey.ToByteArray()); //Hex.Encode(privateKey.ToByteArray()).GetString(encoding.SafeEncodingValue()).ToUpper();
}
