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);
}
internal PgpSignature(
SignaturePacket sigPacket,
TrustPacket trustPacket)
: this(sigPacket)
{
this.trustPck = trustPacket;
}
/// <summary>
/// Creates a new Certification for the UserID.
/// </summary>
/// <param name="spSignature">A signaturepacket that has been
/// prepared for being signed. Things like signature subpackets
/// MUST already be in place. Only the signature type is
/// automatically set to UserIDCertification.</param>
/// <param name="skpKey">A secret key that is used to signed the
/// certification.</param>
/// <param name="strPassphrase">The passphrase that fits to the
/// given secret key packet.</param>
/// <param name="pkpKey">The public key to which the userid that
/// is to be signed belongs.</param>
public void Sign(SignaturePacket spSignature, SecretKeyPacket skpKey, string strPassphrase, PublicKeyPacket pkpKey)
{
if (spSignature.Version == SignaturePacketVersionNumbers.v4)
{
byte[] bKey = new byte[pkpKey.Body.Length + 3];
bKey[0] = 0x99;
bKey[1] = (byte)((pkpKey.Body.Length >> 8) & 0xFF);
bKey[2] = (byte)(pkpKey.Body.Length & 0xFF);
Array.Copy(pkpKey.Body, 0, bKey, 3, pkpKey.Body.Length);
byte[] bUserID = new byte[UserID.Body.Length + 5];
bUserID[0] = 0xb4;
bUserID[1] = (byte)((UserID.Body.Length >> 24) & 0xFF);
bUserID[2] = (byte)((UserID.Body.Length >> 16) & 0xFF);
bUserID[3] = (byte)((UserID.Body.Length >> 8) & 0xFF);
bUserID[4] = (byte)(UserID.Body.Length & 0xFF);
Array.Copy(UserID.Body, 0, bUserID, 5, UserID.Body.Length);
byte[] bData = new byte[bUserID.Length + bKey.Length];
Array.Copy(bKey, 0, bData, 0, bKey.Length);
Array.Copy(bUserID, 0, bData, bKey.Length, bUserID.Length);
spSignature.SignatureType = SignatureTypes.UserIDSignature;
spSignature.Sign(bData, skpKey, strPassphrase);
this.alCertificates.Add(spSignature);
}
else
{
throw new System.NotImplementedException("Only v4 signatures are supported so far!");
}
}
internal PgpSignature(
SignaturePacket sigPacket)
{
sigPck = sigPacket;
signatureType = sigPck.SignatureType;
trustPck = null;
}
public void SignKeyBindingSignature(PublicKeyPacket pkpPrimaryKey, SecretKeyPacket skpPrimaryKey, string strPassphrase)
{
byte[] bSubKey = new byte[pkpSubkey.Body.Length + 3];
bSubKey[0] = 0x99;
bSubKey[1] = (byte)((pkpSubkey.Body.Length >> 8) & 0xFF);
bSubKey[2] = (byte)(pkpSubkey.Body.Length & 0xFF);
Array.Copy(pkpSubkey.Body, 0, bSubKey, 3, pkpSubkey.Body.Length);
byte[] bPrimaryKey = new byte[pkpPrimaryKey.Body.Length + 3];
bPrimaryKey[0] = 0x99;
bPrimaryKey[1] = (byte)((pkpPrimaryKey.Body.Length >> 8) & 0xFF);
bPrimaryKey[2] = (byte)(pkpPrimaryKey.Body.Length & 0xFF);
Array.Copy(pkpPrimaryKey.Body, 0, bPrimaryKey, 3, pkpPrimaryKey.Body.Length);
byte[] bData = new byte[bPrimaryKey.Length + bSubKey.Length];
Array.Copy(bSubKey, 0, bData, 0, bSubKey.Length);
Array.Copy(bPrimaryKey, 0, bData, bSubKey.Length, bPrimaryKey.Length);
SignaturePacket spKeyBindingSig = new SignaturePacket();
spKeyBindingSig.Version = SignaturePacketVersionNumbers.v4;
spKeyBindingSig.HashAlgorithm = HashAlgorithms.SHA1;
spKeyBindingSig.KeyID = pkpPrimaryKey.KeyID;
spKeyBindingSig.SignatureType = SignatureTypes.SubkeyBindingSignature;
spKeyBindingSig.Sign(bData, skpPrimaryKey, strPassphrase);
this.KeyBindingSignature = spKeyBindingSig;
}
private protected PgpKey(IPacketReader packetReader, KeyPacket keyPacket, bool subKey)
: this(keyPacket)
{
// Ignore GPG comment packets if found.
while (packetReader.NextPacketTag() == PacketTag.Experimental2)
{
packetReader.ReadContainedPacket();
}
this.trustPacket = packetReader.NextPacketTag() == PacketTag.Trust ? (TrustPacket)packetReader.ReadContainedPacket() : null;
while (packetReader.NextPacketTag() == PacketTag.Signature)
{
SignaturePacket signaturePacket = (SignaturePacket)packetReader.ReadContainedPacket();
TrustPacket? signatureTrustPacket = packetReader.NextPacketTag() == PacketTag.Trust ? (TrustPacket)packetReader.ReadContainedPacket() : null;
var signature = new PgpSignature(signaturePacket, signatureTrustPacket);
this.keyCertifications.Add(new PgpCertification(signature, null, this));
}
if (!subKey)
{
while (packetReader.NextPacketTag() == PacketTag.UserId ||
packetReader.NextPacketTag() == PacketTag.UserAttribute)
{
ids.Add(new PgpUser(packetReader, this));
}
}
}
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);
}
/// <summary>
/// Initializes a new instance of the <see cref="PgpSignature"/> class.
/// </summary>
/// <param name="sigPacket">The sig packet.</param>
/// <param name="trustPacket">The trust packet.</param>
/// <exception cref="System.ArgumentNullException">sigPacket</exception>
internal PgpSignature(SignaturePacket sigPacket, ITrustPacket trustPacket)
{
if (sigPacket == null)
throw new ArgumentNullException("sigPacket");
_sigPck = sigPacket;
_signatureType = _sigPck.SignatureType;
_trustPck = trustPacket;
}
public PgpSignature(Stream detachedSignature)
{
var packetReader = new PacketReader(detachedSignature);
if (packetReader.NextPacketTag() != PacketTag.Signature)
{
throw new PgpUnexpectedPacketException();
}
this.sigPck = (SignaturePacket)packetReader.ReadContainedPacket();
}
internal PgpSignature(SignaturePacket sigPacket, TrustPacket?trustPacket)
{
if (sigPacket == null)
{
throw new ArgumentNullException(nameof(sigPacket));
}
this.sigPck = sigPacket;
this.trustPck = trustPacket;
}
internal PgpSignature(SignaturePacket sigPacket, TrustPacket trustPacket)
{
if (sigPacket == null)
{
throw new ArgumentNullException("sigPacket");
}
sigPck = sigPacket;
signatureType = sigPck.SignatureType;
trustPck = trustPacket;
}
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;
}
private string FindPrimaryUserID()
{
string strReturn = "";
int nUserIDCounter = 0;
IEnumerator ieCertificates = this.alCertifications.GetEnumerator();
while (ieCertificates.MoveNext())
{
if (!(ieCertificates.Current is CertifiedUserID))
{
continue;
}
nUserIDCounter++;
CertifiedUserID cuiID = (CertifiedUserID)ieCertificates.Current;
IEnumerator ieSignatures = cuiID.Certificates.GetEnumerator();
while (ieSignatures.MoveNext())
{
if (!(ieSignatures.Current is SignaturePacket))
{
continue;
}
SignaturePacket spCertificate = (SignaturePacket)ieSignatures.Current;
// look only at selfsignatures
if (spCertificate.KeyID != this.PrimaryKey.KeyID)
{
continue;
}
if (nUserIDCounter == 1)
{
strReturn = cuiID.UserID.UserID;
}
for (int i = 0; i < spCertificate.UnhashedSubPackets.Length; i++)
{
if ((spCertificate.UnhashedSubPackets[i].Type == SignatureSubPacketTypes.PrimaryUserID) && (spCertificate.UnhashedSubPackets[i].PrimaryUserID))
{
strReturn = cuiID.UserID.UserID;
}
}
for (int i = 0; i < spCertificate.HashedSubPackets.Length; i++)
{
if ((spCertificate.HashedSubPackets[i].Type == SignatureSubPacketTypes.PrimaryUserID) && (spCertificate.HashedSubPackets[i].PrimaryUserID))
{
strReturn = cuiID.UserID.UserID;
}
}
}
}
return(strReturn);
}
internal PgpSignature(SignaturePacket sigPacket, TrustPacket trustPacket)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (sigPacket == null)
{
throw new ArgumentNullException("sigPacket");
}
sigPck = sigPacket;
signatureType = sigPck.SignatureType;
trustPck = trustPacket;
}
/// <summary>
/// Parses a signed message out of the given array of packets.
/// In this special case, the first packet must be a signature
/// packet or a one-pass signature packet. This is followed by
/// an OpenPGP message and optionally (if the first packet was
/// a one-pass signature packet) and ordinary signature packet.
/// </summary>
/// <returns>Returns the number of packets used by the function.
/// </returns>
/// <param name="packets">Array of packets that contains the
/// signed message.</param>
/// <remarks>No remarks</remarks>
public override int ParseMessage(Packet[] packets)
{
if (packets[0] is OnePassSignaturePacket)
{
bOnePassSigned = true;
opsOnePass = (OnePassSignaturePacket)packets[0];
}
else if (packets[0] is SignaturePacket)
{
bOnePassSigned = false;
spSignature = (SignaturePacket)packets[0];
}
else
{
throw new System.ArgumentException("This does not appear to be a valid OpenPGP signed message!");
}
Packet[] pMessage = new Packet[packets.Length - 1];
Array.Copy(packets, 1, pMessage, 0, pMessage.Length);
lmSignedMessage = new LiteralMessage();
int iPos = 0;
try {
iPos = lmSignedMessage.ParseMessage(pMessage);
} catch (Exception) {}
if (iPos == 0)
{
throw new System.ArgumentException("This does not appear to be a valid OpenPGP signed message!");
}
iPos++;
if (bOnePassSigned)
{
if (packets[iPos] is SignaturePacket)
{
spSignature = (SignaturePacket)packets[iPos];
iPos++;
}
else
{
throw new System.ArgumentException("This does not appear to be a valid OpenPGP signed message!");
}
}
return(iPos);
}
/// <summary>
/// Validates all certificates belonging the the given public key packet
/// and the current certifications.
/// </summary>
/// <remarks>
/// So far only works with v4 signatures!
/// </remarks>
/// <param name="pkpKey">The public key packet to which the userid
/// belongs.</param>
/// <param name="pkrRing">A keyring containing all public keys known to
/// the system. This is neccessary in order to verify the signatures.
/// </param>
public void Validate(PublicKeyPacket pkpKey, PublicKeyRing pkrRing)
{
IEnumerator ieCertificates = Certificates.GetEnumerator();
while (ieCertificates.MoveNext())
{
if (ieCertificates.Current is SignaturePacket)
{
SignaturePacket spCert = (SignaturePacket)ieCertificates.Current;
TransportablePublicKey tkpSigningKey = pkrRing.Find(spCert.KeyID);
if (tkpSigningKey == null)
{
continue;
}
PublicKeyPacket pkpSigningKey = tkpSigningKey.PrimaryKey;
if (spCert.Version == SignaturePacketVersionNumbers.v4)
{
byte[] bKey = new byte[pkpKey.Body.Length + 3];
bKey[0] = 0x99;
bKey[1] = (byte)((pkpKey.Body.Length >> 8) & 0xFF);
bKey[2] = (byte)(pkpKey.Body.Length & 0xFF);
Array.Copy(pkpKey.Body, 0, bKey, 3, pkpKey.Body.Length);
byte[] bUserID = new byte[UserID.Body.Length + 5];
bUserID[0] = 0xb4;
bUserID[1] = (byte)((UserID.Body.Length >> 24) & 0xFF);
bUserID[2] = (byte)((UserID.Body.Length >> 16) & 0xFF);
bUserID[3] = (byte)((UserID.Body.Length >> 8) & 0xFF);
bUserID[4] = (byte)(UserID.Body.Length & 0xFF);
Array.Copy(UserID.Body, 0, bUserID, 5, UserID.Body.Length);
byte[] bData = new byte[bUserID.Length + bKey.Length];
Array.Copy(bKey, 0, bData, 0, bKey.Length);
Array.Copy(bUserID, 0, bData, bKey.Length, bUserID.Length);
spCert.Verify(bData, pkpSigningKey);
}
else
{
//TODO: Add code for v3 Signature verification
}
}
}
}
internal static IList ReadSignaturesAndTrust(BcpgInputStream bcpgInput)
{
try
{
IList list = Platform.CreateArrayList();
while (bcpgInput.NextPacketTag() == PacketTag.Signature)
{
SignaturePacket sigPacket = (SignaturePacket)bcpgInput.ReadPacket();
TrustPacket trustPacket = ReadOptionalTrustPacket(bcpgInput);
list.Add(new PgpSignature(sigPacket, trustPacket));
}
return(list);
}
catch (PgpException ex)
{
throw new IOException("can't create signature object: " + ex.Message, ex);
}
}
internal static global::System.Collections.IList ReadSignaturesAndTrust(BcpgInputStream bcpgInput)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
try
{
global::System.Collections.IList list = Platform.CreateArrayList();
while (bcpgInput.NextPacketTag() == PacketTag.Signature)
{
SignaturePacket sigPacket = (SignaturePacket)bcpgInput.ReadPacket();
TrustPacket trustPacket = ReadOptionalTrustPacket(bcpgInput);
list.Add((object)new PgpSignature(sigPacket, trustPacket));
}
return(list);
}
catch (PgpException ex)
{
throw new IOException("can't create signature object: " + ((global::System.Exception)ex).get_Message(), (global::System.Exception)ex);
}
}
public PgpSignatureList GetEmbeddedSignatures()
{
SignatureSubpacket [] sigs = GetSubpackets(SignatureSubpacketTag.EmbeddedSignature);
PgpSignature[] l = new PgpSignature[sigs.Length];
for (int i = 0; i < sigs.Length; i++)
{
try
{
l[i] = new PgpSignature(SignaturePacket.FromByteArray(sigs[i].GetData()));
}
catch (IOException e)
{
throw new PgpException("Unable to parse signature packet: " + e.Message, e);
}
}
return(new PgpSignatureList(l));
}
public void SignKeyBindingSignature(PublicKeyPacket pkpPrimaryKey, SecretKeyPacket skpPrimaryKey, string strPassphrase, DateTime expirationTime, bool revocable)
{
byte[] bSubKey = new byte[pkpSubkey.Body.Length + 3];
bSubKey[0] = 0x99;
bSubKey[1] = (byte)((pkpSubkey.Body.Length >> 8) & 0xFF);
bSubKey[2] = (byte)(pkpSubkey.Body.Length & 0xFF);
Array.Copy(pkpSubkey.Body, 0, bSubKey, 3, pkpSubkey.Body.Length);
byte[] bPrimaryKey = new byte[pkpPrimaryKey.Body.Length + 3];
bPrimaryKey[0] = 0x99;
bPrimaryKey[1] = (byte)((pkpPrimaryKey.Body.Length >> 8) & 0xFF);
bPrimaryKey[2] = (byte)(pkpPrimaryKey.Body.Length & 0xFF);
Array.Copy(pkpPrimaryKey.Body, 0, bPrimaryKey, 3, pkpPrimaryKey.Body.Length);
byte[] bData = new byte[bPrimaryKey.Length + bSubKey.Length];
Array.Copy(bPrimaryKey, 0, bData, 0, bPrimaryKey.Length);
Array.Copy(bSubKey, 0, bData, bPrimaryKey.Length, bSubKey.Length);
SignaturePacket spKeyBindingSig = new SignaturePacket();
spKeyBindingSig.Version = SignaturePacketVersionNumbers.v4;
spKeyBindingSig.HashAlgorithm = HashAlgorithms.SHA1;
spKeyBindingSig.KeyID = pkpPrimaryKey.KeyID;
spKeyBindingSig.SignatureType = SignatureTypes.SubkeyBindingSignature;
if (expirationTime.Ticks != 0)
{
SignatureSubPacket sspExpiration = new SignatureSubPacket();
sspExpiration.Type = SignatureSubPacketTypes.KeyExpirationTime;
sspExpiration.KeyExpirationTime = new DateTime(expirationTime.Ticks + (new DateTime(1970, 1, 2)).Ticks - pkpPrimaryKey.TimeCreated.Ticks);
spKeyBindingSig.AddSubPacket(sspExpiration, true);
}
if (!revocable)
{
SignatureSubPacket sspRevocable = new SignatureSubPacket();
sspRevocable.Type = SignatureSubPacketTypes.Revocable;
sspRevocable.Revocable = revocable;
spKeyBindingSig.AddSubPacket(sspRevocable, true);
}
spKeyBindingSig.Sign(bData, skpPrimaryKey, strPassphrase);
this.KeyBindingSignature = spKeyBindingSig;
}
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 DateTime FindExpirationDate()
{
IEnumerator ieCertificates = this.alCertifications.GetEnumerator();
while (ieCertificates.MoveNext())
{
if (!(ieCertificates.Current is CertifiedUserID))
{
continue;
}
CertifiedUserID cuiID = (CertifiedUserID)ieCertificates.Current;
IEnumerator ieSignatures = cuiID.Certificates.GetEnumerator();
while (ieSignatures.MoveNext())
{
if (!(ieSignatures.Current is SignaturePacket))
{
continue;
}
SignaturePacket spCertificate = (SignaturePacket)ieSignatures.Current;
// look only at selfsignatures
if (spCertificate.KeyID != this.PrimaryKey.KeyID)
{
continue;
}
for (int i = 0; i < spCertificate.HashedSubPackets.Length; i++)
{
if (spCertificate.HashedSubPackets[i].Type == SignatureSubPacketTypes.KeyExpirationTime)
{
return(spCertificate.HashedSubPackets[i].KeyExpirationTime);
}
}
}
}
throw new Exception("never");
}
public SymAlgorithms[] FindPreferedAlgorithms()
{
IEnumerator ieCertificates = this.alCertifications.GetEnumerator();
while (ieCertificates.MoveNext())
{
if (!(ieCertificates.Current is CertifiedUserID))
{
continue;
}
CertifiedUserID cuiID = (CertifiedUserID)ieCertificates.Current;
IEnumerator ieSignatures = cuiID.Certificates.GetEnumerator();
while (ieSignatures.MoveNext())
{
if (!(ieSignatures.Current is SignaturePacket))
{
continue;
}
SignaturePacket spCertificate = (SignaturePacket)ieSignatures.Current;
// look only at selfsignatures
if (spCertificate.KeyID != this.PrimaryKey.KeyID)
{
continue;
}
try {
SymAlgorithms[] saReturn = spCertificate.FindPreferedSymAlgorithms();
return(saReturn);
} catch (Exception) {}
}
}
throw new Exception("none found!");
}
public void AddUserID(ulong lKeyID, string strName, string strEmail, string strPassphrase)
{
TransportableSecretKey tskKey = skrKeyRing.Find(lKeyID);
TransportablePublicKey tpkKey = pkrKeyRing.Find(lKeyID, false);
CertifiedUserID cuiUID = new CertifiedUserID();
UserIDPacket uipUID = new UserIDPacket();
uipUID.UserID = strName.Trim() + " <" + strEmail.Trim() + ">";
cuiUID.UserID = uipUID;
SecretKeyPacket skpSignatureKey = tskKey.FindKey(AsymActions.Sign);
SignaturePacket spSelfSig = new SignaturePacket();
spSelfSig.Version = SignaturePacketVersionNumbers.v4;
spSelfSig.HashAlgorithm = HashAlgorithms.SHA1;
spSelfSig.KeyID = skpSignatureKey.PublicKey.KeyID;
spSelfSig.TimeCreated = DateTime.Now;
cuiUID.Certificates = new System.Collections.ArrayList();
cuiUID.Sign(spSelfSig, skpSignatureKey, strPassphrase, tpkKey.PrimaryKey);
tpkKey.Certifications.Add(cuiUID);
tskKey.UserIDs.Add(uipUID);
}
public PgpSecretKeyRing(
Stream inputStream)
{
this.keys = new ArrayList();
BcpgInputStream bcpgInput = BcpgInputStream.Wrap(inputStream);
PacketTag initialTag = bcpgInput.NextPacketTag();
if (initialTag != PacketTag.SecretKey && initialTag != PacketTag.SecretSubkey)
{
throw new IOException(
"secret key ring doesn't start with secret key tag: " +
"tag 0x" + initialTag.ToString("X"));
}
SecretKeyPacket secret = (SecretKeyPacket)bcpgInput.ReadPacket();
TrustPacket trust = null;
ArrayList keySigs = new ArrayList();
ArrayList ids = new ArrayList();
ArrayList idTrusts = new ArrayList();
ArrayList idSigs = new ArrayList();
IDigest sha;
try
{
sha = DigestUtilities.GetDigest("SHA1");
}
catch (Exception)
{
throw new IOException("can't find SHA1 digest");
}
//
// ignore GPG comment packets if found.
//
while (bcpgInput.NextPacketTag() == PacketTag.Experimental2)
{
bcpgInput.ReadPacket();
}
if (bcpgInput.NextPacketTag() == PacketTag.Trust)
{
trust = (TrustPacket)bcpgInput.ReadPacket(); // ignore for the moment
}
//
// revocation and direct signatures
//
while (bcpgInput.NextPacketTag() == PacketTag.Signature)
{
try
{
keySigs.Add(new PgpSignature(bcpgInput));
}
catch (PgpException e)
{
throw new IOException("can't create signature object: " + e.Message + ", cause: " + e.InnerException.ToString());
}
}
while (bcpgInput.NextPacketTag() == PacketTag.UserId ||
bcpgInput.NextPacketTag() == PacketTag.UserAttribute)
{
object obj = bcpgInput.ReadPacket();
ArrayList sigList = new ArrayList();
if (obj is UserIdPacket)
{
UserIdPacket id = (UserIdPacket)obj;
ids.Add(id.GetId());
}
else
{
UserAttributePacket user = (UserAttributePacket)obj;
ids.Add(new PgpUserAttributeSubpacketVector(user.GetSubpackets()));
}
if (bcpgInput.NextPacketTag() == PacketTag.Trust)
{
idTrusts.Add(bcpgInput.ReadPacket());
}
else
{
idTrusts.Add(null);
}
idSigs.Add(sigList);
while (bcpgInput.NextPacketTag() == PacketTag.Signature)
{
SignaturePacket s = (SignaturePacket)bcpgInput.ReadPacket();
if (bcpgInput.NextPacketTag() == PacketTag.Trust)
{
sigList.Add(new PgpSignature(s, (TrustPacket)bcpgInput.ReadPacket()));
}
else
{
sigList.Add(new PgpSignature(s));
}
}
}
keys.Add(new PgpSecretKey(secret, trust, sha, keySigs, ids, idTrusts, idSigs));
while (bcpgInput.NextPacketTag() == PacketTag.SecretSubkey)
{
SecretSubkeyPacket sub = (SecretSubkeyPacket)bcpgInput.ReadPacket();
TrustPacket subTrust = null;
ArrayList sigList = new ArrayList();
//
// ignore GPG comment packets if found.
//
while (bcpgInput.NextPacketTag() == PacketTag.Experimental2)
{
bcpgInput.ReadPacket();
}
if (bcpgInput.NextPacketTag() == PacketTag.Trust)
{
subTrust = (TrustPacket)bcpgInput.ReadPacket();
}
while (bcpgInput.NextPacketTag() == PacketTag.Signature)
{
SignaturePacket s = (SignaturePacket)bcpgInput.ReadPacket();
if (bcpgInput.NextPacketTag() == PacketTag.Trust)
{
sigList.Add(new PgpSignature(s, (TrustPacket)bcpgInput.ReadPacket()));
}
else
{
sigList.Add(new PgpSignature(s));
}
}
keys.Add(new PgpSecretKey(sub, subTrust, sha, sigList));
}
}
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();
}
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 SymAlgorithms GetSymAlgorithmPreferences(TransportablePublicKey[] tpkKeys)
{
bool bCAST5 = true;
bool bAES256 = true;
bool bAES192 = true;
bool bAES128 = true;
for (int i = 0; i < tpkKeys.Length; i++)
{
TransportablePublicKey tpkKey = tpkKeys[i];
ulong lKeyID = tpkKey.PrimaryKey.KeyID;
IEnumerator ieCerts = tpkKey.Certifications.GetEnumerator();
while (ieCerts.MoveNext())
{
if (!(ieCerts.Current is CertifiedUserID))
{
continue;
}
CertifiedUserID cuiID = (CertifiedUserID)ieCerts.Current;
IEnumerator ieSigs = cuiID.Certificates.GetEnumerator();
while (ieSigs.MoveNext())
{
if (!(ieSigs.Current is SignaturePacket))
{
continue;
}
SignaturePacket spSig = (SignaturePacket)ieSigs.Current;
if ((spSig.Version == SignaturePacketVersionNumbers.v4) && (spSig.KeyID == lKeyID))
{
try {
bool bTmpCAST5 = false;
bool bTmpAES256 = false;
bool bTmpAES192 = false;
bool bTmpAES128 = false;
SymAlgorithms[] saThisKey = spSig.FindPreferedSymAlgorithms();
for (int j = 0; j < saThisKey.Length; j++)
{
if (saThisKey[j] == SymAlgorithms.AES128)
{
bTmpAES128 = true;
}
else if (saThisKey[j] == SymAlgorithms.AES192)
{
bTmpAES192 = true;
}
else if (saThisKey[j] == SymAlgorithms.AES256)
{
bTmpAES256 = true;
}
else if (saThisKey[j] == SymAlgorithms.CAST5)
{
bTmpCAST5 = true;
}
}
if (!bTmpCAST5)
{
bCAST5 = false;
}
if (!bTmpAES256)
{
bAES256 = false;
}
if (!bTmpAES192)
{
bAES192 = false;
}
if (!bTmpAES128)
{
bAES128 = false;
}
} catch (InvalidOperationException) {}
}
}
}
}
if (bAES256)
{
return(SymAlgorithms.AES256);
}
if (bAES192)
{
return(SymAlgorithms.AES192);
}
if (bAES128)
{
return(SymAlgorithms.AES128);
}
if (bCAST5)
{
return(SymAlgorithms.CAST5);
}
return(SymAlgorithms.Triple_DES);
}
public void GenerateKey(string strName, string strEmail, string strKeyType, int iKeySize, long lExpiration, string strPassphrase)
{
if (strKeyType == "ElGamal/DSA")
{
System.Security.Cryptography.RandomNumberGenerator rngRand = System.Security.Cryptography.RandomNumberGenerator.Create();
// let's first create the encryption key
BigInteger[][] biEncryptionKey = GenerateEncryptionKey(iKeySize);
// now the signature key
BigInteger[][] biSignatureKey = GenerateSignatureKey();
PublicKeyPacket pkpSignatureKey = new PublicKeyPacket(false);
pkpSignatureKey.Algorithm = AsymAlgorithms.DSA;
pkpSignatureKey.KeyMaterial = biSignatureKey[0];
pkpSignatureKey.TimeCreated = DateTime.Now;
pkpSignatureKey.Version = PublicKeyPacketVersionNumbers.v4;
SecretKeyPacket skpSignatureKey = new SecretKeyPacket(false);
skpSignatureKey.SymmetricalAlgorithm = SymAlgorithms.AES256;
skpSignatureKey.PublicKey = pkpSignatureKey;
skpSignatureKey.InitialVector = new byte[CipherHelper.CipherBlockSize(SymAlgorithms.AES256)];
rngRand.GetBytes(skpSignatureKey.InitialVector);
skpSignatureKey.EncryptKeyMaterial(biSignatureKey[1], strPassphrase);
skpSignatureKey.PublicKey = pkpSignatureKey;
PublicKeyPacket pkpEncryptionKey = new PublicKeyPacket(true);
pkpEncryptionKey.Algorithm = AsymAlgorithms.ElGamal_Encrypt_Only;
pkpEncryptionKey.KeyMaterial = biEncryptionKey[0];
pkpEncryptionKey.TimeCreated = DateTime.Now;
pkpEncryptionKey.Version = PublicKeyPacketVersionNumbers.v4;
SecretKeyPacket skpEncryptionKey = new SecretKeyPacket(true);
skpEncryptionKey.SymmetricalAlgorithm = SymAlgorithms.AES256;
skpEncryptionKey.PublicKey = pkpEncryptionKey;
skpEncryptionKey.InitialVector = new byte[CipherHelper.CipherBlockSize(SymAlgorithms.AES256)];
rngRand.GetBytes(skpEncryptionKey.InitialVector);
skpEncryptionKey.EncryptKeyMaterial(biEncryptionKey[1], strPassphrase);
skpEncryptionKey.PublicKey = pkpEncryptionKey;
CertifiedUserID cuiUID = new CertifiedUserID();
UserIDPacket uipUID = new UserIDPacket();
uipUID.UserID = strName.Trim() + " <" + strEmail.Trim() + ">";
cuiUID.UserID = uipUID;
SignaturePacket spSelfSig = new SignaturePacket();
spSelfSig.Version = SignaturePacketVersionNumbers.v4;
spSelfSig.HashAlgorithm = HashAlgorithms.SHA1;
spSelfSig.KeyID = pkpSignatureKey.KeyID;
spSelfSig.TimeCreated = DateTime.Now;
SignatureSubPacket sspPrimaryUserID = new SignatureSubPacket();
sspPrimaryUserID.Type = SignatureSubPacketTypes.PrimaryUserID;
sspPrimaryUserID.PrimaryUserID = true;
spSelfSig.AddSubPacket(sspPrimaryUserID, true);
SignatureSubPacket sspPreferedSymAlgos = new SignatureSubPacket();
sspPreferedSymAlgos.Type = SignatureSubPacketTypes.PreferedSymmetricAlgorithms;
sspPreferedSymAlgos.PreferedSymAlgos = new SymAlgorithms[] { SymAlgorithms.AES256, SymAlgorithms.AES192, SymAlgorithms.AES256, SymAlgorithms.CAST5, SymAlgorithms.Triple_DES };
spSelfSig.AddSubPacket(sspPreferedSymAlgos, true);
SignatureSubPacket sspPreferedHashAlgos = new SignatureSubPacket();
sspPreferedHashAlgos.Type = SignatureSubPacketTypes.PreferedHashAlgorithms;
sspPreferedHashAlgos.PreferedHashAlgos = new HashAlgorithms[] { HashAlgorithms.SHA1 };
spSelfSig.AddSubPacket(sspPreferedHashAlgos, true);
if (lExpiration != 0)
{
SignatureSubPacket sspExpiration = new SignatureSubPacket();
sspExpiration.Type = SignatureSubPacketTypes.SignatureExpirationTime;
sspExpiration.SignatureExpirationTime = new DateTime(lExpiration);
spSelfSig.AddSubPacket(sspExpiration, true);
}
cuiUID.Certificates = new System.Collections.ArrayList();
cuiUID.Sign(spSelfSig, skpSignatureKey, strPassphrase, pkpSignatureKey);
CertifiedPublicSubkey cpsEncryptionKey = new CertifiedPublicSubkey();
cpsEncryptionKey.Subkey = pkpEncryptionKey;
cpsEncryptionKey.SignKeyBindingSignature(pkpSignatureKey, skpSignatureKey, strPassphrase, new DateTime(lExpiration), true);
TransportablePublicKey tpkPublicKey = new TransportablePublicKey();
tpkPublicKey.PrimaryKey = pkpSignatureKey;
tpkPublicKey.SubKeys.Add(cpsEncryptionKey);
tpkPublicKey.Certifications.Add(cuiUID);
TransportableSecretKey tskSecretKey = new TransportableSecretKey();
tskSecretKey.PrimaryKey = skpSignatureKey;
tskSecretKey.SubKeys.Add(skpEncryptionKey);
tskSecretKey.UserIDs.Add(uipUID);
this.pkrKeyRing.AddPublicKey(tpkPublicKey);
this.skrKeyRing.AddSecretKey(tskSecretKey);
pkrKeyRing.Save();
skrKeyRing.Save();
// it's an RSA key
}
else if (strKeyType == "RSA")
{
}
}
public void SignKey(ulong lSignedKeyID, ulong lSigningKeyID, string strUserID, int nIntroducerDepth, bool bIsExportable, int nType, string strPassphrase)
{
TransportableSecretKey tskKey = skrKeyRing.Find(lSigningKeyID);
SecretKeyPacket skpSignatureKey = tskKey.FindKey(AsymActions.Sign);
TransportablePublicKey tpkKey = pkrKeyRing.Find(lSignedKeyID, false);
SignaturePacket spCertificate = new SignaturePacket();
spCertificate.SignatureType = (SignatureTypes)nType;
spCertificate.Version = SignaturePacketVersionNumbers.v4;
spCertificate.HashAlgorithm = HashAlgorithms.SHA1;
spCertificate.KeyID = skpSignatureKey.PublicKey.KeyID;
spCertificate.TimeCreated = DateTime.Now;
CertifiedUserID cuiID = null;
IEnumerator ieUserIDs = tpkKey.Certifications.GetEnumerator();
while (ieUserIDs.MoveNext())
{
if (!(ieUserIDs.Current is CertifiedUserID))
{
continue;
}
CertifiedUserID cuiThisID = (CertifiedUserID)ieUserIDs.Current;
if (cuiThisID.ToString() == strUserID)
{
cuiID = cuiThisID;
}
}
if (cuiID == null)
{
throw new Exception("UserID could not be found!");
}
if (bIsExportable == false)
{
SignatureSubPacket sspNotExportable = new SignatureSubPacket();
sspNotExportable.Type = SignatureSubPacketTypes.ExportableSignature;
sspNotExportable.ExportableSignature = false;
spCertificate.AddSubPacket(sspNotExportable, true);
}
if (nIntroducerDepth > 0)
{
SignatureSubPacket sspTrust = new SignatureSubPacket();
sspTrust.Type = SignatureSubPacketTypes.TrustSignature;
sspTrust.TrustLevel = (byte)nIntroducerDepth;
sspTrust.TrustAmount = 120;
spCertificate.AddSubPacket(sspTrust, true);
}
cuiID.Sign(spCertificate, skpSignatureKey, strPassphrase, tpkKey.PrimaryKey);
tpkKey.Certifications.Remove(cuiID);
tpkKey.Certifications.Add(cuiID);
pkrKeyRing.Delete(lSignedKeyID);
pkrKeyRing.AddPublicKey(tpkKey);
pkrKeyRing.Save();
}
/// <summary>
/// Creates a new Certification for the UserID.
/// </summary>
/// <param name="spSignature">A signaturepacket that has been
/// prepared for being signed. Things like signature subpackets
/// MUST already be in place. Only the signature type is
/// automatically set to UserIDCertification.</param>
/// <param name="skpKey">A secret key that is used to signed the
/// certification.</param>
/// <param name="strPassphrase">The passphrase that fits to the
/// given secret key packet.</param>
/// <param name="pkpKey">The public key to which the userid that
/// is to be signed belongs.</param>
public void Sign(SignaturePacket spSignature, SecretKeyPacket skpKey, string strPassphrase, PublicKeyPacket pkpKey)
{
if (spSignature.Version == SignaturePacketVersionNumbers.v4) {
byte[] bKey = new byte[pkpKey.Body.Length + 3];
bKey[0] = 0x99;
bKey[1] = (byte)((pkpKey.Body.Length >> 8) & 0xFF);
bKey[2] = (byte)(pkpKey.Body.Length & 0xFF);
Array.Copy(pkpKey.Body, 0, bKey, 3, pkpKey.Body.Length);
byte[] bUserID = new byte[UserID.Body.Length + 5];
bUserID[0] = 0xb4;
bUserID[1] = (byte)((UserID.Body.Length >> 24) & 0xFF);
bUserID[2] = (byte)((UserID.Body.Length >> 16) & 0xFF);
bUserID[3] = (byte)((UserID.Body.Length >> 8) & 0xFF);
bUserID[4] = (byte)(UserID.Body.Length & 0xFF);
Array.Copy(UserID.Body, 0, bUserID, 5, UserID.Body.Length);
byte[] bData = new byte[bUserID.Length + bKey.Length];
Array.Copy(bKey, 0, bData, 0, bKey.Length);
Array.Copy(bUserID, 0, bData, bKey.Length, bUserID.Length);
spSignature.SignatureType = SignatureTypes.UserIDSignature;
spSignature.Sign(bData, skpKey, strPassphrase);
this.alCertificates.Add(spSignature);
} else {
throw new System.NotImplementedException("Only v4 signatures are supported so far!");
}
}
internal PgpSignature(
SignaturePacket sigPacket)
: this(sigPacket, null)
{
}
/// <summary>
/// Creates a new CertifiedPublicSubkey with all null properties.
/// </summary>
/// <remarks>No remarks</remarks>
public CertifiedPublicSubkey()
{
this.Subkey = null;
this.KeyBindingSignature = null;
this.RevocationSignature = null;
}
internal PgpSignature(
SignaturePacket sigPacket)
: this(sigPacket, null)
{
}
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();
}
public void SignKeyBindingSignature(PublicKeyPacket pkpPrimaryKey, SecretKeyPacket skpPrimaryKey, string strPassphrase, DateTime expirationTime, bool revocable)
{
byte[] bSubKey = new byte[pkpSubkey.Body.Length + 3];
bSubKey[0] = 0x99;
bSubKey[1] = (byte)((pkpSubkey.Body.Length >> 8) & 0xFF);
bSubKey[2] = (byte)(pkpSubkey.Body.Length & 0xFF);
Array.Copy(pkpSubkey.Body, 0, bSubKey, 3, pkpSubkey.Body.Length);
byte[] bPrimaryKey = new byte[pkpPrimaryKey.Body.Length + 3];
bPrimaryKey[0] = 0x99;
bPrimaryKey[1] = (byte)((pkpPrimaryKey.Body.Length >> 8) & 0xFF);
bPrimaryKey[2] = (byte)(pkpPrimaryKey.Body.Length & 0xFF);
Array.Copy(pkpPrimaryKey.Body, 0, bPrimaryKey, 3, pkpPrimaryKey.Body.Length);
byte[] bData = new byte[bPrimaryKey.Length + bSubKey.Length];
Array.Copy(bPrimaryKey, 0, bData, 0, bPrimaryKey.Length);
Array.Copy(bSubKey, 0, bData, bPrimaryKey.Length, bSubKey.Length);
SignaturePacket spKeyBindingSig = new SignaturePacket();
spKeyBindingSig.Version = SignaturePacketVersionNumbers.v4;
spKeyBindingSig.HashAlgorithm = HashAlgorithms.SHA1;
spKeyBindingSig.KeyID = pkpPrimaryKey.KeyID;
spKeyBindingSig.SignatureType = SignatureTypes.SubkeyBindingSignature;
if(expirationTime.Ticks != 0) {
SignatureSubPacket sspExpiration = new SignatureSubPacket();
sspExpiration.Type = SignatureSubPacketTypes.KeyExpirationTime;
sspExpiration.KeyExpirationTime = new DateTime(expirationTime.Ticks + (new DateTime(1970,1,2)).Ticks - pkpPrimaryKey.TimeCreated.Ticks);
spKeyBindingSig.AddSubPacket(sspExpiration, true);
}
if(!revocable) {
SignatureSubPacket sspRevocable = new SignatureSubPacket();
sspRevocable.Type = SignatureSubPacketTypes.Revocable;
sspRevocable.Revocable = revocable;
spKeyBindingSig.AddSubPacket(sspRevocable, true);
}
spKeyBindingSig.Sign(bData, skpPrimaryKey, strPassphrase);
this.KeyBindingSignature = spKeyBindingSig;
}
public string GetPublicKeyProperties(ulong lKeyID)
{
TransportablePublicKey tpkKey = pkrKeyRing.Find(lKeyID, false);
XmlDocument xmlDoc = new XmlDocument();
XmlElement xmlPublicKey = xmlDoc.CreateElement("PublicKey");
xmlPublicKey.SetAttribute("keyid", "0x" + tpkKey.PrimaryKey.KeyID.ToString("x"));
xmlPublicKey.SetAttribute("fingerprint", tpkKey.PrimaryKey.Fingerprint.ToString(16));
xmlPublicKey.SetAttribute("created", tpkKey.PrimaryKey.TimeCreated.Ticks.ToString());
try {
xmlPublicKey.SetAttribute("expiration", tpkKey.KeyExpirationTime.Ticks.ToString());
} catch (System.Exception) {
xmlPublicKey.SetAttribute("expiration", "never");
}
xmlPublicKey.SetAttribute("size", tpkKey.PrimaryKey.KeyMaterial[0].bitCount().ToString());
xmlPublicKey.SetAttribute("algorithm", tpkKey.PrimaryKey.Algorithm.ToString());
XmlElement xmlUserIDs = xmlDoc.CreateElement("UserIDs");
XmlElement xmlUserID;
IEnumerator ieUserIDs = tpkKey.Certifications.GetEnumerator();
while (ieUserIDs.MoveNext())
{
if (!(ieUserIDs.Current is CertifiedUserID))
{
continue;
}
CertifiedUserID cuiUID = (CertifiedUserID)ieUserIDs.Current;
cuiUID.Validate(tpkKey.PrimaryKey, pkrKeyRing);
xmlUserID = xmlDoc.CreateElement("UserID");
xmlUserID.SetAttribute("name", cuiUID.UserID.UserID);
string strPrimary = "false";
if (tpkKey.PrimaryUserID == cuiUID.UserID.UserID)
{
strPrimary = "true";
}
xmlUserID.SetAttribute("primary", strPrimary);
DateTime dtTimeCreated = DateTime.Now;
XmlElement xmlSignature;
IEnumerator ieSignatures = cuiUID.Certificates.GetEnumerator();
while (ieSignatures.MoveNext())
{
if (!(ieSignatures.Current is SignaturePacket))
{
continue;
}
SignaturePacket spSignature = (SignaturePacket)ieSignatures.Current;
xmlSignature = xmlDoc.CreateElement("Signature");
xmlSignature.SetAttribute("keyid", "0x" + spSignature.KeyID.ToString("x"));
xmlSignature.SetAttribute("created", spSignature.TimeCreated.Ticks.ToString());
string strExpiration = "";
try {
strExpiration = spSignature.FindExpirationTime().Ticks.ToString();
} catch (InvalidOperationException) {
strExpiration = "never";
}
xmlSignature.SetAttribute("expiration", strExpiration);
xmlSignature.SetAttribute("signaturestatus", spSignature.SignatureStatus.ToString());
string strCreator = "";
try {
TransportablePublicKey tpkSignatureKey = pkrKeyRing.Find(spSignature.KeyID, false);
strCreator = tpkSignatureKey.PrimaryUserID;
} catch (Exception) {
strCreator = "0x" + spSignature.KeyID.ToString("x");
}
xmlSignature.SetAttribute("creator", strCreator);
xmlSignature.SetAttribute("algorithm", spSignature.SignatureAlgorithm.ToString());
if (spSignature.KeyID == tpkKey.PrimaryKey.KeyID)
{
dtTimeCreated = spSignature.TimeCreated;
}
xmlUserID.AppendChild(xmlSignature);
}
xmlUserID.SetAttribute("created", dtTimeCreated.Ticks.ToString());
xmlUserIDs.AppendChild(xmlUserID);
}
xmlPublicKey.AppendChild(xmlUserIDs);
XmlElement xmlSubkeys = xmlDoc.CreateElement("Subkeys");
XmlElement xmlSubkey;
IEnumerator ieSubkeys = tpkKey.SubKeys.GetEnumerator();
while (ieSubkeys.MoveNext())
{
if (!(ieSubkeys.Current is CertifiedPublicSubkey))
{
continue;
}
CertifiedPublicSubkey cpsSubkey = (CertifiedPublicSubkey)ieSubkeys.Current;
xmlSubkey = xmlDoc.CreateElement("Subkey");
xmlSubkey.SetAttribute("keyid", "0x" + cpsSubkey.Subkey.KeyID.ToString("x"));
xmlSubkey.SetAttribute("fingerprint", cpsSubkey.Subkey.Fingerprint.ToString(16));
xmlSubkey.SetAttribute("created", cpsSubkey.Subkey.TimeCreated.Ticks.ToString());
string strExpiration = "";
try {
strExpiration = cpsSubkey.KeyBindingSignature.FindExpirationTime().Ticks.ToString();
} catch (InvalidOperationException) {
strExpiration = "never";
}
xmlSubkey.SetAttribute("expiration", strExpiration);
xmlSubkey.SetAttribute("size", cpsSubkey.Subkey.KeyMaterial[0].bitCount().ToString());
xmlSubkey.SetAttribute("algorithm", cpsSubkey.Subkey.Algorithm.ToString());
xmlSubkeys.AppendChild(xmlSubkey);
}
xmlPublicKey.AppendChild(xmlSubkeys);
xmlDoc.AppendChild(xmlPublicKey);
return(xmlDoc.OuterXml);
}
