public void Close()
{
if (cOut != null)
{
if (digestOut != null)
{
BcpgOutputStream bcpgOutputStream = new BcpgOutputStream(digestOut, PacketTag.ModificationDetectionCode, 20L);
bcpgOutputStream.Flush();
digestOut.Flush();
byte[] array = DigestUtilities.DoFinal(digestOut.WriteDigest());
cOut.Write(array, 0, array.Length);
}
cOut.Flush();
try
{
pOut.Write(c.DoFinal());
pOut.Finish();
}
catch (Exception ex)
{
throw new IOException(ex.Message, ex);
}
cOut = null;
pOut = null;
}
}
/// <summary>
/// Create decorator streams implementing the Encrypt-then-MAC scheme (CipherStream bound to a MacStream).
/// </summary>
/// <param name="item">Item to create resources for.</param>
/// <param name="encryptor">Cipher stream (output).</param>
/// <param name="authenticator">MAC stream (output).</param>
protected void CreateEtMDecorator(PayloadItem item, out CipherStream encryptor, out MacStream authenticator)
{
byte[] encryptionKey, authenticationKey;
if (item.SymmetricCipherKey.IsNullOrZeroLength() == false && item.AuthenticationKey.IsNullOrZeroLength() == false)
{
encryptionKey = item.SymmetricCipherKey;
authenticationKey = item.AuthenticationKey;
}
else if (PayloadItemPreKeys.ContainsKey(item.Identifier))
{
if (item.Authentication.KeySizeBits.HasValue == false)
{
throw new ConfigurationInvalidException(
"Payload item authentication configuration is missing size specification of MAC key.");
}
KeyStretchingUtility.DeriveWorkingKeys(PayloadItemPreKeys[item.Identifier],
item.SymmetricCipher.KeySizeBits / 8,
item.Authentication.KeySizeBits.Value / 8, item.KeyDerivation, out encryptionKey,
out authenticationKey);
}
else
{
throw new ItemKeyMissingException(item);
}
authenticator = new MacStream(PayloadStream, Writing, item.Authentication,
authenticationKey, false);
encryptor = new CipherStream(authenticator, Writing, item.SymmetricCipher,
encryptionKey, false);
}
private object Decrypt(string dataString)
{
var key = Convert.FromBase64String(subscriptionInfo.DeliveryMode.EncryptionKey);
var keyParameter = ParameterUtilities.CreateKeyParameter("AES", key);
var cipher = CipherUtilities.GetCipher("AES/ECB/PKCS7Padding");
cipher.Init(false, keyParameter);
var data = Convert.FromBase64String(dataString);
var memoryStream = new MemoryStream(data, false);
var cipherStream = new CipherStream(memoryStream, cipher, null);
var bufferSize = 1024;
var buffer = new byte[bufferSize];
var length = 0;
var resultStream = new MemoryStream();
while ((length = cipherStream.Read(buffer, 0, bufferSize)) > 0)
{
resultStream.Write(buffer, 0, length);
}
var resultBytes = resultStream.ToArray();
var result = Encoding.UTF8.GetString(resultBytes, 0, resultBytes.Length);
return(JsonConvert.DeserializeObject(result));
}
public async Task <string> LoadFirstLinesFromDiskAsync(string fileName, int lineCount, SecureString passphrase)
{
using (var inputStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true))
{
using (var outputStream = new MemoryStream())
{
var password = SecureStringCredentialStore.SecureStringToString(passphrase);
using (var cryptoStream = CipherStream.Open(inputStream, password))
{
while (cryptoStream.CanRead)
{
var buffer = new byte[4096];
await cryptoStream.ReadAsync(buffer, 0, 4096);
await outputStream.WriteAsync(buffer, 0, 4096);
char[] chunk = Encoding.UTF8.GetChars(buffer);
var occurances = chunk.Count(c => c == '\n');
if (occurances >= lineCount)
{
break;
}
}
}
outputStream.Position = 0;
using (var reader = new StreamReader(outputStream))
{
return(await reader.ReadToEndAsync());
}
}
}
}
public void AESDecryption()
{
var dataString = "YSholLwd6hNXsLPHW+DZQsdhFutxTGa04L6E4ySBQ4ihyjZ/7iH9VdqAiEsmFLrNNaHT+RfGAJfqmwoAfS2E0uJI/dY3UkuiBq152iKnoWkEhphdkAeerQwBbCCl82F6/2ezoyBbTomwkalyV32djQF7Xh5jxJGw1xorldxX6WUJ/a3g4EPU7zAIVBElx+kOJm4TwfiznJoNAArVFp96MxjDe4aHrVNpPSFzQrVKdgTVsXuqTaX5j0Dq1bHfZZ539L7C/yTT1mSCO9BCWdyclquDdKwf40V+Up0eMYgV8tGMqI5r0I8OaU7djD66Jv/HICikqFOLwPoHj7uQby/SXMKPKxA/7UVfDFeNHrC7ZXdIj2LDv7NC2WHG/c92qDoORbuO20+dLWUGqyKnwYx4Xh7EqBfVM2uQErbH9pk2DZ1WL93I6zdoGtRwzQBI7GwRY0KtPchJICdHkjA42s3U0g==";
var keyString = "1q3kw4BhAAtT0SJkZ0a8EA==";
var expected = "{\"uuid\":\"3622482f-465b-4f6b-9beb-44f508b59016\",\"event\":\"/restapi/v1.0/account/~/extension/850957020/message-store\",\"timestamp\":\"2016-05-25T00:54:36.834Z\",\"subscriptionId\":\"57b5d366-ab22-490b-9754-b60fa6aab373\",\"body\":{\"extensionId\":850957020,\"lastUpdated\":\"2016-05-25T00:54:22.055+0000\",\"changes\":[{\"type\":\"SMS\",\"newCount\":0,\"updatedCount\":1}]}}";
var key = Convert.FromBase64String(keyString);
var keyParameter = ParameterUtilities.CreateKeyParameter("AES", key);
var cipher = CipherUtilities.GetCipher("AES/ECB/PKCS7Padding");
cipher.Init(false, keyParameter);
var data = Convert.FromBase64String(dataString);
var memoryStream = new MemoryStream(data, false);
var cipherStream = new CipherStream(memoryStream, cipher, null);
var bufferSize = 1024;
var buffer = new byte[bufferSize];
var length = 0;
var resultStream = new MemoryStream();
while ((length = cipherStream.Read(buffer, 0, bufferSize)) > 0)
{
resultStream.Write(buffer, 0, length);
}
var result = Encoding.UTF8.GetString(resultStream.ToArray());
Assert.AreEqual(expected, result);
}
public static string DecryptForJava(string input, string key)
{
var inputArrary = Convert.FromBase64String(input);
var outCipher = CreateCipher(false, key);
var encryptedDataStream = new MemoryStream(inputArrary, false);
var dataStream = new MemoryStream();
var outCipherStream = new CipherStream(dataStream, null, outCipher);
int ch;
while ((ch = encryptedDataStream.ReadByte()) >= 0)
{
outCipherStream.WriteByte((byte)ch);
}
outCipherStream.Close();
encryptedDataStream.Close();
var dataBytes = dataStream.ToArray();
return(Encoding.UTF8.GetString(dataBytes));
}
private static byte[] RSAEncryptData(AsymmetricKeyParameter publicKey, byte[] originalDataBytes)
{
bool isEncryption = true;
byte[] encryptedDataArray;
using (MemoryStream originalDataStream = new MemoryStream(originalDataBytes, false))
{
using (MemoryStream encryptedDataStream = new MemoryStream())
{
IBufferedCipher rsacipher = RSACreateCipher(isEncryption, publicKey);
using (CipherStream cipherStream = new CipherStream(originalDataStream, rsacipher, null))
{
int oneByte;
while ((oneByte = cipherStream.ReadByte()) >= 0)
{
encryptedDataStream.WriteByte((byte)oneByte);
}
cipherStream.Close();
cipherStream.Dispose();
}
encryptedDataArray = encryptedDataStream.ToArray();
encryptedDataStream.Close();
encryptedDataStream.Dispose();
}
originalDataStream.Close();
originalDataStream.Dispose();
}
return(encryptedDataArray);
}
// "private class Pkcs12Test" @ https://github.com/bcgit/bc-csharp/blob/b19e68a517e56ef08cd2e50df4dcb8a96ddbe507/crypto/test/src/test/PBETest.cs
// https://github.com/bcgit/bc-csharp/blob/b19e68a517e56ef08cd2e50df4dcb8a96ddbe507/crypto/src/crypto/generators/Pkcs12ParametersGenerator.cs
// https://github.com/bcgit/bc-csharp/blob/master/crypto/src/crypto/BufferedStreamCipher.cs
// https://github.com/bcgit/bc-csharp/blob/master/crypto/src/crypto/io/CipherStream.cs
// https://forum.facepunch.com/f/nerds/payx/How-can-I-encrypt-a-txt-file/1/#posticazt
public static void EncryptStreamPBE(
Action <Stream> streamWriter,
Stream outStream,
EncryptionAlgorithm algorithm,
string key)
{
var pbeAlg = PBEAlgorithmMap[algorithm];
var digest = pbeAlg.Digest;
byte[] salt = DigestUtilities.DoFinal(digest);
PbeParametersGenerator pGen = new Pkcs12ParametersGenerator(digest);
pGen.Init(
PbeParametersGenerator.Pkcs12PasswordToBytes(key.ToArray()),
salt,
IterationCount);
ParametersWithIV parameters = (ParametersWithIV)
pGen.GenerateDerivedParameters(pbeAlg.BaseAlgorithm, pbeAlg.KeySize, pbeAlg.IVSize);
KeyParameter encKey = (KeyParameter)parameters.Parameters;
IBufferedCipher c = CipherUtilities.GetCipher(pbeAlg.BaseAlgorithm + "/CBC/PKCS7Padding");
c.Init(true, parameters);
using (CipherStream encStream = new CipherStream(outStream, null, c))
{
streamWriter(encStream);
}
}
public void Close()
{
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
if (cOut != null)
{
if (digestOut != null)
{
BcpgOutputStream bcpgOutputStream = new BcpgOutputStream((Stream)(object)digestOut, PacketTag.ModificationDetectionCode, 20L);
((Stream)bcpgOutputStream).Flush();
((Stream)digestOut).Flush();
byte[] array = DigestUtilities.DoFinal(digestOut.WriteDigest());
((Stream)cOut).Write(array, 0, array.Length);
}
((Stream)cOut).Flush();
try
{
pOut.Write(c.DoFinal());
pOut.Finish();
}
catch (global::System.Exception ex)
{
throw new IOException(ex.get_Message(), ex);
}
cOut = null;
pOut = null;
}
}
protected void RunSegmentedVectorTest(int number, SegmentedVectorTestCase testCase)
{
CipherConfiguration config = GetCipherConfiguration(testCase);
var plaintext = new byte[testCase.IV.Length];
TestVectorSegment lastSegment = testCase.Segments.Last();
int requiredCiphertextLength = lastSegment.Offset + lastSegment.Length;
var msCiphertext = new MemoryStream();
using (var cs = new CipherStream(msCiphertext, true, config, testCase.Key, false)) {
while (cs.BytesOut < requiredCiphertextLength)
{
cs.Write(plaintext, 0, plaintext.Length);
}
}
// Now we analyse the ciphertext segment-wise
foreach (var segment in testCase.Segments)
{
msCiphertext.Seek(segment.Offset, SeekOrigin.Begin);
var segmentCiphertext = new byte[segment.Length];
msCiphertext.Read(segmentCiphertext, 0, segment.Length);
byte[] referenceCiphertext = segment.Ciphertext;
// Validate the segment
Assert.IsTrue(referenceCiphertext.SequenceEqualShortCircuiting(segmentCiphertext),
"Segmented vector test #{0} (\"{1}\") failed at segment {2}!",
number, testCase.Name, segment.Name);
}
}
private void DescriptionTest(CipherDescription Description)
{
AllocateRandom(ref _iv, 16);
AllocateRandom(ref _key, 32);
AllocateRandom(ref _plnText);
KeyParams kp = new KeyParams(_key, _iv);
MemoryStream mIn = new MemoryStream(_plnText);
MemoryStream mOut = new MemoryStream();
MemoryStream mRes = new MemoryStream();
CipherStream cs = new CipherStream(Description);
cs.Initialize(true, kp);
cs.Write(mIn, mOut);
mOut.Seek(0, SeekOrigin.Begin);
cs.Initialize(false, kp);
cs.Write(mOut, mRes);
if (!Evaluate.AreEqual(mRes.ToArray(), _plnText))
{
throw new Exception("CipherStreamTest: Encrypted arrays are not equal!");
}
}
private static async Task <(MemoryStream output, IMS2SizeHeader size)> InternalGetEncryptionStreamAsync(Stream input, long inputSize, IBufferedCipher cipher, long headerSize)
{
byte[] inputBytes = new byte[inputSize];
int read = await input.ReadAsync(inputBytes, 0, (int)inputSize).ConfigureAwait(false);
if (inputSize != read)
{
throw new EndOfStreamException();
}
using var msInput = new MemoryStream(inputBytes);
using var cs = new CipherStream(msInput, cipher, null);
using var ms = new MemoryStream();
var output = new MemoryStream();
await cs.CopyToAsync(ms).ConfigureAwait(false);
var data = ms.ToArray();
var encoder = new Base64Encoder();
encoder.Encode(data, 0, data.Length, output);
var header = new MS2SizeHeader(output.Length, inputSize, headerSize);
output.Position = 0;
return(output, header);
}
public CmsEnvelopedDataOutputStream(CmsEnvelopedGenerator outer, CipherStream outStream, BerSequenceGenerator cGen, BerSequenceGenerator envGen, BerSequenceGenerator eiGen)
{
_outer = outer;
_out = outStream;
_cGen = cGen;
_envGen = envGen;
_eiGen = eiGen;
}
public MonoAesStream(System.IO.Stream stream, byte[] key)
{
BaseStream = stream;
BufferedBlockCipher enc = GenerateAES(key, true);
BufferedBlockCipher dec = GenerateAES(key, false);
cstream = new CipherStream(stream, dec, enc);
}
public Stream BcDecryptStream(Stream inputStream)
{
var cipher = CipherUtilities.GetCipher("ChaCha20-Poly1305");
cipher.Init(false, new ParametersWithIV(new KeyParameter(Key), Iv));
var cs = new CipherStream(inputStream, cipher, cipher);
return(cs);
}
public void EncriptChannel(byte[] secretKey)
{
var output = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));
output.Init(true, new ParametersWithIV(new KeyParameter(secretKey), secretKey, 0, 16));
var input = new BufferedBlockCipher(new CfbBlockCipher(new AesFastEngine(), 8));
input.Init(false, new ParametersWithIV(new KeyParameter(secretKey), secretKey, 0, 16));
var cipherStream = new CipherStream(client.GetStream(), input, output);
streamWrapper = new StreamWrapper(cipherStream);
}
private Stream Open(Stream outStream, AlgorithmIdentifier encAlgID, ICipherParameters cipherParameters, Asn1EncodableVector recipientInfos)
{
//IL_0120: Expected O, but got Unknown
try
{
BerSequenceGenerator berSequenceGenerator = new BerSequenceGenerator(outStream);
berSequenceGenerator.AddObject(CmsObjectIdentifiers.EnvelopedData);
BerSequenceGenerator berSequenceGenerator2 = new BerSequenceGenerator(berSequenceGenerator.GetRawOutputStream(), 0, isExplicit: true);
berSequenceGenerator2.AddObject(Version);
Stream rawOutputStream = berSequenceGenerator2.GetRawOutputStream();
Asn1Generator asn1Generator = (_berEncodeRecipientSet ? ((Asn1Generator) new BerSetGenerator(rawOutputStream)) : ((Asn1Generator) new DerSetGenerator(rawOutputStream)));
global::System.Collections.IEnumerator enumerator = recipientInfos.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
Asn1Encodable obj = (Asn1Encodable)enumerator.get_Current();
asn1Generator.AddObject(obj);
}
}
finally
{
global::System.IDisposable disposable = enumerator as global::System.IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
asn1Generator.Close();
BerSequenceGenerator berSequenceGenerator3 = new BerSequenceGenerator(rawOutputStream);
berSequenceGenerator3.AddObject(CmsObjectIdentifiers.Data);
berSequenceGenerator3.AddObject(encAlgID);
Stream stream = CmsUtilities.CreateBerOctetOutputStream(berSequenceGenerator3.GetRawOutputStream(), 0, isExplicit: false, _bufferSize);
IBufferedCipher cipher = CipherUtilities.GetCipher(encAlgID.Algorithm);
cipher.Init(forEncryption: true, new ParametersWithRandom(cipherParameters, rand));
CipherStream outStream2 = new CipherStream(stream, null, cipher);
return((Stream)(object)new CmsEnvelopedDataOutputStream(this, outStream2, berSequenceGenerator, berSequenceGenerator2, berSequenceGenerator3));
}
catch (SecurityUtilityException e)
{
throw new CmsException("couldn't create cipher.", e);
}
catch (InvalidKeyException e2)
{
throw new CmsException("key invalid in message.", e2);
}
catch (IOException val)
{
IOException e3 = val;
throw new CmsException("exception decoding algorithm parameters.", (global::System.Exception)(object) e3);
}
}
public MuxItemResourceContainer(CipherStream encryptor, MacStream authenticator, int?bufferCapacity)
{
Encryptor = encryptor;
Authenticator = authenticator;
if (bufferCapacity != null)
{
Buffer = new Lazy <RingBufferStream>(() => new RingBufferStream(bufferCapacity.Value, false));
}
else
{
SkippedLength = 0;
}
}
// Performance testing resources (not called in this base class, but called from derived classes)
protected void RunPerformanceTest(CipherConfiguration config, byte[] overrideKey = null)
{
MemoryStream msInputPlaintext = LargeBinaryFile;
byte[] key = overrideKey ?? CreateRandomByteArray(config.KeySizeBits);
var msCiphertext = new MemoryStream((int)(msInputPlaintext.Length * 1.1));
var sw = new Stopwatch();
// TEST STARTS HERE
using (var cs = new CipherStream(msCiphertext, true, config, key, false)) {
sw.Start();
msInputPlaintext.CopyTo(cs, GetBufferSize());
}
sw.Stop();
TimeSpan encryptionElapsed = sw.Elapsed;
var msOutputPlaintext = new MemoryStream((int)msInputPlaintext.Length);
msCiphertext.Seek(0, SeekOrigin.Begin);
sw.Reset();
using (var cs = new CipherStream(msCiphertext, false, config, key, false)) {
sw.Start();
cs.CopyTo(msOutputPlaintext, GetBufferSize());
}
sw.Stop();
TimeSpan decryptionElapsed = sw.Elapsed;
// TEST ENDS HERE
// TEST OUTPUT PLAINTEXT VALIDITY
msInputPlaintext.Seek(0, SeekOrigin.Begin);
msOutputPlaintext.Seek(0, SeekOrigin.Begin);
int failurePosition;
Assert.IsTrue(StreamsContentMatches(msInputPlaintext, msOutputPlaintext, (int)msInputPlaintext.Length, out failurePosition),
"Input and output plaintext does not match. First failure observed at position # " + failurePosition);
// OUTPUT SUCCESS STATISTICS
double encSpeed = ((double)msInputPlaintext.Length / 1048576) / encryptionElapsed.TotalSeconds,
decSpeed =
((double)msInputPlaintext.Length / 1048576) / decryptionElapsed.TotalSeconds;
Assert.Pass("{0:N0} ms ({1:N2} MB/s) : {2:N0} ms ({3:N2} MB/s)",
encryptionElapsed.TotalMilliseconds, encSpeed, decryptionElapsed.TotalMilliseconds, decSpeed);
}
private byte[] encryptOnWrite(byte[] dataBytes)
{
MemoryStream encryptedDataStream = new MemoryStream();
IBufferedCipher outCipher = createCipher(true);
CipherStream outCipherStream = new CipherStream(encryptedDataStream, null, outCipher);
outCipherStream.Write(dataBytes, 0, dataBytes.Length);
Assert.AreEqual(0L, encryptedDataStream.Position % outCipher.GetBlockSize());
outCipherStream.Close();
byte[] encryptedDataBytes = encryptedDataStream.ToArray();
Assert.AreEqual(dataBytes.Length, encryptedDataBytes.Length);
return encryptedDataBytes;
}
private byte[] encryptOnWrite(byte[] dataBytes)
{
MemoryStream encryptedDataStream = new MemoryStream();
IBufferedCipher outCipher = createCipher(true);
CipherStream outCipherStream = new CipherStream(encryptedDataStream, null, outCipher);
outCipherStream.Write(dataBytes, 0, dataBytes.Length);
Assert.AreEqual(0L, encryptedDataStream.Position % outCipher.GetBlockSize());
outCipherStream.Close();
byte[] encryptedDataBytes = encryptedDataStream.ToArray();
Assert.AreEqual(dataBytes.Length, encryptedDataBytes.Length);
return(encryptedDataBytes);
}
public Stream BcEncryptStream(Stream inputStream)
{
CipherKeyGenerator gen = GeneratorUtilities.GetKeyGenerator("ChaCha20-Poly1305");
var cipher = CipherUtilities.GetCipher("ChaCha20-Poly1305");
Key = gen.GenerateKey();
SecureRandom random = new SecureRandom();
Iv = new byte[12];
random.NextBytes(Iv);
cipher.Init(true, new ParametersWithIV(new KeyParameter(Key), Iv));
var cs = new CipherStream(inputStream, cipher, null);
return(cs);
}
protected void RunDiscreteVectorTest(int number, DiscreteVectorTestCase testCase)
{
CipherConfiguration config = GetCipherConfiguration(testCase);
byte[] plaintext = testCase.Plaintext;
byte[] ciphertext;
using (var msCiphertext = new MemoryStream()) {
using (var cs = new CipherStream(msCiphertext, true, config, testCase.Key, false)) {
cs.Write(plaintext, 0, plaintext.Length);
}
ciphertext = msCiphertext.ToArray();
}
Assert.IsTrue(testCase.Ciphertext.SequenceEqualShortCircuiting(ciphertext),
"Test #{0} (\"{1}\") failed!", number, testCase.Name);
}
public static byte[] AESEncryptData(byte[] originalDataBytes, byte[] aesKeyByteData, byte[] iv = null)
{
bool isEncryption = true;
MemoryStream originalDataStream = new MemoryStream(originalDataBytes, false);
MemoryStream encryptedDataStream = new MemoryStream();
IBufferedCipher aesCipher = AESCreateCipher(isEncryption, aesKeyByteData, iv);
CipherStream cipherStream = new CipherStream(originalDataStream, aesCipher, null);
int oneByte;
while ((oneByte = cipherStream.ReadByte()) >= 0)
{
encryptedDataStream.WriteByte((byte)oneByte);
}
encryptedDataStream.Close();
cipherStream.Close();
return(encryptedDataStream.ToArray());
}
void StreamModesTest(ICipherMode Cipher, IPadding Padding)
{
if (Cipher.Engine.LegalKeySizes[0] > 32)
{
AllocateRandom(ref _key, 192);
}
else
{
AllocateRandom(ref _key, 32);
}
AllocateRandom(ref _iv, 16);
// we are testing padding modes, make sure input size is random, but -not- block aligned..
AllocateRandom(ref _plnText, 0, Cipher.BlockSize);
KeyParams kp = new KeyParams(_key, _iv);
MemoryStream mIn = new MemoryStream(_plnText);
MemoryStream mOut = new MemoryStream();
MemoryStream mRes = new MemoryStream();
CipherStream cs = new CipherStream(Cipher, Padding);
cs.Initialize(true, kp);
cs.Write(mIn, mOut);
cs.Initialize(false, kp);
mOut.Seek(0, SeekOrigin.Begin);
cs.Write(mOut, mRes);
int pos = (int)mRes.Position;
byte[] res = new byte[_plnText.Length];
Buffer.BlockCopy(mRes.ToArray(), 0, res, 0, pos);
if (!Evaluate.AreEqual(res, _plnText))
{
throw new Exception("CipherStreamTest: Encrypted arrays are not equal!");
}
Cipher.Dispose();
}
public void Constructor_PassReference_Pass()
{
string passwd = "superpassword";
byte[] salt = {
1,2,3,4,5,6,7,8,9
};
Cipher originCipher;
Cipher handlerCipher;
using(SymmetricCipher<AesManaged> cipher = new SymmetricCipher<AesManaged>(passwd, salt))
{
using(var handler = new CipherStream<AesManaged>(cipher))
{
handlerCipher = handler.Cipher;
}
originCipher = cipher;
Assert.ReferenceEquals(originCipher, handlerCipher);
}
}
/// <summary>
/// Initialize the cipher instance
/// </summary>
///
/// <param name="KeyStream">A stream containing a volume key</param>
public void Initialize(Stream KeyStream)
{
m_keyStream = KeyStream;
m_volumeKey = new VolumeKey(KeyStream);
if (!CipherDescription.IsValid(m_volumeKey.Description))
{
throw new CryptoProcessingException("VolumeCipher:Initialize", "The key Header is invalid!", new ArgumentException());
}
CipherDescription dsc = m_volumeKey.Description;
try
{
m_cipherStream = new CipherStream(dsc);
}
catch (Exception ex)
{
throw new CryptoProcessingException("VolumeCipher:Initialize", "The cipher could not be initialized!", ex);
}
}
private byte[] encryptOnRead(byte[] dataBytes)
{
MemoryStream dataStream = new MemoryStream(dataBytes, false);
MemoryStream encryptedDataStream = new MemoryStream();
IBufferedCipher inCipher = createCipher(true);
CipherStream inCipherStream = new CipherStream(dataStream, inCipher, null);
int ch;
while ((ch = inCipherStream.ReadByte()) >= 0)
{
encryptedDataStream.WriteByte((byte) ch);
}
encryptedDataStream.Close();
inCipherStream.Close();
byte[] encryptedDataBytes = encryptedDataStream.ToArray();
Assert.AreEqual(dataBytes.Length, encryptedDataBytes.Length);
return encryptedDataBytes;
}
public static byte[] AESDecryptData(byte[] encryptedDataBytes, byte[] aesKeyByteData, byte[] iv = null)
{
bool isEncryption = false;
MemoryStream enryptedDataSream = new MemoryStream(encryptedDataBytes, false);
MemoryStream decryptedDataStream = new MemoryStream();
IBufferedCipher aesCipher = AESCreateCipher(isEncryption, aesKeyByteData, iv);
CipherStream decodedCipherStream = new CipherStream(enryptedDataSream, aesCipher, null);
int oneByte;
while ((oneByte = decodedCipherStream.ReadByte()) >= 0)
{
decryptedDataStream.WriteByte((byte)oneByte);
}
decodedCipherStream.Close();
decryptedDataStream.Close();
return(decryptedDataStream.ToArray());
}
private static byte[] RSAEntschluesselDaten(AsymmetricKeyParameter privateKey, byte[] encryptedDataBytes)
{
bool isEncryption = false;
MemoryStream enryptedDataSream = new MemoryStream(encryptedDataBytes, false);
MemoryStream decryptedDataStream = new MemoryStream();
IBufferedCipher aesCipher = RSACreateCipher(isEncryption, privateKey);
CipherStream decodedCipherStream = new CipherStream(enryptedDataSream, aesCipher, null);
int oneByte;
while ((oneByte = decodedCipherStream.ReadByte()) >= 0)
{
decryptedDataStream.WriteByte((byte)oneByte);
}
decodedCipherStream.Close();
decryptedDataStream.Close();
return(decryptedDataStream.ToArray());
}
private Stream Open(Stream outStream, AlgorithmIdentifier encAlgID, ICipherParameters cipherParameters, Asn1EncodableVector recipientInfos)
{
Stream result;
try
{
BerSequenceGenerator berSequenceGenerator = new BerSequenceGenerator(outStream);
berSequenceGenerator.AddObject(CmsObjectIdentifiers.EnvelopedData);
BerSequenceGenerator berSequenceGenerator2 = new BerSequenceGenerator(berSequenceGenerator.GetRawOutputStream(), 0, true);
berSequenceGenerator2.AddObject(this.Version);
Stream rawOutputStream = berSequenceGenerator2.GetRawOutputStream();
Asn1Generator asn1Generator = this._berEncodeRecipientSet ? new BerSetGenerator(rawOutputStream) : new DerSetGenerator(rawOutputStream);
foreach (Asn1Encodable obj in recipientInfos)
{
asn1Generator.AddObject(obj);
}
asn1Generator.Close();
BerSequenceGenerator berSequenceGenerator3 = new BerSequenceGenerator(rawOutputStream);
berSequenceGenerator3.AddObject(CmsObjectIdentifiers.Data);
berSequenceGenerator3.AddObject(encAlgID);
Stream stream = CmsUtilities.CreateBerOctetOutputStream(berSequenceGenerator3.GetRawOutputStream(), 0, false, this._bufferSize);
IBufferedCipher cipher = CipherUtilities.GetCipher(encAlgID.ObjectID);
cipher.Init(true, new ParametersWithRandom(cipherParameters, this.rand));
CipherStream outStream2 = new CipherStream(stream, null, cipher);
result = new CmsEnvelopedDataStreamGenerator.CmsEnvelopedDataOutputStream(this, outStream2, berSequenceGenerator, berSequenceGenerator2, berSequenceGenerator3);
}
catch (SecurityUtilityException e)
{
throw new CmsException("couldn't create cipher.", e);
}
catch (InvalidKeyException e2)
{
throw new CmsException("key invalid in message.", e2);
}
catch (IOException e3)
{
throw new CmsException("exception decoding algorithm parameters.", e3);
}
return(result);
}
private byte[] encryptOnRead(byte[] dataBytes)
{
MemoryStream dataStream = new MemoryStream(dataBytes, false);
MemoryStream encryptedDataStream = new MemoryStream();
IBufferedCipher inCipher = createCipher(true);
CipherStream inCipherStream = new CipherStream(dataStream, inCipher, null);
int ch;
while ((ch = inCipherStream.ReadByte()) >= 0)
{
encryptedDataStream.WriteByte((byte)ch);
}
encryptedDataStream.Close();
inCipherStream.Close();
byte[] encryptedDataBytes = encryptedDataStream.ToArray();
Assert.AreEqual(dataBytes.Length, encryptedDataBytes.Length);
return(encryptedDataBytes);
}
/// <summary>
/// <p>
/// Close off the encrypted object - this is equivalent to calling Close() on the stream
/// returned by the Open() method.
/// </p>
/// <p>
/// <b>Note</b>: This does not close the underlying output stream, only the stream on top of
/// it created by the Open() method.
/// </p>
/// </summary>
public void Close()
{
if (_cOut == null)
{
return;
}
// TODO Should this all be under the try/catch block?
if (_digestOut != null)
{
//
// hand code a mod detection packet
//
var bOut = new BcpgOutputStream(
_digestOut, PacketTag.ModificationDetectionCode, 20);
bOut.Flush();
_digestOut.Flush();
// TODO
var dig = DigestUtilities.DoFinal(_digestOut.WriteDigest());
_cOut.Write(dig, 0, dig.Length);
}
_cOut.Flush();
try
{
_pOut.Write(_c.DoFinal());
_pOut.Finish();
}
catch (Exception e)
{
throw new IOException(e.Message, e);
}
_cOut = null;
_pOut = null;
}
private byte[] decryptOnWrite(byte[] encryptedDataBytes)
{
MemoryStream encryptedDataStream = new MemoryStream(encryptedDataBytes, false);
MemoryStream dataStream = new MemoryStream();
IBufferedCipher outCipher = createCipher(false);
CipherStream outCipherStream = new CipherStream(dataStream, null, outCipher);
int ch;
while ((ch = encryptedDataStream.ReadByte()) >= 0)
{
outCipherStream.WriteByte((byte) ch);
}
outCipherStream.Close();
encryptedDataStream.Close();
byte[] dataBytes = dataStream.ToArray();
Assert.AreEqual(encryptedDataBytes.Length, dataBytes.Length);
return dataBytes;
}
