public RSAKEY GetKey(string s1, string s2)
{
//获取公钥和密钥
AsymmetricKeyParameter publicKey = GetPublicKeyParameter(s1);
AsymmetricKeyParameter privateKey = GetPrivateKeyParameter(s2);
SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
byte[] publicInfoByte = asn1ObjectPublic.GetEncoded("UTF-8");
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded("UTF-8");
RSAKEY item = new RSAKEY()
{
PublicKey = Convert.ToBase64String(publicInfoByte),
PrivateKey = Convert.ToBase64String(privateInfoByte)
};
return(item);
}
public static string RSAPrivateKeyDotNet2Java(string privateKey)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(privateKey);
BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
return(Convert.ToBase64String(serializedPrivateBytes));
}
public virtual void WritePem(PrivateKeyInfo privateKeyInfo, string filename = "id_econfig.pem")
{
using (var writer = new StreamWriter(filename))
{
new PemWriter(writer).WriteObject(new PemObject("RSA PRIVATE KEY", privateKeyInfo.ToAsn1Object().GetDerEncoded()));
}
}
/// <summary>
/// 获取RSA私钥
/// </summary>
/// <param name="p12CertData">P12/PFX证书</param>
/// <param name="certPwdData">证书密码</param>
/// <returns></returns>
public static byte[] GetPrivateKeyFromPcks12(byte[] p12CertData, char[] certPwdData)
{
var privateKeyParam = GetFromPcks12(p12CertData, certPwdData, (store, keyAlias) => store.GetKey(keyAlias).Key);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
return(privateKeyInfo.ToAsn1Object().GetEncoded());
}
public key GetKey()
{
RsaKeyPairGenerator keyPairGenerator = new RsaKeyPairGenerator();
RsaKeyGenerationParameters param = new RsaKeyGenerationParameters(BigInteger.ValueOf(3), new SecureRandom(), 1024, 25);
keyPairGenerator.Init(param);
AsymmetricCipherKeyPair keyPair = keyPairGenerator.GenerateKeyPair();
AsymmetricKeyParameter publicKey = keyPair.Public;
AsymmetricKeyParameter privateKey = keyPair.Private;
SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
byte[] publicInfoByte = asn1ObjectPublic.GetEncoded("UTF-8");
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded("UTF-8");
return(new key()
{
publicKey = Convert.ToBase64String(publicInfoByte),
privateKey = Convert.ToBase64String(privateInfoByte)
});
}
public static RSAKEY GenerateRSAKey()
{
//RSA密钥对的构造器
RsaKeyPairGenerator keyGenerator = new RsaKeyPairGenerator();
//RSA密钥构造器的参数
RsaKeyGenerationParameters param = new RsaKeyGenerationParameters(
Org.BouncyCastle.Math.BigInteger.ValueOf(0x3),
new Org.BouncyCastle.Security.SecureRandom(),
1024, //密钥长度
25);
//用参数初始化密钥构造器
keyGenerator.Init(new KeyGenerationParameters(new SecureRandom(), 1024));
//产生密钥对
AsymmetricCipherKeyPair keyPair = keyGenerator.GenerateKeyPair();
//获取公钥和密钥
AsymmetricKeyParameter publicKey = keyPair.Public;
AsymmetricKeyParameter privateKey = keyPair.Private;
SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
byte[] publicInfoByte = asn1ObjectPublic.GetEncoded("UTF-8");
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded("UTF-8");
RSAKEY item = new RSAKEY()
{
PublicKey = Convert.ToBase64String(publicInfoByte),
PrivateKey = Convert.ToBase64String(privateInfoByte)
};
return(item);
}
private static byte[] CreatePfxFile(Org.BouncyCastle.X509.X509Certificate certificate, AsymmetricKeyParameter privateKey, string password = null)
{
// create certificate entry
var certEntry = new X509CertificateEntry(certificate);
string friendlyName = certificate.SubjectDN.ToString();
// get bytes of private key.
PrivateKeyInfo keyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
byte[] keyBytes = keyInfo.ToAsn1Object().GetEncoded();
var builder = new Pkcs12StoreBuilder();
builder.SetUseDerEncoding(true);
var store = builder.Build();
// create store entry
store.SetKeyEntry("", new AsymmetricKeyEntry(privateKey), new X509CertificateEntry[] { certEntry });
byte[] pfxBytes = null;
using (MemoryStream stream = new MemoryStream())
{
store.Save(stream, password?.ToCharArray(), new SecureRandom());
pfxBytes = stream.ToArray();
}
var result = Pkcs12Utilities.ConvertToDefiniteLength(pfxBytes);
return(result);
}
/// <summary>
/// RSA私钥格式转换 .net->Java
/// </summary>
/// <param name="privateKey">.net生成的私钥</param>
/// <returns>JAVA用的私钥</returns>
public static string ConvertRSAPrivateKey_DotNet2Java(string strPrivateDotnetRSAKey)
{
try
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(strPrivateDotnetRSAKey);
BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
return(Convert.ToBase64String(serializedPrivateBytes));
}
catch (Exception e)
{
Console.WriteLine($"[Error] Convert RSA private key (DotNet to Java) failed. Error = {e.ToString()}");
return(string.Empty);
}
}
/// <summary>
/// 加载Pkcs1格式的私钥
/// </summary>
/// <param name="privateKey"></param>
/// <returns></returns>
public static AsymmetricKeyParameter loadPrivateKeyPk1(string privateKey)
{
AsymmetricCipherKeyPair keyPair = null;
try
{
keyPair = ReadPem(privateKey); // 直接读取字符串生成密码钥
}
catch (Exception)
{
throw new Exception("密钥格式不正确");
}
try
{
AsymmetricKeyParameter private_key = keyPair.Private;
// 前面私钥为pkcs1格式，经过下面处理后，变成pkcs8格式
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(private_key);
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(asn1ObjectPrivate));
return(priKey);
}
catch (Exception)
{
throw new Exception("加载失败");
}
}
public static void GenKey(out string publicKey, out string privateKey, out string privateKeyPk8)
{
publicKey = string.Empty;
privateKey = string.Empty;
privateKeyPk8 = string.Empty;
try
{
//RSA密钥对的构造器
RsaKeyPairGenerator r = new RsaKeyPairGenerator();
//RSA密钥构造器的参数
RsaKeyGenerationParameters param = new RsaKeyGenerationParameters(
Org.BouncyCastle.Math.BigInteger.ValueOf(3),
new SecureRandom(),
1024, //密钥长度
25);
r.Init(param);
AsymmetricCipherKeyPair keyPair = r.GenerateKeyPair();
//获取公钥和密钥
AsymmetricKeyParameter private_key = keyPair.Private;
AsymmetricKeyParameter public_key = keyPair.Public;
if (((RsaKeyParameters)public_key).Modulus.BitLength < 1024)
{
Console.WriteLine("failed key generation (1024) length test");
}
using (TextWriter textWriter = new StringWriter())
{
PemWriter pemWriter = new PemWriter(textWriter);
pemWriter.WriteObject(keyPair.Private);
pemWriter.Writer.Flush();
privateKey = textWriter.ToString();
}
using (TextWriter textpubWriter = new StringWriter())
{
PemWriter pempubWriter = new PemWriter(textpubWriter);
pempubWriter.WriteObject(keyPair.Public);
pempubWriter.Writer.Flush();
publicKey = textpubWriter.ToString();
}
//keyPair = ReadPem(privateKey); // 直接读取字符串生成密码钥
//public_key = keyPair.Public;//公钥
//private_key = keyPair.Private;//私钥
// 前面私钥为pkcs1格式，经过下面处理后，变成pkcs8格式
SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(public_key);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(private_key);
Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
byte[] publicInfoByte = asn1ObjectPublic.GetEncoded();
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded();
var pubkeyb64 = Convert.ToBase64String(publicInfoByte);
// 这里生成的是Pkcs8的密钥
privateKeyPk8 = PrivateKeyPk8Format(Convert.ToBase64String(privateInfoByte));
privateKey = PrivateKeyFormat(privateKey);
publicKey = PublicKeyFormat(publicKey);
}
catch (Exception ex) {
throw ex;
}
}
/// <summary>
/// 将Pkcs1格式的私转成Pkcs8格式
/// </summary>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string ConvertPriPk1ToPk8(string privateKey)
{
AsymmetricCipherKeyPair keyPair = null;
try
{
keyPair = ReadPem(privateKey); // 直接读取字符串生成密码钥
}
catch (Exception)
{
throw new Exception("密钥格式不正确");
}
try
{
AsymmetricKeyParameter private_key = keyPair.Private;
AsymmetricKeyParameter public_key = keyPair.Public;
// 前面私钥为pkcs1格式，经过下面处理后，变成pkcs8格式
SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(public_key);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(private_key);
Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
byte[] publicInfoByte = asn1ObjectPublic.GetEncoded();
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded();
var pubkeyb64 = Convert.ToBase64String(publicInfoByte);
// 这里生成的是Pkcs8的密钥
return(PrivateKeyFormat(Convert.ToBase64String(privateInfoByte)));
}
catch (Exception)
{
throw new Exception("转换失败");
}
}
public static string RsaSign(string content)
{
content = HMACSHA1Encode(content);
var signer = SignerUtilities.GetSigner("SHA1withRSA");
var stringReader = new StringReader(_privateKeyString);
var pemReader = new PemReader(stringReader, new PasswordFinder("trdfdsfsd@12311".ToCharArray()));
var keyPair = (AsymmetricCipherKeyPair)pemReader.ReadObject();
AsymmetricKeyParameter publicKey = keyPair.Public;
AsymmetricKeyParameter privateKey = keyPair.Private;
SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
byte[] publicInfoByte = asn1ObjectPublic.GetEncoded();
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded();
var privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(privateInfoByte);
signer.Init(true, privateKeyParam);
var plainBytes = Encoding.UTF8.GetBytes(content);
signer.BlockUpdate(plainBytes, 0, plainBytes.Length);
var signBytes = signer.GenerateSignature();
return(ByteToHexStr(signBytes));
}
public static string RSAPrivateKeyDotNet2Java(string privateKey, string keyFileName)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(privateKey);
BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
if (!string.IsNullOrEmpty(keyFileName))
{
using (StreamWriter writer = new StreamWriter(string.Format("{0}.txt", keyFileName)))
{
writer.Write(Convert.ToBase64String(serializedPrivateBytes));
}
}
return(Convert.ToBase64String(serializedPrivateBytes));
}
public static byte[] GetSerializedPrivateKey(AsymmetricKeyParameter keyPair)
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded();
return(serializedPrivateBytes);
}
public static Models.KeyPair GenerateKeyPair()
{
RsaKeyPairGenerator _RSAKeyPairGnr = new RsaKeyPairGenerator();
_RSAKeyPairGnr.Init(new KeyGenerationParameters(new SecureRandom(), 2048));
AsymmetricCipherKeyPair _KeyPair = _RSAKeyPairGnr.GenerateKeyPair();
PrivateKeyInfo _PrivateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(_KeyPair.Private);
Byte[] _SerializedPrivateBytes = _PrivateKeyInfo.ToAsn1Object().GetDerEncoded();
String _SerializedPrivate = Convert.ToBase64String(_SerializedPrivateBytes);
SubjectPublicKeyInfo _PublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(_KeyPair.Public);
Byte[] _SerializedPublicBytes = _PublicKeyInfo.ToAsn1Object().GetDerEncoded();
String _SerializedPublic = Convert.ToBase64String(_SerializedPublicBytes);
if (Db.DbContextManager._Db.Accounts.Any(x => x.PublicKey == _SerializedPublic))
{
return(GenerateKeyPair());
}
Models.KeyPair _KP = new Models.KeyPair
{
PriveteKey = _SerializedPrivate,
PublicKey = _SerializedPublic
};
return(_KP);
}
public static string GetPrivateKeyBase64(AsymmetricKeyParameter key)
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(key);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded();
return(Convert.ToBase64String(serializedPrivateBytes));
}
/// <summary>
/// 从 .Net RSA 算法私钥参数转换为 Java 格式的 RSA 私钥
/// </summary>
/// <param name="privateKey">.Net生成的私钥参数</param>
/// <returns></returns>
public static string ToJavaPrivateKey(this RSAParameters privateKey)
{
AsymmetricCipherKeyPair keyPair = DotNetUtilities.GetRsaKeyPair(privateKey);
PrivateKeyInfo info = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);
byte[] bytes = info.ToAsn1Object().GetEncoded();
return(ToBase64(bytes));
}
internal static byte[] ToBytes(this RsaKeyParameters pubKey)
{
RsaPublicKeyStructure keyStruct = new RsaPublicKeyStructure(
pubKey.Modulus,
pubKey.Exponent);
var privInfo = new PrivateKeyInfo(AlgID, keyStruct.ToAsn1Object());
return(privInfo.ToAsn1Object().GetEncoded());
}
public static string SerializePrivateKey(this AsymmetricKeyParameter privateKey, bool encodeInHex = encodeInHexValue)
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded();
string serializedPrivate = encodeInHex ? serializedPrivateBytes.ToHex() : Convert.ToBase64String(serializedPrivateBytes);
return(serializedPrivate);
}
public byte[] ToBytes()
{
RsaPublicKeyStructure keyStruct = new RsaPublicKeyStructure(
_Key.Modulus,
_Key.Exponent);
var privInfo = new PrivateKeyInfo(RsaKey.algID, keyStruct.ToAsn1Object());
return(privInfo.ToAsn1Object().GetEncoded());
}
public static string GetSerializedPrivateKey(RsaKeyParameters privateKey)
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded();
string serializedPrivate = Convert.ToBase64String(serializedPrivateBytes);
return(serializedPrivate);
}
/// <summary>
/// Genera el archivo pfx y devuelve el resultado con su contraseña
/// </summary>
/// <param name="rutaArchivoCer"></param>
/// <param name="rutaArchivoKey"></param>
/// <param name="secretArchivoKey"></param>
/// <param name="rutaGuardado"></param>
/// <param name="nombreArchivoPfx"></param>
/// <param name="secretArchivoPfx"></param>
/// <param name="conservarArchivo"></param>
/// <returns>Pfx</returns>
public static CfdiPfx generarArchivoPfx(string rutaArchivoCer, string rutaArchivoKey, string secretArchivoKey, string rutaGuardado, string nombreArchivoPfx, string secretArchivoPfx, Boolean conservarArchivo)
{
try
{
string rutaArchivoPfx = Path.Combine(rutaGuardado, nombreArchivoPfx);
if (!Directory.Exists(rutaGuardado))
{
Directory.CreateDirectory(rutaGuardado);
}
if (File.Exists(rutaArchivoPfx))
{
File.Delete(rutaArchivoPfx);
}
X509Certificate2 certificado = new X509Certificate2(rutaArchivoCer);
Org.BouncyCastle.X509.X509Certificate certificate = DotNetUtilities.FromX509Certificate(certificado);
byte[] bytesArchivoKey = File.ReadAllBytes(rutaArchivoKey);
AsymmetricKeyParameter privateKey = PrivateKeyFactory.DecryptKey(secretArchivoKey.ToCharArray(), bytesArchivoKey);
var certEntry = new X509CertificateEntry(certificate);
string friendlyName = certificate.SubjectDN.ToString();
PrivateKeyInfo keyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
byte[] keyBytes = keyInfo.ToAsn1Object().GetEncoded();
var builder = new Pkcs12StoreBuilder();
builder.SetUseDerEncoding(true);
var store = builder.Build();
store.SetKeyEntry("PrivateKeyAlias", new AsymmetricKeyEntry(privateKey), new X509CertificateEntry[] { certEntry });
byte[] pfxBytes = null;
using (MemoryStream stream = new MemoryStream())
{
store.Save(stream, secretArchivoPfx.ToCharArray(), new SecureRandom());
pfxBytes = stream.ToArray(); // Este sirve para la cancelacion
}
var result = Pkcs12Utilities.ConvertToDefiniteLength(pfxBytes);
if (conservarArchivo)
{
File.WriteAllBytes(rutaArchivoPfx, result);
}
return(new CfdiPfx(result, secretArchivoPfx));
}
catch (Exception ex)
{
throw ex;
}
}
public DecFormatter()
{
SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/octet-stream"));
// 載入私鑰.
AsymmetricCipherKeyPair keyPair = ReadPem(this.pri_key);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(keyPair.Private);
Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
this.priKey = PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(asn1ObjectPrivate));
}
protected byte[] GetPrivateKey(AsymmetricKeyParameter key)
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(key);
byte[] privateKeyContent = privateKeyInfo
.ToAsn1Object()
.GetDerEncoded();
return(privateKeyContent);
}
/// <summary>
/// Converts the 32 byte private key to a 25 word mnemonic, including a checksum.
/// Refer to the mnemonic package for additional documentation.
/// </summary>
/// <returns>return string a 25 word mnemonic</returns>
public string ToMnemonic()
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(this.privateKeyPair.Private);
byte[] X509enc = privateKeyInfo.ToAsn1Object().GetEncoded();
PrivateKeyInfo pkinfo = PrivateKeyInfo.GetInstance(X509enc);
var keyOcts = pkinfo.ParsePrivateKey();
byte[] res = Asn1OctetString.GetInstance(keyOcts).GetOctets();
return(Mnemonic.FromKey(res));
}
public static (string pub, string priv) SerializeKeyPair(this AsymmetricCipherKeyPair pair, bool encodeInHex = encodeInHexValue)
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(pair.Private);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded();
string serializedPrivate = encodeInHex ? serializedPrivateBytes.ToHex() : Convert.ToBase64String(serializedPrivateBytes);
SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pair.Public);
byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
string serializedPublic = encodeInHex ? serializedPublicBytes.ToHex() : Convert.ToBase64String(serializedPublicBytes);
return(serializedPublic, serializedPrivate);
}
/// <summary>
/// eth Sign
/// </summary>
/// <param name="macdata"></param>
/// <param name="ecdsaPrivateKey"></param>
/// <returns>r,s,v</returns>
public static Tuple <byte[], byte[], byte[]> Sign(byte[] macdata, ECPrivateKeyParameters ecdsaPrivateKey)
{
MessageSigner signer = new MessageSigner();
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(ecdsaPrivateKey);
PemObject pemObj = new PemObject("PRIVATE KEY", privateKeyInfo.ToAsn1Object().GetEncoded());
StringWriter strPri = new StringWriter();
Org.BouncyCastle.Utilities.IO.Pem.PemWriter pemW = new Org.BouncyCastle.Utilities.IO.Pem.PemWriter(strPri);
pemW.WriteObject(pemObj);
var signData = signer.SignAndCalculateV(macdata, ConvertPrikToHexString(strPri.ToString()));
return(new Tuple <byte[], byte[], byte[]>(signData.R, signData.S, signData.V));
}
/// <summary>
/// save private key
/// </summary>
/// <param name="privateKey">private key</param>
/// <param name="pkUrl">key file</param>
public static void SavePriKey(AsymmetricKeyParameter privateKey, string pkUrl)
{
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
PemObject pemObj = new PemObject("PRIVATE KEY", privateKeyInfo.ToAsn1Object().GetEncoded());
StringWriter strPri = new StringWriter();
Org.BouncyCastle.Utilities.IO.Pem.PemWriter pemW = new Org.BouncyCastle.Utilities.IO.Pem.PemWriter(strPri);
pemW.WriteObject(pemObj);
byte[] priInfoByte = System.Text.Encoding.UTF8.GetBytes(strPri.ToString());
FileStream fs = new FileStream(pkUrl, FileMode.Create, FileAccess.Write);
fs.Write(priInfoByte, 0, priInfoByte.Length);
fs.Close();
}
/// <summary>
/// Returns a byte array containing the private key in PEM format.
/// </summary>
public static byte[] ExportPrivateKeyAsPEM(
X509Certificate2 certificate
)
{
RsaPrivateCrtKeyParameters privateKeyParameter = X509Utils.GetPrivateKeyParameter(certificate);
using (TextWriter textWriter = new StringWriter())
{
// write private key as PKCS#8
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParameter);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded();
return(EncodeAsPEM(serializedPrivateBytes, "PRIVATE KEY"));
}
}
public static void RSA_GeneratePEMKey()
{
if (RSA != null)
{
return;
}
RsaKeyPairGenerator g = new RsaKeyPairGenerator();
g.Init(new KeyGenerationParameters(new SecureRandom(), 1024));
var pair = g.GenerateKeyPair();
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(pair.Private);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded();
/////PEM秘钥
PemPrivateKey = Convert.ToBase64String(serializedPrivateBytes);
SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pair.Public);
byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
//PEM公钥
PemPublicKey = Convert.ToBase64String(serializedPublicBytes);
RsaPrivateCrtKeyParameters privateKey = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(PemPrivateKey));
RsaKeyParameters publicKey = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(PemPublicKey));
RSACryptoServiceProvider rcsp = new RSACryptoServiceProvider();
RSAParameters parms = new RSAParameters();
//So the thing changed is offcourse the ToByteArrayUnsigned() instead of
//ToByteArray()
parms.Modulus = privateKey.Modulus.ToByteArrayUnsigned();
parms.P = privateKey.P.ToByteArrayUnsigned();
parms.Q = privateKey.Q.ToByteArrayUnsigned();
parms.DP = privateKey.DP.ToByteArrayUnsigned();
parms.DQ = privateKey.DQ.ToByteArrayUnsigned();
parms.InverseQ = privateKey.QInv.ToByteArrayUnsigned();
parms.D = privateKey.Exponent.ToByteArrayUnsigned();
parms.Exponent = privateKey.PublicExponent.ToByteArrayUnsigned();
//So now this now appears to work.
rcsp.ImportParameters(parms);
RSA = rcsp;
//string privateKeyXmlText = rcsp.ToXmlString(true);//XML秘钥
//string publicKeyXmlText = rcsp.ToXmlString(false);//XML公钥
//加密解密
//string texta1 = "abc", texta2 = "", textb1 = "";
//byte[] cipherbytes;
//cipherbytes = rcsp.Encrypt(Encoding.UTF8.GetBytes(texta1), false);
//texta2 = Convert.ToBase64String(cipherbytes);
//cipherbytes = rcsp.Decrypt(Convert.FromBase64String(texta2), false);
//textb1 = Encoding.UTF8.GetString(cipherbytes);
}
