public void Test_Tag()
{
var tag = new Chat("oooo", new byte[32]);
Chat tag2;
{
var ds = new DataContractSerializer(typeof(Chat));
using (BufferStream stream = new BufferStream(BufferManager.Instance))
{
using (WrapperStream wrapperStream = new WrapperStream(stream, true))
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(wrapperStream))
{
ds.WriteObject(xmlDictionaryWriter, tag);
}
stream.Position = 0;
using (XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
{
tag2 = (Chat)ds.ReadObject(xmlDictionaryReader);
}
}
}
Assert.AreEqual(tag, tag2, "Tag #1");
Chat tag3;
using (var tagStream = tag.Export(_bufferManager))
{
tag3 = Chat.Import(tagStream, _bufferManager);
}
Assert.AreEqual(tag, tag3, "Tag #2");
}
public void Test_Metadata()
{
foreach (var a in new DigitalSignatureAlgorithm[] { DigitalSignatureAlgorithm.Rsa2048_Sha256, DigitalSignatureAlgorithm.EcDsaP521_Sha256 })
{
var id = new byte[32];
_random.NextBytes(id);
var key = new Key(id, HashAlgorithm.Sha256);
var tag = new Chat("oooo", new byte[32]);
var miner = new Miner(CashAlgorithm.Version1, -1, TimeSpan.Zero);
var digitalSignature = new DigitalSignature("123", a);
var metadata = new ChatMessageMetadata(tag, DateTime.UtcNow, key, miner, digitalSignature);
ChatMessageMetadata metadata2;
{
var ds = new DataContractSerializer(typeof(ChatMessageMetadata));
using (BufferStream stream = new BufferStream(BufferManager.Instance))
{
using (WrapperStream wrapperStream = new WrapperStream(stream, true))
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(wrapperStream))
{
ds.WriteObject(xmlDictionaryWriter, metadata);
}
stream.Position = 0;
using (XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
{
metadata2 = (ChatMessageMetadata)ds.ReadObject(xmlDictionaryReader);
}
}
}
Assert.AreEqual(metadata, metadata2, "Metadata #1");
ChatMessageMetadata metadata3;
using (var metadataStream = metadata.Export(_bufferManager))
{
metadata3 = ChatMessageMetadata.Import(metadataStream, _bufferManager);
}
Assert.AreEqual(metadata, metadata3, "Metadata #2");
Assert.IsTrue(metadata3.VerifyCertificate(), "Metadata #3");
}
}
private static Stream Encrypt(Stream stream, IExchangeEncrypt publicKey)
{
if (stream == null) throw new ArgumentNullException("stream");
if (publicKey == null) throw new ArgumentNullException("publicKey");
try
{
BufferStream outStream = null;
try
{
outStream = new BufferStream(_bufferManager);
outStream.WriteByte((byte)ConvertCryptoAlgorithm.Aes256);
byte[] cryptoKey = new byte[32];
_random.GetBytes(cryptoKey);
{
var encryptedBuffer = Exchange.Encrypt(publicKey, cryptoKey);
outStream.Write(NetworkConverter.GetBytes((int)encryptedBuffer.Length), 0, 4);
outStream.Write(encryptedBuffer, 0, encryptedBuffer.Length);
}
byte[] iv = new byte[32];
_random.GetBytes(iv);
outStream.Write(iv, 0, iv.Length);
using (Stream inStream = new WrapperStream(stream, true))
{
using (var rijndael = new RijndaelManaged() { KeySize = 256, BlockSize = 256, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7 })
using (CryptoStream cs = new CryptoStream(inStream, rijndael.CreateEncryptor(cryptoKey, iv), CryptoStreamMode.Read))
{
byte[] buffer = null;
try
{
buffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = cs.Read(buffer, 0, buffer.Length)) > 0)
{
outStream.Write(buffer, 0, i);
}
}
finally
{
if (buffer != null)
{
_bufferManager.ReturnBuffer(buffer);
}
}
}
}
outStream.Seek(0, SeekOrigin.Begin);
}
catch (Exception)
{
if (outStream != null)
{
outStream.Dispose();
}
throw;
}
return outStream;
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
private static Stream Decrypt(Stream stream, IExchangeDecrypt privateKey)
{
if (stream == null) throw new ArgumentNullException("stream");
if (privateKey == null) throw new ArgumentNullException("privateKey");
try
{
byte type = (byte)stream.ReadByte();
if (type == (byte)ConvertCryptoAlgorithm.Aes256)
{
byte[] cryptoKey;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) throw new ArgumentException();
int length = NetworkConverter.ToInt32(lengthBuffer);
byte[] encryptedBuffer = new byte[length];
if (stream.Read(encryptedBuffer, 0, encryptedBuffer.Length) != encryptedBuffer.Length) throw new ArgumentException();
cryptoKey = Exchange.Decrypt(privateKey, encryptedBuffer);
}
BufferStream outStream = null;
try
{
outStream = new BufferStream(_bufferManager);
using (Stream dataStream = new WrapperStream(stream, true))
{
var iv = new byte[32];
dataStream.Read(iv, 0, iv.Length);
using (var rijndael = new RijndaelManaged() { KeySize = 256, BlockSize = 256, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7 })
using (var inStream = new RangeStream(dataStream, dataStream.Position, dataStream.Length - dataStream.Position))
using (CryptoStream cs = new CryptoStream(inStream, rijndael.CreateDecryptor(cryptoKey, iv), CryptoStreamMode.Read))
{
byte[] buffer = null;
try
{
buffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = cs.Read(buffer, 0, buffer.Length)) > 0)
{
outStream.Write(buffer, 0, i);
}
}
finally
{
_bufferManager.ReturnBuffer(buffer);
}
}
}
outStream.Seek(0, SeekOrigin.Begin);
}
catch (Exception)
{
if (outStream != null)
{
outStream.Dispose();
}
throw;
}
return outStream;
}
throw new NotSupportedException();
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
private static Stream Decompress(Stream stream)
{
if (stream == null) throw new ArgumentNullException("stream");
try
{
var targetStream = new RangeStream(stream, true);
byte type = (byte)targetStream.ReadByte();
if (type == (byte)ConvertCompressionAlgorithm.None)
{
return new RangeStream(targetStream);
}
else if (type == (byte)ConvertCompressionAlgorithm.Deflate)
{
using (Stream dataStream = new WrapperStream(targetStream, true))
{
BufferStream deflateBufferStream = null;
try
{
deflateBufferStream = new BufferStream(_bufferManager);
using (DeflateStream deflateStream = new DeflateStream(dataStream, CompressionMode.Decompress, true))
{
byte[] decompressBuffer = null;
try
{
decompressBuffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = deflateStream.Read(decompressBuffer, 0, decompressBuffer.Length)) > 0)
{
deflateBufferStream.Write(decompressBuffer, 0, i);
}
}
finally
{
if (decompressBuffer != null)
{
_bufferManager.ReturnBuffer(decompressBuffer);
}
}
}
deflateBufferStream.Seek(0, SeekOrigin.Begin);
#if DEBUG
Debug.WriteLine("ContentConverter Decompress {3} : {0}→{1} {2}",
NetworkConverter.ToSizeString(dataStream.Length),
NetworkConverter.ToSizeString(deflateBufferStream.Length),
NetworkConverter.ToSizeString(dataStream.Length - deflateBufferStream.Length),
ConvertCompressionAlgorithm.Deflate);
#endif
return deflateBufferStream;
}
catch (Exception)
{
if (deflateBufferStream != null)
{
deflateBufferStream.Dispose();
}
}
}
}
throw new ArgumentException("ArgumentException");
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
private static Stream AddType(Stream stream, string type)
{
if (stream == null) throw new ArgumentNullException("stream");
List<Stream> streams = new List<Stream>();
Encoding encoding = new UTF8Encoding(false);
// Type
if (type != null)
{
BufferStream bufferStream = new BufferStream(_bufferManager);
bufferStream.SetLength(4);
bufferStream.Seek(4, SeekOrigin.Begin);
using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true))
using (StreamWriter writer = new StreamWriter(wrapperStream, encoding))
{
writer.Write(type);
}
bufferStream.Seek(0, SeekOrigin.Begin);
bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 4), 0, 4);
streams.Add(bufferStream);
}
streams.Add(new WrapperStream(stream, true));
return new UniteStream(streams);
}
