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); }
/// <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 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 byte[] GetPublicKey() { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(this.keyPair.Public); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return(serializedPublicBytes); }
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); }
internal static byte[] GetPublicKeyInBytes(AsymmetricKeyParameter publicKey) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey); return(publicKeyInfo.ToAsn1Object().GetDerEncoded()); }
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 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 byte[] GetSerializedPublicKey(AsymmetricKeyParameter keyPair) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return(serializedPublicBytes); }
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; } }
public static string GetPublicKeyBase64(AsymmetricKeyParameter key) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(key); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return(Convert.ToBase64String(serializedPublicBytes)); }
public static byte[] EncodeKeyParameter(AsymmetricKeyParameter key) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory .CreateSubjectPublicKeyInfo(key); return(publicKeyInfo.ToAsn1Object().GetDerEncoded()); }
public byte [] GenerateEncodedPublicKeyInfo() { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory .CreateSubjectPublicKeyInfo(GetPublicKeyParameter()); return(publicKeyInfo.ToAsn1Object().GetDerEncoded()); }
/// <summary> /// 从 .Net RSA 算法公钥参数转换为 Java 格式的 RSA 公钥 /// </summary> /// <param name="publicKey">.Net生成的公钥参数</param> /// <returns></returns> public static string ToJavaPublicKey(this RSAParameters publicKey) { RsaKeyParameters para = DotNetUtilities.GetRsaPublicKey(publicKey); SubjectPublicKeyInfo info = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(para); byte[] bytes = info.ToAsn1Object().GetDerEncoded(); return(ToBase64(bytes)); }
/// <summary> /// 获取一个密钥对,其中私钥是DES加密后的 /// </summary> /// <param name="userPassword"></param> /// <returns></returns> public static bool CreateRSAKeypair(string pwd, ref KeyPair resultKeypair) { _error = ""; try { resultKeypair = new KeyPair { publicKey = "", privateKey = "" }; //RSA密钥对的构造器 RsaKeyPairGenerator keyGenerator = new RsaKeyPairGenerator(); //RSA密钥构造器的参数 RsaKeyGenerationParameters param = new RsaKeyGenerationParameters( Org.BouncyCastle.Math.BigInteger.ValueOf(3), new Org.BouncyCastle.Security.SecureRandom(), 1024, //密钥长度 25); //用参数初始化密钥构造器 keyGenerator.Init(param); //产生密钥对 AsymmetricCipherKeyPair keyPair = keyGenerator.GenerateKeyPair(); if (((RsaKeyParameters)keyPair.Public).Modulus.BitLength < 1024) { _error = "密钥生成失败,长度不足1024字节。"; return(false); } //获取公钥和密钥 SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public); Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object(); byte[] pbkByte = asn1ObjectPublic.GetEncoded(); resultKeypair.publicKey = Convert.ToBase64String(pbkByte); string alg = "1.2.840.113549.1.12.1.3"; // 3 key triple DES with SHA-1 byte[] salt = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int count = 1000; char[] password = pwd.ToCharArray(); EncryptedPrivateKeyInfo enPrivateKeyInfo = EncryptedPrivateKeyInfoFactory.CreateEncryptedPrivateKeyInfo( alg, password, salt, count, keyPair.Private); byte[] prkByte = enPrivateKeyInfo.ToAsn1Object().GetEncoded(); resultKeypair.privateKey = Convert.ToBase64String(prkByte); return(true); } catch (Exception ex) { _error = ex.Message; return(false); } }
public static string PrintPublicKey(AsymmetricCipherKeyPair keys) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keys.Public); byte[] serializedBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); string serialized = Convert.ToBase64String(serializedBytes); return("Key==>" + serialized); }
public static string SavePublicKey(AsymmetricKeyParameter publicKey) { //保存公钥到文件 SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey); Asn1Object aobject = publicKeyInfo.ToAsn1Object(); byte[] pubInfoByte = aobject.GetEncoded(); return(Convert.ToBase64String(pubInfoByte)); }
public static string SerializePublicKey(this AsymmetricKeyParameter publicKey, bool encodeInHex = encodeInHexValue) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); string serializedPublic = encodeInHex ? serializedPublicBytes.ToHex() : Convert.ToBase64String(serializedPublicBytes); return(serializedPublic); }
public static string GetSerializedPublicKey(RsaKeyParameters publicKey) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); string serializedPublic = Convert.ToBase64String(serializedPublicBytes); return(serializedPublic); }
public string getRSAPublicKey() { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(rsaKeyPair.Public); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); string serializedPublic = Convert.ToBase64String(serializedPublicBytes); return(serializedPublic); }
protected byte[] GetPublicKey(AsymmetricKeyParameter key) { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(key); byte[] publicKeyContent = publicKeyInfo .ToAsn1Object() .GetDerEncoded(); return(publicKeyContent); }
/// <summary> /// Get the public key fingerprint(hash) of an Aysmmetric Cipher Key Pair /// </summary> /// <param name="keyPair">Key pair to fingerprint</param> /// <returns>MD5 Hash of the given keypair</returns> public static string GetPublicKeyFingerprint(AsymmetricCipherKeyPair keyPair) { if (keyPair == null) { throw new ArgumentNullException(KEYPAIR_NULL); } SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public); byte[] serializedPublicKey = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return(ComputeHash(serializedPublicKey)); }
/// <summary> /// RSA公钥格式转换,.net->java /// </summary> /// <param name="publicKey">.net生成的公钥</param> /// <returns></returns> public static string RSAPublicKeyDotNet2Java(string publicKey) { XmlDocument doc = new XmlDocument(); doc.LoadXml(publicKey); BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText)); BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText)); RsaKeyParameters pub = new RsaKeyParameters(false, m, p); SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return(Convert.ToBase64String(serializedPublicBytes)); }
public byte[] GetPublicKey() { SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey); Console.WriteLine("Public Key -> exported as ASN1.DER Encoded"); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); Console.WriteLine("Public Key: -> \n" + Utils.HexDump(serializedPublicBytes)); Console.WriteLine("Public Key -> pad bits = " + publicKeyInfo.PublicKeyData.PadBits); Console.WriteLine("Public Key -> Exponent = " + publicKey.Exponent.ToString()); //return BitConverter.ToString(serializedPublicBytes).Replace("-", string.Empty); return(serializedPublicBytes); }
private void GenerateKey(string fileName) { string fileNamePublic = fileName + ".pub"; if (File.Exists(fileNamePublic) && ShowMessageBox("Overwrite", "File " + fileNamePublic + " already exists. Overwrite?", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No) { return; } RsaKeyPairGenerator g = new RsaKeyPairGenerator(); g.Init(new KeyGenerationParameters(new SecureRandom(), Convert.ToInt32(cbKeyLength.Text, 10))); AsymmetricCipherKeyPair pair = g.GenerateKeyPair(); //PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(pair.Private); //byte [] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetDerEncoded(); SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pair.Public); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); //Save private key to filename try { using (StreamWriter file = new StreamWriter(fileName)) { PemWriter pWrt = new PemWriter(file); pWrt.WriteObject(pair); pWrt.Writer.Close(); } //Save public key to filename using (StreamWriter file = new StreamWriter(fileNamePublic)) { PemWriter pWrt = new PemWriter(file); pWrt.WriteObject(pair.Public); pWrt.Writer.Close(); } } catch (Exception ex) { ShowMessageBox("Key file error.", "Couldn't save key pair:\n" + ex.Message, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } UpdateSuggestedDns(Convert.ToBase64String(serializedPublicBytes)); SetDomainKeyPath(fileName); }
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); }
//XML 公鑰轉換為 PEM 公鑰 public static string publicKeyXml2Pem(string publicXmlKeyString) { XmlDocument doc = new XmlDocument(); doc.LoadXml(publicXmlKeyString); BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText)); BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText)); RsaKeyParameters pub = new RsaKeyParameters(false, m, p); SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return("-----BEGIN PUBLIC KEY-----\n" + Convert.ToBase64String(serializedPublicBytes) + "\n-----END PUBLIC KEY-----"); }
/// <summary> /// RSA 公钥格式转换,.net => java /// </summary> /// <param name="publicKey">.net生成的公钥</param> /// <returns></returns> public static string RsaPublicKeyDotNet2Java(this string publicKey) { XmlDocument doc = new XmlDocument(); doc.LoadXml(publicKey); BigInteger modulus = doc.GetBigInteger("Modulus"); BigInteger publicExponent = doc.GetBigInteger("Exponent"); RsaKeyParameters publicKeyParam = new RsaKeyParameters(false, modulus, publicExponent); SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKeyParam); byte[] serializePublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return(Convert.ToBase64String(serializePublicBytes)); }
/// <summary> /// 把XML格式的秘钥转为Java格式 /// </summary> /// <param name="XML">XML秘钥</param> /// <returns>Java秘钥</returns> private static string PublicKeyToJavaFormat(string XML) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(XML); BigInteger m = new BigInteger(1, Convert.FromBase64String(xmlDocument.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText)); BigInteger p = new BigInteger(1, Convert.FromBase64String(xmlDocument.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText)); RsaKeyParameters pub = new RsaKeyParameters(false, m, p); SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub); byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded(); return(Convert.ToBase64String(serializedPublicBytes)); }
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); }