static void Main(string[] args) { //Key Generation const string privKeyHex = "E9873D79C6D87DC0FB6A5778633389F4453213303DA61F20BD67FC233AA33262"; BigInteger privateKey = Hex.HexToBigInteger(privKeyHex); ECPoint publicKey = Secp256k1.G.Multiply(privateKey); string bitcoinAddressUncompressed = publicKey.GetBitcoinAddress(compressed: false); string bitcoinAddressCompressed = publicKey.GetBitcoinAddress(compressed: true); Console.WriteLine("PrivateKey (Hex): {0}", privateKey.ToHex()); Console.WriteLine("Address (Uncompressed): {0}", bitcoinAddressUncompressed); Console.WriteLine("Address ( Compressed): {0}", bitcoinAddressCompressed); // encryption ECEncryption encryption = new ECEncryption(); const string message = "This is my encrypted message"; byte[] encrypted = encryption.Encrypt(publicKey, message); byte[] decrypted = encryption.Decrypt(privateKey, encrypted); string decryptedMessage = Encoding.UTF8.GetString(decrypted); // signing MessageSignerVerifier messageSigner = new MessageSignerVerifier(); SignedMessage signedMessage = messageSigner.Sign(privateKey, "Test Message to sign, you can verify this on http://brainwallet.org/#verify"); bool verified = messageSigner.Verify(signedMessage); Console.WriteLine("Press Any Key ..."); Console.ReadKey(); }
public void EncryptAndSignFile(string strPath, string strOutput, ulong[] lTargetKeyIDs, ulong lSignatureKeyID, string strPassphrase) { TransportablePublicKey[] tpkSelectedKeys = new TransportablePublicKey[lTargetKeyIDs.Length]; for (int i = 0; i < lTargetKeyIDs.Length; i++) { tpkSelectedKeys[i] = pkrKeyRing.Find(lTargetKeyIDs[i], true); } System.IO.FileStream fsFile = new FileStream(strPath, FileMode.Open); BinaryReader brReader = new BinaryReader(fsFile); byte[] bFileContent = brReader.ReadBytes((int)fsFile.Length); brReader.Close(); fsFile.Close(); LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Binary); lmMessage.Binary = bFileContent; lmMessage.TimeCreated = DateTime.Now; int iLastBackslash = strPath.LastIndexOf("\\"); lmMessage.Filename = strPath.Substring(iLastBackslash + 1, strPath.Length - iLastBackslash - 1); SignedMessage smMessage = SignMessage(lmMessage, lSignatureKeyID, strPassphrase); byte[] bReturn = EncryptMessage(smMessage, lTargetKeyIDs); FileStream fsOut = new FileStream(strOutput, FileMode.CreateNew); BinaryWriter bwWrite = new BinaryWriter(fsOut); bwWrite.Write(bReturn); bwWrite.Close(); fsOut.Close(); }
public void SignFile(string strPath, string strOutput, ulong lSignatureKeyID, string strPassphrase) { System.IO.FileStream fsFile = new FileStream(strPath, FileMode.Open); BinaryReader brReader = new BinaryReader(fsFile); byte[] bFileContent = brReader.ReadBytes((int)fsFile.Length); brReader.Close(); fsFile.Close(); LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Binary); lmMessage.Binary = bFileContent; lmMessage.TimeCreated = DateTime.Now; int iLastBackslash = strPath.LastIndexOf("\\"); lmMessage.Filename = strPath.Substring(iLastBackslash + 1, strPath.Length - iLastBackslash - 1); SignedMessage smMessage = SignMessage(lmMessage, lSignatureKeyID, strPassphrase); byte[] bReturn = smMessage.GetEncoded(); FileStream fsOut = new FileStream(strOutput, FileMode.CreateNew); BinaryWriter bwWrite = new BinaryWriter(fsOut); bwWrite.Write(bReturn); bwWrite.Close(); fsOut.Close(); }
public SignedMessage EncryptAndSign(string message) { SignedMessage signedMessage = new SignedMessage(); byte[] encrypytedMessage = Encrypt(message); byte[] signature = Sign(encrypytedMessage); signedMessage.Message = Convert.ToBase64String(encrypytedMessage); signedMessage.Signature = Convert.ToBase64String(signature); return(signedMessage); }
private void HelloMessage(ChatUser cu = null) { if (cu != null) { UserProfile.Destination = cu.Sender; } SignedMessage signedUserProfileMessage = new SignedMessage(UserProfile.ToJson()); userModule.SendMessage <string>(signedUserProfileMessage.ToJson(), messageModule.Id.ToString()); }
public SignedMessage GetSignedMessage(Guid groupId, string email) { var participant = context.Participants.FirstOrDefault(p => p.Email == email); var authMessage = context.AuthenticationMessages.FirstOrDefault(m => m.GroupId == groupId && m.ParticipantId == participant.Id); var signedMessage = new SignedMessage(); signedMessage.Email = participant.Email; signedMessage.Message = authMessage.Message; signedMessage.Signature = authMessage.Signature; return(signedMessage); }
public string VerifyAndDecrypt(SignedMessage signedMessage) { byte[] signature = Convert.FromBase64String(signedMessage.Signature); byte[] encrypytedMessage = Convert.FromBase64String(signedMessage.Message); if (Verify(encrypytedMessage, signature)) { return(Decrypt(encrypytedMessage)); } else { return("Error: peer verification failed."); } }
public void RSAHelperCrossSignedMessageE2E() { RSAHelper receiver = new RSAHelper(); RSAHelper sender = new RSAHelper(); sender.SetPeerPublicKey(receiver.MyPublicKey); receiver.SetPeerPublicKey(sender.MyPublicKey); string original = "This is test message"; SignedMessage signedMessage = sender.EncryptAndSign(original); string decrypted = receiver.VerifyAndDecrypt(signedMessage); Assert.Equal(original, decrypted); }
public string EncryptAndSignText(string strMessage, ulong[] lTargetKeyIDs, ulong lSignatureKeyID, string strPassphrase) { LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Text); lmMessage.Text = strMessage; lmMessage.TimeCreated = DateTime.Now; lmMessage.Filename = ""; SignedMessage smMessage = this.SignMessage(lmMessage, lSignatureKeyID, strPassphrase); byte[] bReturn = EncryptMessage(smMessage, lTargetKeyIDs); string strReturn = Radix64.Encode(bReturn, true); strReturn = Armor.WrapMessage(strReturn); return(strReturn); }
/// <summary> /// Unseals the given JSON message, performing the necessary signature verification and decryption steps. /// </summary> /// <param name="sealedMessage">A message generated by the Google Pay API (in JSON format)</param> /// <returns>Unsealed message (in JSON format)</returns> public string Unseal(string sealedMessage) { if (_privateKeys.Count == 0) { throw new InvalidOperationException("At least one private key must be added"); } PaymentData paymentData = Util.Json.Parse <PaymentData>(sealedMessage); SignedMessage signedMessage = Util.Json.Parse <SignedMessage>(paymentData.SignedMessage); KeyDerivation keyDerivation; switch (paymentData.ProtocolVersion) { case ECv1: keyDerivation = new KeyDerivation(SymmetricKeySizeECv1, MacKeySizeECv1); break; case ECv2: keyDerivation = new KeyDerivation(SymmetricKeySizeECv2, MacKeySizeECv2); break; default: throw new SecurityException($"Unsupported protocol version {paymentData.ProtocolVersion}"); } if (!_signatureVerification.VerifyMessage(paymentData, GoogleSenderId, _recipientId, _signatureKeyProvider)) { throw new SecurityException("Cannot verify signature"); } byte[] message = Base64.Decode(signedMessage.EncryptedMessage); KeyDerivation.DerivedKeys keys = _privateKeys.Select(key => keyDerivation.Derive(key, signedMessage.EphemeralPublicKey) ).FirstOrDefault(derivedKeys => new TagVerification(derivedKeys.MacKey).Verify(message, signedMessage.Tag) ); if (keys == null) { throw new SecurityException("Cannot decrypt; invalid MAC"); } var decryption = new MessageDecryption(keys.SymmetricEncryptionKey); return(decryption.Decrypt(message)); }
private async Task <List <OperationResult> > SendOperations(JToken operations, Keys keys, JObject head = null) { JObject result = new JObject(); if (head == null) { head = await GetHeader(); } JArray arrOps = operations as JArray; if (arrOps == null) { arrOps = new JArray(operations); } JToken forgedOpGroup = await ForgeOperations(head, arrOps); SignedMessage signedOpGroup; if (keys == null) { signedOpGroup = new SignedMessage { SignedBytes = forgedOpGroup.ToString() + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", EncodedSignature = "edsigtXomBKi5CTRf5cjATJWSyaRvhfYNHqSUGrn4SdbYRcGwQrUGjzEfQDTuqHhuA8b2d8NarZjz8TRf65WkpQmo423BtomS8Q" }; } else { Crypto c = new Crypto(); signedOpGroup = c.Sign(forgedOpGroup.ToString(), keys, Watermark.Generic); } List <OperationResult> opResults = await PreApplyOperations(head, arrOps, signedOpGroup.EncodedSignature); if (opResults.All(op => op.Succeeded)) { JToken injectedOperation = await InjectOperations(signedOpGroup.SignedBytes); } return(opResults); }
private SignedMessage SignMessage(LiteralMessage lmToBeSigned, ulong lSignatureKeyID, string strPassphrase) { TransportableSecretKey tskKey = skrKeyRing.Find(lSignatureKeyID); SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmToBeSigned; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmToBeSigned.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; return(smMessage); }
/// <summary> /// Verifies the signature given a signed file and a signature file /// </summary> /// <param name="strFile">signature file bytes</param> /// <param name="fileToVerify">signed file</param> /// <returns></returns> private string FileSignatureVerify(byte[] bData, string fileToVerify) { SharpPrivacy.SharpPrivacyLib.OpenPGP.Messages.Message mContent = null; byte[] decodedbData = null; string strMessage = System.Text.Encoding.UTF8.GetString(bData); ArmorTypes atType = new ArmorTypes(); string strRest = ""; string strRadix64 = Armor.RemoveArmor(strMessage, ref atType, ref strRest); if (strRadix64.Length > 0) decodedbData = Radix64.Decode(strRadix64); if (atType == ArmorTypes.OpenPGPSignature) { SignedMessage smMessage = new SignedMessage(); Packet[] pPackets; pPackets = Packet.ParsePackets(decodedbData); if (!(pPackets[0] is SignaturePacket)) { throw new Exception("Not a valid cleartext signature!"); } smMessage.Signature = (SignaturePacket)pPackets[0]; mContent = smMessage; } else { // let us see what kind of message this is Packet[] pPackets; try { pPackets = Packet.ParsePackets(bData); mContent = new SignedMessage(); ((SignedMessage)mContent).Signature = (SignaturePacket)pPackets[0]; //((SignedMessage)mContent).OnePassSigned = false; } catch (Exception ee) { throw new Exception("There was an error decrypting your message: " + ee.Message); } } byte[] bFileContent = new byte[0]; try { System.IO.FileStream fsFile = new FileStream(fileToVerify, FileMode.Open); BinaryReader brReader = new BinaryReader(fsFile); bFileContent = brReader.ReadBytes((int)fsFile.Length); brReader.Close(); fsFile.Close(); } catch (Exception e) { throw new Exception("An error occured while opening the file " + e.Message); } LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Binary); lmMessage.Binary = bFileContent; lmMessage.TimeCreated = ((SignedMessage)mContent).Signature.TimeCreated; lmMessage.Filename = fileToVerify; ((SignedMessage)mContent).MessageSigned = lmMessage; LiteralMessage lmContent = new LiteralMessage(); string strDisplay = ""; if (mContent is SignedMessage) { SignedMessage smContent = (SignedMessage)mContent; lmContent = smContent.MessageSigned; strDisplay += "*** OpenPGP Signed Message ***\r\n"; strDisplay += "*** Signature Status: " + smContent.Verify(pkrPublicKeyRing) + " ***\r\n"; strDisplay += "*** Signing Key: " + smContent.Signature.KeyID.ToString("x") + " ***\r\n"; try { try { strDisplay += "*** Signing Key Expiration: " + pkrPublicKeyRing.Find(smContent.Signature.KeyID,true).KeyExpirationTime + " ***\r\n"; } catch(Exception e) { if(e.Message.Equals("never")) { strDisplay += "*** Signing Key Expiration: "+e.Message+" ***\r\n"; } else { throw new Exception("Signing_Key_Not_Available"); } } try { strDisplay += "*** Signing Key Revoked: "+ this.pkrPublicKeyRing.isRevoked(smContent.Signature.KeyID) +" ***\r\n"; } catch(Exception e) { string msg = e.Message; strDisplay += "*** Signing Key Revoked: Revocation_Key_Not_Available ***\r\n"; } } catch (Exception e) { string warn = e.Message; strDisplay += "*** Signing Key Expiration: " + SignatureStatusTypes.Signing_Key_Not_Available + " ***\r\n"; } strDisplay += "*** Signing Date: " + smContent.Signature.TimeCreated.ToString() + "***\r\n\r\n"; } else if (mContent is LiteralMessage) { lmContent = (LiteralMessage)mContent; strDisplay += "*** OpenPGP Encrypted Message ***\r\n\r\n"; } else { throw new Exception("An error occured: Could not find an encrypted or signed message!"); } if (lmContent.DataFormat == DataFormatTypes.Text) { strDisplay += lmContent.Text; strDisplay += "\r\n\r\n*** End OpenPGP Message ***\r\n"; } return strDisplay; }
/// <summary> /// Method handling decrypting and verifying /// </summary> /// <param name="bData">data to be decrypted</param> /// <param name="strPassphrase">passphrase</param> /// <param name="fileOut">the decrypted file location if one produced</param> /// <returns>verifying process result</returns> private string DecryptAndVerify(byte[] bData, string strPassphrase, string fileOut) { string strMessage = System.Text.Encoding.UTF8.GetString(bData); ArmorTypes atType = new ArmorTypes(); string strRest = ""; string strRadix64 = Armor.RemoveArmor(strMessage, ref atType, ref strRest); if (strRadix64.Length > 0) bData = Radix64.Decode(strRadix64); SharpPrivacy.SharpPrivacyLib.OpenPGP.Messages.Message mContent = null; if (atType == ArmorTypes.OpenPGPSignedMessage) { string strSignature = ""; string strSignedMessage = Armor.RemoveClearSignatureArmor(strMessage, ref atType, ref strSignature); strSignedMessage = Radix64.DashUnescape(strSignedMessage); strSignedMessage = Radix64.TrimMessage(strSignedMessage); SignedMessage smMessage = new SignedMessage(); Packet[] pPackets; pPackets = Packet.ParsePackets(strSignature); if (!(pPackets[0] is SignaturePacket)) { throw new Exception("Not a valid cleartext signature!"); } smMessage.Signature = (SignaturePacket)pPackets[0]; LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Text); lmMessage.Text = strSignedMessage; smMessage.MessageSigned = lmMessage; mContent = smMessage; } else { // let us see what kind of message this is EncryptedMessage emMessage = new EncryptedMessage(); Packet[] pPackets; try { pPackets = Packet.ParsePackets(bData); try { emMessage.ParseMessage(pPackets); if (emMessage.SymmetricallyEncrypted) { // Query passphrase for symmetrically encrypted message mContent = emMessage.Decrypt(strPassphrase); } else { ulong lKeyID = emMessage.GetFittingKeyID(skrSecretKeyRing); mContent = emMessage.Decrypt(skrSecretKeyRing, strPassphrase); } } catch (Exception) { mContent = new CompressedMessage(); mContent.ParseMessage(pPackets); } while ((!(mContent is LiteralMessage)) && (!(mContent is SignedMessage))) { if (mContent is CompressedMessage) { mContent = ((CompressedMessage)mContent).Uncompress(); } else { throw new Exception("This is not a valid OpenPGP message!"); } } } catch (Exception ee) { throw new Exception("There was an error decrypting your message: " + ee.Message); } } LiteralMessage lmContent = new LiteralMessage(); string strDisplay = ""; if (mContent is SignedMessage) { SignedMessage smContent = (SignedMessage)mContent; lmContent = smContent.MessageSigned; strDisplay += "*** OpenPGP Signed Message ***\r\n"; strDisplay += "*** Signature Status: " + smContent.Verify(pkrPublicKeyRing) + " ***\r\n"; strDisplay += "*** Signing Key Dec: " + smContent.Signature.KeyID.ToString() + " ***\r\n"; strDisplay += "*** Signing Key Hex: " + smContent.Signature.KeyID.ToString("x") + " ***\r\n"; try { try { strDisplay += "*** Signing Key Expiration: " + pkrPublicKeyRing.Find(smContent.Signature.KeyID,true).KeyExpirationTime + " ***\r\n"; } catch(Exception e) { if(e.Message.Equals("never")) strDisplay += "*** Signing Key Expiration: "+e.Message+" ***\r\n"; else throw new Exception("Signing_Key_Not_Available"); } try { strDisplay += "*** Signing Key Revoked: "+ this.pkrPublicKeyRing.isRevoked(smContent.Signature.KeyID) +" ***\r\n"; } catch(Exception e) { string msg = e.Message; strDisplay += "*** Signing Key Revoked: Revocation_Key_Not_Available ***\r\n"; } } catch (Exception e) { string warn = e.Message; strDisplay += "*** Signing Key Expiration: " + SignatureStatusTypes.Signing_Key_Not_Available + " ***\r\n"; } strDisplay += "*** Signing Date: " + smContent.Signature.TimeCreated.ToString() + "***\r\n\r\n"; } else if (mContent is LiteralMessage) { lmContent = (LiteralMessage)mContent; strDisplay += "*** OpenPGP Encrypted Message ***\r\n\r\n"; } else { throw new Exception("An error occured: Could not find an encrypted or signed message!"); } if (lmContent.DataFormat == DataFormatTypes.Text) { strDisplay += lmContent.Text; strDisplay += "\r\n\r\n*** End OpenPGP Message ***\r\n"; if(fileOut != null && fileOut != "") { System.IO.FileStream fsOut = new FileStream(fileOut, FileMode.Create); System.IO.BinaryWriter bwOut = new BinaryWriter(fsOut); bwOut.Write(lmContent.Binary); bwOut.Close(); fsOut.Close(); } } else { System.IO.FileStream fsOut = new FileStream(fileOut, FileMode.Create); System.IO.BinaryWriter bwOut = new BinaryWriter(fsOut); bwOut.Write(lmContent.Binary); bwOut.Close(); fsOut.Close(); } return strDisplay; }
public async Task <bool> SignAsync( IKeyStorage keyStorage, WalletAddress address, CancellationToken cancellationToken = default(CancellationToken)) { var xtz = (Atomix.Tezos)Currency; if (address.KeyIndex == null) { Log.Error("Can't find private key for address {@address}", address); return(false); } var privateKey = keyStorage .GetPrivateKey(Currency, address.KeyIndex); if (privateKey == null) { Log.Error("Can't find private key for address {@address}", address); return(false); } var publicKey = keyStorage .GetPublicKey(Currency, address.KeyIndex); var rpc = new Rpc(xtz.RpcProvider); Head = await rpc .GetHeader() .ConfigureAwait(false); var managerKey = await rpc .GetManagerKey(From) .ConfigureAwait(false); Operations = new JArray(); var gas = GasLimit.ToString(CultureInfo.InvariantCulture); var storage = StorageLimit.ToString(CultureInfo.InvariantCulture); if (managerKey["key"] == null) { var revealOpCounter = await TezosCounter.Instance .GetCounter(xtz, From, Head) .ConfigureAwait(false); var revealOp = new JObject { ["kind"] = OperationType.Reveal, ["fee"] = "0", ["public_key"] = Base58Check.Encode(publicKey, Prefix.Edpk), ["source"] = From, ["storage_limit"] = storage, ["gas_limit"] = gas, ["counter"] = revealOpCounter.ToString() }; Operations.AddFirst(revealOp); } var counter = await TezosCounter.Instance .GetCounter(xtz, From, Head) .ConfigureAwait(false); var transaction = new JObject { ["kind"] = OperationType.Transaction, ["source"] = From, ["fee"] = Fee.ToString(CultureInfo.InvariantCulture), ["counter"] = counter.ToString(), ["gas_limit"] = gas, ["storage_limit"] = storage, ["amount"] = Math.Round(Amount, 0).ToString(CultureInfo.InvariantCulture), ["destination"] = To }; Operations.Add(transaction); if (Params != null) { transaction["parameters"] = Params; } else { var parameters = new JObject { ["prim"] = "Unit", ["args"] = new JArray() }; transaction["parameters"] = parameters; } var forgedOpGroup = await rpc .ForgeOperations(Head, Operations) .ConfigureAwait(false); SignedMessage = TezosSigner.SignHash( data: Hex.FromString(forgedOpGroup.ToString()), privateKey: privateKey, watermark: Watermark.Generic, isExtendedKey: privateKey.Length == 64); return(true); }
private static string GetSignature(GroupRegistration groupRegistration, SignedMessage signedMessage) { return(Convert.ToBase64String(groupRegistration.ContentBlinder.GetUnblindedSignature(Convert.FromBase64String(signedMessage.Signature)))); }
private static void DecryptAndVerify(SecretKeyRing skrSecretKeyRing, PublicKeyRing pkrPublicKeyRing, byte[] bData) { string strMessage = System.Text.Encoding.UTF8.GetString(bData); ArmorTypes atType = new ArmorTypes(); string strRest = ""; string strRadix64 = Armor.RemoveArmor(strMessage, ref atType, ref strRest); if (strRadix64.Length > 0) { bData = Radix64.Decode(strRadix64); } SharpPrivacy.OpenPGP.Messages.Message mContent = null; if (atType == ArmorTypes.OpenPGPSignature) { string strSignature = ""; string strSignedMessage = Armor.RemoveClearSignatureArmor(strMessage, ref atType, ref strSignature); strSignedMessage = Radix64.DashUnescape(strSignedMessage); strSignedMessage = Radix64.TrimMessage(strSignedMessage); SignedMessage smMessage = new SignedMessage(); Packet[] pPackets = Packet.ParsePackets(strSignature); if (!(pPackets[0] is SignaturePacket)) { MessageBox.Show("Not a valid cleartext signature!"); return; } smMessage.Signature = (SignaturePacket)pPackets[0]; LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Text); lmMessage.Text = strSignedMessage; smMessage.MessageSigned = lmMessage; mContent = smMessage; } else { // let us see what kind of message this is EncryptedMessage emMessage = new EncryptedMessage(); try { Packet[] pPackets = Packet.ParsePackets(bData); emMessage.ParseMessage(pPackets); if (emMessage.SymmetricallyEncrypted) { // Query passphrase for symmetrically encrypted message QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(); string strPassphrase = qpPassphrase.Passphrase; mContent = emMessage.Decrypt(strPassphrase); } else { ulong lKeyID = emMessage.GetFittingKeyID(skrSecretKeyRing); QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(skrSecretKeyRing.Find(lKeyID)); string strPassphrase = qpPassphrase.Passphrase; mContent = emMessage.Decrypt(skrSecretKeyRing, strPassphrase); } while ((!(mContent is LiteralMessage)) && (!(mContent is SignedMessage))) { if (mContent is CompressedMessage) { mContent = ((CompressedMessage)mContent).Uncompress(); } else { MessageBox.Show("This is not a valid OpenPGP message!"); return; } } } catch (Exception ee) { MessageBox.Show("There was an error decrypting your message: " + ee.Message); return; } } LiteralMessage lmContent = new LiteralMessage(); string strDisplay = ""; if (mContent is SignedMessage) { SignedMessage smContent = (SignedMessage)mContent; lmContent = smContent.MessageSigned; strDisplay += "*** OpenPGP Signed Message ***\r\n"; strDisplay += "*** Signature Status: " + smContent.Verify(pkrPublicKeyRing) + " ***\r\n"; strDisplay += "*** Signing Key: " + smContent.Signature.KeyID.ToString("x") + " ***\r\n"; strDisplay += "*** Signing Date: " + smContent.Signature.TimeCreated.ToString() + "***\r\n\r\n"; } else if (mContent is LiteralMessage) { lmContent = (LiteralMessage)mContent; strDisplay += "*** OpenPGP Encrypted Message ***\r\n\r\n"; } else { MessageBox.Show("An error occured: Could not find an encrypted or signed message!", "Error..."); return; } if (lmContent.DataFormat == DataFormatTypes.Text) { strDisplay += lmContent.Text; strDisplay += "\r\n\r\n*** End OpenPGP Message ***\r\n"; PlaintextViewer pvViewer = new PlaintextViewer(); pvViewer.MessageText = strDisplay; pvViewer.Show(); } else { if (MessageBox.Show(strDisplay, "Signature Status...", MessageBoxButtons.OKCancel, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1) == DialogResult.OK) { System.Windows.Forms.SaveFileDialog sfdSave = new SaveFileDialog(); sfdSave.OverwritePrompt = true; sfdSave.Filter = "All Files (*.*)|*.*"; sfdSave.FileName = lmContent.Filename; sfdSave.ShowDialog(); if (sfdSave.FileName.Length > 0) { System.IO.FileStream fsOut = new FileStream(sfdSave.FileName, FileMode.CreateNew); System.IO.BinaryWriter bwOut = new BinaryWriter(fsOut); bwOut.Write(lmContent.Binary); bwOut.Close(); fsOut.Close(); } } } }
public static string EncryptText(string strMessage, PublicKeyRing pkrPublicKeyRing, SecretKeyRing skrSecretKeyRing, bool bSign) { PublicKeySelector pksSelectKeys = new PublicKeySelector(pkrPublicKeyRing); pksSelectKeys.ShowDialog(); TransportableSecretKey tskKey = new TransportableSecretKey(); string strPassphrase = ""; if (bSign) { QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(skrSecretKeyRing); tskKey = qpPassphrase.SelectedKey; strPassphrase = qpPassphrase.Passphrase; } if (pksSelectKeys.SelectedKeys.Count == 0) return strMessage; Working wWorking = new Working(); wWorking.Show(); LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Text); lmMessage.Text = strMessage; lmMessage.TimeCreated = DateTime.Now; lmMessage.Filename = ""; SharpPrivacy.OpenPGP.Messages.Message mEncryptionMessage = lmMessage; if (bSign) { SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmMessage; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmMessage.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; mEncryptionMessage = smMessage; } CompressedMessage cmMessage = new CompressedMessage(); cmMessage.Compress(mEncryptionMessage); wWorking.Progress(20); SymAlgorithms saAlgo = GetSymAlgorithmPreferences(pksSelectKeys.SelectedKeys); SymmetricallyEncryptedDataPacket sedpEncrypted = new SymmetricallyEncryptedDataPacket(); SymmetricAlgorithm saEncrypt = CipherHelper.CreateSymAlgorithm(saAlgo); saEncrypt.Mode = CipherMode.OpenPGP_CFB; saEncrypt.GenerateKey(); byte[] bKey = saEncrypt.Key; wWorking.Progress(10); ESKSequence esksKeys = new ESKSequence(); try { esksKeys = CreateESKSequence(pksSelectKeys.SelectedKeys, AsymActions.Encrypt, saAlgo, bKey); } catch (Exception e) { wWorking.Hide(); MessageBox.Show("The following error occured: " + e.Message, "Error..."); return strMessage; } wWorking.Progress(50); ICryptoTransform ictEncryptor = saEncrypt.CreateEncryptor(); byte[] bMessage = cmMessage.GetEncoded(); byte[] bOutput = new byte[bMessage.Length]; ictEncryptor.TransformBlock(bMessage, 0, bMessage.Length, ref bOutput, 0); bKey.Initialize(); wWorking.Progress(10); int iOutLength = (saEncrypt.BlockSize >> 3) + 2 + bMessage.Length; sedpEncrypted.Body = new byte[iOutLength]; Array.Copy(bOutput, 0, sedpEncrypted.Body, 0, iOutLength); byte[] bESK = esksKeys.GetEncoded(); byte[] bEncrypted = sedpEncrypted.Generate(); byte[] bReturn = new byte[bESK.Length + bEncrypted.Length]; bESK.CopyTo(bReturn, 0); bEncrypted.CopyTo(bReturn, bESK.Length); wWorking.Progress(10); string strReturn = Radix64.Encode(bReturn, true); strReturn = Armor.WrapMessage(strReturn); wWorking.Hide(); return strReturn; }
private SignedMessage SignMessage(LiteralMessage lmToBeSigned, ulong lSignatureKeyID, string strPassphrase) { TransportableSecretKey tskKey = skrKeyRing.Find(lSignatureKeyID); SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmToBeSigned; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmToBeSigned.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; return smMessage; }
private string DecryptAndVerifyData(byte[] bData, string strPassphrase) { // let us see what kind of message this is bool bSymEncrypted = false; bool bAsymEncrypted = false; bool bSigned = false; SharpPrivacyLib.OpenPGP.Messages.Message mContent = null; EncryptedMessage emMessage = new EncryptedMessage(); Packet[] pPackets = Packet.ParsePackets(bData); XmlDocument xmlDoc = new XmlDocument(); XmlElement xmlMessage = xmlDoc.CreateElement("OpenPGPMessage"); try { emMessage.ParseMessage(pPackets); if (emMessage.SymmetricallyEncrypted) { mContent = emMessage.Decrypt(strPassphrase); bSymEncrypted = true; } else { ulong lKeyID = emMessage.GetFittingKeyID(skrKeyRing); mContent = emMessage.Decrypt(skrKeyRing, strPassphrase); bAsymEncrypted = true; } } catch (ArgumentException) { //obviously it wasn't an encrypted message. perhaps the //message has only been signed, but not encrypted! try { SignedMessage smMessage = new SignedMessage(); smMessage.ParseMessage(pPackets); mContent = smMessage; } catch (Exception e) { throw new Exception("Not a valid OpenPGP Message: " + e.Message); } } while ((!(mContent is LiteralMessage)) && (!(mContent is SignedMessage))) { if (mContent is CompressedMessage) { mContent = ((CompressedMessage)mContent).Uncompress(); } else { throw new Exception("Not a valid OpenPGP Message!"); } } LiteralMessage lmContent = new LiteralMessage(); if (mContent is SignedMessage) { bSigned = true; SignedMessage smContent = (SignedMessage)mContent; lmContent = smContent.MessageSigned; xmlMessage.SetAttribute("signaturestatus", smContent.Verify(pkrKeyRing).ToString()); xmlMessage.SetAttribute("signingkey", "0x" + smContent.Signature.KeyID.ToString("x")); xmlMessage.SetAttribute("signingdate", smContent.Signature.TimeCreated.Ticks.ToString()); mContent = lmContent; } xmlMessage.SetAttribute("symmetricallyencrypted", bSymEncrypted.ToString()); xmlMessage.SetAttribute("asymmetricallyencrypted", bAsymEncrypted.ToString()); xmlMessage.SetAttribute("signed", bSigned.ToString()); XmlElement xmlLiteral = xmlDoc.CreateElement("LiteralMessage"); if (mContent is LiteralMessage) { lmContent = (LiteralMessage)mContent; xmlLiteral.SetAttribute("dataformat", lmContent.DataFormat.ToString()); xmlLiteral.SetAttribute("timecreated", lmContent.TimeCreated.Ticks.ToString()); xmlLiteral.SetAttribute("filename", lmContent.Filename); } else { throw new Exception("Error decrypting the message!"); } if (lmContent.DataFormat == DataFormatTypes.Binary) { xmlLiteral.InnerText = Convert.ToBase64String(lmContent.Binary); } else { xmlLiteral.InnerText = lmContent.Text; } xmlMessage.AppendChild(xmlLiteral); return xmlMessage.OuterXml; }
/// <summary> /// Methond handling encryption/signing /// </summary> /// <param name="strFiles">file list to be encrypted</param> /// <param name="tskKey">secret key needed for encyption purpose</param> /// <param name="tpkKeys">public key needed for signing purpose</param> /// <param name="strPassphrase">passphrase for secret key</param> /// <param name="bEncrypt">encrypt files?</param> /// <param name="bSign">sign files?</param> public void EncryptFiles(String[] strFiles, TransportableSecretKey tskKey, ArrayList tpkKeys, string strPassphrase, bool bEncrypt, bool bSign, bool embedMsg) { if(this.pkrPublicKeyRing == null || this.skrSecretKeyRing == null) { throw new Exception("<ERROR code=\"5\">"); } if (bSign && tskKey == null) { throw new Exception("Need a Private Key To Sign!"); } if (bEncrypt && (tpkKeys == null || tpkKeys.Count < 1)) { throw new Exception("Need Public Keys To Encrypt!"); } for (int i=0; i<strFiles.Length; i++) { byte[] bFileContent = new byte[0]; try { System.IO.FileStream fsFile = new FileStream(strFiles[i], FileMode.Open); BinaryReader brReader = new BinaryReader(fsFile); bFileContent = brReader.ReadBytes((int)fsFile.Length); brReader.Close(); fsFile.Close(); } catch (Exception e) { throw new Exception("An error occured while opening the file " + strFiles[i] + ": " + e.Message); } LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Binary); lmMessage.Binary = bFileContent; lmMessage.TimeCreated = DateTime.Now; int iLastBackslash = strFiles[i].LastIndexOf("\\"); lmMessage.Filename = strFiles[i].Substring(iLastBackslash + 1, strFiles[i].Length - iLastBackslash - 1); SharpPrivacy.SharpPrivacyLib.OpenPGP.Messages.Message mEncryptionMessage = lmMessage; if (bSign) { SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmMessage; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmMessage.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; mEncryptionMessage = smMessage; } CompressedMessage cmMessage = new CompressedMessage(); cmMessage.Compress(mEncryptionMessage); byte[] bReturn = new byte[0]; if (bEncrypt) { SymAlgorithms saAlgo = GetSymAlgorithmPreferences(tpkKeys); SymmetricallyEncryptedDataPacket sedpEncrypted = new SymmetricallyEncryptedDataPacket(); SymmetricAlgorithm saEncrypt = CipherHelper.CreateSymAlgorithm(saAlgo); saEncrypt.Mode = CipherMode.OpenPGP_CFB; saEncrypt.GenerateKey(); byte[] bKey = saEncrypt.Key; ESKSequence esksKeys = new ESKSequence(); try { esksKeys = CreateESKSequence(tpkKeys, AsymActions.Encrypt, saAlgo, bKey); } catch (Exception e) { throw new Exception("The following error occured: " + e.Message); } ICryptoTransform ictEncryptor = saEncrypt.CreateEncryptor(); byte[] bMessage = cmMessage.GetEncoded(); byte[] bOutput = new byte[bMessage.Length]; ictEncryptor.TransformBlock(bMessage, 0, bMessage.Length, ref bOutput, 0); bKey.Initialize(); int iOutLength = (saEncrypt.BlockSize >> 3) + 2 + bMessage.Length; sedpEncrypted.Body = new byte[iOutLength]; Array.Copy(bOutput, 0, sedpEncrypted.Body, 0, iOutLength); byte[] bESK = esksKeys.GetEncoded(); byte[] bEncrypted = sedpEncrypted.Generate(); bReturn = new byte[bESK.Length + bEncrypted.Length]; bESK.CopyTo(bReturn, 0); bEncrypted.CopyTo(bReturn, bESK.Length); } else { if(embedMsg) { bReturn = cmMessage.GetEncoded(); } else { byte[] bSignature = ((SignedMessage)mEncryptionMessage).Signature.Generate(); string strSignature = Radix64.Encode(bSignature, true); string strFinal = Armor.WrapCleartextSignature(strSignature); try { FileStream fsOut = new FileStream(strFiles[i] + ".asc", FileMode.Create); StreamWriter bwWrite = new StreamWriter(fsOut); bwWrite.Write(strFinal); bwWrite.Close(); fsOut.Close(); return; } catch (IOException io) { throw new Exception("Could not write to file. The following error occured: " + io.Message); } } } try { FileStream fsOut = new FileStream(strFiles[i] + ".asc", FileMode.Create); BinaryWriter bwWrite = new BinaryWriter(fsOut); bwWrite.Write(bReturn); bwWrite.Close(); fsOut.Close(); } catch (IOException io) { throw new Exception("Could not write to file. The following error occured: " + io.Message); } } }
public static void EncryptFiles(String[] strFiles, PublicKeyRing pkrPublicKeyRing, SecretKeyRing skrSecretKeyRing, bool bEncrypt, bool bSign) { PublicKeySelector pksSelectKeys = new PublicKeySelector(pkrPublicKeyRing); if (bEncrypt) { pksSelectKeys.ShowDialog(); if (pksSelectKeys.SelectedKeys.Count == 0) { MessageBox.Show("You did not select a public key to encrypt to. Doing nothing...", "Nothing Done..."); return; } } TransportableSecretKey tskKey = new TransportableSecretKey(); string strPassphrase = ""; if (bSign) { QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(skrSecretKeyRing); tskKey = qpPassphrase.SelectedKey; strPassphrase = qpPassphrase.Passphrase; } Working wWorking = new Working(); wWorking.Show(); for (int i=0; i<strFiles.Length; i++) { byte[] bFileContent = new byte[0]; try { System.IO.FileStream fsFile = new FileStream(strFiles[i], FileMode.Open); BinaryReader brReader = new BinaryReader(fsFile); bFileContent = brReader.ReadBytes((int)fsFile.Length); brReader.Close(); fsFile.Close(); } catch (Exception e) { wWorking.Hide(); MessageBox.Show("An error occured while opening the file " + strFiles[i] + ": " + e.Message, "Error..."); return; } LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Binary); lmMessage.Binary = bFileContent; lmMessage.TimeCreated = DateTime.Now; int iLastBackslash = strFiles[i].LastIndexOf("\\"); lmMessage.Filename = strFiles[i].Substring(iLastBackslash + 1, strFiles[i].Length - iLastBackslash - 1); SharpPrivacy.OpenPGP.Messages.Message mEncryptionMessage = lmMessage; if (bSign) { SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmMessage; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmMessage.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; mEncryptionMessage = smMessage; } CompressedMessage cmMessage = new CompressedMessage(); cmMessage.Compress(mEncryptionMessage); wWorking.Progress(20/strFiles.Length); SymAlgorithms saAlgo = GetSymAlgorithmPreferences(pksSelectKeys.SelectedKeys); wWorking.Progress(10/strFiles.Length); byte[] bReturn = new byte[0]; if (bEncrypt) { SymmetricallyEncryptedDataPacket sedpEncrypted = new SymmetricallyEncryptedDataPacket(); SymmetricAlgorithm saEncrypt = CipherHelper.CreateSymAlgorithm(saAlgo); saEncrypt.Mode = CipherMode.OpenPGP_CFB; saEncrypt.GenerateKey(); byte[] bKey = saEncrypt.Key; ESKSequence esksKeys = new ESKSequence(); try { esksKeys = CreateESKSequence(pksSelectKeys.SelectedKeys, AsymActions.Encrypt, saAlgo, bKey); } catch (Exception e) { wWorking.Hide(); MessageBox.Show("The following error occured: " + e.Message, "Error..."); return; } wWorking.Progress(50/strFiles.Length); ICryptoTransform ictEncryptor = saEncrypt.CreateEncryptor(); byte[] bMessage = cmMessage.GetEncoded(); byte[] bOutput = new byte[bMessage.Length]; ictEncryptor.TransformBlock(bMessage, 0, bMessage.Length, ref bOutput, 0); bKey.Initialize(); wWorking.Progress(10/strFiles.Length); int iOutLength = (saEncrypt.BlockSize >> 3) + 2 + bMessage.Length; sedpEncrypted.Body = new byte[iOutLength]; Array.Copy(bOutput, 0, sedpEncrypted.Body, 0, iOutLength); byte[] bESK = esksKeys.GetEncoded(); byte[] bEncrypted = sedpEncrypted.Generate(); bReturn = new byte[bESK.Length + bEncrypted.Length]; bESK.CopyTo(bReturn, 0); bEncrypted.CopyTo(bReturn, bESK.Length); } else { wWorking.Progress(60/strFiles.Length); bReturn = cmMessage.GetEncoded(); } wWorking.Progress(10/strFiles.Length); try { FileStream fsOut = new FileStream(strFiles[i] + ".asc", FileMode.CreateNew); BinaryWriter bwWrite = new BinaryWriter(fsOut); bwWrite.Write(bReturn); bwWrite.Close(); fsOut.Close(); } catch (IOException io) { MessageBox.Show("Could not write to file. The following error occured: " + io.Message, "Error..."); } } wWorking.Hide(); }
/// <summary> /// Method handling encryption/signing /// </summary> /// <param name="strMessage">text to be encrypted</param> /// <param name="tskKey">secret key needed for encyption purpose</param> /// <param name="tpkKeys">public key needed for signing purpose</param> /// <param name="bSign">sign text?</param> /// <param name="strPassphrase">passphrase for the secret key</param> /// <returns>the encrypted text</returns> public string EncryptText(string strMessage, TransportableSecretKey tskKey, ArrayList tpkKeys, bool bSign, string strPassphrase) { if(this.pkrPublicKeyRing == null || this.skrSecretKeyRing == null) { throw new Exception("<ERROR code=\"5\">"); } if(bSign && tskKey == null) { throw new Exception("Need a Private Key To Sign!"); } LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Text); lmMessage.Text = strMessage; lmMessage.TimeCreated = DateTime.Now; lmMessage.Filename = ""; SharpPrivacy.SharpPrivacyLib.OpenPGP.Messages.Message mEncryptionMessage = lmMessage; if (bSign) { SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmMessage; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmMessage.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; mEncryptionMessage = smMessage; } CompressedMessage cmMessage = new CompressedMessage(); cmMessage.Compress(mEncryptionMessage); SymAlgorithms saAlgo = GetSymAlgorithmPreferences(tpkKeys); SymmetricallyEncryptedDataPacket sedpEncrypted = new SymmetricallyEncryptedDataPacket(); SymmetricAlgorithm saEncrypt = CipherHelper.CreateSymAlgorithm(saAlgo); saEncrypt.Mode = CipherMode.OpenPGP_CFB; saEncrypt.GenerateKey(); byte[] bKey = saEncrypt.Key; ESKSequence esksKeys = new ESKSequence(); try { esksKeys = CreateESKSequence(tpkKeys, AsymActions.Encrypt, saAlgo, bKey); } catch (Exception e) { throw new Exception("The following error occured: " + e.Message); } ICryptoTransform ictEncryptor = saEncrypt.CreateEncryptor(); byte[] bMessage = cmMessage.GetEncoded(); byte[] bOutput = new byte[bMessage.Length]; ictEncryptor.TransformBlock(bMessage, 0, bMessage.Length, ref bOutput, 0); bKey.Initialize(); int iOutLength = (saEncrypt.BlockSize >> 3) + 2 + bMessage.Length; sedpEncrypted.Body = new byte[iOutLength]; Array.Copy(bOutput, 0, sedpEncrypted.Body, 0, iOutLength); byte[] bESK = esksKeys.GetEncoded(); byte[] bEncrypted = sedpEncrypted.Generate(); byte[] bReturn = new byte[bESK.Length + bEncrypted.Length]; bESK.CopyTo(bReturn, 0); bEncrypted.CopyTo(bReturn, bESK.Length); string strReturn = Radix64.Encode(bReturn, true); strReturn = Armor.WrapMessage(strReturn); return strReturn; }
/// <summary> /// Send message to the channel /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Send(object sender, RoutedEventArgs e) { List <ChatUser> selectedToSend = new List <ChatUser>(); foreach (ChatUser cu in Book.UserList) { if (cu.Selected) { selectedToSend.Add(cu); } } this.Dispatcher.Invoke(() => { Message MessageToSend = null; if (UploadReady) { //send the uploaded file with the text message MessageToSend = Uploaded; MessageToSend.Sender = messageModule.Id; MessageToSend.StringContent = MessageText.Text; } else { //prepare a text message MessageToSend = new Message() { Sender = messageModule.Id, Kind = MessageKindType.STRING, StringContent = MessageText.Text }; } if (selectedToSend.Count == 0) { SignedMessage signedTextMessage = new SignedMessage(MessageToSend.ToJson()); messageModule.SendMessage <string>(signedTextMessage.ToJson()); } else { bool sentToMyself = false; foreach (ChatUser cu in selectedToSend) { MessageToSend.Destination = cu.Sender; SignedMessage signedTextMessage = new SignedMessage(MessageToSend.ToJson()); messageModule.SendMessage <string>(signedTextMessage.ToJson()); if (cu.Sender == UserProfile.Sender) { sentToMyself = true; } } if (!sentToMyself) { //send always a copy of the encrypted message to myself MessageToSend.Destination = UserProfile.Sender; SignedMessage signedTextMessage = new SignedMessage(MessageToSend.ToJson()); messageModule.SendMessage <string>(signedTextMessage.ToJson()); } } MessageText.Text = string.Empty; Uploaded = null; UploadReady = false; }); }
private string DecryptAndVerifyData(byte[] bData, string strPassphrase) { // let us see what kind of message this is bool bSymEncrypted = false; bool bAsymEncrypted = false; bool bSigned = false; SharpPrivacyLib.OpenPGP.Messages.Message mContent = null; EncryptedMessage emMessage = new EncryptedMessage(); Packet[] pPackets = Packet.ParsePackets(bData); XmlDocument xmlDoc = new XmlDocument(); XmlElement xmlMessage = xmlDoc.CreateElement("OpenPGPMessage"); try { emMessage.ParseMessage(pPackets); if (emMessage.SymmetricallyEncrypted) { mContent = emMessage.Decrypt(strPassphrase); bSymEncrypted = true; } else { ulong lKeyID = emMessage.GetFittingKeyID(skrKeyRing); mContent = emMessage.Decrypt(skrKeyRing, strPassphrase); bAsymEncrypted = true; } } catch (ArgumentException) { //obviously it wasn't an encrypted message. perhaps the //message has only been signed, but not encrypted! try { SignedMessage smMessage = new SignedMessage(); smMessage.ParseMessage(pPackets); mContent = smMessage; } catch (Exception e) { throw new Exception("Not a valid OpenPGP Message: " + e.Message); } } while ((!(mContent is LiteralMessage)) && (!(mContent is SignedMessage))) { if (mContent is CompressedMessage) { mContent = ((CompressedMessage)mContent).Uncompress(); } else { throw new Exception("Not a valid OpenPGP Message!"); } } LiteralMessage lmContent = new LiteralMessage(); if (mContent is SignedMessage) { bSigned = true; SignedMessage smContent = (SignedMessage)mContent; lmContent = smContent.MessageSigned; xmlMessage.SetAttribute("signaturestatus", smContent.Verify(pkrKeyRing).ToString()); xmlMessage.SetAttribute("signingkey", "0x" + smContent.Signature.KeyID.ToString("x")); xmlMessage.SetAttribute("signingdate", smContent.Signature.TimeCreated.Ticks.ToString()); mContent = lmContent; } xmlMessage.SetAttribute("symmetricallyencrypted", bSymEncrypted.ToString()); xmlMessage.SetAttribute("asymmetricallyencrypted", bAsymEncrypted.ToString()); xmlMessage.SetAttribute("signed", bSigned.ToString()); XmlElement xmlLiteral = xmlDoc.CreateElement("LiteralMessage"); if (mContent is LiteralMessage) { lmContent = (LiteralMessage)mContent; xmlLiteral.SetAttribute("dataformat", lmContent.DataFormat.ToString()); xmlLiteral.SetAttribute("timecreated", lmContent.TimeCreated.Ticks.ToString()); xmlLiteral.SetAttribute("filename", lmContent.Filename); } else { throw new Exception("Error decrypting the message!"); } if (lmContent.DataFormat == DataFormatTypes.Binary) { xmlLiteral.InnerText = Convert.ToBase64String(lmContent.Binary); } else { xmlLiteral.InnerText = lmContent.Text; } xmlMessage.AppendChild(xmlLiteral); return(xmlMessage.OuterXml); }
/// <summary> /// Uncompresses the current compressed message and returns the message that /// was inside of the compressed message. Usually this should be a literal /// data message. /// </summary> /// <returns>Returns the message that was inside of the compressed message. /// Usually this should be a literal data message.</returns> /// <exception cref="System.Exception">Throws an exception if the content /// of the compressed message is not another valid message.</exception> /// <remarks>No remarks</remarks> public Message Uncompress() { if (!(pPackets[0] is CompressedDataPacket)) throw new System.Exception("You should never see this message. If you do, something in CompressedMessage went terribly wrong!"); CompressedDataPacket cdpPacket = (CompressedDataPacket)pPackets[0]; Packet[] pContent = cdpPacket.Uncompress(); // A compressed data packet can contain: // - a literal message LiteralMessage lmMessage = new LiteralMessage(); try { int iPos = lmMessage.ParseMessage(pContent); return lmMessage; } catch (Exception) {} // - a signed message SignedMessage smMessage = new SignedMessage(); try { int iPos = smMessage.ParseMessage(pContent); return smMessage; } catch (Exception) {} // TODO: Try to think of other packets that might // occur in a compressed data packet throw new Exception("The content of the compressed message does not appear to be a valid OpenPGP message!"); }
public static void EncryptFiles(String[] strFiles, PublicKeyRing pkrPublicKeyRing, SecretKeyRing skrSecretKeyRing, bool bEncrypt, bool bSign) { PublicKeySelector pksSelectKeys = new PublicKeySelector(pkrPublicKeyRing); if (bEncrypt) { pksSelectKeys.ShowDialog(); if (pksSelectKeys.SelectedKeys.Count == 0) { MessageBox.Show("You did not select a public key to encrypt to. Doing nothing...", "Nothing Done..."); return; } } TransportableSecretKey tskKey = new TransportableSecretKey(); string strPassphrase = ""; if (bSign) { QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(skrSecretKeyRing); tskKey = qpPassphrase.SelectedKey; strPassphrase = qpPassphrase.Passphrase; } Working wWorking = new Working(); wWorking.Show(); for (int i = 0; i < strFiles.Length; i++) { byte[] bFileContent = new byte[0]; try { System.IO.FileStream fsFile = new FileStream(strFiles[i], FileMode.Open); BinaryReader brReader = new BinaryReader(fsFile); bFileContent = brReader.ReadBytes((int)fsFile.Length); brReader.Close(); fsFile.Close(); } catch (Exception e) { wWorking.Hide(); MessageBox.Show("An error occured while opening the file " + strFiles[i] + ": " + e.Message, "Error..."); return; } LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Binary); lmMessage.Binary = bFileContent; lmMessage.TimeCreated = DateTime.Now; int iLastBackslash = strFiles[i].LastIndexOf("\\"); lmMessage.Filename = strFiles[i].Substring(iLastBackslash + 1, strFiles[i].Length - iLastBackslash - 1); SharpPrivacy.OpenPGP.Messages.Message mEncryptionMessage = lmMessage; if (bSign) { SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmMessage; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmMessage.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; mEncryptionMessage = smMessage; } CompressedMessage cmMessage = new CompressedMessage(); cmMessage.Compress(mEncryptionMessage); wWorking.Progress(20 / strFiles.Length); SymAlgorithms saAlgo = GetSymAlgorithmPreferences(pksSelectKeys.SelectedKeys); wWorking.Progress(10 / strFiles.Length); byte[] bReturn = new byte[0]; if (bEncrypt) { SymmetricallyEncryptedDataPacket sedpEncrypted = new SymmetricallyEncryptedDataPacket(); SymmetricAlgorithm saEncrypt = CipherHelper.CreateSymAlgorithm(saAlgo); saEncrypt.Mode = CipherMode.OpenPGP_CFB; saEncrypt.GenerateKey(); byte[] bKey = saEncrypt.Key; ESKSequence esksKeys = new ESKSequence(); try { esksKeys = CreateESKSequence(pksSelectKeys.SelectedKeys, AsymActions.Encrypt, saAlgo, bKey); } catch (Exception e) { wWorking.Hide(); MessageBox.Show("The following error occured: " + e.Message, "Error..."); return; } wWorking.Progress(50 / strFiles.Length); ICryptoTransform ictEncryptor = saEncrypt.CreateEncryptor(); byte[] bMessage = cmMessage.GetEncoded(); byte[] bOutput = new byte[bMessage.Length]; ictEncryptor.TransformBlock(bMessage, 0, bMessage.Length, ref bOutput, 0); bKey.Initialize(); wWorking.Progress(10 / strFiles.Length); int iOutLength = (saEncrypt.BlockSize >> 3) + 2 + bMessage.Length; sedpEncrypted.Body = new byte[iOutLength]; Array.Copy(bOutput, 0, sedpEncrypted.Body, 0, iOutLength); byte[] bESK = esksKeys.GetEncoded(); byte[] bEncrypted = sedpEncrypted.Generate(); bReturn = new byte[bESK.Length + bEncrypted.Length]; bESK.CopyTo(bReturn, 0); bEncrypted.CopyTo(bReturn, bESK.Length); } else { wWorking.Progress(60 / strFiles.Length); bReturn = cmMessage.GetEncoded(); } wWorking.Progress(10 / strFiles.Length); try { FileStream fsOut = new FileStream(strFiles[i] + ".asc", FileMode.CreateNew); BinaryWriter bwWrite = new BinaryWriter(fsOut); bwWrite.Write(bReturn); bwWrite.Close(); fsOut.Close(); } catch (IOException io) { MessageBox.Show("Could not write to file. The following error occured: " + io.Message, "Error..."); } } wWorking.Hide(); }
private static void DecryptAndVerify(SecretKeyRing skrSecretKeyRing, PublicKeyRing pkrPublicKeyRing, byte[] bData) { string strMessage = System.Text.Encoding.UTF8.GetString(bData); ArmorTypes atType = new ArmorTypes(); string strRest = ""; string strRadix64 = Armor.RemoveArmor(strMessage, ref atType, ref strRest); if (strRadix64.Length > 0) bData = Radix64.Decode(strRadix64); SharpPrivacy.OpenPGP.Messages.Message mContent = null; if (atType == ArmorTypes.OpenPGPSignature) { string strSignature = ""; string strSignedMessage = Armor.RemoveClearSignatureArmor(strMessage, ref atType, ref strSignature); strSignedMessage = Radix64.DashUnescape(strSignedMessage); strSignedMessage = Radix64.TrimMessage(strSignedMessage); SignedMessage smMessage = new SignedMessage(); Packet[] pPackets = Packet.ParsePackets(strSignature); if (!(pPackets[0] is SignaturePacket)) { MessageBox.Show("Not a valid cleartext signature!"); return; } smMessage.Signature = (SignaturePacket)pPackets[0]; LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Text); lmMessage.Text = strSignedMessage; smMessage.MessageSigned = lmMessage; mContent = smMessage; } else { // let us see what kind of message this is EncryptedMessage emMessage = new EncryptedMessage(); try { Packet[] pPackets = Packet.ParsePackets(bData); emMessage.ParseMessage(pPackets); if (emMessage.SymmetricallyEncrypted) { // Query passphrase for symmetrically encrypted message QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(); string strPassphrase = qpPassphrase.Passphrase; mContent = emMessage.Decrypt(strPassphrase); } else { ulong lKeyID = emMessage.GetFittingKeyID(skrSecretKeyRing); QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(skrSecretKeyRing.Find(lKeyID)); string strPassphrase = qpPassphrase.Passphrase; mContent = emMessage.Decrypt(skrSecretKeyRing, strPassphrase); } while ((!(mContent is LiteralMessage)) && (!(mContent is SignedMessage))) { if (mContent is CompressedMessage) { mContent = ((CompressedMessage)mContent).Uncompress(); } else { MessageBox.Show("This is not a valid OpenPGP message!"); return; } } } catch (Exception ee) { MessageBox.Show("There was an error decrypting your message: " + ee.Message); return; } } LiteralMessage lmContent = new LiteralMessage(); string strDisplay = ""; if (mContent is SignedMessage) { SignedMessage smContent = (SignedMessage)mContent; lmContent = smContent.MessageSigned; strDisplay += "*** OpenPGP Signed Message ***\r\n"; strDisplay += "*** Signature Status: " + smContent.Verify(pkrPublicKeyRing) + " ***\r\n"; strDisplay += "*** Signing Key: " + smContent.Signature.KeyID.ToString("x") + " ***\r\n"; strDisplay += "*** Signing Date: " + smContent.Signature.TimeCreated.ToString() + "***\r\n\r\n"; } else if (mContent is LiteralMessage) { lmContent = (LiteralMessage)mContent; strDisplay += "*** OpenPGP Encrypted Message ***\r\n\r\n"; } else { MessageBox.Show("An error occured: Could not find an encrypted or signed message!", "Error..."); return; } if (lmContent.DataFormat == DataFormatTypes.Text) { strDisplay += lmContent.Text; strDisplay += "\r\n\r\n*** End OpenPGP Message ***\r\n"; PlaintextViewer pvViewer = new PlaintextViewer(); pvViewer.MessageText = strDisplay; pvViewer.Show(); } else { if (MessageBox.Show(strDisplay, "Signature Status...", MessageBoxButtons.OKCancel, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1) == DialogResult.OK) { System.Windows.Forms.SaveFileDialog sfdSave = new SaveFileDialog(); sfdSave.OverwritePrompt = true; sfdSave.Filter = "All Files (*.*)|*.*"; sfdSave.FileName = lmContent.Filename; sfdSave.ShowDialog(); if (sfdSave.FileName.Length > 0) { System.IO.FileStream fsOut = new FileStream(sfdSave.FileName, FileMode.CreateNew); System.IO.BinaryWriter bwOut = new BinaryWriter(fsOut); bwOut.Write(lmContent.Binary); bwOut.Close(); fsOut.Close(); } } } }
private async Task <List <OperationResult> > SendOperations(JToken operations, Keys keys, JObject head = null) { if (head == null) { head = await GetHeader(); } JArray arrOps = operations as JArray; if (arrOps == null) { arrOps = new JArray(operations); } JToken forgedOpGroup = await ForgeOperations(head, arrOps); // TODO: Not sure about what is this for //if (keys == null) //{ // signedOpGroup = new SignedMessage // { // SignedBytes = forgedOpGroup.ToString() + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", // EncodedSignature = "edsigtXomBKi5CTRf5cjATJWSyaRvhfYNHqSUGrn4SdbYRcGwQrUGjzEfQDTuqHhuA8b2d8NarZjz8TRf65WkpQmo423BtomS8Q" // }; //} //else //{ // Crypto c = new Crypto(); // signedOpGroup = c.Sign(forgedOpGroup.ToString(), keys, Watermark.Generic); //} Crypto c = new Crypto(); SignedMessage signedOpGroup = c.Sign(forgedOpGroup.ToString(), keys, Watermark.Generic); List <OperationResult> opResults = await PreApplyOperations(head, arrOps, signedOpGroup.EncodedSignature); ///deleting too big contractCode from response foreach (var opResult in opResults) { if (opResult.Data?["metadata"]?["operation_result"]?["status"]?.ToString() == "failed") { foreach (JObject error in opResult.Data["metadata"]["operation_result"]["errors"]) { if (error["contractCode"]?.ToString().Length > 1000) { error["contractCode"] = ""; } } } } string op_hash = ""; if (opResults.All(op => op.Succeeded)) { JToken injectedOperation = await InjectOperations(signedOpGroup.SignedBytes); op_hash = injectedOperation.ToString(); opResults.LastOrDefault().Data["op_hash"] = op_hash; } return(opResults); }
public static string EncryptText(string strMessage, PublicKeyRing pkrPublicKeyRing, SecretKeyRing skrSecretKeyRing, bool bSign) { PublicKeySelector pksSelectKeys = new PublicKeySelector(pkrPublicKeyRing); pksSelectKeys.ShowDialog(); TransportableSecretKey tskKey = new TransportableSecretKey(); string strPassphrase = ""; if (bSign) { QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(skrSecretKeyRing); tskKey = qpPassphrase.SelectedKey; strPassphrase = qpPassphrase.Passphrase; } if (pksSelectKeys.SelectedKeys.Count == 0) { return(strMessage); } Working wWorking = new Working(); wWorking.Show(); LiteralMessage lmMessage = new LiteralMessage(DataFormatTypes.Text); lmMessage.Text = strMessage; lmMessage.TimeCreated = DateTime.Now; lmMessage.Filename = ""; SharpPrivacy.OpenPGP.Messages.Message mEncryptionMessage = lmMessage; if (bSign) { SignedMessage smMessage = new SignedMessage(); smMessage.MessageSigned = lmMessage; SignaturePacket spPacket = new SignaturePacket(); spPacket.Version = SignaturePacketVersionNumbers.v3; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spPacket.KeyID = skpKey.PublicKey.KeyID; spPacket.HashAlgorithm = HashAlgorithms.SHA1; spPacket.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spPacket.TimeCreated = DateTime.Now; spPacket.SignatureType = SignatureTypes.TextSignature; spPacket.Sign(lmMessage.Binary, skpKey, strPassphrase); smMessage.Signature = spPacket; mEncryptionMessage = smMessage; } CompressedMessage cmMessage = new CompressedMessage(); cmMessage.Compress(mEncryptionMessage); wWorking.Progress(20); SymAlgorithms saAlgo = GetSymAlgorithmPreferences(pksSelectKeys.SelectedKeys); SymmetricallyEncryptedDataPacket sedpEncrypted = new SymmetricallyEncryptedDataPacket(); SymmetricAlgorithm saEncrypt = CipherHelper.CreateSymAlgorithm(saAlgo); saEncrypt.Mode = CipherMode.OpenPGP_CFB; saEncrypt.GenerateKey(); byte[] bKey = saEncrypt.Key; wWorking.Progress(10); ESKSequence esksKeys = new ESKSequence(); try { esksKeys = CreateESKSequence(pksSelectKeys.SelectedKeys, AsymActions.Encrypt, saAlgo, bKey); } catch (Exception e) { wWorking.Hide(); MessageBox.Show("The following error occured: " + e.Message, "Error..."); return(strMessage); } wWorking.Progress(50); ICryptoTransform ictEncryptor = saEncrypt.CreateEncryptor(); byte[] bMessage = cmMessage.GetEncoded(); byte[] bOutput = new byte[bMessage.Length]; ictEncryptor.TransformBlock(bMessage, 0, bMessage.Length, ref bOutput, 0); bKey.Initialize(); wWorking.Progress(10); int iOutLength = (saEncrypt.BlockSize >> 3) + 2 + bMessage.Length; sedpEncrypted.Body = new byte[iOutLength]; Array.Copy(bOutput, 0, sedpEncrypted.Body, 0, iOutLength); byte[] bESK = esksKeys.GetEncoded(); byte[] bEncrypted = sedpEncrypted.Generate(); byte[] bReturn = new byte[bESK.Length + bEncrypted.Length]; bESK.CopyTo(bReturn, 0); bEncrypted.CopyTo(bReturn, bESK.Length); wWorking.Progress(10); string strReturn = Radix64.Encode(bReturn, true); strReturn = Armor.WrapMessage(strReturn); wWorking.Hide(); return(strReturn); }