static void Main(string[] args) { Console.WriteLine("\n --- RSA.ALGORITHM ---\n"); RsaAlgorithm rsa = new RsaAlgorithm(); RsaPublicKey publicKey = rsa.GetPublicKeyEN(); RsaPrivateKey privateKey = rsa.GetPrivateKeyDN(); Console.WriteLine($" * Private key: {privateKey.D}, {privateKey.N}"); Console.WriteLine($" * Public key: {publicKey.E}, {publicKey.N}"); int input; do { Console.Write("\n - Enter for encrypt/decrypt (1 - 10000): "); input = int.Parse(Console.ReadLine() ?? string.Empty); } while (input < 1 || input > 10000); int encrypt = rsa.EncryptMessage(input); int decrypt = rsa.DecryptMessage(encrypt); Console.WriteLine($"\n * Encrypt: {encrypt}"); Console.WriteLine($" * Decrypt: {decrypt}"); Console.Write("\n --- Press <ENTER>: "); Console.ReadLine(); }
private void GenerateKeys(string seed) { // generate the RSA keypair for the address AsymmetricCipherKeyPair rsaKeyPair = WalletController.GetRSAKeyPairFromSeed(seed); RsaKeyParameters rsaPublicKey = rsaKeyPair.Public as RsaKeyParameters; RsaPublicKey pbk = new RsaPublicKey() { Exponent = rsaPublicKey.Exponent.ToByteArrayUnsigned(), Modulus = rsaPublicKey.Modulus.ToByteArrayUnsigned() }; RsaPrivateCrtKeyParameters rsaPrivateKey = rsaKeyPair.Private as RsaPrivateCrtKeyParameters; RsaPrivateKey prk = new RsaPrivateKey() { DP = rsaPrivateKey.DP.ToByteArrayUnsigned(), DQ = rsaPrivateKey.DQ.ToByteArrayUnsigned(), Exponent = rsaPrivateKey.Exponent.ToByteArrayUnsigned(), Modulus = rsaPrivateKey.Modulus.ToByteArrayUnsigned(), P = rsaPrivateKey.P.ToByteArrayUnsigned(), PublicExponent = rsaPrivateKey.PublicExponent.ToByteArrayUnsigned(), Q = rsaPrivateKey.Q.ToByteArrayUnsigned(), QInv = rsaPrivateKey.QInv.ToByteArrayUnsigned() }; this._testOutputHelper.WriteLine($"Public key: {pbk.ToHex()}"); this._testOutputHelper.WriteLine($"Private key: {prk.ToHex()}"); }
// http://blog.endpoint.com/2014/10/openssl-csr-with-alternative-names-one.html public override PrivateKey GeneratePrivateKey(PrivateKeyParams pkp) { var rsaPkp = pkp as RsaPrivateKeyParams; if (rsaPkp != null) { var tempKeyFile = Path.GetTempFileName(); try { var args = $"genpkey -algorithm RSA -out {tempKeyFile}"; if (rsaPkp.NumBits > 0) { args += $" -pkeyopt rsa_keygen_bits:{rsaPkp.NumBits}"; } if (!string.IsNullOrEmpty(rsaPkp.PubExp)) { args += $" -pkeyopt rsa_keygen_pubexp:{rsaPkp.PubExp}"; } RunCli(args); var rsaPk = new RsaPrivateKey(rsaPkp.NumBits, rsaPkp.PubExp, File.ReadAllText(tempKeyFile)); return(rsaPk); } finally { File.Delete(tempKeyFile); } } throw new NotSupportedException("unsupported private key parameters type"); }
public IActionResult LoginInit() { try { var serviceLocator = new ServiceLocator( new MvcSessionDataHandler(HttpContext.Session), new MvcLogger(mLogger)) { ServerConfig = new CustomGoodIdServerConfig(goodIdConfig) }; var goodIdHttpResponse = GoodIdEndpointFactory.CreateGoodIDEndpoint( serviceLocator, new MvcIncomingRequest(Request), goodIdConfig.Value.ClientId, RsaPrivateKey.FromPem(goodIdConfig.Value.SigPrivKeyPem), RsaPrivateKey.FromPem(goodIdConfig.Value.EncPrivKeyPem), new OpenIdRequestObject(sSelectedclaims.ToString()), goodIdConfig.Value.RedirectUri, sSelectedAcr).Run(); return(ToActionResult(goodIdHttpResponse)); } catch (GoodIdException e) { mLogger.LogError(e, "GoodIdException happened on login initiation endpoint."); return(new StatusCodeResult(500)); } }
protected GoodIdEndpoint( IncomingRequest incomingRequest, string clientId, RsaPrivateKey signingKey, RsaPrivateKey encryptionKey, OpenIdRequestSource requestSource, string redirectUri, Acr acr, int?maxAge, ServiceLocator serviceLocator) { if (string.IsNullOrEmpty(clientId)) { throw new GoodIdException($"{nameof(clientId)} can not be empty"); } if (maxAge.HasValue && (maxAge.Value < MAX_AGE_MIN_VALUE || maxAge.Value > MAX_AGE_MAX_VALUE)) { throw new GoodIdException($"{nameof(maxAge)} must be null or an int in the range [{MAX_AGE_MIN_VALUE}, {MAX_AGE_MAX_VALUE}]"); } mIncomingRequest = incomingRequest; mClientId = clientId; mSigningKey = signingKey; mEncryptionKey = encryptionKey; mRequestSource = requestSource; mRedirectUri = redirectUri; mAcr = acr; mMaxAge = maxAge; mServiceLocator = serviceLocator; }
public void LoadFromCertificateFile_Should_ThrowException_When_PrivateKeyPasswordNotProvided() { // Arrange var cert = $"{_assemblyPath}RsaEncrypt.pfx"; // Assert Assert.Throws <ArgumentNullException>(() => RsaPrivateKey.LoadFromCertificateFile(cert, "")); }
public void GenerateNewKeyset_Should_ThrowException_When_PublicKeyIsNull() { // Arrange var key = new RsaEncryption(); var privateKey = new RsaPrivateKey(); RsaPublicKey publicKey = null; // Act & Assert Assert.Throws <ArgumentNullException>(() => key.GenerateNewKeyset(ref publicKey, ref privateKey)); }
public void A_RsaPrivateKey_can_be_created_and_configured_in_code() { var privateKey = new RsaPrivateKey(ConfigUtils.GetAppSetting("ServerPrivateKey")); var factory = new FactoryProvider(this.factoryConfig); factory.Register(privateKey); var resolvedPrivateKey = factory.Resolve <RsaPrivateKey>(); Assert.That(resolvedPrivateKey, Is.Not.Null); }
public void ExportToXmlFile_Should_ThrowException_IfPrivateKeyFileExist() { // Arrange var file = $"{_assemblyPath}{Guid.NewGuid()}.xml"; var key = RsaPrivateKey.LoadFromXmlFile($"{_assemblyPath}privateKey.xml"); key.ExportToXmlFile(file); // Act & Assert Assert.Throws <IOException>(() => key.ExportToXmlFile(file)); }
public void LoadFromCertificateFile_Should_LoadCertificate_When_FileIsPasswordProtected() { // Arrange var cert = $"{_assemblyPath}RsaEncrypt.pfx"; // Act var privateKey = RsaPrivateKey.LoadFromCertificateFile(cert, "password"); // Assert Assert.NotNull(privateKey); }
public void ToPublicKey_Should_ReturnThePublicKeyPortionOfAPrivateKey() { // Arrange var key = RsaPrivateKey.LoadFromXmlFile($"{_assemblyPath}privateKey.xml"); // Act var publicKey = key.ToPublicKey(); // Assert Assert.Equal("AQAB", publicKey.Exponent); }
public void Constructor_Should_ThrowException_When_RSAPrivateKeyIsNotProvided() { // Arrange RsaPrivateKey key = null; // Act & Assert Assert.Throws <ArgumentNullException>( () => { var e1 = new ASymmetricEncryption(key); }); }
public void ExportToXmlFile_Should_SaveThePrivateKey() { // Arrange var file = $"{_assemblyPath}{Guid.NewGuid()}.xml"; var key = RsaPrivateKey.LoadFromXmlFile($"{_assemblyPath}privateKey.xml"); // Act key.ExportToXmlFile(file); // Assert Assert.True(File.Exists(file)); }
public void LoadFromXmlFile_Should_LoadThePrivateKeyFromFile() { // Arrange const string expected = "71bwZomEwGq5FFx+43FIFngA6uZEZqPTMcTfc250F8WH" + "7AFE94ucRpQR6JOKt6POZj/2NtY499YIKlJIjWM4Qw=="; var file = $"{_assemblyPath}privateKey.xml"; // Act var key = RsaPrivateKey.LoadFromXmlFile(file); // Assert Assert.Equal(expected, key.PrimeP); }
public void Encrypt_Should_ThrowException_When_EncryptingToMuchData() { // Arrange var publicKey = new RsaPublicKey(); var privateKey = new RsaPrivateKey(); var e1 = new RsaEncryption(); // Act e1.GenerateNewKeyset(ref publicKey, ref privateKey); // Assert Assert.Throws <CryptographicException>(() => e1.Encrypt(new EncryptionData(_targetString), publicKey)); }
public void Encrypt_Should_ThrowException_When_DataIsNull() { // Arrange var publicKey = new RsaPublicKey(); var privateKey = new RsaPrivateKey(); var e1 = new RsaEncryption(); e1.GenerateNewKeyset(ref publicKey, ref privateKey); EncryptionData data = null; // Act & Assert Assert.Throws <ArgumentNullException>(() => e1.Encrypt(data, publicKey)); }
public void AgentCreateDeviceSetRsaKey() { // generate RSA key pair RsaKeyGenerator generator = new RsaKeyGenerator(); RsaPrivateKey privateKey = generator.GeneratePrivateKey(2048); RsaPublicKey publicKey = generator.GeneratePublicKey(privateKey); // set RSA keys into a CreateDeviceRequest object CreateDeviceRequest request = new CreateDeviceRequest(); request.ClientRsaPrivateKey = privateKey; request.ClientRsaPublicKey = publicKey; }
public async Task <IActionResult> Index() { const string rootUri = "/"; // If it is a GoodID login: if (HttpContext.Request.Query.ContainsKey("code") || HttpContext.Request.Query.ContainsKey("error")) { try { var serviceLocator = new ServiceLocator( new MvcSessionDataHandler(HttpContext.Session), new MvcLogger(mLogger)) { ServerConfig = new CustomGoodIdServerConfig(goodIdConfig) }; var response = await new GoodIdResponseCollector( serviceLocator, new MvcIncomingRequest(Request), goodIdConfig.Value.ClientId, goodIdConfig.Value.ClientSecret, RsaPrivateKey.FromPem(goodIdConfig.Value.SigPrivKeyPem), new RsaPrivateKey[] { RsaPrivateKey.FromPem(goodIdConfig.Value.EncPrivKeyPem) } ).CollectAsync(); if (response is GoodIdResponseError errorResponse) { ViewData["Error"] = errorResponse.Error + ": " + errorResponse.ErrorDescription; } else if (response is GoodIdResponseSuccess successResponse) { mLogger.LogDebug("There was a success response"); ViewData["Response"] = successResponse.DataJObject.ToString(); } } catch (GoodIdException e) { ViewData["Error"] = e.ToString(); // Please don't display the actual error string in production. } } ViewData["RootUri"] = rootUri; ViewData["ClientId"] = goodIdConfig.Value.ClientId; ViewData["SelectedClaims"] = sSelectedclaims; ViewData["SelectedAcr"] = sSelectedAcr; ViewData["Claims"] = ""; return(View()); }
public IActionResult DecryptWantedSystemMessageAsync([FromBody] DecryptWantedSystemMessageRequest request) { Guard.NotNull(request, nameof(request)); // checks the request is valid if (!this.ModelState.IsValid) { return(ModelStateErrors.BuildErrorResponse(this.ModelState)); } try { Script scriptPubKey = this.network.CreateTransaction(request.TransactionHex).Outputs[request.MessageOutputIndex].ScriptPubKey; RsaPrivateKey rsaPrivateKey = null; if (!String.IsNullOrEmpty(request.RsaPrivateKeyHex)) { try { rsaPrivateKey = RsaPrivateKey.FromHex(request.RsaPrivateKeyHex); } catch { throw new Exception("The RSA private key you provided was not in the correct form."); } } NBitcoin.Messaging.WantedSystemMessage sm = WantedSystemMessageTemplate.Instance.GetWantedSystemMessage(scriptPubKey, rsaPrivateKey); var model = new DecryptedWantedSystemMessageModel { Version = sm.Version, Compression = sm.Compression.ToString(), ChecksumType = sm.ChecksumType.ToString(), Encryption = sm.Encryption.ToString(), Metadata = sm.Metadata.ToString(), Text = sm.Text }; return(this.Json(model)); } catch (Exception e) { this.logger.LogError("Exception occurred: {0}", e.ToString()); return(ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, e.Message, e.ToString())); } }
public GoodIdResponseCollector( ServiceLocator serviceLocator, IncomingRequest incomingRequest, string clientId, string clientSecret, RsaPrivateKey signingKey, RsaPrivateKey[] encryptionKeys, bool matchingResponseValidation = true) { mServiceLocator = serviceLocator; mIncomingRequest = incomingRequest; mClientId = clientId; mClientSecret = clientSecret; mSigningKey = signingKey; mEncryptionKeys = encryptionKeys; mMatchingResponseValidation = matchingResponseValidation; }
public void Decrypt_Should_ThrowException_When_ProvidedWrongPrivateKey() { // Arrange var wrongKey = RsaPrivateKey.LoadFromCertificateFile( $"{_assemblyPath}ASymmetricEncryptionWrong.pfx", "password"); var e1 = new ASymmetricEncryption(_publicKey); var e2 = new ASymmetricEncryption(wrongKey); var encrypted = e1.Encrypt(_targetData); // Act & Assert Assert.Throws <CryptographicException>(() => { var decrypted = e2.Decrypt(encrypted); }); }
public void Decrypt_Should_ReturnExpectedResult_When_UsingExplicitKeySizeAndGeneratedKeys() { // Arrange var publicKey = new RsaPublicKey(); var privateKey = new RsaPrivateKey(); var e1 = new RsaEncryption(4096); var e2 = new RsaEncryption(4096); e1.GenerateNewKeyset(ref publicKey, ref privateKey); // Act var encryptedData = e1.Encrypt(new EncryptionData(Secret), publicKey); var decryptedData = e2.Decrypt(encryptedData, privateKey); // Assert Assert.Equal(decryptedData.Text, Secret); }
public void Decrypt_Should_ReturnExpectedResult_When_KeyIsStoredInCertificate() { // Arrange var cert = $"{_assemblyPath}RsaEncrypt"; var publicKey = RsaPublicKey.LoadFromCertificateFile(cert + ".cer"); var privateKey = RsaPrivateKey.LoadFromCertificateFile(cert + ".pfx", "password"); var e1 = new RsaEncryption(); var e2 = new RsaEncryption(); // Act var encryptedData = e1.Encrypt(new EncryptionData(Secret), publicKey); var decryptedData = e2.Decrypt(encryptedData, privateKey); // Assert Assert.Equal(decryptedData.Text, Secret); }
public void Verify_Should_ReturnTrue_When_ValidatingUnChangedSignedData() { // Arrange var secretData = new EncryptionData(Secret); var publicKey = new RsaPublicKey(); var privateKey = new RsaPrivateKey(); var e1 = new RsaEncryption(); e1.GenerateNewKeyset(ref publicKey, ref privateKey); // Act var signature = e1.Sign(secretData, privateKey); var actual = e1.Verify(secretData, signature, publicKey); // Assert Assert.True(actual); }
public void Decrypt_Should_ReturnExpectedResult_When_KeyIsStoredInXml() { // Arrange const string publicKeyXml = "<RSAKeyValue>" + "<Modulus>0D59Km2Eo9oopcm7Y2wOXx0TRRXQFybl9HHe/ve47Qcf2EoKbs9nkuMmhCJlJ" + "zrq6ZJzgQSEbpVyaWn8OHq0I50rQ13dJsALEquhlfwVWw6Hit7qRvveKlOAGfj8xdkaXJ" + "LYS1tA06tKHfYxgt6ysMBZd0DIedYoE1fe3VlLZyE=</Modulus>" + "<Exponent>AQAB</Exponent>" + "</RSAKeyValue>"; const string privateKeyXml = "<RSAKeyValue>" + "<Modulus>0D59Km2Eo9oopcm7Y2wOXx0TRRXQFybl9HHe/ve47Qcf2EoKbs9nkuMmhCJlJ" + "zrq6ZJzgQSEbpVyaWn8OHq0I50rQ13dJsALEquhlfwVWw6Hit7qRvveKlOAGfj8xdkaXJ" + "LYS1tA06tKHfYxgt6ysMBZd0DIedYoE1fe3VlLZyE=</Modulus>" + "<Exponent>AQAB</Exponent>" + "<P>/1cvDks8qlF1IXKNwcXW8tjTlhjidjGtbT9k7FCYug+P6ZBDfqhUqfvjgLFF" + "/+dAkoofNqliv89b8DRy4gS4qQ==</P>" + "<Q>0Mgq7lyvmVPR1r197wnba1bWbJt8W2Ki8ilUN6lX6Lkk04ds9y3A0txy0ESya7dyg" + "9NLscfU3NQMH8RRVnJtuQ==</Q>" + "<DP>+uwfRumyxSDlfSgInFqh/+YKD5+GtGXfKtO4hu4xF+8BGqJ1YXtkL" + "+Njz2zmADOt5hOr1tigPSQ2EhhIqUnAeQ==</DP>" + "<DQ>M5Ofd28SOjCIwCHjwG+Q8v1qzz3CBNljI6uuEGoXO3ix" + "bkggVRfKcMzg2C6AXTfeZE6Ifoy9OyhvLlHTPiXakQ==</DQ>" + "<InverseQ>yQIJMLdL6kU4VK7M5b5PqWS8XzkgxfnaowRs9mhSEDdwwWPtUXO8aQ9G3" + "zuiDUqNq9j5jkdt77+c2stBdV97ew==</InverseQ>" + "<D>HOpQXu/OFyJXuo2EY43BgRt8bX9V4aEZFRQqrqSfHOp8VYASasiJzS+VTYupGAVqUP" + "xw5V1HNkOyG0kIKJ+BG6BpIwLIbVKQn/ROs7E3/vBdg2+QXKhikMz/4gY" + "x2oEsXW2kzN1GMRop2lrrJZJNGE/eG6i4lQ1/inj1Tk/sqQE=</D>" + "</RSAKeyValue>"; var publicKey = new RsaPublicKey(publicKeyXml); var privateKey = new RsaPrivateKey(privateKeyXml); var e1 = new RsaEncryption(); var e2 = new RsaEncryption(); // Act var encryptedData = e1.Encrypt(new EncryptionData(Secret), publicKey); var decryptedData = e2.Decrypt(encryptedData, privateKey); // Assert Assert.Equal(decryptedData.Text, Secret); }
public void Decrypt_Should_ReturnExpectedResult_When_KeyIsStoredInConfig() { // Arrange AddKeysToEnvironment(); var publicKey = RsaPublicKey.LoadFromEnvironment(); var privateKey = RsaPrivateKey.LoadFromEnvironment(); var e1 = new RsaEncryption(); var e2 = new RsaEncryption(); // Act var encryptedData = e1.Encrypt(new EncryptionData(Secret), publicKey); var decryptedData = e2.Decrypt(encryptedData, privateKey); // Assert Assert.Equal(decryptedData.Text, Secret); RemoveKeysToEnvironment(); }
public void Sign_Should_CorrectlyCreateProperSignature() { // Arrange var secretData = new EncryptionData(Secret); var xml = File.ReadAllText($"{_assemblyPath}privateKey.xml"); var privateKey = RsaPrivateKey.LoadFromXml(xml); const string expected = "kZmV1cUO91lpOQkgz5HLbWsfeXabJOPfcWjH72EytH95AAJEVq+nonJm9A" + "UjHy53VAIagJFJYiORcgsHC1klkppM71hRD1xUs70ggPiMIcTv/CDij3" + "6FYxGd7n9GAh5LikojbWJxJHc3A5LqnAwSBBfOfY2K4gY5lZ3rSmhNHDM="; var e1 = new RsaEncryption(); // Act var signature = e1.Sign(secretData, privateKey); // Assert Assert.Equal(signature.Base64, expected); }
private static byte[] RSADecryptByteArray(byte[] ciphertext, RsaPrivateKey privateKey) { byte[] result = null; using (var rsa = RSA.Create()) { RSAParameters rsaParameters = new RSAParameters(); rsaParameters.D = privateKey.Exponent; rsaParameters.DP = privateKey.DP; rsaParameters.DQ = privateKey.DQ; rsaParameters.Exponent = privateKey.PublicExponent; rsaParameters.InverseQ = privateKey.QInv; rsaParameters.Modulus = privateKey.Modulus; rsaParameters.P = privateKey.P; rsaParameters.Q = privateKey.Q; rsa.ImportParameters(rsaParameters); result = rsa.Decrypt(ciphertext, RSAEncryptionPadding.Pkcs1); } return(result); }
async Task <JObject> GetRequestJObjectAsync(string requestSource, RsaPrivateKey signingKey) { try { return(JObject.Parse(requestSource)); } catch (JsonReaderException) { // It wasn't object, no problem } try { var requestUri = (string)JToken.Parse(requestSource); if (requestUri != OpenIdRequestSource.CONTENT_IS_ENCRYPTED) { var downloadedRequestSource = await new OpenIdRequestUri(requestUri).ToJsonAsync(signingKey); var jToken = JToken.Parse(downloadedRequestSource); if (jToken.Type == JTokenType.Object) { return((JObject)jToken); } if (jToken.Type != JTokenType.String || (string)jToken != OpenIdRequestSource.CONTENT_IS_ENCRYPTED) { throw new Exception(); } } } catch (Exception) { throw new GoodIdException($"invalid {nameof(requestSource)}"); } return(null); }
public static GoodIdEndpoint CreateGoodIDEndpoint( ServiceLocator serviceLocator, IncomingRequest incomingRequest, string clientId, RsaPrivateKey signingKey, RsaPrivateKey encryptionKey, OpenIdRequestSource openIdRequestSource, string redirectUri, Acr acr = Acr.LEVEL_DEFAULT, int?maxAge = null ) { try { var goodIdServerConfig = serviceLocator.ServerConfig; var sessionDataHandler = serviceLocator.SessionDataHandler; var stateNonceHandler = serviceLocator.StateNonceHandler; return(new GoodIdRequestBuilderEndpoint( incomingRequest, clientId, signingKey, encryptionKey, openIdRequestSource, redirectUri, acr, maxAge, serviceLocator )); }catch (GoodIdException) { throw; } catch (Exception e) { throw new GoodIdException("Unknown error: " + e.Message); } }
public static byte[] RsaDecrypt(byte[] encryptedData, RsaPrivateKey key) { Argument.ValidateIsNotNull(encryptedData, "encryptedData"); Argument.ValidateIsNotNull(key, "key"); // RSA works with integers, not bytes, so transform the bytes into an integer. var encryptedInteger = BytesToBigInteger(encryptedData); // It's as simple as that: s = (c**d) mod n var decryptedInteger = BigInteger.ModPow(encryptedInteger, key.D, key.N); return BigIntegerToBytes(decryptedInteger); }
/// <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> /// <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) { 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; if (bouncyKey is RsaPrivateCrtKeyParameters) { var keyParam = bouncyKey as RsaPrivateCrtKeyParameters; key = new RsaPrivateKey() { PublicKey = new RsaPublicKey() { Modulus = keyParam.Modulus.ToSystemBigInteger(), PublicExponent = keyParam.PublicExponent.ToSystemBigInteger(), Size = keyParam.Modulus.BitLength, }, PrimeP = keyParam.P.ToSystemBigInteger(), PrimeExponentP = keyParam.DP.ToSystemBigInteger(), PrimeExponentQ = keyParam.DQ.ToSystemBigInteger(), PrimeQ = keyParam.Q.ToSystemBigInteger(), CrtCoefficient = keyParam.QInv.ToSystemBigInteger(), PrivateExponent = keyParam.Exponent.ToSystemBigInteger(), Size = keyParam.Modulus.BitLength, }; } else if (bouncyKey is DsaPrivateKeyParameters) { var keyParam = bouncyKey as DsaPrivateKeyParameters; if (KeyPurpose.DecryptAndEncrypt == purpose) { throw new InvalidKeySetException("DSA key cannot be used for encryption and decryption!"); } key = new DsaPrivateKey() { X = keyParam.X.ToSystemBigInteger(), PublicKey = new DsaPublicKey { Y = keyParam.Parameters.G.ModPow(keyParam.X, keyParam.Parameters.P) .ToSystemBigInteger(), G = keyParam.Parameters.G.ToSystemBigInteger(), P = keyParam.Parameters.P.ToSystemBigInteger(), Q = keyParam.Parameters.Q.ToSystemBigInteger(), Size = keyParam.Parameters.P.BitLength }, Size = keyParam.Parameters.P.BitLength }; } else { throw new InvalidKeySetException("Unsupported key type!"); } return new ImportedKeySet(key, purpose, "imported from pkcs file"); } }