/// <summary> /// RSA私钥格式转换,pem->xml /// </summary> /// <param name="pemPrivateKey">pem格式的RSA私钥</param> /// <returns>xml格式的RSA私钥</returns> public static string XmlPrivateKeyByPem(string pemPrivateKey) { byte[] bytes = Convert.FromBase64String(pemPrivateKey); var privateKeyParam = PrivateKeyFactory.CreateKey(bytes) as RsaPrivateCrtKeyParameters; string modulus = Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()); string exponent = Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()); string p = Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()); string q = Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()); string dp = Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()); string dq = Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()); string qinv = Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()); string d = Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()); string pemKey = string.Format(@"<RSAKeyValue> <Modulus>{0}</Modulus> <Exponent>{1}</Exponent> <P>{2}</P> <Q>{3}</Q> <DP>{4}</DP> <DQ>{5}</DQ> <InverseQ>{6}</InverseQ> <D>{7}</D> </RSAKeyValue>", modulus, exponent, p, q, dp, dq, qinv, d); return(pemKey); }
/// <summary> /// 基于BouncyCastle的RSA签名 /// </summary> /// <param name="data"></param> /// <param name="privateKeyJava"></param> /// <param name="hashAlgorithm">JAVA的和.NET的不一样,如:MD5(.NET)等同于MD5withRSA(JAVA)</param> /// <param name="encoding"></param> /// <returns></returns> public static string RSASignJavaBouncyCastle(string data, string privateKeyJava, string hashAlgorithm = "PSSwithRSA", string encoding = "UTF-8") { RsaKeyParameters privateKeyParam; try { var keyBytes = Convert.FromBase64String(privateKeyJava); var asymmetricKeyParameter = PrivateKeyFactory.CreateKey(keyBytes); privateKeyParam = (RsaKeyParameters)asymmetricKeyParameter; } catch (Exception ex) { return("Unable to load private key"); //throw new Exception("Unable to load private key"); } //RsaKeyParameters privateKeyParam = // (RsaKeyParameters) PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKeyJava)); ISigner signer = SignerUtilities.GetSigner(hashAlgorithm); signer.Init(true, privateKeyParam); //参数为true验签,参数为false加签 var dataByte = Encoding.GetEncoding(encoding).GetBytes(data); signer.BlockUpdate(dataByte, 0, dataByte.Length); //return Encoding.GetEncoding(encoding).GetString(signer.GenerateSignature()); //签名结果 非Base64String return(Convert.ToBase64String(signer.GenerateSignature())); }
public void TestElGamal() { BigInteger ELGamalParaG = new BigInteger(Base64.Decode("QAZPRcsH8kHVKS5065R1Xy6QtsPvDkmDZtPuq18EJkvLrCIZivE/m5puQp3/VKJrG7dKgz4NBGpONp3HT+Cn/g==")); BigInteger ELGamalParaP = new BigInteger(Base64.Decode("AKXmAwgkudDLI/Yxk6wk3APn+mSjX5QSyDwpchmegSIi1ZNC0Jb+IbxjroKNhRTBKjtv4/JTXtJS6IqaZv9uKes=")); BigInteger ELGamalPubY = new BigInteger(Base64.Decode("AJ/gXuZuCA2X044otNkzs8FI36XuFu1L/YHg5cEmDvICTigycRN2E1DnhP+CTqxEqgEqX8rBe5tuGDlkTLwgNqM=")); BigInteger ELGamalPriv = new BigInteger(Base64.Decode("CqVr+K0TpuJKQnc76MjKhxrJzGr93jnuE3mTpth486Meymt8uWEVAQj1tGc9DTt14F9aV9WIT2oYYbvLJRcwow==")); ElGamalParameters elPara = new ElGamalParameters(ELGamalParaP, ELGamalParaG); ElGamalPrivateKeyParameters elPriv = new ElGamalPrivateKeyParameters(ELGamalPriv, elPara); ElGamalPublicKeyParameters elPub = new ElGamalPublicKeyParameters(ELGamalPubY, elPara); SubjectPublicKeyInfo subInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(elPub); PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(elPriv); ElGamalPrivateKeyParameters telPriv = (ElGamalPrivateKeyParameters)PrivateKeyFactory.CreateKey(privInfo); ElGamalPublicKeyParameters telPub = (ElGamalPublicKeyParameters)PublicKeyFactory.CreateKey(subInfo); // Console.WriteLine(telPriv.Equals(elPriv)); Assert.IsTrue(telPriv.Equals(elPriv), "ELGamal Private key to into back to private key."); Assert.IsTrue(telPub.Equals(elPub), "ELGamal Public key to into back to private key."); Assert.IsTrue(true, "ELGamal Test worked."); }
/// <summary> /// 私钥加密 RSA解密密文大小 /// </summary> /// <param name="privateKey"></param> /// <param name="contentData"></param> /// <param name="encoding"></param> /// <param name="algorithm"></param> /// <param name="forEncryption"></param> /// <returns></returns> public static string DecryptByPrivateKey(string privateKey, string contentData, string encoding = "UTF-8", string algorithm = "RSA/ECB/PKCS1Padding", bool forEncryption = false) { RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey)); var c = CipherUtilities.GetCipher(algorithm); c.Init(forEncryption, new ParametersWithRandom(privateKeyParam)); byte[] data = Encoding.GetEncoding(encoding).GetBytes(contentData); int inputLen = data.Length; MemoryStream ms = new MemoryStream(); int offSet = 0; byte[] cache; int i = 0; // 对数据分段加�? while (inputLen - offSet > 0) { if (inputLen - offSet > MAX_ENCRYPT_BLOCK) { cache = c.DoFinal(data, offSet, MAX_ENCRYPT_BLOCK); } else { cache = c.DoFinal(data, offSet, inputLen - offSet); } ms.Write(cache, 0, cache.Length); i++; offSet = i * MAX_ENCRYPT_BLOCK; } byte[] encryptedData = ms.ToArray(); ms.Close(); return(Convert.ToBase64String(encryptedData)); }
/// <summary> /// Create an RSA parameter based on the xml format private key /// </summary> /// <param name="privateKey"></param> /// <returns></returns> protected sealed override RSAParameters CreateRsapFromPrivateKey(string privateKey) { privateKey = RsaPemFormatHelper.Pkcs1PrivateKeyFormat(privateKey); PemReader pr = new PemReader(new StringReader(privateKey)); if (!(pr.ReadObject() is AsymmetricCipherKeyPair asymmetricCipherKeyPair)) { throw new Exception("Private key format is incorrect"); } RsaPrivateCrtKeyParameters rsaPrivateCrtKeyParameters = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey( PrivateKeyInfoFactory.CreatePrivateKeyInfo(asymmetricCipherKeyPair.Private)); var rsap = new RSAParameters(); rsap.Modulus = rsaPrivateCrtKeyParameters.Modulus.ToByteArrayUnsigned(); rsap.Exponent = rsaPrivateCrtKeyParameters.PublicExponent.ToByteArrayUnsigned(); rsap.P = rsaPrivateCrtKeyParameters.P.ToByteArrayUnsigned(); rsap.Q = rsaPrivateCrtKeyParameters.Q.ToByteArrayUnsigned(); rsap.DP = rsaPrivateCrtKeyParameters.DP.ToByteArrayUnsigned(); rsap.DQ = rsaPrivateCrtKeyParameters.DQ.ToByteArrayUnsigned(); rsap.InverseQ = rsaPrivateCrtKeyParameters.QInv.ToByteArrayUnsigned(); rsap.D = rsaPrivateCrtKeyParameters.Exponent.ToByteArrayUnsigned(); return(rsap); }
public static string RSAPrivateKeyJava2DotNet(string privateKey, string keyFileName) { var pk = ""; RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey)); pk = string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>", Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()), Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()), Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()), Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()), Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()), Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()), Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()), Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned())); if (!string.IsNullOrEmpty(keyFileName)) { using (StreamWriter writer = new StreamWriter(string.Format("{0}.xml", keyFileName))) { writer.Write(pk); } } return(pk); }
internal static ECPrivateKeyParameters PrivateParamsFromDerOrRaw(ReadOnlyMemory <byte> privateKey) { AsymmetricKeyParameter asymmetricKeyParameter; try { if (privateKey.Length == 32) { return(new ECPrivateKeyParameters(new BigInteger(privateKey.ToArray()), domain)); } asymmetricKeyParameter = PrivateKeyFactory.CreateKey(privateKey.ToArray()); } catch (Exception ex) { if (privateKey.Length == 0) { throw new ArgumentOutOfRangeException("Private Key cannot be empty.", ex); } throw new ArgumentOutOfRangeException("The private key was not provided in a recognizable ECDSA Secp256K1 format.", ex); } if (asymmetricKeyParameter is ECPrivateKeyParameters ecPrivateKeyParameters) { if (ecPrivateKeyParameters.IsPrivate) { return(ecPrivateKeyParameters); } throw new ArgumentOutOfRangeException("This is not an ECDSA Secp256K1 private key, it appears to be a public key."); } throw new ArgumentOutOfRangeException("The private key does not appear to be encoded in ECDSA Secp256K1 format."); }
internal static (KeyType keyType, AsymmetricKeyParameter publicKeyParam) ParsePrivateKeyFromDerBytes(ReadOnlyMemory <byte> privateKey) { AsymmetricKeyParameter asymmetricKeyParameter; try { asymmetricKeyParameter = PrivateKeyFactory.CreateKey(privateKey.ToArray()); } catch (Exception ex) { throw new ArgumentOutOfRangeException("The private key does not appear to be encoded as a recognizable private key format.", ex); } if (asymmetricKeyParameter is Ed25519PrivateKeyParameters ed25519PrivateKeyParameters) { if (ed25519PrivateKeyParameters.IsPrivate) { return(KeyType.Ed25519, ed25519PrivateKeyParameters); } throw new ArgumentOutOfRangeException("This is not an Ed25519 private key, it appears to be a public key."); } if (asymmetricKeyParameter is ECPrivateKeyParameters ecPrivateKeyParameters) { if (ecPrivateKeyParameters.IsPrivate) { return(KeyType.ECDSASecp256K1, ecPrivateKeyParameters); } throw new ArgumentOutOfRangeException("This is not an ECDSA Secp256K1 private key, it appears to be a public key."); } throw new ArgumentOutOfRangeException("The private key does not appear to be encoded in Ed25519 format."); }
public void TestRsa() { BigInteger rsaPubMod = new BigInteger(Base64.Decode("AIASoe2PQb1IP7bTyC9usjHP7FvnUMVpKW49iuFtrw/dMpYlsMMoIU2jupfifDpdFxIktSB4P+6Ymg5WjvHKTIrvQ7SR4zV4jaPTu56Ys0pZ9EDA6gb3HLjtU+8Bb1mfWM+yjKxcPDuFjwEtjGlPHg1Vq+CA9HNcMSKNn2+tW6qt")); BigInteger rsaPubExp = new BigInteger(Base64.Decode("EQ==")); BigInteger rsaPrivMod = new BigInteger(Base64.Decode("AIASoe2PQb1IP7bTyC9usjHP7FvnUMVpKW49iuFtrw/dMpYlsMMoIU2jupfifDpdFxIktSB4P+6Ymg5WjvHKTIrvQ7SR4zV4jaPTu56Ys0pZ9EDA6gb3HLjtU+8Bb1mfWM+yjKxcPDuFjwEtjGlPHg1Vq+CA9HNcMSKNn2+tW6qt")); BigInteger rsaPrivDP = new BigInteger(Base64.Decode("JXzfzG5v+HtLJIZqYMUefJfFLu8DPuJGaLD6lI3cZ0babWZ/oPGoJa5iHpX4Ul/7l3s1PFsuy1GhzCdOdlfRcQ==")); BigInteger rsaPrivDQ = new BigInteger(Base64.Decode("YNdJhw3cn0gBoVmMIFRZzflPDNthBiWy/dUMSRfJCxoZjSnr1gysZHK01HteV1YYNGcwPdr3j4FbOfri5c6DUQ==")); BigInteger rsaPrivExp = new BigInteger(Base64.Decode("DxFAOhDajr00rBjqX+7nyZ/9sHWRCCp9WEN5wCsFiWVRPtdB+NeLcou7mWXwf1Y+8xNgmmh//fPV45G2dsyBeZbXeJwB7bzx9NMEAfedchyOwjR8PYdjK3NpTLKtZlEJ6Jkh4QihrXpZMO4fKZWUm9bid3+lmiq43FwW+Hof8/E=")); BigInteger rsaPrivP = new BigInteger(Base64.Decode("AJ9StyTVW+AL/1s7RBtFwZGFBgd3zctBqzzwKPda6LbtIFDznmwDCqAlIQH9X14X7UPLokCDhuAa76OnDXb1OiE=")); BigInteger rsaPrivQ = new BigInteger(Base64.Decode("AM3JfD79dNJ5A3beScSzPtWxx/tSLi0QHFtkuhtSizeXdkv5FSba7lVzwEOGKHmW829bRoNxThDy4ds1IihW1w0=")); BigInteger rsaPrivQinv = new BigInteger(Base64.Decode("Lt0g7wrsNsQxuDdB8q/rH8fSFeBXMGLtCIqfOec1j7FEIuYA/ACiRDgXkHa0WgN7nLXSjHoy630wC5Toq8vvUg==")); RsaKeyParameters rsaPublic = new RsaKeyParameters(false, rsaPubMod, rsaPubExp); RsaPrivateCrtKeyParameters rsaPrivate = new RsaPrivateCrtKeyParameters(rsaPrivMod, rsaPubExp, rsaPrivExp, rsaPrivP, rsaPrivQ, rsaPrivDP, rsaPrivDQ, rsaPrivQinv); SubjectPublicKeyInfo subInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(rsaPublic); RsaKeyParameters testResult = (RsaKeyParameters)PublicKeyFactory.CreateKey(subInfo); // check RSA public key. Assert.IsFalse(!testResult.Equals(rsaPublic), "RSA: test failed on public key to info and back to public key."); PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(rsaPrivate); testResult = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(privInfo); Assert.IsFalse(!testResult.Equals(rsaPrivate), "RSA: private key to info back to private key."); Assert.IsTrue(true, "RSATest worked."); }
public void TestDSA() { BigInteger DSAParaG = new BigInteger(Base64.Decode("AL0fxOTq10OHFbCf8YldyGembqEu08EDVzxyLL29Zn/t4It661YNol1rnhPIs+cirw+yf9zeCe+KL1IbZ/qIMZM=")); BigInteger DSAParaP = new BigInteger(Base64.Decode("AM2b/UeQA+ovv3dL05wlDHEKJ+qhnJBsRT5OB9WuyRC830G79y0R8wuq8jyIYWCYcTn1TeqVPWqiTv6oAoiEeOs=")); BigInteger DSAParaQ = new BigInteger(Base64.Decode("AIlJT7mcKL6SUBMmvm24zX1EvjNx")); BigInteger DSAPublicY = new BigInteger(Base64.Decode("TtWy2GuT9yGBWOHi1/EpCDa/bWJCk2+yAdr56rAcqP0eHGkMnA9s9GJD2nGU8sFjNHm55swpn6JQb8q0agrCfw==")); BigInteger DsaPrivateX = new BigInteger(Base64.Decode("MMpBAxNlv7eYfxLTZ2BItJeD31A=")); DsaParameters para = new DsaParameters(DSAParaP, DSAParaQ, DSAParaG); DsaPrivateKeyParameters dsaPriv = new DsaPrivateKeyParameters(DsaPrivateX, para); DsaPublicKeyParameters dsaPub = new DsaPublicKeyParameters(DSAPublicY, para); SubjectPublicKeyInfo subInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(dsaPub); DsaKeyParameters testResult = (DsaKeyParameters)PublicKeyFactory.CreateKey(subInfo); // check RSA public key. Assert.IsFalse(!testResult.Equals(dsaPub), "DSA: test failed on public key to info and back to public key."); PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(dsaPriv); testResult = (DsaPrivateKeyParameters)PrivateKeyFactory.CreateKey(privInfo); Assert.IsFalse(!testResult.Equals(dsaPriv), "DSA: private key to info back to private key."); Assert.IsTrue(true, "DSATest worked."); }
AsymmetricKeyParameter DecryptAsymmetricKeyParameter(byte[] buffer, int length) { using (var memory = new MemoryStream(buffer, 0, length, false)) { using (var asn1 = new Asn1InputStream(memory)) { var sequence = asn1.ReadObject() as Asn1Sequence; if (sequence == null) { return(null); } var encrypted = EncryptedPrivateKeyInfo.GetInstance(sequence); var algorithm = encrypted.EncryptionAlgorithm; var encoded = encrypted.GetEncryptedData(); var cipher = PbeUtilities.CreateEngine(algorithm) as IBufferedCipher; if (cipher == null) { return(null); } var cipherParameters = PbeUtilities.GenerateCipherParameters(algorithm, passwd); cipher.Init(false, cipherParameters); var decrypted = cipher.DoFinal(encoded); var keyInfo = PrivateKeyInfo.GetInstance(decrypted); return(PrivateKeyFactory.CreateKey(keyInfo)); } } }
public static ECPrivateKeyParameters DeserializePrivateKey(string priv, bool encodeInHex = encodeInHexValue) { var keyByteArray = encodeInHex ? FromHex(priv) : Convert.FromBase64String(priv); ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters)PrivateKeyFactory.CreateKey(keyByteArray); return(privateKey); }
private void cryptInitPrivate() { RsaPrivateCrtKeyParameters privateKey = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(pgpKey); encryptEngine = new Pkcs1Encoding(new RsaEngine()); encryptEngine.Init(true, privateKey); // ???? }
/// <summary> /// Get the signature based on the timestamp. If the timestamp is null, create /// a new timestamp. /// </summary> /// <param name="timeStamp"> /// The time stamp. /// </param> /// <returns> /// The calculate signature <see cref="string"/>. /// </returns> public string GetSignature(string timeStamp) { this.TimeStamp = timeStamp ?? GetTimestampInJavaMillis(); // Append values into string for signing var message = this.ConsumerId + "\n" + this.RequestUrl + "\n" + this.RequestMethod.ToUpper() + "\n" + this.TimeStamp + "\n"; RsaKeyParameters rsaKeyParameter; try { var keyBytes = Convert.FromBase64String(this.PrivateKey); var asymmetricKeyParameter = PrivateKeyFactory.CreateKey(keyBytes); rsaKeyParameter = (RsaKeyParameters)asymmetricKeyParameter; } catch (System.Exception) { throw new Exception("Unable to load private key"); } var signer = SignerUtilities.GetSigner("SHA256withRSA"); signer.Init(true, rsaKeyParameter); var messageBytes = Encoding.UTF8.GetBytes(message); signer.BlockUpdate(messageBytes, 0, messageBytes.Length); var signed = signer.GenerateSignature(); var hashed = Convert.ToBase64String(signed); return(hashed); }
public override void PerformTest() { IAsymmetricCipherKeyPairGenerator pGen = GeneratorUtilities.GetKeyPairGenerator("RSA"); RsaKeyGenerationParameters genParam = new RsaKeyGenerationParameters( BigInteger.ValueOf(0x10001), new SecureRandom(), 512, 25); pGen.Init(genParam); IAsymmetricCipherKeyPair pair = pGen.GenerateKeyPair(); // // set up the parameters // byte[] salt = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int iterationCount = 100; // // set up the key // char[] password1 = { 'h', 'e', 'l', 'l', 'o' }; EncryptedPrivateKeyInfo encInfo = EncryptedPrivateKeyInfoFactory.CreateEncryptedPrivateKeyInfo(alg, password1, salt, iterationCount, PrivateKeyInfoFactory.CreatePrivateKeyInfo(pair.Private)); PrivateKeyInfo info = PrivateKeyInfoFactory.CreatePrivateKeyInfo(password1, encInfo); IAsymmetricKeyParameter key = PrivateKeyFactory.CreateKey(info); if (!key.Equals(pair.Private)) { Fail("Key corrupted"); } doOpensslTestKeys(); }
/// <summary> /// Initializes a new instance of the <see cref="T:Sensus.Encryption.AsymmetricEncryption"/> class. /// </summary> /// <param name="publicKeyString">Public key string. Can be generated following the generation of the private key (see below) /// using the following command: /// /// openssl rsa -in private.pem -outform PEM -pubout -out public.pem /// /// </param> /// <param name="privateKeyString">Private key string. Only necessary if you want to be able to decrypt using this object. Can /// be generated with the following commands: /// /// openssl genrsa -des3 -out private.pem 2048 /// openssl pkcs8 -topk8 -nocrypt -in private.pem /// /// </param> public AsymmetricEncryption(string publicKeyString, string privateKeyString) { // the following is adapted from http://stackoverflow.com/questions/9283716/c-sharp-net-crypto-using-base64-encoded-public-key-to-verify-rsa-signature/9290086#9290086 if (publicKeyString != null) { byte[] publicKeyBytes = Convert.FromBase64String(publicKeyString); RsaKeyParameters rsaKeyParameters = PublicKeyFactory.CreateKey(publicKeyBytes) as RsaKeyParameters; _rsaPublicParameters = new RSAParameters(); _rsaPublicParameters.Modulus = rsaKeyParameters.Modulus.ToByteArrayUnsigned(); _rsaPublicParameters.Exponent = rsaKeyParameters.Exponent.ToByteArrayUnsigned(); } if (privateKeyString != null) { byte[] privateKeyBytes = Convert.FromBase64String(privateKeyString); RsaPrivateCrtKeyParameters privateKeyParameters = PrivateKeyFactory.CreateKey(privateKeyBytes) as RsaPrivateCrtKeyParameters; _rsaPrivateParameters = new RSAParameters(); _rsaPrivateParameters.DP = privateKeyParameters.DP.ToByteArrayUnsigned(); _rsaPrivateParameters.DQ = privateKeyParameters.DQ.ToByteArrayUnsigned(); _rsaPrivateParameters.P = privateKeyParameters.P.ToByteArrayUnsigned(); _rsaPrivateParameters.Q = privateKeyParameters.Q.ToByteArrayUnsigned(); _rsaPrivateParameters.InverseQ = privateKeyParameters.QInv.ToByteArrayUnsigned(); _rsaPrivateParameters.Modulus = privateKeyParameters.Modulus.ToByteArrayUnsigned(); _rsaPrivateParameters.Exponent = privateKeyParameters.PublicExponent.ToByteArrayUnsigned(); } }
static byte[] GetPfxCertificateByteArray(ref string certString, ref string privateKey) { byte[] certArray = Convert.FromBase64String(certString); byte[] privateKeyArray = Convert.FromBase64String(privateKey); //Translate to Pkcs#12 var store = new Pkcs12StoreBuilder().Build(); Org.BouncyCastle.X509.X509Certificate certTranslate = new X509CertificateParser().ReadCertificate(certArray); var certEntry = new X509CertificateEntry(certTranslate); var pk = PrivateKeyFactory.CreateKey(privateKeyArray); var keyEntry = new AsymmetricKeyEntry(pk); store.SetKeyEntry("", keyEntry, new X509CertificateEntry[] { certEntry }); MemoryStream stream = new MemoryStream(); store.Save(stream, new char[] { }, new SecureRandom()); stream.Dispose(); //FromString byte[] pfxByteArray = stream.ToArray(); return(pfxByteArray); }
/// <summary> /// Creates a private key <see cref="AsymmetricKeyParameter"/> from a byte array containing the exponent and modulus /// </summary> /// <param name="publicKey">the byte array conatining the exponent and the modulus</param> /// <returns>The private key parameter object</returns> protected AsymmetricKeyParameter CreateAsymmetricKeyParameterFromPrivateKeyInfo(byte[] privateKeyInfo) { AsymmetricKeyParameter privateKey = null; try { privateKey = PrivateKeyFactory.CreateKey(privateKeyInfo); } catch (SecurityUtilityException exception) { string message = "Private Key Import Failed!\n" + $"{exception.Message}.\n" + "The contents of the source do not represent a usable object identifier\n" + "Verify that the public key is not corrupted"; throw new CryptoException(message, exception); } catch (IOException exception) { string message = "Private Key Import Failed!\n" + $"{exception.Message}.\n" + "The contents of source do not represent an ASN1 - BER - encoded PKCS#8 structure.\n" + "Verify that the public key is not corrupted"; throw new CryptoException(message, exception); } catch (ArgumentException exception) { string message = "Private Key Import Failed!\n" + $"{exception.Message}\n" + "The contents of source do not represent an ASN.1 - BER - encoded PKCS#8 structure.\n" + "Verify that the private key is not corrupted"; throw new CryptoException(message, exception); } return(privateKey); }
/// <summary> /// Private Key Convert Pkcs8->xml /// </summary> /// <param name="privateKey"></param> /// <returns></returns> public static string PrivateKeyPkcs8ToXml(string privateKey) { privateKey = RsaPemFormatHelper.Pkcs8PrivateKeyFormatRemove(privateKey); RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey)); XElement privatElement = new XElement("RSAKeyValue"); //Modulus XElement primodulus = new XElement("Modulus", Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned())); //Exponent XElement priexponent = new XElement("Exponent", Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned())); //P XElement prip = new XElement("P", Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned())); //Q XElement priq = new XElement("Q", Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned())); //DP XElement pridp = new XElement("DP", Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned())); //DQ XElement pridq = new XElement("DQ", Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned())); //InverseQ XElement priinverseQ = new XElement("InverseQ", Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned())); //D XElement prid = new XElement("D", Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned())); privatElement.Add(primodulus); privatElement.Add(priexponent); privatElement.Add(prip); privatElement.Add(priq); privatElement.Add(pridp); privatElement.Add(pridq); privatElement.Add(priinverseQ); privatElement.Add(prid); return(privatElement.ToString()); }
private AsymmetricCipherKeyPair ReadECPrivateKey( string endMarker) { try { byte[] bytes = ReadBytes(endMarker); ECPrivateKeyStructure pKey = new ECPrivateKeyStructure( (Asn1Sequence)Asn1Object.FromByteArray(bytes)); AlgorithmIdentifier algId = new AlgorithmIdentifier( X9ObjectIdentifiers.IdECPublicKey, pKey.GetParameters()); PrivateKeyInfo privInfo = new PrivateKeyInfo(algId, pKey.ToAsn1Object()); SubjectPublicKeyInfo pubInfo = new SubjectPublicKeyInfo(algId, pKey.GetPublicKey().GetBytes()); // TODO Are the keys returned here ECDSA, as Java version forces? return(new AsymmetricCipherKeyPair( PublicKeyFactory.CreateKey(pubInfo), PrivateKeyFactory.CreateKey(privInfo))); } catch (InvalidCastException e) { throw new IOException("wrong ASN.1 object found in stream.", e); } catch (Exception e) { throw new IOException("problem parsing EC private key.", e); } }
public void TestRfc4134Ex5_1() { byte[] data = Hex.Decode("5468697320697320736f6d652073616d706c6520636f6e74656e742e"); // KeyFactory kFact = KeyFactory.GetInstance("RSA"); // Key key = kFact.generatePrivate(new PKCS8EncodedKeySpec(bobPrivRsaEncrypt)); AsymmetricKeyParameter key = PrivateKeyFactory.CreateKey(bobPrivRsaEncrypt); CmsEnvelopedData ed = new CmsEnvelopedData(rfc4134ex5_1); RecipientInformationStore recipients = ed.GetRecipientInfos(); Assert.AreEqual("1.2.840.113549.3.7", ed.EncryptionAlgOid); ICollection c = recipients.GetRecipients(); Assert.AreEqual(1, c.Count); foreach (RecipientInformation recipient in c) { byte[] recData = recipient.GetContent(key); Assert.IsTrue(Arrays.AreEqual(data, recData)); } }
/// <summary> /// Import the PKCS key. /// </summary> /// <param name="purpose">The purpose.</param> /// <param name="input">The input.</param> /// <param name="passwordPrompt">The pass phrase prompt.</param> /// <param name="official"></param> /// <param name="hint"></param> /// <returns></returns> /// <exception cref="InvalidKeySetException">DSA key cannot be used for encryption and decryption!</exception> /// <exception cref="InvalidKeySetException">Unsupported key type!</exception> public virtual ImportedKeySet PkcsKey(KeyPurpose purpose, Stream input, Func <string> passwordPrompt = null, bool official = false, KeyType hint = null) { using (var password = CachedPrompt.Password(passwordPrompt)) { AsymmetricKeyParameter bouncyKey; var resetStream = Utility.ResetStreamWhenFinished(input); using (var streamReader = new NondestructiveStreamReader(input)) { bouncyKey = new PemReader(streamReader, new PasswordFinder(password.Prompt)).ReadObject() as AsymmetricKeyParameter; } if (bouncyKey == null) { resetStream.Reset(); bouncyKey = passwordPrompt == null ? PrivateKeyFactory.CreateKey(input) : PrivateKeyFactory.DecryptKey( (password.Prompt() ?? String.Empty).ToCharArray(), input); } Key key; switch (bouncyKey) { case RsaPrivateCrtKeyParameters rsa: key = KeyFromBouncyCastle(rsa, purpose, official, hint); break; case DsaPrivateKeyParameters dsa: if (KeyPurpose.DecryptAndEncrypt == purpose) { throw new InvalidKeySetException("DSA key cannot be used for encryption and decryption!"); } key = KeyFromBouncyCastle(dsa); break; case RsaKeyParameters rsa: key = KeyFromBouncyCastle(rsa, purpose, official, hint); break; case DsaPublicKeyParameters dsa: if (KeyPurpose.Encrypt == purpose) { throw new InvalidKeySetException("DSA key cannot be used for encryption!"); } key = KeyFromBouncyCastle(dsa); break; default: throw new InvalidKeySetException("Unsupported key type!"); } return(new ImportedKeySet(key, purpose, "imported from pkcs file")); } }
private static AsymmetricKeyParameter GetPrivateKeyParameter(string s) { s = s.Replace("\r", "").Replace("\n", "").Replace(" ", ""); var privateInfoByte = Convert.FromBase64String(s); var priKey = PrivateKeyFactory.CreateKey(privateInfoByte); return(priKey); }
public PKCS12KeyStore(string keyAlias, RSAKeyPair keyPair, X509CertificateBase certificate) { m_KeyStore = new Pkcs12StoreBuilder().SetUseDerEncoding(true).Build(); m_KeyStore.SetKeyEntry(keyAlias, new AsymmetricKeyEntry(PrivateKeyFactory.CreateKey(keyPair.PrivateKey)), new[] { new X509CertificateEntry(new X509CertificateParser().ReadCertificate(certificate.GetEncoded())) }); }
private AsymmetricKeyParameter GetPrivateKeyParameter(string keyBase64) { keyBase64 = keyBase64.Replace("\r", string.Empty).Replace("\n", string.Empty).Replace(" ", string.Empty); var privateInfoByte = Convert.FromBase64String(keyBase64); var priKey = PrivateKeyFactory.CreateKey(privateInfoByte); return(priKey); }
/// <summary> /// Loads RSA private key. /// </summary> /// <param name="key">RSA private key DER encoded.</param> /// <returns>RSA Private Key</returns> public static RsaPrivateCrtKeyParameters LoadPrivateKey(byte[] key) { var algorithm = new AlgorithmIdentifier(PkcsObjectIdentifiers.RsaEncryption, DerNull.Instance); var privateKeyStructure = RsaPrivateKeyStructure.GetInstance(Asn1Sequence.GetInstance(key)); var privateKeyInfo = new PrivateKeyInfo(algorithm, privateKeyStructure); return(PrivateKeyFactory.CreateKey(privateKeyInfo) as RsaPrivateCrtKeyParameters); }
public UserKeyPair(byte[] privatKeyByte) { if (privatKeyByte == null) { throw new NullReferenceException("private key value cannot be null"); } PrivatKey = (RsaKeyParameters)PrivateKeyFactory.CreateKey(privatKeyByte); }
public void TestECKeyAgreeVectors() { AsymmetricKeyParameter privKey = PrivateKeyFactory.CreateKey(ecKeyAgreeKey); VerifyECKeyAgreeVectors(privKey, "2.16.840.1.101.3.4.1.42", ecKeyAgreeMsgAES256); VerifyECKeyAgreeVectors(privKey, "2.16.840.1.101.3.4.1.2", ecKeyAgreeMsgAES128); VerifyECKeyAgreeVectors(privKey, "1.2.840.113549.3.7", ecKeyAgreeMsgDESEDE); }
public static AsymEncryption Decryptor(byte[] privateKey) { return(new AsymEncryption { // FIX there is a problem here. we serialize the PrivateKeyInfo, not the PrivateKey PrivateKey = PrivateKeyFactory.CreateKey(privateKey) }); }
public void LoadPrivateKeyFromHexed(string privateKeyAsHex) { var privateKey = PrivateKeyFactory.CreateKey(Hex.ToByte(privateKeyAsHex)); var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey); File.WritePem(privateKeyInfo); logger.Info($"Loaded key to {Directory.GetCurrentDirectory()}\\id_econfig.pem."); }