internal static void Encode( BcpgOutputStream bcpgOut, BigInteger val) { bcpgOut.WriteShort((short) val.BitLength); bcpgOut.Write(val.ToByteArrayUnsigned()); }
internal OutputStreamPacket( BcpgOutputStream bcpgOut) { if (bcpgOut == null) throw new ArgumentNullException("bcpgOut"); this.bcpgOut = bcpgOut; }
public virtual byte[] GetEncoded() { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.WriteObject(this); return bOut.ToArray(); }
public byte[] GetEncoded() { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.WritePacket(this); return bOut.ToArray(); }
public override void Encode( BcpgOutputStream bcpgOut) { byte[] oid = this.oid.GetEncoded(); bcpgOut.Write(oid, 1, oid.Length - 1); MPInteger point = new MPInteger(this.point); bcpgOut.WriteObject(point); }
public override void Encode( BcpgOutputStream bcpgOut) { base.Encode(bcpgOut); bcpgOut.WriteByte(0x3); bcpgOut.WriteByte(reserved); bcpgOut.WriteByte(hashFunctionId); bcpgOut.WriteByte(symAlgorithmId); }
/// <summary> /// Gets the encoded version of this instance. /// </summary> /// <returns></returns> public byte[] GetEncoded() { using (var bOut = new MemoryStream()) { using (var pOut = new BcpgOutputStream(bOut)) { pOut.WritePacket(this); return bOut.ToArray(); } } }
public override void Encode( BcpgOutputStream bcpgOut) { MemoryStream bOut = new MemoryStream(); for (int i = 0; i != subpackets.Length; i++) { subpackets[i].Encode(bOut); } bcpgOut.WritePacket(PacketTag.UserAttribute, bOut.ToArray(), false); }
public byte[] GetEncoded() { try { using (var bOut = new MemoryStream()) { using (var pOut = new BcpgOutputStream(bOut)) { pOut.WriteObject(this); return bOut.ToArray(); } } } catch (Exception) { return null; } }
public override void Encode( BcpgOutputStream bcpgOut) { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.Write( (byte) version, (byte) sigType, (byte) hashAlgorithm, (byte) keyAlgorithm); pOut.WriteLong(keyId); pOut.WriteByte((byte) nested); bcpgOut.WritePacket(PacketTag.OnePassSignature, bOut.ToArray(), true); }
public override void Encode( BcpgOutputStream bcpgOut) { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.WriteByte((byte) version); pOut.WriteLong(keyId); pOut.WriteByte((byte)algorithm); for (int i = 0; i != data.Length; i++) { MPInteger.Encode(pOut, data[i]); } bcpgOut.WritePacket(PacketTag.PublicKeyEncryptedSession , bOut.ToArray(), true); }
public override void Encode( BcpgOutputStream bcpgOut) { int length = val.BitLength; bcpgOut.WriteByte((byte) (length >> 8)); bcpgOut.WriteByte((byte) length); byte[] bytes = val.ToByteArray(); if (bytes[0] == 0) { bcpgOut.Write(bytes, 1, bytes.Length - 1); } else { bcpgOut.Write(bytes); } }
public override void Encode( BcpgOutputStream bcpgOut) { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.Write( (byte) version, (byte) encAlgorithm); pOut.WriteObject(s2k); if (secKeyData != null && secKeyData.Length > 0) { pOut.Write(secKeyData); } bcpgOut.WritePacket(PacketTag.SymmetricKeyEncryptedSessionKey, bOut.ToArray(), true); }
public static void SignFile(Stream input, Stream outputStream, Stream keyIn, char[] pass) { var secretKey = ReadSecretKey(keyIn); var privateKey = secretKey.ExtractPrivateKey(pass); var signatureGenerator = new PgpSignatureGenerator(secretKey.PublicKey.Algorithm, HashAlgorithmTag.Sha1); var subpacketGenerator = new PgpSignatureSubpacketGenerator(); signatureGenerator.InitSign(PgpSignature.CanonicalTextDocument, privateKey); foreach (string userId in secretKey.PublicKey.GetUserIds()) { var signatureSubpacketGenerator = new PgpSignatureSubpacketGenerator(); signatureSubpacketGenerator.SetSignerUserId(isCritical: false, userId: userId); signatureGenerator.SetHashedSubpackets(signatureSubpacketGenerator.Generate()); // Just the first one! break; } // Closing armouredOutputStream does not close the underlying stream var armouredOutputStream = new ArmoredOutputStream(outputStream); using (var bcpgOutputStream = new BcpgOutputStream(armouredOutputStream)) { armouredOutputStream.BeginClearText(HashAlgorithmTag.Sha1); int chr; while ((chr = input.ReadByte()) > 0) { signatureGenerator.Update((byte)chr); bcpgOutputStream.Write((byte)chr); } // For some reason we need to add a trailing newline bcpgOutputStream.Write((byte)'\n'); armouredOutputStream.EndClearText(); signatureGenerator.Generate().Encode(bcpgOutputStream); } }
/** * Return the byte encoding of the signature section. * @return uninterpreted signature bytes. */ public byte[] GetSignatureBytes() { if (signatureEncoding != null) { return((byte[])signatureEncoding.Clone()); } MemoryStream bOut = new MemoryStream(); BcpgOutputStream bcOut = new BcpgOutputStream(bOut); foreach (MPInteger sigObj in signature) { try { bcOut.WriteObject(sigObj); } catch (IOException e) { throw new Exception("internal error: " + e); } } return(bOut.ToArray()); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WriteByte((byte)this.type); bcpgOut.WriteByte((byte)this.algorithm); if (this.type != 101) { if (this.type != 0) { bcpgOut.Write(this.iv); } if (this.type == 3) { bcpgOut.WriteByte((byte)this.itCount); return; } } else { bcpgOut.WriteByte(71); bcpgOut.WriteByte(78); bcpgOut.WriteByte(85); bcpgOut.WriteByte((byte)this.protectionMode); } }
public byte[] GetSignatureBytes() { if (this.signatureEncoding != null) { return((byte[])this.signatureEncoding.Clone()); } MemoryStream memoryStream = new MemoryStream(); BcpgOutputStream bcpgOutputStream = new BcpgOutputStream(memoryStream); MPInteger[] array = this.signature; for (int i = 0; i < array.Length; i++) { MPInteger bcpgObject = array[i]; try { bcpgOutputStream.WriteObject(bcpgObject); } catch (IOException arg) { throw new Exception("internal error: " + arg); } } return(memoryStream.ToArray()); }
public byte[] GetEncodedContents() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Expected O, but got Unknown MemoryStream val = new MemoryStream(); BcpgOutputStream bcpgOutputStream = new BcpgOutputStream((Stream)(object)val); bcpgOutputStream.Write(pubKeyPacket.GetEncodedContents()); ((Stream)bcpgOutputStream).WriteByte((byte)s2kUsage); if (s2kUsage == 255 || s2kUsage == 254) { ((Stream)bcpgOutputStream).WriteByte((byte)encAlgorithm); bcpgOutputStream.WriteObject(s2k); } if (iv != null) { bcpgOutputStream.Write(iv); } if (secKeyData != null && secKeyData.Length > 0) { bcpgOutputStream.Write(secKeyData); } return(val.ToArray()); }
public byte[] GetEncodedContents() { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.WriteByte((byte) version); pOut.WriteInt((int) time); if (version <= 3) { pOut.WriteShort((short) validDays); } pOut.WriteByte((byte) algorithm); pOut.WriteObject((BcpgObject)key); return bOut.ToArray(); }
private static void EncodeLengthAndData(BcpgOutputStream pOut, byte[] data) { pOut.WriteShort((short)data.Length); pOut.Write(data); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.PublicSubkey, GetEncodedContents(), oldFormat: true); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(tag, contents, true); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WriteShort((short)this.val.BitLength); bcpgOut.Write(this.val.ToByteArrayUnsigned()); }
public abstract void Encode(BcpgOutputStream bcpgOut);
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(tag, contents, oldFormat: true); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.UserId, idData, oldFormat: true); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.UserId, idData, true); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.SecretSubkey, base.GetEncodedContents(), true); }
private string signEnvelopeData(string msg) { Stream privateKeyStream = getPrivateKeyStream(_privateKey); MemoryStream result = new MemoryStream(); ArmoredOutputStream aOut = new ArmoredOutputStream(result); BcpgOutputStream bOut = null; char[] privateKeyPassword = _passPhrase.ToCharArray(); var utf8Encoding = new System.Text.UTF8Encoding(); try { PgpSecretKey sk = readSecretKey(privateKeyStream); PgpPrivateKey pk = sk.ExtractPrivateKey(privateKeyPassword); PgpSignatureGenerator sigGen = new PgpSignatureGenerator(sk.PublicKey.Algorithm,HashAlgorithmTag.Sha256); PgpSignatureSubpacketGenerator spGen = new PgpSignatureSubpacketGenerator(); var enumerator = sk.PublicKey.GetUserIds().GetEnumerator(); if(enumerator.MoveNext()) { spGen.SetSignerUserId(false, (string)enumerator.Current); sigGen.SetHashedSubpackets(spGen.Generate()); } aOut.BeginClearText(HashAlgorithmTag.Sha256); sigGen.InitSign(PgpSignature.CanonicalTextDocument, pk); byte[] msgBytes = utf8Encoding.GetBytes(msg); sigGen.Update(msgBytes, 0, msgBytes.Length); aOut.Write(msgBytes, 0, msgBytes.Length); bOut = new BcpgOutputStream(aOut); aOut.EndClearText(); sigGen.Generate().Encode(bOut); using (BinaryReader br = new BinaryReader(result)) { br.BaseStream.Position = 0; return utf8Encoding.GetString(br.ReadBytes((int)result.Length)); } } catch (Exception e) { Console.WriteLine("This happened: " + e.Message); throw new Exception("Signing Failed: " + e.Message); } finally { try { if (privateKeyStream != null) privateKeyStream.Close(); //if(bOut != null) //bOut.Close(); //aOut.Close(); result.Close(); } catch (IOException) {} } }
public override void Encode( BcpgOutputStream bcpgOut) { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.WriteByte((byte) version); pOut.WriteLong(keyId); pOut.WriteByte((byte)algorithm); for (int i = 0; i < data.Length; ++i) { pOut.Write(data[i]); } Platform.Dispose(pOut); bcpgOut.WritePacket(PacketTag.PublicKeyEncryptedSession , bOut.ToArray(), true); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(this.tag, this.contents, true); }
public override void Encode(IBcpgOutputStream bcpgOut) { using (var bOut = new MemoryStream()) { using (var pOut = new BcpgOutputStream(bOut)) { pOut.WriteByte((byte)_version); pOut.WriteLong(_keyId); pOut.WriteByte((byte)_algorithm); for (var i = 0; i != _data.Length; i++) { MPInteger.EncodeInteger(pOut, _data[i]); } if (_extraData != null) { if (_extraData.Length > 0xFF) throw new PgpException("Extra Data is too large."); pOut.WriteByte((byte)_extraData.Length); pOut.Write(_extraData, 0, _extraData.Length); } bcpgOut.WritePacket(PacketTag.PublicKeyEncryptedSession, bOut.ToArray(), true); } } }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.SecretSubkey, GetEncodedContents(), true); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WriteObjects(d, p, q, u); }
/// <summary> /// Attempt to sign a PGP message using the specific private key. /// </summary> /// <param name="messageStream">Stream containing the message to sign.</param> /// <param name="signatureStream">Stream to write the signature into.</param> /// <param name="senderPublicKey">The BouncyCastle public key associated with the signature.</param> /// <param name="senderPrivateKey">The BouncyCastle private key to be used for signing.</param> /// <param name="hashAlgorithmTag">The hash algorithm tag to use for signing.</param> /// <param name="armor">Whether to wrap the message with ASCII armor.</param> /// <returns>Whether the signature completed successfully.</returns> public static bool Sign(Stream messageStream, Stream signatureStream, PgpPublicKey senderPublicKey, PgpPrivateKey senderPrivateKey, HashAlgorithmTag hashAlgorithmTag = HashAlgorithmTag.Sha256, bool armor = true) { // Create a signature generator. PgpSignatureGenerator signatureGenerator = new PgpSignatureGenerator(senderPublicKey.Algorithm, hashAlgorithmTag); signatureGenerator.InitSign(PgpSignature.BinaryDocument, senderPrivateKey); // Add the public key user ID. foreach (string userId in senderPublicKey.GetUserIds()) { PgpSignatureSubpacketGenerator signatureSubGenerator = new PgpSignatureSubpacketGenerator(); signatureSubGenerator.SetSignerUserId(false, userId); signatureGenerator.SetHashedSubpackets(signatureSubGenerator.Generate()); break; } // Handle ASCII armor. if (armor) { using (ArmoredOutputStream armoredStream = new ArmoredOutputStream(signatureStream)) { armoredStream.BeginClearText(hashAlgorithmTag); // Process each character in the message. int messageChar; while ((messageChar = messageStream.ReadByte()) >= 0) { armoredStream.WriteByte((byte)messageChar); signatureGenerator.Update((byte)messageChar); } armoredStream.EndClearText(); using (BcpgOutputStream bcpgStream = new BcpgOutputStream(armoredStream)) { signatureGenerator.Generate().Encode(bcpgStream); } } } else { // Process each character in the message. int messageChar; while ((messageChar = messageStream.ReadByte()) >= 0) { signatureGenerator.Update((byte)messageChar); } signatureGenerator.Generate().Encode(signatureStream); } return true; }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.Trust, levelAndTrustAmount, true); }
/** * Return the byte encoding of the signature section. * @return uninterpreted signature bytes. */ public byte[] GetSignatureBytes() { if (signatureEncoding != null) { return (byte[]) signatureEncoding.Clone(); } MemoryStream bOut = new MemoryStream(); BcpgOutputStream bcOut = new BcpgOutputStream(bOut); foreach (MPInteger sigObj in signature) { try { bcOut.WriteObject(sigObj); } catch (IOException e) { throw new Exception("internal error: " + e); } } return bOut.ToArray(); }
internal static void Encode(BcpgOutputStream bcpgOut, BigInteger val) { bcpgOut.WriteShort((short)val.BitLength); bcpgOut.Write(val.ToByteArrayUnsigned()); }
public override void Encode( BcpgOutputStream bcpgOut) { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.WriteByte((byte) version); if (version == 3 || version == 2) { pOut.Write( 5, // the length of the next block (byte) signatureType); pOut.WriteInt((int)(creationTime / 1000L)); pOut.WriteLong(keyId); pOut.Write( (byte) keyAlgorithm, (byte) hashAlgorithm); } else if (version == 4) { pOut.Write( (byte) signatureType, (byte) keyAlgorithm, (byte) hashAlgorithm); EncodeLengthAndData(pOut, GetEncodedSubpackets(hashedData)); EncodeLengthAndData(pOut, GetEncodedSubpackets(unhashedData)); } else { throw new IOException("unknown version: " + version); } pOut.Write(fingerprint); if (signature != null) { pOut.WriteObjects(signature); } else { pOut.Write(signatureEncoding); } bcpgOut.WritePacket(PacketTag.Signature, bOut.ToArray(), true); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.Marker, marker, true); }
private static void EncodeLengthAndData( BcpgOutputStream pOut, byte[] data) { pOut.WriteShort((short) data.Length); pOut.Write(data); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WriteObject(x); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.ModificationDetectionCode, digest, false); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.PublicKey, GetEncodedContents(), true); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WriteObject(this.x); }
public override void Encode(BcpgOutputStream bcpgOut) { bcpgOut.WritePacket(PacketTag.UserId, this.idData, true); }
public byte[] GetEncodedContents() { MemoryStream bOut = new MemoryStream(); BcpgOutputStream pOut = new BcpgOutputStream(bOut); pOut.Write(pubKeyPacket.GetEncodedContents()); pOut.WriteByte((byte) s2kUsage); if (s2kUsage == UsageChecksum || s2kUsage == UsageSha1) { pOut.WriteByte((byte) encAlgorithm); pOut.WriteObject(s2k); } if (iv != null) { pOut.Write(iv); } if (secKeyData != null && secKeyData.Length > 0) { pOut.Write(secKeyData); } return bOut.ToArray(); }
public override void Encode( BcpgOutputStream bcpgOut) { bcpgOut.WriteObjects(p, g, y); }