/// <summary> /// Revoke a subkey /// </summary> /// <param name="KeyID">subkey ID</param> /// <param name="skpKeySigner">revoker secret key</param> /// <param name="strPassphrase">revoker passphrase</param> /// <param name="exportable">exportable revocation</param> public void RevokeSubKey(ulong KeyID, TransportableSecretKey skpKeySigner, string strPassphrase, bool exportable) { TransportablePublicKey tspKey = this.PublicRing.Find(KeyID,false); if(tspKey == null) throw new Exception("Public Key not found"); if(tspKey.PrimaryKey.KeyID == KeyID) throw new Exception("This is a primary key... use RevokeKey method instead."); CertifiedPublicSubkey cps = null; foreach(CertifiedPublicSubkey cpsi in tspKey.SubKeys) { if(cpsi.Subkey.KeyID == KeyID) cps = cpsi; } bool allowed = false; ulong issuer = skpKeySigner.PrimaryKey.PublicKey.KeyID; if(issuer == tspKey.PrimaryKey.KeyID) { allowed = true; } else { foreach (SignaturePacket spPacket in tspKey.RevocationKeys) { foreach (BigInteger revoker in spPacket.FindRevokerKeys()) { if (revoker.ToString() == skpKeySigner.PrimaryKey.PublicKey.Fingerprint.ToString()) { allowed = true; } } } } if (allowed && cps.KeyBindingSignature.isRevocable()) { if (this.PublicRing.isRevoked(KeyID)) throw new Exception("Public SubKey alreadyRevoked"); SignaturePacket spSig = new SignaturePacket(); spSig.Version = SignaturePacketVersionNumbers.v4; spSig.HashAlgorithm = HashAlgorithms.SHA1; spSig.KeyID = skpKeySigner.PrimaryKey.PublicKey.KeyID; spSig.TimeCreated = DateTime.Now; SignatureSubPacket sspExportableSignature = new SignatureSubPacket(); sspExportableSignature.Type = SignatureSubPacketTypes.ExportableSignature; sspExportableSignature.ExportableSignature = exportable; spSig.AddSubPacket(sspExportableSignature, false); byte[] subkey = new byte[cps.Subkey.Length]; cps.Subkey.Header.CopyTo(subkey,0); cps.Subkey.Body.CopyTo(subkey,cps.Subkey.Header.Length); subkey[0]=0x99; byte[] mainkey = new byte[tspKey.PrimaryKey.Length]; tspKey.PrimaryKey.Header.CopyTo(mainkey,0); tspKey.PrimaryKey.Body.CopyTo(mainkey,tspKey.PrimaryKey.Header.Length); byte[] key = new byte[subkey.Length+mainkey.Length]; mainkey.CopyTo(key,0); subkey.CopyTo(key,mainkey.Length); spSig.SignatureType = SignatureTypes.SubkeyRevocationSignature; spSig.Sign(key, skpKeySigner.PrimaryKey, strPassphrase); cps.RevocationSignature=spSig; } else throw new Exception("Not allowed to revoke this subkey"); }
/// <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> /// Revoke a key /// </summary> /// <param name="KeyID">key to be revoked</param> /// <param name="skpKeySigner">revoker secret key</param> /// <param name="strPassphrase">revoker passphrase</param> /// <param name="exportable">exportable revocation</param> public void RevokeKey(ulong KeyID, TransportableSecretKey skpKeySigner, string strPassphrase, bool exportable) { TransportablePublicKey tspKey = this.PublicRing.Find(KeyID,false); if (tspKey == null) throw new Exception("Public Key not found"); if (this.PublicRing.isRevoked(KeyID)) throw new Exception("Public Key alreadyRevoked"); if (tspKey.PrimaryKey.KeyID != KeyID) throw new Exception("This is not a Primary key... use Revoke Subkey method instead"); foreach (SignaturePacket sign in tspKey.PrimaryUserIDCert.Certificates) { if (!sign.isRevocable()) return; } bool isRevokerKey = false; if (KeyID == skpKeySigner.PrimaryKey.PublicKey.KeyID) { isRevokerKey = true; } else { foreach (SignaturePacket spPacket in tspKey.RevocationKeys) { foreach (BigInteger revoker in spPacket.FindRevokerKeys()) { if (revoker.ToString() == skpKeySigner.PrimaryKey.PublicKey.Fingerprint.ToString()) { isRevokerKey = true; } } } } if (!isRevokerKey) throw new Exception("You cannot revoke this key"); SignaturePacket spSig = new SignaturePacket(); spSig.Version = SignaturePacketVersionNumbers.v4; spSig.HashAlgorithm = HashAlgorithms.SHA1; spSig.KeyID = skpKeySigner.PrimaryKey.PublicKey.KeyID; spSig.TimeCreated = DateTime.Now; SignatureSubPacket sspExportableSignature = new SignatureSubPacket(); sspExportableSignature.Type = SignatureSubPacketTypes.ExportableSignature; sspExportableSignature.ExportableSignature = exportable; spSig.AddSubPacket(sspExportableSignature, false); PublicKeyPacket pkpKey = tspKey.PrimaryKey; byte[] key = new byte[tspKey.PrimaryKey.Length]; tspKey.PrimaryKey.Header.CopyTo(key,0); tspKey.PrimaryKey.Body.CopyTo(key,tspKey.PrimaryKey.Header.Length); spSig.SignatureType = SignatureTypes.KeyRevocationSignature; spSig.Sign(key, skpKeySigner.PrimaryKey, strPassphrase); tspKey.RevocationSignatures.Add(spSig); }
/// <summary> /// Text signing /// </summary> /// <param name="strMessage">text to be signed</param> /// <param name="tskKey">secret key for signing purpose</param> /// <param name="strPassphrase">passphrase for the secret key</param> /// <returns>the signed text</returns> public string ClearTextSign(string strMessage, TransportableSecretKey tskKey, string strPassphrase, bool embedMessage) { SignaturePacket spSign = new SignaturePacket(); strMessage = Radix64.TrimMessage(strMessage); SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spSign.HashAlgorithm = HashAlgorithms.SHA1; spSign.Format = PacketFormats.New; SignatureSubPacket sspCreator = new SignatureSubPacket(); sspCreator.Type = SignatureSubPacketTypes.IssuerKeyID; sspCreator.KeyID = skpKey.PublicKey.KeyID; SignatureSubPacket sspCreationTime = new SignatureSubPacket(); sspCreationTime.Type = SignatureSubPacketTypes.SignatureCreationTime; sspCreationTime.TimeCreated = DateTime.Now; spSign.HashedSubPackets = new SignatureSubPacket[2]; spSign.HashedSubPackets[0] = sspCreator; spSign.HashedSubPackets[1] = sspCreationTime; //spSign.KeyID = skpKey.PublicKey.KeyID; //spSign.TimeCreated = DateTime.Now; spSign.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spSign.SignatureType = SignatureTypes.TextSignature; spSign.Version = SignaturePacketVersionNumbers.v4; byte[] bMessage = System.Text.Encoding.UTF8.GetBytes(strMessage); spSign.Sign(bMessage, skpKey, strPassphrase); byte[] bSignature = spSign.Generate(); string strSignature = Radix64.Encode(bSignature, true); string strFinal; if(embedMessage) strFinal = Armor.WrapCleartextSignature(strMessage, strSignature); else strFinal = Armor.WrapCleartextSignature(strSignature); return strFinal; }
/// <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); } } }
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; }
public string SignText(string strMessage, ulong lSignatureKeyID, string strPassphrase) { SignaturePacket spSign = new SignaturePacket(); strMessage = Radix64.TrimMessage(strMessage); TransportableSecretKey tskKey = skrKeyRing.Find(lSignatureKeyID); SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); spSign.HashAlgorithm = HashAlgorithms.SHA1; spSign.Format = PacketFormats.New; spSign.KeyID = skpKey.PublicKey.KeyID; spSign.TimeCreated = DateTime.Now; spSign.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spSign.SignatureType = SignatureTypes.TextSignature; spSign.Version = SignaturePacketVersionNumbers.v4; byte[] bMessage = System.Text.Encoding.UTF8.GetBytes(strMessage); spSign.Sign(bMessage, skpKey, strPassphrase); byte[] bSignature = spSign.Generate(); string strSignature = Radix64.Encode(bSignature, true); string strFinal = Armor.WrapCleartextSignature(strMessage, strSignature); return strFinal; }
public static string ClearTextSign(string strMessage, SecretKeyRing skrKeyRing) { SignaturePacket spSign = new SignaturePacket(); strMessage = Radix64.TrimMessage(strMessage); QueryPassphrase qpPassphrase = new QueryPassphrase(); qpPassphrase.ShowMyDialog(skrKeyRing); string strPassphrase = qpPassphrase.Passphrase; TransportableSecretKey tskKey = qpPassphrase.SelectedKey; SecretKeyPacket skpKey = tskKey.FindKey(AsymActions.Sign); Working wWorking = new Working(); wWorking.Show(); spSign.HashAlgorithm = HashAlgorithms.SHA1; spSign.Format = PacketFormats.New; wWorking.Progress(10); SignatureSubPacket sspCreator = new SignatureSubPacket(); sspCreator.Type = SignatureSubPacketTypes.IssuerKeyID; sspCreator.KeyID = skpKey.PublicKey.KeyID; SignatureSubPacket sspCreationTime = new SignatureSubPacket(); sspCreationTime.Type = SignatureSubPacketTypes.SignatureCreationTime; sspCreationTime.TimeCreated = DateTime.Now; spSign.HashedSubPackets = new SignatureSubPacket[2]; spSign.HashedSubPackets[0] = sspCreator; spSign.HashedSubPackets[1] = sspCreationTime; wWorking.Progress(20); //spSign.KeyID = skpKey.PublicKey.KeyID; //spSign.TimeCreated = DateTime.Now; spSign.SignatureAlgorithm = skpKey.PublicKey.Algorithm; spSign.SignatureType = SignatureTypes.TextSignature; spSign.Version = SignaturePacketVersionNumbers.v4; wWorking.Progress(10); byte[] bMessage = System.Text.Encoding.UTF8.GetBytes(strMessage); spSign.Sign(bMessage, skpKey, strPassphrase); wWorking.Progress(40); byte[] bSignature = spSign.Generate(); string strSignature = Radix64.Encode(bSignature, true); wWorking.Progress(20); string strFinal = Armor.WrapCleartextSignature(strMessage, strSignature); wWorking.Hide(); return strFinal; }
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; }
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(); }