public static void VerifyKnownSignature()
{
byte[] hash = "012d161304fa0c6321221516415813022320620c".HexToByteArray();
byte[] sig;
using (RSA key = RSAFactory.Create())
{
key.ImportParameters(TestData.RSA1024Params);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("SHA1");
sig = formatter.CreateSignature(hash);
byte[] expectedSig =
("566390012605b1c4c01c3c2f91ce27d19476ab7131d9ee9cd1b811afb2be02ab6b498b862f0b2368ed6b09ccc9e0ec0d4f97a4f318f4f11" +
"ae882a1131012dc35d2e0b810a38e05da71d291e88b306605c9d34815091641370bd7db7a87b115bd427fcb9993bc5ba2bd518745aef80c" +
"a4557cfa1d827ff1610595d8eeb4c15073").HexToByteArray();
Assert.Equal(expectedSig, sig);
}
using (RSA key = RSAFactory.Create()) // Test against a different instance
{
key.ImportParameters(TestData.RSA1024Params);
RSAPKCS1SignatureDeformatter deformatter = new RSAPKCS1SignatureDeformatter(key);
deformatter.SetHashAlgorithm("SHA1");
bool verified = deformatter.VerifySignature(hash, sig);
Assert.True(verified);
sig[3] ^= 0xff;
verified = deformatter.VerifySignature(hash, sig);
Assert.False(verified);
}
}
public static string RSAGetSignature(string PrivateKey, string Code)
{
RSACryptoServiceProvider key = new RSACryptoServiceProvider();
key.FromXmlString(PrivateKey);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("SHA1");
byte[] bytes = Encoding.ASCII.GetBytes(Code);
byte[] rgbHash = new SHA1Managed().ComputeHash(bytes);
return(Convert.ToBase64String(formatter.CreateSignature(rgbHash)));
}
private static void StrongName(Stream stream, StrongNameKeyPair keyPair, uint headerLength, uint textSectionFileOffset, uint strongNameSignatureFileOffset, uint strongNameSignatureLength)
{
SHA1Managed hash = new SHA1Managed();
using (CryptoStream cs = new CryptoStream(Stream.Null, hash, CryptoStreamMode.Write))
{
stream.Seek(0, SeekOrigin.Begin);
byte[] buf = new byte[8192];
HashChunk(stream, cs, buf, (int)headerLength);
stream.Seek(textSectionFileOffset, SeekOrigin.Begin);
HashChunk(stream, cs, buf, (int)(strongNameSignatureFileOffset - textSectionFileOffset));
stream.Seek(strongNameSignatureLength, SeekOrigin.Current);
HashChunk(stream, cs, buf, (int)(stream.Length - (strongNameSignatureFileOffset + strongNameSignatureLength)));
}
using (RSA rsa = keyPair.CreateRSA())
{
RSAPKCS1SignatureFormatter sign = new RSAPKCS1SignatureFormatter(rsa);
byte[] signature = sign.CreateSignature(hash);
Array.Reverse(signature);
if (signature.Length != strongNameSignatureLength)
{
throw new InvalidOperationException("Signature length mismatch");
}
stream.Seek(strongNameSignatureFileOffset, SeekOrigin.Begin);
stream.Write(signature, 0, signature.Length);
}
// compute the PE checksum
stream.Seek(0, SeekOrigin.Begin);
int count = (int)stream.Length / 4;
BinaryReader br = new BinaryReader(stream);
long sum = 0;
for (int i = 0; i < count; i++)
{
sum += br.ReadUInt32();
int carry = (int)(sum >> 32);
sum &= 0xFFFFFFFFU;
sum += carry;
}
while ((sum >> 16) != 0)
{
sum = (sum & 0xFFFF) + (sum >> 16);
}
sum += stream.Length;
// write the PE checksum, note that it is always at offset 0xD8 in the file
ByteBuffer bb = new ByteBuffer(4);
bb.Write((int)sum);
stream.Seek(0xD8, SeekOrigin.Begin);
bb.WriteTo(stream);
}
public static byte[] CreateSignWithPrivateKey(byte[] msgin, X509Certificate2 pfx)
{
HashAlgorithm SHA1 = HashAlgorithm.Create("sha1");
byte[] hashdata = SHA1.ComputeHash(msgin);//求数字指纹
RSAPKCS1SignatureFormatter signCrt = new RSAPKCS1SignatureFormatter();
signCrt.SetKey(pfx.PrivateKey);
signCrt.SetHashAlgorithm("sha1");
return(signCrt.CreateSignature(hashdata));
}
public static byte[] SignData(byte[] hashOfDataToSign)
{
using (var rsa = new RSACryptoServiceProvider(2048))
{
rsa.PersistKeyInCsp = false;
rsa.ImportParameters(_privateKey);
var rsaFormatter = new RSAPKCS1SignatureFormatter(rsa);
rsaFormatter.SetHashAlgorithm("SHA256");
return(rsaFormatter.CreateSignature(hashOfDataToSign));
}
}
public static bool VertifySignedByCertify(string input)
{
var data = Convert.FromBase64String(SignDataUseCertify(input));
string path = @"D:\Ceetificate\1.p12";
X509Certificate2 x509 = new X509Certificate2(path);
RSAPKCS1SignatureFormatter sign = new RSAPKCS1SignatureFormatter();
rsa.FromXmlString(x509.PublicKey.Key.ToXmlString(false));
bool vertify = rsa.VerifyData(Encoding.Default.GetBytes(input), "SHA1", data);
return(vertify);
}
public string SignData(byte[] sha256hashOfDataToSign, string key)
{
this.rsa.ImportRSAPrivateKey(this.ImportKey(key), out _);
var rsaFormatter = new RSAPKCS1SignatureFormatter(this.rsa);
rsaFormatter.SetHashAlgorithm("SHA256");
var signature = rsaFormatter.CreateSignature(sha256hashOfDataToSign);
return(Convert.ToBase64String(signature));
}
public byte[] Sign(byte[] securedInput, object key)
{
using (var sha = HashAlgorithm)
{
var privateKey = Ensure.Type <AsymmetricAlgorithm>(key, "RsaUsingSha alg expects key to be of AsymmetricAlgorithm type.");
var pkcs1 = new RSAPKCS1SignatureFormatter(privateKey);
pkcs1.SetHashAlgorithm(hashMethod);
return(pkcs1.CreateSignature(sha.ComputeHash(securedInput)));
}
}
public static byte[] Sign(string data, string privateKey)
{
byte[] hash = Hash.Calculate(data);
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
{
string privateKeyReadable = Encoding.UTF8.GetString(Convert.FromBase64String(privateKey));
rsa.FromXmlString(privateKeyReadable);
RSAPKCS1SignatureFormatter rsaFormatter = new RSAPKCS1SignatureFormatter(rsa);
rsaFormatter.SetHashAlgorithm("SHA256");
return(rsaFormatter.CreateSignature(hash));
}
}
public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
{
if (key == null)
{
throw new ArgumentNullException("RSAPKCS1SHA256SignatureDescription AsymmetricAlgorithm param: key is null");
}
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("SHA256");
return(formatter);
}
public virtual byte[] Sign(RSA key)
{
string oid = this.GetOid(this.hashName);
ASN1 tbs = this.ToBeSigned(oid);
byte[] rgbHash = HashAlgorithm.Create(this.hashName).ComputeHash(tbs.GetBytes());
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm(this.hashName);
byte[] signature = formatter.CreateSignature(rgbHash);
return(this.Build(tbs, oid, signature));
}
public bool SignatureFormatter(string p_strKeyPrivate, byte[] HashbyteSignature, ref string m_strEncryptedSignatureData)
{
RSACryptoServiceProvider key = new RSACryptoServiceProvider();
key.FromXmlString(p_strKeyPrivate);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("MD5");
byte[] inArray = formatter.CreateSignature(HashbyteSignature);
m_strEncryptedSignatureData = Convert.ToBase64String(inArray);
return(true);
}
/// <summary>
/// 对MD5加密后的密文进行签名
/// </summary>
/// <param name="p_strKeyPrivate">私钥</param>
/// <param name="m_strHashbyteSignature">MD5加密后的密文</param>
/// <returns></returns>
public static string SignatureFormatter(string p_strKeyPrivate, string m_strHashbyteSignature)
{
byte[] rgbHash = Convert.FromBase64String(m_strHashbyteSignature);
RSACryptoServiceProvider key = new RSACryptoServiceProvider();
key.FromXmlString(p_strKeyPrivate);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("MD5");
byte[] inArray = formatter.CreateSignature(rgbHash);
return(Convert.ToBase64String(inArray));
}
public string generatesignature(RSAParameters privatekey1)
{
var sha = SHA256.Create(); //SHA256 ile daha sonra RSA ile şifreliyorum
var hashedData = sha.ComputeHash(FileReadWrite.fileData);
var rsa = RSA.Create();
rsa.ImportParameters(privatekey1);
var signer = new RSAPKCS1SignatureFormatter(rsa);
signer.SetHashAlgorithm("SHA256");
return(Convert.ToBase64String(signer.CreateSignature(hashedData)));
}
public byte[] AssinarDados(byte[] hashDeDadosParaAssinar)
{
using (var rsa = new RSACryptoServiceProvider(2048))
{
rsa.PersistKeyInCsp = false;
rsa.ImportParameters(_chavePrivada);
var rsaFormato = new RSAPKCS1SignatureFormatter(rsa);
rsaFormato.SetHashAlgorithm("SHA256");
return(rsaFormato.CreateSignature(hashDeDadosParaAssinar));
}
}
/// <summary>
/// Generate a PKS1 Signature of SHA1 digest
/// </summary>
/// <param name="xParam"></param>
/// <param name="xHash"></param>
/// <returns></returns>
public static byte[] SignatureGenerate(RSAParameters xParam, byte[] xHash)
{
RSACryptoServiceProvider xRSACrypto = new RSACryptoServiceProvider();
RSAPKCS1SignatureFormatter xRSASigFormat = new RSAPKCS1SignatureFormatter();
try { xRSACrypto.ImportParameters(xParam); }
catch (Exception xerror) { throw xerror; }
xRSASigFormat.SetHashAlgorithm("SHA1");
xRSASigFormat.SetKey(xRSACrypto);
try { return(xRSASigFormat.CreateSignature(xHash)); }
catch { throw CryptoExcepts.CryptoSign; }
}
public static byte[] Sign(byte[] data, RSAParameters privateKey)
{
using (var rsa = new RSACryptoServiceProvider(2048))
{
rsa.ImportParameters(privateKey);
var rsaFormatter = new RSAPKCS1SignatureFormatter(rsa);
rsaFormatter.SetHashAlgorithm("SHA256");
return(rsaFormatter.CreateSignature(data));
}
}
public bool SignatureFormatter(string p_strKeyPrivate, string m_strHashbyteSignature, ref byte[] EncryptedSignatureData)
{
byte[] rgbHash = Convert.FromBase64String(m_strHashbyteSignature);
RSACryptoServiceProvider key = new RSACryptoServiceProvider();
key.FromXmlString(p_strKeyPrivate);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("MD5");
EncryptedSignatureData = formatter.CreateSignature(rgbHash);
return(true);
}
/// <summary>
/// Returns the strong name signature
/// </summary>
/// <param name="snk">Strong name key</param>
/// <param name="hashAlg">Hash algorithm</param>
/// <param name="hash">Strong name hash of the .NET PE file</param>
/// <returns>Strong name signature</returns>
private byte[] GetStrongNameSignature(StrongNameKey snk, AssemblyHashAlgorithm hashAlg, byte[] hash)
{
using (var rsa = snk.CreateRSA())
{
var rsaFmt = new RSAPKCS1SignatureFormatter(rsa);
string hashName = hashAlg.GetName() ?? AssemblyHashAlgorithm.SHA1.GetName();
rsaFmt.SetHashAlgorithm(hashName);
var snSig = rsaFmt.CreateSignature(hash);
Array.Reverse(snSig);
return(snSig);
}
}
public static byte[] CreateSignature(byte[] data, RSAParameters rsaParams)
{
RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
provider.ImportParameters(rsaParams);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(provider);
formatter.SetHashAlgorithm("SHA2");
return(provider.SignData(data, "SHA256"));
}
public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
var formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm(_algorithm);
return(formatter);
}
//RSA签名
/// <summary>
/// RSA签名
/// </summary>
/// <param name="hashbyteSignature">签名字节数据</param>
/// <param name="privateKey">私钥</param>
/// <returns>处理结果</returns>
/// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired. </exception>
/// <exception cref="CryptographicUnexpectedOperationException">The key is null.-or- The hash algorithm is null. </exception>
public static byte[] SignatureBytes(this byte[] hashbyteSignature, string privateKey)
{
var rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(privateKey);
var rsaFormatter = new RSAPKCS1SignatureFormatter(rsa);
//设置签名的算法为MD5
rsaFormatter.SetHashAlgorithm("MD5");
//执行签名
return(rsaFormatter.CreateSignature(hashbyteSignature));
}
void a()
{
//加密解密用到的公钥与私钥
RSACryptoServiceProvider oRSA = new RSACryptoServiceProvider();
string privatekey = oRSA.ToXmlString(true);//私钥
string publickey = oRSA.ToXmlString(false);//公钥
//这两个密钥需要保存下来
byte[] messagebytes = Encoding.UTF8.GetBytes("luo罗"); //需要加密的数据
//公钥加密
RSACryptoServiceProvider oRSA1 = new RSACryptoServiceProvider();
oRSA1.FromXmlString(publickey); //加密要用到公钥所以导入公钥
byte[] AOutput = oRSA1.Encrypt(messagebytes, false); //AOutput 加密以后的数据
//私钥解密
RSACryptoServiceProvider oRSA2 = new RSACryptoServiceProvider();
oRSA2.FromXmlString(privatekey);
byte[] AInput = oRSA2.Decrypt(AOutput, false);
string reslut = Encoding.ASCII.GetString(AInput);
// 2、用RSACryptoServiceProvider签名验签
byte[] messagebytes = Encoding.UTF8.GetBytes("luo罗");
RSACryptoServiceProvider oRSA = new RSACryptoServiceProvider();
string privatekey = oRSA.ToXmlString(true);
string publickey = oRSA.ToXmlString(false);
//私钥签名
RSACryptoServiceProvider oRSA3 = new RSACryptoServiceProvider();
oRSA3.FromXmlString(privatekey);
byte[] AOutput = oRSA3.SignData(messagebytes, "SHA1");
//公钥验证
RSACryptoServiceProvider oRSA4 = new RSACryptoServiceProvider();
oRSA4.FromXmlString(publickey);
bool bVerify = oRSA4.VerifyData(messagebytes, "SHA1", AOutput);
// 3、用证书进行签名
//因为一般证书的私钥是不可以导出的所以所以用第2种方法导入私钥的来进行签名行不通
byte[] messagebytes = Encoding.UTF8.GetBytes("luo罗");
string Path = @"D:Certificate1.P12";
X509Certificate2 x509 = new X509Certificate2(Path, "12345678");
SHA1 sha1 = new SHA1CryptoServiceProvider();
byte[] hashbytes = sha1.ComputeHash(messagebytes); //对要签名的数据进行哈希
RSAPKCS1SignatureFormatter signe = new RSAPKCS1SignatureFormatter();
signe.SetKey(x509.PrivateKey); //设置签名用到的私钥
signe.SetHashAlgorithm("SHA1"); //设置签名算法
byte[] reslut = signe.CreateSignature(hashbytes);
//验签：与第2方法相同
RSACryptoServiceProvider oRSA4 = new RSACryptoServiceProvider();
oRSA4.FromXmlString(x509.PublicKey.Key.ToXmlString(false));
bool bVerify = oRSA4.VerifyData(messagebytes, "SHA1", reslut);
}
protected void Page_Load(object sender, EventArgs e)
{
productName = Server.UrlDecode(Request.QueryString["productName"]);
OrderAmountText = decimal.Parse(Server.UrlDecode(Request.QueryString["orderAmount"]));
productDesc = Server.UrlDecode(Request.QueryString["productDesc"]);
orderAmount = Convert.ToInt32(OrderAmountText * 100).ToString();
this.lab_ProductName.Text = productName;
this.lab_OrderAmount.Text = OrderAmountText.ToString();
this.lab_ProductDesc.Text = productDesc;
//拼接字符串
string signMsgVal = "";
signMsgVal = appendParam(signMsgVal, "inputCharset", inputCharset);
signMsgVal = appendParam(signMsgVal, "pageUrl", pageUrl);
signMsgVal = appendParam(signMsgVal, "bgUrl", bgUrl);
signMsgVal = appendParam(signMsgVal, "version", version);
signMsgVal = appendParam(signMsgVal, "language", language);
signMsgVal = appendParam(signMsgVal, "signType", signType);
signMsgVal = appendParam(signMsgVal, "merchantAcctId", merchantAcctId);
signMsgVal = appendParam(signMsgVal, "payerName", payerName);
signMsgVal = appendParam(signMsgVal, "payerContactType", payerContactType);
signMsgVal = appendParam(signMsgVal, "payerContact", payerContact);
signMsgVal = appendParam(signMsgVal, "orderId", orderId);
signMsgVal = appendParam(signMsgVal, "orderAmount", orderAmount);
signMsgVal = appendParam(signMsgVal, "orderTime", orderTime);
signMsgVal = appendParam(signMsgVal, "productName", productName);
signMsgVal = appendParam(signMsgVal, "productNum", productNum);
signMsgVal = appendParam(signMsgVal, "productId", productId);
signMsgVal = appendParam(signMsgVal, "productDesc", productDesc);
signMsgVal = appendParam(signMsgVal, "ext1", ext1);
signMsgVal = appendParam(signMsgVal, "ext2", ext2);
signMsgVal = appendParam(signMsgVal, "payType", payType);
signMsgVal = appendParam(signMsgVal, "redoFlag", redoFlag);
signMsgVal = appendParam(signMsgVal, "pid", pid);
///PKI加密
///编码方式UTF-8 GB2312 用户可以根据自己系统的编码选择对应的加密方式
///byte[] OriginalByte=Encoding.GetEncoding("GB2312").GetBytes(OriginalString);
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(signMsgVal);
X509Certificate2 cert = new X509Certificate2(HttpContext.Current.Server.MapPath("~/99bill/99bill-rsa.pfx"), "fei580lwhui", X509KeyStorageFlags.MachineKeySet);
RSACryptoServiceProvider rsapri = (RSACryptoServiceProvider)cert.PrivateKey;
RSAPKCS1SignatureFormatter f = new RSAPKCS1SignatureFormatter(rsapri);
byte[] result;
f.SetHashAlgorithm("SHA1");
SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
result = sha.ComputeHash(bytes);
signMsg = System.Convert.ToBase64String(f.CreateSignature(result)).ToString();
}
private static byte[] GenerateSignatureRSASHA1(string signatureBase, string privateKey)
{
byte[] dataBuffer = Encoding.ASCII.GetBytes(signatureBase);
using (SHA1CryptoServiceProvider sha1 = GenerateSha1Hash(dataBuffer))
using (AsymmetricAlgorithm algorithm = new RSACryptoServiceProvider())
{
algorithm.FromXmlString(privateKey);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(algorithm);
formatter.SetHashAlgorithm("MD5");
return(formatter.CreateSignature(sha1));
}
}
public void CreateSignatureHashMD5()
{
fmt = new RSAPKCS1SignatureFormatter();
byte[] data = new byte [16];
// we need the private key
fmt.SetKey(rsa);
// good MD5
HashAlgorithm hash = MD5.Create();
hash.ComputeHash(data);
byte[] signature = fmt.CreateSignature(hash);
AssertNotNull("CreateSignature(MD5)", signature);
}
/// <summary>
/// Calculate the signature of <paramref name="data"/>
/// </summary>
/// <param name="data">The data to sign</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns>The signature</returns>
public string CalculateSignature(byte[] data, string consumerSecret, string tokenSecret)
{
var signatureFormatter = new RSAPKCS1SignatureFormatter(_privateKey);
signatureFormatter.SetHashAlgorithm("SHA1");
using (var hasher = HashAlgorithm.Create("SHA1"))
{
Debug.Assert(hasher != null, "hasher != null");
var hash = hasher.ComputeHash(data);
var signature = signatureFormatter.CreateSignature(hash);
return(Convert.ToBase64String(signature));
}
}
public static byte[] SignData(RSAParameters rsaParams, byte[] Data)
{
byte[] rgbHash = SHA1(Data);
RSACryptoServiceProvider key = new RSACryptoServiceProvider();
key.ImportParameters(rsaParams);
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("SHA1");
byte[] array = formatter.CreateSignature(rgbHash);
Array.Reverse(array);
return(array);
}
/// <summary>
/// Creates a counter signature, just like
/// <c>sn -a IdentityPubKey.snk IdentityKey.snk SignaturePubKey.snk</c> can do.
/// The public key <c>sn</c> prints is <paramref name="signaturePubKey"/>'s value.
/// </summary>
/// <param name="identityPubKey">Identity public key</param>
/// <param name="identityKey">Identity strong name key pair</param>
/// <param name="signaturePubKey">Signature public key</param>
/// <returns>The counter signature</returns>
public static byte[] CreateCounterSignature(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey)
{
var hash = AssemblyHash.Hash(signaturePubKey.CreatePublicKey(), identityPubKey.HashAlgorithm);
using (var rsa = identityKey.CreateRSA()) {
var rsaFmt = new RSAPKCS1SignatureFormatter(rsa);
string hashName = identityPubKey.HashAlgorithm.GetName();
rsaFmt.SetHashAlgorithm(hashName);
var snSig = rsaFmt.CreateSignature(hash);
Array.Reverse(snSig);
return(snSig);
}
}
public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
{
if (key == null)
{
throw new Exception("Invalid key specified for RSAPKCS1SHA256SignatureDescription!");
}
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("SHA256");
return(formatter);
}
/// <inheritdoc />
public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
key = GetSha2CompatibleKey(key);
var formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("SHA256");
return(formatter);
}
public static void VerifySignature_SHA256()
{
using (RSA rsa = RSAFactory.Create())
{
var formatter = new RSAPKCS1SignatureFormatter(rsa);
var deformatter = new RSAPKCS1SignatureDeformatter(rsa);
using (SHA256 alg = SHA256.Create())
{
VerifySignature(formatter, deformatter, alg, "SHA256");
VerifySignature(formatter, deformatter, alg, "sha256");
}
}
}
public static void InvalidHashAlgorithm()
{
using (RSA rsa = RSAFactory.Create())
{
var formatter = new RSAPKCS1SignatureFormatter(rsa);
var deformatter = new RSAPKCS1SignatureDeformatter(rsa);
// Exception is deferred until VerifySignature
formatter.SetHashAlgorithm("INVALIDVALUE");
deformatter.SetHashAlgorithm("INVALIDVALUE");
using (SHA1 alg = SHA1.Create())
{
Assert.Throws<CryptographicUnexpectedOperationException>(() =>
VerifySignature(formatter, deformatter, alg, "INVALIDVALUE"));
}
}
}
/// <summary>
/// Generate a PKS1 Signature of SHA1 digest
/// </summary>
/// <param name="xParam"></param>
/// <param name="xHash"></param>
/// <returns></returns>
public static byte[] SignatureGenerate(RSAParameters xParam, byte[] xHash)
{
RSACryptoServiceProvider xRSACrypto = new RSACryptoServiceProvider();
RSAPKCS1SignatureFormatter xRSASigFormat = new RSAPKCS1SignatureFormatter();
try { xRSACrypto.ImportParameters(xParam); }
catch (Exception xerror) { throw xerror; }
xRSASigFormat.SetHashAlgorithm("SHA1");
xRSASigFormat.SetKey(xRSACrypto);
try { return xRSASigFormat.CreateSignature(xHash); }
catch { throw CryptoExcepts.CryptoSign; }
}
public override AsymmetricSignatureFormatter CreateFormatter(AsymmetricAlgorithm key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
formatter.SetHashAlgorithm("SHA256");
return formatter;
}
public MerchantApiKeyAuth(string merchantId, string userId, RSA privateKey)
{
this.merchantId = merchantId;
this.userId = userId;
signer = new RSAPKCS1SignatureFormatter(privateKey);
}
