public override void Encode(BcpgOutputStream bcpgOut)
{
base.Encode(bcpgOut);
bcpgOut.WriteByte(3);
bcpgOut.WriteByte(reserved);
bcpgOut.WriteByte((byte)hashFunctionId);
bcpgOut.WriteByte((byte)symAlgorithmId);
}
public override void Encode(BcpgOutputStream bcpgOut)
{
MemoryStream memoryStream = new MemoryStream();
BcpgOutputStream bcpgOutputStream = new BcpgOutputStream(memoryStream);
bcpgOutputStream.WriteByte((byte)version);
bcpgOutputStream.WriteLong(keyId);
bcpgOutputStream.WriteByte((byte)algorithm);
for (int i = 0; i < data.Length; i++)
{
bcpgOutputStream.Write(data[i]);
}
Platform.Dispose(bcpgOutputStream);
bcpgOut.WritePacket(PacketTag.PublicKeyEncryptedSession, memoryStream.ToArray(), oldFormat: true);
}
public virtual byte[] GetEncodedContents()
{
MemoryStream memoryStream = new MemoryStream();
BcpgOutputStream bcpgOutputStream = new BcpgOutputStream(memoryStream);
bcpgOutputStream.WriteByte((byte)version);
bcpgOutputStream.WriteInt((int)time);
if (version <= 3)
{
bcpgOutputStream.WriteShort((short)validDays);
}
bcpgOutputStream.WriteByte((byte)algorithm);
bcpgOutputStream.WriteObject((BcpgObject)key);
return(memoryStream.ToArray());
}
private void DoOpen()
{
_pkOut.WriteByte((byte)_algorithm);
switch (_algorithm)
{
case CompressionAlgorithmTag.Uncompressed:
_dOut = _pkOut;
break;
case CompressionAlgorithmTag.Zip:
_dOut = new SafeZOutputStream(_pkOut, _compression, true);
break;
case CompressionAlgorithmTag.ZLib:
_dOut = new SafeZOutputStream(_pkOut, _compression, false);
break;
case CompressionAlgorithmTag.BZip2:
_dOut = new SafeCBZip2OutputStream(_pkOut);
break;
default:
// Constructor should guard against this possibility
throw new InvalidOperationException();
}
}
private void doOpen()
{
pkOut.WriteByte((byte)algorithm);
switch (algorithm)
{
case CompressionAlgorithmTag.Uncompressed:
dOut = pkOut;
break;
case CompressionAlgorithmTag.Zip:
dOut = new SafeZOutputStream(pkOut, compression, nowrap: true);
break;
case CompressionAlgorithmTag.ZLib:
dOut = new SafeZOutputStream(pkOut, compression, nowrap: false);
break;
case CompressionAlgorithmTag.BZip2:
dOut = new SafeCBZip2OutputStream(pkOut);
break;
default:
throw new InvalidOperationException();
}
}
public override void Encode(BcpgOutputStream bcpgOut)
{
MemoryStream memoryStream = new MemoryStream();
BcpgOutputStream bcpgOutputStream = new BcpgOutputStream(memoryStream);
bcpgOutputStream.WriteByte((byte)version);
if (version == 3 || version == 2)
{
bcpgOutputStream.Write(5, (byte)signatureType);
bcpgOutputStream.WriteInt((int)(creationTime / 1000));
bcpgOutputStream.WriteLong(keyId);
bcpgOutputStream.Write((byte)keyAlgorithm, (byte)hashAlgorithm);
}
else
{
if (version != 4)
{
throw new IOException("unknown version: " + version);
}
bcpgOutputStream.Write((byte)signatureType, (byte)keyAlgorithm, (byte)hashAlgorithm);
EncodeLengthAndData(bcpgOutputStream, GetEncodedSubpackets(hashedData));
EncodeLengthAndData(bcpgOutputStream, GetEncodedSubpackets(unhashedData));
}
bcpgOutputStream.Write(fingerprint);
if (signature != null)
{
bcpgOutputStream.WriteObjects(signature);
}
else
{
bcpgOutputStream.Write(signatureEncoding);
}
bcpgOut.WritePacket(PacketTag.Signature, memoryStream.ToArray(), oldFormat: true);
}
private void doOpen()
{
pkOut.WriteByte((byte)algorithm);
switch (algorithm)
{
case CompressionAlgorithmTag.Uncompressed:
dOut = pkOut;
break;
case CompressionAlgorithmTag.Zip:
dOut = new ZDeflaterOutputStream(pkOut, compression, true);
break;
case CompressionAlgorithmTag.ZLib:
dOut = new ZDeflaterOutputStream(pkOut, compression, false);
break;
case CompressionAlgorithmTag.BZip2:
dOut = new CBZip2OutputStream(pkOut);
break;
default:
// Constructor should guard against this possibility
throw new InvalidOperationException();
}
}
public override void Encode(BcpgOutputStream bcpgOut)
{
MemoryStream memoryStream = new MemoryStream();
BcpgOutputStream bcpgOutputStream = new BcpgOutputStream(memoryStream);
bcpgOutputStream.Write((byte)version, (byte)sigType, (byte)hashAlgorithm, (byte)keyAlgorithm);
bcpgOutputStream.WriteLong(keyId);
bcpgOutputStream.WriteByte((byte)nested);
bcpgOut.WritePacket(PacketTag.OnePassSignature, memoryStream.ToArray(), oldFormat: true);
}
public byte[] GetEncodedContents()
{
MemoryStream memoryStream = new MemoryStream();
BcpgOutputStream bcpgOutputStream = new BcpgOutputStream(memoryStream);
bcpgOutputStream.Write(pubKeyPacket.GetEncodedContents());
bcpgOutputStream.WriteByte((byte)s2kUsage);
if (s2kUsage == 255 || s2kUsage == 254)
{
bcpgOutputStream.WriteByte((byte)encAlgorithm);
bcpgOutputStream.WriteObject(s2k);
}
if (iv != null)
{
bcpgOutputStream.Write(iv);
}
if (secKeyData != null && secKeyData.Length > 0)
{
bcpgOutputStream.Write(secKeyData);
}
return(memoryStream.ToArray());
}
private void doOpen()
{
pkOut.WriteByte((byte)algorithm);
switch (algorithm)
{
case CompressionAlgorithmTag.Uncompressed:
dOut = pkOut;
break;
//case CompressionAlgorithmTag.Zip:
// dOut = new DeflaterOutputStream(pkOut, new Deflater(compression, true));
// break;
//case CompressionAlgorithmTag.ZLib:
// dOut = new DeflaterOutputStream(pkOut, new Deflater(compression, false));
// break;
//case CompressionAlgorithmTag.BZip2:
// dOut = new BZip2OutputStream(pkOut);
// break;
default:
// Constructor should guard against this possibility
throw new ExecutionEngineException();
}
}
public override void Encode(BcpgOutputStream bcpgOut)
{
bcpgOut.WriteByte((byte)type);
bcpgOut.WriteByte((byte)algorithm);
if (type != 101)
{
if (type != 0)
{
bcpgOut.Write(iv);
}
if (type == 3)
{
bcpgOut.WriteByte((byte)itCount);
}
}
else
{
bcpgOut.WriteByte(71);
bcpgOut.WriteByte(78);
bcpgOut.WriteByte(85);
bcpgOut.WriteByte((byte)protectionMode);
}
}
/// <summary>
/// <p>
/// If buffer is non null stream assumed to be partial, otherwise the length will be used
/// to output a fixed length packet.
/// </p>
/// <p>
/// The stream created can be closed off by either calling Close()
/// on the stream or Close() on the generator. Closing the returned
/// stream does not close off the Stream parameter <c>outStr</c>.
/// </p>
/// </summary>
private Stream Open(Stream outStr, long length, byte[] buffer)
{
if (_cOut != null)
{
throw new InvalidOperationException("generator already in open state");
}
if (_methods.Count == 0)
{
throw new InvalidOperationException("No encryption methods specified");
}
if (outStr == null)
{
throw new ArgumentNullException("outStr");
}
_pOut = new BcpgOutputStream(outStr);
KeyParameter key;
if (_methods.Count == 1)
{
var pbeMethod = _methods[0] as PbeMethod;
if (pbeMethod != null)
{
key = pbeMethod.GetKey();
}
else
{
var pubMethod = (PubMethod)_methods[0];
key = PgpUtilities.MakeRandomKey(_defAlgorithm, _rand);
var sessionInfo = CreateSessionInfo(_defAlgorithm, key);
try
{
pubMethod.AddSessionInfo(sessionInfo, _rand);
}
catch (Exception e)
{
throw new PgpException("exception encrypting session key", e);
}
}
_pOut.WritePacket((ContainedPacket)_methods[0]);
}
else // multiple methods
{
key = PgpUtilities.MakeRandomKey(_defAlgorithm, _rand);
var sessionInfo = CreateSessionInfo(_defAlgorithm, key);
for (var i = 0; i != _methods.Count; i++)
{
var m = (EncMethod)_methods[i];
try
{
m.AddSessionInfo(sessionInfo, _rand);
}
catch (Exception e)
{
throw new PgpException("exception encrypting session key", e);
}
_pOut.WritePacket(m);
}
}
var cName = PgpUtilities.GetSymmetricCipherName(_defAlgorithm);
if (cName == null)
{
throw new PgpException("null cipher specified");
}
try
{
if (_withIntegrityPacket)
{
cName += "/CFB/NoPadding";
}
else
{
cName += "/OpenPGPCFB/NoPadding";
}
_c = CipherUtilities.GetCipher(cName);
// TODO Confirm the IV should be all zero bytes (not inLineIv - see below)
var iv = new byte[_c.GetBlockSize()];
_c.Init(true, new ParametersWithRandom(new ParametersWithIV(key, iv), _rand));
if (buffer == null)
{
//
// we have to Add block size + 2 for the Generated IV and + 1 + 22 if integrity protected
//
if (_withIntegrityPacket)
{
_pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricEncryptedIntegrityProtected,
length + _c.GetBlockSize() + 2 + 1 + 22);
_pOut.WriteByte(1); // version number
}
else
{
_pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricKeyEncrypted,
length + _c.GetBlockSize() + 2, _oldFormat);
}
}
else
{
if (_withIntegrityPacket)
{
_pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricEncryptedIntegrityProtected, buffer);
_pOut.WriteByte(1); // version number
}
else
{
_pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricKeyEncrypted, buffer);
}
}
var blockSize = _c.GetBlockSize();
var inLineIv = new byte[blockSize + 2];
_rand.NextBytes(inLineIv, 0, blockSize);
Array.Copy(inLineIv, inLineIv.Length - 4, inLineIv, inLineIv.Length - 2, 2);
Stream myOut = _cOut = new CipherStream(_pOut, null, _c);
if (_withIntegrityPacket)
{
var digestName = PgpUtilities.GetDigestName(HashAlgorithmTag.Sha1);
var digest = DigestUtilities.GetDigest(digestName);
myOut = _digestOut = new DigestStream(myOut, null, digest);
}
myOut.Write(inLineIv, 0, inLineIv.Length);
return(new WrappedGeneratorStream(this, myOut));
}
catch (Exception e)
{
throw new PgpException("Exception creating cipher", e);
}
}
/// <summary>
/// <p>
/// If buffer is non null stream assumed to be partial, otherwise the length will be used
/// to output a fixed length packet.
/// </p>
/// <p>
/// The stream created can be closed off by either calling Close()
/// on the stream or Close() on the generator. Closing the returned
/// stream does not close off the Stream parameter <c>outStr</c>.
/// </p>
/// </summary>
private Stream Open(
Stream outStr,
long length,
byte[] buffer)
{
if (cOut != null)
throw new InvalidOperationException("generator already in open state");
if (methods.Count == 0)
throw new InvalidOperationException("No encryption methods specified");
if (outStr == null)
throw new ArgumentNullException("outStr");
pOut = new BcpgOutputStream(outStr);
KeyParameter key;
if (methods.Count == 1)
{
if (methods[0] is PbeMethod)
{
PbeMethod m = (PbeMethod)methods[0];
key = m.GetKey();
}
else
{
key = PgpUtilities.MakeRandomKey(defAlgorithm, rand);
byte[] sessionInfo = CreateSessionInfo(defAlgorithm, key);
PubMethod m = (PubMethod)methods[0];
try
{
m.AddSessionInfo(sessionInfo, rand);
}
catch (Exception e)
{
throw new PgpException("exception encrypting session key", e);
}
}
pOut.WritePacket((ContainedPacket)methods[0]);
}
else // multiple methods
{
key = PgpUtilities.MakeRandomKey(defAlgorithm, rand);
byte[] sessionInfo = CreateSessionInfo(defAlgorithm, key);
for (int i = 0; i != methods.Count; i++)
{
EncMethod m = (EncMethod)methods[i];
try
{
m.AddSessionInfo(sessionInfo, rand);
}
catch (Exception e)
{
throw new PgpException("exception encrypting session key", e);
}
pOut.WritePacket(m);
}
}
string cName = PgpUtilities.GetSymmetricCipherName(defAlgorithm);
if (cName == null)
{
throw new PgpException("null cipher specified");
}
try
{
if (withIntegrityPacket)
{
cName += "/CFB/NoPadding";
}
else
{
cName += "/OpenPGPCFB/NoPadding";
}
c = CipherUtilities.GetCipher(cName);
// TODO Confirm the IV should be all zero bytes (not inLineIv - see below)
byte[] iv = new byte[c.GetBlockSize()];
c.Init(true, new ParametersWithRandom(new ParametersWithIV(key, iv), rand));
if (buffer == null)
{
//
// we have to Add block size + 2 for the Generated IV and + 1 + 22 if integrity protected
//
if (withIntegrityPacket)
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricEncryptedIntegrityProtected, length + c.GetBlockSize() + 2 + 1 + 22);
pOut.WriteByte(1); // version number
}
else
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricKeyEncrypted, length + c.GetBlockSize() + 2, oldFormat);
}
}
else
{
if (withIntegrityPacket)
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricEncryptedIntegrityProtected, buffer);
pOut.WriteByte(1); // version number
}
else
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricKeyEncrypted, buffer);
}
}
int blockSize = c.GetBlockSize();
byte[] inLineIv = new byte[blockSize + 2];
rand.NextBytes(inLineIv, 0, blockSize);
Array.Copy(inLineIv, inLineIv.Length - 4, inLineIv, inLineIv.Length - 2, 2);
Stream myOut = cOut = new CipherStream(pOut, null, c);
if (withIntegrityPacket)
{
string digestName = PgpUtilities.GetDigestName(HashAlgorithmTag.Sha1);
IDigest digest = DigestUtilities.GetDigest(digestName);
myOut = digestOut = new DigestStream(myOut, null, digest);
}
myOut.Write(inLineIv, 0, inLineIv.Length);
return new WrappedGeneratorStream(this, myOut);
}
catch (Exception e)
{
throw new PgpException("Exception creating cipher", e);
}
}
private Stream Open(Stream outStr, long length, byte[] buffer)
{
if (cOut != null)
{
throw new InvalidOperationException("generator already in open state");
}
if (methods.Count == 0)
{
throw new InvalidOperationException("No encryption methods specified");
}
if (outStr == null)
{
throw new ArgumentNullException("outStr");
}
pOut = new BcpgOutputStream(outStr);
KeyParameter keyParameter;
if (methods.Count == 1)
{
if (methods[0] is PbeMethod)
{
PbeMethod pbeMethod = (PbeMethod)methods[0];
keyParameter = pbeMethod.GetKey();
}
else
{
keyParameter = PgpUtilities.MakeRandomKey(defAlgorithm, rand);
byte[] si = CreateSessionInfo(defAlgorithm, keyParameter);
PubMethod pubMethod = (PubMethod)methods[0];
try
{
pubMethod.AddSessionInfo(si, rand);
}
catch (Exception exception)
{
throw new PgpException("exception encrypting session key", exception);
}
}
pOut.WritePacket((ContainedPacket)methods[0]);
}
else
{
keyParameter = PgpUtilities.MakeRandomKey(defAlgorithm, rand);
byte[] si2 = CreateSessionInfo(defAlgorithm, keyParameter);
for (int i = 0; i != methods.Count; i++)
{
EncMethod encMethod = (EncMethod)methods[i];
try
{
encMethod.AddSessionInfo(si2, rand);
}
catch (Exception exception2)
{
throw new PgpException("exception encrypting session key", exception2);
}
pOut.WritePacket(encMethod);
}
}
string symmetricCipherName = PgpUtilities.GetSymmetricCipherName(defAlgorithm);
if (symmetricCipherName == null)
{
throw new PgpException("null cipher specified");
}
try
{
symmetricCipherName = ((!withIntegrityPacket) ? (symmetricCipherName + "/OpenPGPCFB/NoPadding") : (symmetricCipherName + "/CFB/NoPadding"));
c = CipherUtilities.GetCipher(symmetricCipherName);
byte[] iv = new byte[c.GetBlockSize()];
c.Init(forEncryption: true, new ParametersWithRandom(new ParametersWithIV(keyParameter, iv), rand));
if (buffer == null)
{
if (withIntegrityPacket)
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricEncryptedIntegrityProtected, length + c.GetBlockSize() + 2 + 1 + 22);
pOut.WriteByte(1);
}
else
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricKeyEncrypted, length + c.GetBlockSize() + 2, oldFormat);
}
}
else if (withIntegrityPacket)
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricEncryptedIntegrityProtected, buffer);
pOut.WriteByte(1);
}
else
{
pOut = new BcpgOutputStream(outStr, PacketTag.SymmetricKeyEncrypted, buffer);
}
int blockSize = c.GetBlockSize();
byte[] array = new byte[blockSize + 2];
rand.NextBytes(array, 0, blockSize);
Array.Copy(array, array.Length - 4, array, array.Length - 2, 2);
Stream stream = cOut = new CipherStream(pOut, null, c);
if (withIntegrityPacket)
{
string digestName = PgpUtilities.GetDigestName(HashAlgorithmTag.Sha1);
IDigest digest = DigestUtilities.GetDigest(digestName);
stream = (digestOut = new DigestStream(stream, null, digest));
}
stream.Write(array, 0, array.Length);
return(new WrappedGeneratorStream(this, stream));
}
catch (Exception exception3)
{
throw new PgpException("Exception creating cipher", exception3);
}
}