public SignatureMessage GetMessage(SignatureMessageMetadata metadata, ExchangePrivateKey exchangePrivateKey)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (exchangePrivateKey == null)
{
throw new ArgumentNullException("exchangePrivateKey");
}
lock (this.ThisLock)
{
if (!_cacheManager.Contains(metadata.Key))
{
_connectionsManager.Download(metadata.Key);
return(null);
}
else
{
ArraySegment <byte> buffer = new ArraySegment <byte>();
try
{
buffer = _cacheManager[metadata.Key];
var message = ContentConverter.FromSignatureMessageBlock(buffer, exchangePrivateKey);
if (metadata.Signature != message.Signature ||
metadata.CreationTime != message.CreationTime ||
metadata.Certificate.ToString() != message.Certificate.ToString())
{
return(null);
}
this.Lock(metadata.Key);
return(message);
}
catch (Exception)
{
}
finally
{
if (buffer.Array != null)
{
_bufferManager.ReturnBuffer(buffer.Array);
}
}
return(null);
}
}
}
public SignatureMessage GetMessage(SignatureMessageMetadata metadata, ExchangePrivateKey exchangePrivateKey)
{
if (_disposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
lock (this.ThisLock)
{
return(_downloadManager.GetMessage(metadata, exchangePrivateKey));
}
}
public static T FromCryptoStream <T>(Stream stream, ExchangePrivateKey privateKey)
where T : ItemBase <T>
{
if (stream == null)
{
throw new ArgumentException("stream", nameof(stream));
}
if (privateKey == null)
{
throw new ArgumentNullException(nameof(privateKey));
}
try
{
return(ItemBase <T> .Import(Decompress(RemovePadding(RemoveHash(Decrypt(RemoveVersion(stream, 0), privateKey)))), _bufferManager));
}
catch (Exception)
{
return(null);
}
}
public IEnumerable<Information> GetUnicastMessages(string signature, ExchangePrivateKey exchangePrivateKey)
{
this.Check();
lock (this.ThisLock)
{
return _backgroundDownloadManager.GetUnicastMessages(signature, exchangePrivateKey);
}
}
private static Stream Decrypt(Stream stream, ExchangePrivateKey privateKey)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (privateKey == null)
{
throw new ArgumentNullException(nameof(privateKey));
}
try
{
int type = (int)Varint.GetUInt64(stream);
if (type == (int)ConvertCryptoAlgorithm.Aes256)
{
byte[] cryptoKey;
{
int length = (int)Varint.GetUInt64(stream);
var encryptedBuffer = new byte[length];
if (stream.Read(encryptedBuffer, 0, encryptedBuffer.Length) != encryptedBuffer.Length)
{
throw new ArgumentException();
}
cryptoKey = Exchange.Decrypt(privateKey, encryptedBuffer);
}
var iv = new byte[32];
stream.Read(iv, 0, iv.Length);
RecyclableMemoryStream outStream = null;
try
{
outStream = new RecyclableMemoryStream(_bufferManager);
using (var aes = Aes.Create())
{
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
using (var inStream = new RangeStream(stream, stream.Position, stream.Length - stream.Position, true))
using (var cs = new CryptoStream(inStream, aes.CreateDecryptor(cryptoKey, iv), CryptoStreamMode.Read))
using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4))
{
int length;
while ((length = cs.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0)
{
outStream.Write(safeBuffer.Value, 0, length);
}
}
}
outStream.Seek(0, SeekOrigin.Begin);
}
catch (Exception)
{
if (outStream != null)
{
outStream.Dispose();
}
throw;
}
return(outStream);
}
else
{
throw new NotSupportedException();
}
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
}
public Task <IEnumerable <UnicastMessage <MailMessage> > > GetMailMessages(Signature signature, ExchangePrivateKey exchangePrivateKey, CancellationToken token)
{
this.Check();
lock (_lockObject)
{
return(_messageManager.GetMailMessages(signature, exchangePrivateKey));
}
}
public Task <IEnumerable <UnicastMessage <MailMessage> > > GetMailMessages(Signature signature, ExchangePrivateKey exchangePrivateKey)
{
if (signature == null)
{
throw new ArgumentNullException(nameof(signature));
}
if (exchangePrivateKey == null)
{
throw new ArgumentNullException(nameof(exchangePrivateKey));
}
return(Task.Run(() =>
{
var results = new List <UnicastMessage <MailMessage> >();
var trusts = new List <UnicastMetadata>();
foreach (var unicastMetadata in _coreManager.GetUnicastMetadatas(signature, "MailMessage"))
{
if (_searchSignatures.Contains(unicastMetadata.Certificate.GetSignature()))
{
trusts.Add(unicastMetadata);
}
}
trusts.Sort((x, y) => y.CreationTime.CompareTo(x.CreationTime));
foreach (var unicastMetadata in trusts.Take(1024))
{
var dic = _cache_MailMessages.GetOrAdd(unicastMetadata.Signature, (_) => new LockedHashDictionary <UnicastMetadata, UnicastMessage <MailMessage> >());
// Cache
{
if (dic.TryGetValue(unicastMetadata, out var result))
{
results.Add(result);
continue;
}
}
{
var stream = _coreManager.VolatileGetStream(unicastMetadata.Metadata, 1024 * 1024 * 1);
if (stream == null)
{
continue;
}
var result = new UnicastMessage <MailMessage>(
unicastMetadata.Signature,
unicastMetadata.Certificate.GetSignature(),
unicastMetadata.CreationTime,
ContentConverter.FromCryptoStream <MailMessage>(stream, exchangePrivateKey));
if (result.Value == null)
{
continue;
}
dic[unicastMetadata] = result;
results.Add(result);
}
}
return (IEnumerable <UnicastMessage <MailMessage> >)results.ToArray();
}));
}
public Task <IEnumerable <UnicastMessage <MailMessage> > > GetMailMessages(Signature signature, ExchangePrivateKey exchangePrivateKey, CancellationToken token)
{
this.Check();
lock (_lockObject)
{
return(Task.Run(() =>
{
return this.Function <IEnumerable <UnicastMessage <MailMessage> >, (Signature, ExchangePrivateKey)>(AmoebaRequestType.GetMailMessages, (signature, exchangePrivateKey), token);
}));
}
}
public IEnumerable<SignatureMessage> GetSignatureMessages(string signature, ExchangePrivateKey exchangePrivateKey, int limit)
{
if (signature == null) throw new ArgumentNullException("signature");
if (exchangePrivateKey == null) throw new ArgumentNullException("exchangePrivateKey");
lock (this.ThisLock)
{
Dictionary<SignatureMessageMetadata, SignatureMessage> dic;
if (!_cache_Metadata_SignatureMessage_Pairs_Dictionary.TryGetValue(signature, out dic))
{
dic = new Dictionary<SignatureMessageMetadata, SignatureMessage>();
_cache_Metadata_SignatureMessage_Pairs_Dictionary[signature] = dic;
}
var metadatas = new HashSet<SignatureMessageMetadata>(_connectionsManager.GetSignatureMessageMetadatas(signature));
foreach (var metadata in dic.Keys.ToArray())
{
if (!metadatas.Contains(metadata)) continue;
dic.Remove(metadata);
}
var signatureMessages = new List<SignatureMessage>();
foreach (var metadata in metadatas)
{
if (limit < 0)
{
if (!_settings.TrustSignatures.Contains(metadata.Certificate.ToString())) continue;
}
else
{
if (!_settings.TrustSignatures.Contains(metadata.Certificate.ToString()) && metadata.Cost < limit) continue;
}
if (!_cacheManager.Contains(metadata.Key))
{
_connectionsManager.Download(metadata.Key);
}
SignatureMessage signatureMessage;
if (!dic.TryGetValue(metadata, out signatureMessage))
{
ArraySegment<byte> buffer = new ArraySegment<byte>();
try
{
buffer = _cacheManager[metadata.Key];
var package = ContentConverter.FromSignatureMessageBlock(buffer, exchangePrivateKey);
if (metadata.Signature != package.Signature
|| metadata.CreationTime != package.CreationTime
|| metadata.Certificate.ToString() != package.Certificate.ToString()) continue;
dic[metadata] = package;
signatureMessage = package;
}
catch (Exception)
{
}
finally
{
if (buffer.Array != null)
{
_bufferManager.ReturnBuffer(buffer.Array);
}
}
}
if (signatureMessage != null) signatureMessages.Add(signatureMessage);
}
return signatureMessages;
}
}
public IEnumerable<SignatureMessage> GetSignatureMessages(string signature, ExchangePrivateKey exchangePrivateKey, int limit)
{
lock (this.ThisLock)
{
return _downloadManager.GetSignatureMessages(signature, exchangePrivateKey, limit);
}
}
