private static RsaKeyPair GetRsaKeyPair(RSA rsa, string comment) { const string sshrsa = "ssh-rsa"; // Use Bouncy castle's pem reader to get the modulus and exponent as a byte array PemReader reader = new PemReader(new StringReader(rsa.PublicKeyAsPEM)); RsaKeyParameters r = (RsaKeyParameters)reader.ReadObject(); byte[] sshrsa_bytes = Encoding.Default.GetBytes(sshrsa); byte[] n = r.Modulus.ToByteArray(); byte[] e = r.Exponent.ToByteArray(); Buffer buf = new Buffer(sshrsa_bytes.Length + 4 + e.Length + 4 + n.Length + 4); // Add the bytes buf.add(sshrsa_bytes, e, n); // Encode in Base64 string buffer64 = buf.AsBase64String(); // Set the base DTO RsaKeyPair pair = new RsaKeyPair() { PublicSSHKey = string.Format("ssh-rsa {0} {1}", buffer64, comment), PublicKeyAsPEM = rsa.PublicKeyAsPEM, PrivateKeyAsPEM = rsa.PrivateKeyAsPEM, // Later add parameters if required. }; return pair; }
private void importButton_Click(object sender, RoutedEventArgs e) { RsaKeyPair result = new RsaKeyPair() { PublicKey = publicTextBox.Text, PrivateKey = privateTextBox.Text, Timestamp = (int)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds }; bool error = false; if (Crypto.PublicKeyFromPem(result.PublicKey) == null) { Result = null; error = true; errorTextBlock.Visibility = Visibility.Visible; } if (!result.PublicOnly && Crypto.PrivateKeyFromPem(result.PrivateKey) == null) { Result = null; error = true; errorTextBlock.Visibility = Visibility.Visible; } if (!error) { Result = result; this.Close(); } }
public void CreateKeyPair() { var pair = new RsaKeyPair(); Assert.NotNull(pair.PublicKey); Assert.NotNull(pair.PrivateKey); }
private static RsaKeyPair GetRsaKeyPair(RSA rsa, string comment) { const string sshrsa = "ssh-rsa"; // Use Bouncy castle's pem reader to get the modulus and exponent as a byte array PemReader reader = new PemReader(new StringReader(rsa.PublicKeyAsPEM)); RsaKeyParameters r = (RsaKeyParameters)reader.ReadObject(); byte[] sshrsa_bytes = Encoding.Default.GetBytes(sshrsa); byte[] n = r.Modulus.ToByteArray(); byte[] e = r.Exponent.ToByteArray(); Buffer buf = new Buffer(sshrsa_bytes.Length + 4 + e.Length + 4 + n.Length + 4); // Add the bytes buf.add(sshrsa_bytes, e, n); // Encode in Base64 string buffer64 = buf.AsBase64String(); // Set the base DTO RsaKeyPair pair = new RsaKeyPair() { PublicSSHKey = string.Format("ssh-rsa {0} {1}", buffer64, comment), PublicKeyAsPEM = rsa.PublicKeyAsPEM, PrivateKeyAsPEM = rsa.PrivateKeyAsPEM, // Later add parameters if required. }; return(pair); }
public static Certificate Deserialize(string data, RsaKeyPair key) { var result = new Certificate(key); result.AddChain(new CertificateChain(data)); return(result); }
/// <summary> /// Create a new private/public key pair as PEM formatted strings. /// </summary> /// <returns>An <see cref="RsaKeyPair"/>.</returns> public static RsaKeyPair GenerateRsaKeyPair() { var rsaGenerator = new RsaKeyPairGenerator(); rsaGenerator.Init(new KeyGenerationParameters(new SecureRandom(), 2048)); var keyPair = rsaGenerator.GenerateKeyPair(); var rsaKeyPair = new RsaKeyPair(); using (var privateKeyTextWriter = new StringWriter()) { var pemWriter = new PemWriter(privateKeyTextWriter); pemWriter.WriteObject(keyPair.Private); pemWriter.Writer.Flush(); rsaKeyPair.PrivateKey = privateKeyTextWriter.ToString(); } using (var publicKeyTextWriter = new StringWriter()) { var pemWriter = new PemWriter(publicKeyTextWriter); pemWriter.WriteObject(keyPair.Public); pemWriter.Writer.Flush(); rsaKeyPair.PublicKey = publicKeyTextWriter.ToString(); } return(rsaKeyPair); }
public static Csr GenerateCsr(CsrDetails csrDetails, RsaKeyPair rsaKeyPair, string messageDigest = "SHA256") { var rsaKeys = CryptoKey.FromPrivateKey(rsaKeyPair.Pem, null); // Translate from our external form to our OpenSSL internal form // Ref: https://www.openssl.org/docs/manmaster/crypto/X509_NAME_new.html var xn = new X509Name(); if (!string.IsNullOrEmpty(csrDetails.CommonName /**/)) xn.Common = csrDetails.CommonName; // CN; if (!string.IsNullOrEmpty(csrDetails.Country /**/)) xn.Common = csrDetails.Country; // C; if (!string.IsNullOrEmpty(csrDetails.StateOrProvince /**/)) xn.Common = csrDetails.StateOrProvince; // ST; if (!string.IsNullOrEmpty(csrDetails.Locality /**/)) xn.Common = csrDetails.Locality; // L; if (!string.IsNullOrEmpty(csrDetails.Organization /**/)) xn.Common = csrDetails.Organization; // O; if (!string.IsNullOrEmpty(csrDetails.OrganizationUnit /**/)) xn.Common = csrDetails.OrganizationUnit; // OU; if (!string.IsNullOrEmpty(csrDetails.Description /**/)) xn.Common = csrDetails.Description; // D; if (!string.IsNullOrEmpty(csrDetails.Surname /**/)) xn.Common = csrDetails.Surname; // S; if (!string.IsNullOrEmpty(csrDetails.GivenName /**/)) xn.Common = csrDetails.GivenName; // G; if (!string.IsNullOrEmpty(csrDetails.Initials /**/)) xn.Common = csrDetails.Initials; // I; if (!string.IsNullOrEmpty(csrDetails.Title /**/)) xn.Common = csrDetails.Title; // T; if (!string.IsNullOrEmpty(csrDetails.SerialNumber /**/)) xn.Common = csrDetails.SerialNumber; // SN; if (!string.IsNullOrEmpty(csrDetails.UniqueIdentifier /**/)) xn.Common = csrDetails.UniqueIdentifier; // UID; var xr = new X509Request(0, xn, rsaKeys); var md = MessageDigest.CreateByName(messageDigest); ; xr.Sign(rsaKeys, md); using (var bio = BIO.MemoryBuffer()) { xr.Write(bio); return new Csr(bio.ReadString()); } }
/// <summary> /// Creates a new wire message. /// </summary> /// <param name="messageType">Message type name</param> /// <param name="serializedMessage">Serialized message</param> /// <param name="serializer">Serializer used to serialize the signed content</param> /// <param name="keyPair">RSA key pair to be used for creating a RSA signature for the message data</param> /// <param name="sharedSecret">Shared secret (wire message will be not encrypted, if null)</param> /// <param name="error">Species whether the wire message is in error state</param> /// <param name="uniqueCallKey">Unique key to correlate RPC call</param> /// <returns>The created wire message</returns> /// <exception cref="ArgumentException">Thrown if the message type is left empty.</exception> public WireMessage CreateWireMessage( string messageType, byte[] serializedMessage, ISerializerAdapter serializer, RsaKeyPair keyPair = null, byte[] sharedSecret = null, bool error = false, byte[] uniqueCallKey = null) { if (string.IsNullOrWhiteSpace(messageType)) { throw new ArgumentException("Message type must not be empty.", nameof(messageType)); } byte[] iv = sharedSecret == null ? new byte[0] : AesEncryption.GenerateIv(); byte[] rawContent; if (keyPair != null && sharedSecret != null) { var signedMessageData = new SignedMessageData() { MessageRawData = serializedMessage, Signature = RsaSignature.CreateSignature( keySize: keyPair.KeySize, sendersPrivateKeyBlob: keyPair.PrivateKey, rawData: serializedMessage) }; rawContent = serializer.Serialize(typeof(SignedMessageData), signedMessageData); } else { rawContent = serializedMessage; } byte[] messageContent = sharedSecret == null ? rawContent : AesEncryption.Encrypt( dataToEncrypt: rawContent, sharedSecret: sharedSecret, iv: iv); return (new WireMessage() { MessageType = messageType, Data = messageContent, Iv = iv, Error = error, UniqueCallKey = uniqueCallKey }); }
private void ciphertextTextBox_TextChanged(object sender, TextChangedEventArgs e) { if (!editingPlaintext && !string.IsNullOrWhiteSpace(ciphertextTextBox.Text)) { lastPlaintext = false; editingCiphertext = true; if (identityComboBox.SelectedIndex != -1) { RsaKeyPair selectedKey = KeyManager.Keys[identityComboBox.SelectedIndex]; if (!selectedKey.PublicOnly) { string cipher = ciphertextTextBox.Text.Split(new char[] { ']', '[' }, StringSplitOptions.RemoveEmptyEntries).Last(); cipher = cipher.Replace("\n", ""); string error = string.Empty; byte[] cipherBytes = null; try { cipherBytes = Convert.FromBase64String(cipher); } catch { error = "Invalid Base64"; } string plain = ""; if (string.IsNullOrWhiteSpace(error)) { try { plain = System.Text.Encoding.UTF8.GetString(Crypto.RsaDecrypt(selectedKey.PrivateCsp, cipherBytes)); } catch { error = "Decryption Failure"; } } if (string.IsNullOrWhiteSpace(error)) { plaintextTextBox.Text = plain; arrowRight.Visibility = Visibility.Collapsed; arrowLeft.Visibility = Visibility.Visible; errorTextBlock.Visibility = Visibility.Collapsed; } else { errorTextBlock.Visibility = Visibility.Visible; errorTextBlock.Text = error; } } } } editingCiphertext = false; }
// Static Methods public static Account Create(List <string> contactEmails) { var key = RsaKeyPair.New(); return(new Account(key) { Contact = contactEmails }); }
// Sign up user with passed credentials. RSA key pair will be generated automatically. public static bool SignUp(string name, string login, string password) { // Generate new key pair. var keyPair = RsaKeyPair.GenerateKeyPair(); // Persist private key. Not the best place to do it, but it doesn't matter. CredentialsManager.Store(login, keyPair.PrivateKeyXml); // Client method call. return(AppUser.GetInstance().Client.SignUp(login, name, password, keyPair.PublicKeyXml)); }
/// <summary> /// Writes the public key from the private key specified. /// </summary> /// <param name="privateKeyFile"></param> public static void WriteRsaKeyPair(string privateKeyFile, string comment) { RsaKeyPair pair = GenerateRsaKeyPair(privateKeyFile, comment); // We only need to write the public key since we already got the private one. TextWriter tw = new StreamWriter(privateKeyFile + ".pub", false); tw.WriteLine(pair.PublicSSHKey); tw.Close(); }
public static void RsaManagerTests() { string data = "HelloWorld!!!"; Console.WriteLine("█ BER"); RsaKeyPair keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Ber); Console.WriteLine("Public:\n" + keyPair.PublicKey); Console.WriteLine("Private:\n" + keyPair.PrivateKey); string encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey); Console.WriteLine("Encrypted: " + encrypted); Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey)); Console.WriteLine("█ XML"); keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Xml, false); Console.WriteLine("Public:\n" + keyPair.PublicKey); Console.WriteLine("Private:\n" + keyPair.PrivateKey); encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey); Console.WriteLine("Encrypted: " + encrypted); Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey)); Console.WriteLine("█ XML INDENTED"); keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Xml); Console.WriteLine("Public:\n" + keyPair.PublicKey); Console.WriteLine("Private:\n" + keyPair.PrivateKey); encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey); Console.WriteLine("Encrypted: " + encrypted); Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey)); Console.WriteLine("█ JSON"); keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Json, false); Console.WriteLine("Public:\n" + keyPair.PublicKey); Console.WriteLine("Private:\n" + keyPair.PrivateKey); encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey); Console.WriteLine("Encrypted: " + encrypted); Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey)); Console.WriteLine("█ JSON INDENTED"); keyPair = RsaManager.CreateKeyPair(512, RsaKeyEncoding.Json); Console.WriteLine("Public:\n" + keyPair.PublicKey); Console.WriteLine("Private:\n" + keyPair.PrivateKey); encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey); Console.WriteLine("Encrypted: " + encrypted); Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey)); Console.WriteLine("█ PEM"); keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Pem); Console.WriteLine("Public:\n" + keyPair.PublicKey); Console.WriteLine("Private:\n" + keyPair.PrivateKey); encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey); Console.WriteLine("Encrypted: " + encrypted); Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey)); }
private const string XmlPublicAndPrivateKeyPattern = "(\\s*<\\s*RSAKeyValue\\s*>\\s*(?:\\s*<\\s*Modulus\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*Modulus\\s*>()|\\s*<\\s*Exponent\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*Exponent\\s*>()|\\s*<\\s*P\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*P\\s*>()|\\s*<\\s*Q\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*Q\\s*>()|\\s*<\\s*DP\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*DP\\s*>()|\\s*<\\s*DQ\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*DQ\\s*>()|\\s*<\\s*InverseQ\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*InverseQ\\s*>()|\\s*<\\s*D\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*D\\s*>()){8}\\s*<\\/\\s*RSAKeyValue\\s*>\\s*\\2\\3\\4\\5\\6\\7\\8\\9)|(\\s*<\\s*RSAKeyValue\\s*>\\s*(?:\\s*<\\s*Modulus\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*Modulus\\s*>()|\\s*<\\s*Exponent\\s*>\\s*[a-zA-Z0-9\\+\\/]+={0,2}\\s*<\\/\\s*Exponent\\s*>()){2}\\s*<\\/\\s*RSAKeyValue\\s*>\\s*\\11\\12)"; //https://regex101.com/r/fQV2VN/4 (\s*<\s*RSAKeyValue\s*>\s*(?:\s*<\s*Modulus\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*Modulus\s*>()|\s*<\s*Exponent\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*Exponent\s*>()|\s*<\s*P\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*P\s*>()|\s*<\s*Q\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*Q\s*>()|\s*<\s*DP\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*DP\s*>()|\s*<\s*DQ\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*DQ\s*>()|\s*<\s*InverseQ\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*InverseQ\s*>()|\s*<\s*D\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*D\s*>()){8}\s*<\/\s*RSAKeyValue\s*>\s*\2\3\4\5\6\7\8\9)|(\s*<\s*RSAKeyValue\s*>\s*(?:\s*<\s*Modulus\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*Modulus\s*>()|\s*<\s*Exponent\s*>\s*[a-zA-Z0-9\+\/]+={0,2}\s*<\/\s*Exponent\s*>()){2}\s*<\/\s*RSAKeyValue\s*>\s*\11\12) public static RsaKeyPair CreateRsaKeyPair(this uint keySize, RsaKeyEncoding encoding = RsaKeyEncoding.Ber, bool indent = true) { RsaKeyPair result; using (RSACryptoServiceProvider Csp = new RSACryptoServiceProvider((int)keySize)) { switch (encoding) { case RsaKeyEncoding.Xml: result = new RsaKeyPair( publicKey: XDocument.Parse(Csp.ToXmlString(false)).ToString(indent ? SaveOptions.None : SaveOptions.DisableFormatting), privateKey: XDocument.Parse(Csp.ToXmlString(true)).ToString(indent ? SaveOptions.None : SaveOptions.DisableFormatting) ); break; case RsaKeyEncoding.Json: RSAParameters parameters = Csp.ExportParameters(true); var pubKey = new { Modulus = (parameters.Modulus !).ToBase64(), Exponent = (parameters.Exponent !).ToBase64(), }; var privKey = new { Modulus = (parameters.Modulus !).ToBase64(), Exponent = (parameters.Exponent !).ToBase64(), P = (parameters.P !).ToBase64(), Q = (parameters.Q !).ToBase64(), DP = (parameters.DP !).ToBase64(), DQ = (parameters.DQ !).ToBase64(), InverseQ = (parameters.InverseQ !).ToBase64(), D = (parameters.D !).ToBase64() }; var options = new JsonSerializerOptions { WriteIndented = indent }; result = new RsaKeyPair(JsonSerializer.Serialize(pubKey, options), JsonSerializer.Serialize(privKey, options)); break; case RsaKeyEncoding.Pem: result = new RsaKeyPair($"{RsaPemPublicKeyInitialString}{Environment.NewLine}{Csp.ExportSubjectPublicKeyInfo().ToBase64(HashExtensions.PemLineBreaksLength)}{Environment.NewLine}{RsaPemPublicKeyFinalString}", $"{RsaPemPrivateKeyInitialString}{Environment.NewLine}{Csp.ExportPkcs8PrivateKey().ToBase64(HashExtensions.PemLineBreaksLength)}{Environment.NewLine}{RsaPemPrivateKeyFinalString}"); break; default: result = new RsaKeyPair(publicKey: Csp.ExportSubjectPublicKeyInfo().ToBase64(), privateKey: Csp.ExportPkcs8PrivateKey().ToBase64()); break; } ValidateRsaPublicKey(result.PublicKey); ValidateRsaPrivateKey(result.PrivateKey); return(result); } }
// Ctor public Certificate(RsaKeyPair key = null) { // Generate new RSA key for certificate if (key == null) { Key = RsaKeyPair.New(); } else { Key = key; } }
public static async Task <Account> LoadAsync(string contactEmail) { var location = await _localStorage.LoadAccount(contactEmail); var privateKeyPem = await _localStorage.LoadPrivateKey(contactEmail); //var publicKeyPem = await _localStorage.LoadPublicKey(contactEmail); var key = new RsaKeyPair(privateKeyPem); return(new Account(key, location)); }
/// <summary> /// Writes a pair of files representing the Public Key in ssh-required format /// and the Private key in PEM format. /// </summary> /// <param name="bits"></param> /// <param name="comment"></param> /// <param name="privFileName"></param> public static void WriteRsaKeyPair(int bits, string comment, string privFileName) { RsaKeyPair pair = GenerateRsaKeyPair(bits, comment); TextWriter tw; tw = new StreamWriter(privFileName, false); tw.WriteLine(pair.PrivateKeyAsPEM); tw.Close(); tw = new StreamWriter(privFileName + ".pub", false); tw.WriteLine(pair.PublicSSHKey); tw.Close(); }
public void TestRsaEncryptAndDecrypt() { string _data = "I am union guy." , _dataEncrypted = "" , _dataDecrypted = ""; RsaKeyPair _rsaKeyPair = new RsaKeyPair(); RsaKeyFormat _rsaKeyFormat = RsaKeyFormat.PEM; _dataEncrypted = RsaHelper.Encrypt(_rsaKeyFormat, _rsaKeyPair.PublicKey_PEM, _data); _dataDecrypted = RsaHelper.Decrypt(_rsaKeyFormat, _rsaKeyPair.PrivateKey_PEM, _dataEncrypted); Assert.AreEqual(_data, _dataDecrypted, string.Format("Data = {0}, DataEncrypted = {1}, DataDecrypted = {2}", _data, _dataEncrypted, _dataDecrypted)); }
public static void SaveKey(RsaKeyPair Key) { string json = Key.ToJson(); byte[] bytes = Crypto.RsaEncrypt(masterKey.PublicCsp, System.Text.Encoding.UTF8.GetBytes(json)); string filename = $"{path}\\{Key.Hash.Replace("+", "").Replace("=", "").Replace("/", "").Substring(0, 16)}.key"; if (System.IO.File.Exists(filename)) { System.IO.File.Delete(filename); } System.IO.File.WriteAllBytes(filename, bytes); }
public void EncryptAndDecrypt() { var pair = new RsaKeyPair(); var str = "Hello"; var encoded = RsaCipher.Encrypt(str, pair.PublicKey); Assert.NotEqual(str, encoded); var decoded = RsaCipher.Decrypt(encoded, pair.PrivateKey); Assert.Equal(str, decoded); }
public void SaveAndLoad() { var pair = new RsaKeyPair(); pair.SaveToFile(PairFile); var pair2 = new RsaKeyPair(); pair2.LoadFromFile(PairFile); Assert.Equal(pair.PublicKey.Parameters.Exponent, pair2.PublicKey.Parameters.Exponent); Assert.Equal(pair.PublicKey.Parameters.Modulus, pair2.PublicKey.Parameters.Modulus); Assert.Equal(pair2.PublicKey.Parameters.D, null); }
/// <summary> /// Creates a new instance of the RemotingClient class. /// </summary> /// <param name="config">Configuration settings</param> public RemotingClient(ClientConfig config) : this() { if (config == null) { throw new ArgumentException("No config provided and no default configuration found."); } Serializer = config.Serializer ?? new BsonSerializerAdapter(); MessageEncryption = config.MessageEncryption; _config = config; if (MessageEncryption) { _keyPair = new RsaKeyPair(config.KeySize); } _channel = config.Channel ?? new WebsocketClientChannel(); _channel.Init(this); _rawMessageTransport = _channel.RawMessageTransport; _rawMessageTransport.ReceiveMessage += OnMessage; _rawMessageTransport.ErrorOccured += (s, exception) => { if (exception != null) { throw exception; } throw new NetworkException(s); }; _clientInstances.AddOrUpdate( key: config.UniqueClientInstanceName, addValueFactory: uniqueInstanceName => this, updateValueFactory: (uniqueInstanceName, oldClient) => { oldClient?.Dispose(); return(this); }); if (!config.IsDefault) { return; } RemotingClient.DefaultRemotingClient ??= this; }
private void exportButton_Click(object sender, RoutedEventArgs e) { RsaKeyPair key = ((Button)e.OriginalSource).DataContext as RsaKeyPair; Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog(); dlg.FileName = MakeValidFileName((string.IsNullOrWhiteSpace(key.Note) ? "" : key.Note + ".") + (key.PublicOnly ? "Public." : "") + key.Hash.Substring(0, 16));//key.Hash.Substring(0,16); dlg.Filter = "JSON (.json)|*.json|plain text (*.txt)|*.txt|All files (*.*)|*.*"; dlg.FilterIndex = 1; dlg.RestoreDirectory = true; dlg.Title = "Export Key"; if (dlg.ShowDialog() == true) { try { if (System.IO.File.Exists(dlg.FileName)) { System.IO.File.Delete(dlg.FileName); } if (dlg.FileName.EndsWith(".JSON", StringComparison.InvariantCultureIgnoreCase)) { System.IO.File.WriteAllText(dlg.FileName, key.ToJson()); } else { string text = key.PublicKey; if (!key.PublicOnly) { text += "\n" + key.PrivateKey; } text += "\n"; System.IO.File.WriteAllText(dlg.FileName, text); } MessageBox.Show("File saved", "Success", MessageBoxButton.OK, MessageBoxImage.Asterisk); } catch (Exception ex) { MessageBox.Show($"Encountered an error while trying to write to\n{dlg.FileName}", "Error", MessageBoxButton.OK, MessageBoxImage.Error); } } }
private void plaintextTextBox_TextChanged(object sender, TextChangedEventArgs e) { if (!editingCiphertext && !string.IsNullOrWhiteSpace(plaintextTextBox.Text)) { lastPlaintext = true; editingPlaintext = true; if (identityComboBox.SelectedIndex != -1) { RsaKeyPair selectedKey = KeyManager.Keys[identityComboBox.SelectedIndex]; byte[] buffer = Crypto.RsaEncrypt(selectedKey.PublicCsp, System.Text.Encoding.UTF8.GetBytes(plaintextTextBox.Text)); string cipher = $"[{selectedKey.Hash.Substring(0, 16)}]\n{Convert.ToBase64String(buffer)}"; ciphertextTextBox.Text = cipher; arrowRight.Visibility = Visibility.Visible; arrowLeft.Visibility = Visibility.Collapsed; } } editingPlaintext = false; }
public void VerifySignature_should_return_true_if_signature_is_valid() { int keySize = 4096; var keyPair = new RsaKeyPair(keySize); var data = Encoding.UTF8.GetBytes("Test"); var signature = RsaSignature.CreateSignature( keySize: keySize, sendersPrivateKeyBlob: keyPair.PrivateKey, rawData: data); var result = RsaSignature.VerifySignature( keySize: keySize, sendersPublicKeyBlob: keyPair.PublicKey, rawData: data, signature: signature); Assert.Equal(512, signature.Length); Assert.True(result); }
public static void Initialize(string Password) { if (Initialized) { return; } path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ApplicationData) + @"\OradeTech\CryptoTool\Keys"; if (!System.IO.Directory.Exists(path)) { System.IO.Directory.CreateDirectory(path); } salt = System.Text.Encoding.UTF8.GetBytes(Password); masterKey = Crypto.RsaKeysFromPassword(Password, salt); var files = System.IO.Directory.GetFiles(path); foreach (string keyFile in files) { try { byte[] buffer = System.IO.File.ReadAllBytes(keyFile); byte[] decrypted = Crypto.RsaDecrypt(masterKey.PrivateCsp, buffer); string json = System.Text.Encoding.UTF8.GetString(decrypted); RsaKeyPair key = RsaKeyPair.FromJson(json); Keys.Add(key); } catch { Console.WriteLine("Failed to load key"); } } Initialized = true; }
public Account(RsaKeyPair key) : this() { Key = key; Signer = new JwsSigner(Key); }
private void privateTextBox_TextChanged(object sender, TextChangedEventArgs e) { Result = null; errorTextBlock.Visibility = Visibility.Hidden; }
// Ctor public JwsSigner(RsaKeyPair key) { _key = key; }
public Account(RsaKeyPair key, string location) : this(key) { Location = new Uri(location); }
public static Csr GenerateCsr(CsrDetails csrDetails, RsaKeyPair rsaKeyPair, string messageDigest = "SHA256") { var rsaKeys = CryptoKey.FromPrivateKey(rsaKeyPair.Pem, null); // Translate from our external form to our OpenSSL internal form // Ref: https://www.openssl.org/docs/manmaster/crypto/X509_NAME_new.html var xn = new X509Name(); if (!string.IsNullOrEmpty(csrDetails.CommonName /**/)) { xn.Common = csrDetails.CommonName; // CN; } if (!string.IsNullOrEmpty(csrDetails.Country /**/)) { xn.Common = csrDetails.Country; // C; } if (!string.IsNullOrEmpty(csrDetails.StateOrProvince /**/)) { xn.Common = csrDetails.StateOrProvince; // ST; } if (!string.IsNullOrEmpty(csrDetails.Locality /**/)) { xn.Common = csrDetails.Locality; // L; } if (!string.IsNullOrEmpty(csrDetails.Organization /**/)) { xn.Common = csrDetails.Organization; // O; } if (!string.IsNullOrEmpty(csrDetails.OrganizationUnit /**/)) { xn.Common = csrDetails.OrganizationUnit; // OU; } if (!string.IsNullOrEmpty(csrDetails.Description /**/)) { xn.Common = csrDetails.Description; // D; } if (!string.IsNullOrEmpty(csrDetails.Surname /**/)) { xn.Common = csrDetails.Surname; // S; } if (!string.IsNullOrEmpty(csrDetails.GivenName /**/)) { xn.Common = csrDetails.GivenName; // G; } if (!string.IsNullOrEmpty(csrDetails.Initials /**/)) { xn.Common = csrDetails.Initials; // I; } if (!string.IsNullOrEmpty(csrDetails.Title /**/)) { xn.Common = csrDetails.Title; // T; } if (!string.IsNullOrEmpty(csrDetails.SerialNumber /**/)) { xn.Common = csrDetails.SerialNumber; // SN; } if (!string.IsNullOrEmpty(csrDetails.UniqueIdentifier /**/)) { xn.Common = csrDetails.UniqueIdentifier; // UID; } var xr = new X509Request(0, xn, rsaKeys); var md = MessageDigest.CreateByName(messageDigest);; xr.Sign(rsaKeys, md); using (var bio = BIO.MemoryBuffer()) { xr.Write(bio); return(new Csr(bio.ReadString())); } }
private void cancelButton_Click(object sender, RoutedEventArgs e) { Result = null; this.Close(); }