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);
}
