private async Task <ICryptoTransform> CreateAndSetEncryptionContext(SendHeaders metadata, CancellationToken cancellationToken)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
if (this.encryptionKey == null)
{
throw new InvalidOperationException("Key is not initialized. Encryption requires it to be initialized.");
}
using (AesCryptoServiceProvider provider = new AesCryptoServiceProvider())
{
var data = new EncryptionData
{
EncryptionAgent = new EncryptionAgent("1.0", EncryptionAlgorithm.AES_CBC_256)
};
var key = this.encryptionKey();
var result = await key.WrapKeyAsync(provider.Key, null, cancellationToken).ConfigureAwait(false);
data.WrappedContentKey = new WrappedKey(key.Kid, result.Item1, result.Item2);
data.ContentEncryptionIV = provider.IV;
metadata.Set(EncryptionHeaderDataKey, JsonConvert.SerializeObject(data));
return(provider.CreateEncryptor());
}
}
static void SetHeaders(IDictionary <string, object> dictionary, SendHeaders headers)
{
foreach (KeyValuePair <string, object> header in headers.GetAll())
{
if (header.Value == null)
{
if (dictionary.ContainsKey(header.Key))
{
dictionary.Remove(header.Key);
}
continue;
}
if (dictionary.ContainsKey(header.Key))
{
continue;
}
switch (header.Value)
{
case DateTimeOffset value:
if (_dateTimeOffsetConverter.TryConvert(value, out string text))
{
dictionary[header.Key] = text;
}
break;
case DateTime value:
if (_dateTimeConverter.TryConvert(value, out text))
{
dictionary[header.Key] = text;
}
break;
case string value:
dictionary[header.Key] = value;
break;
case bool value when value:
dictionary[header.Key] = bool.TrueString;
break;
case IFormattable formatValue:
if (header.Value.GetType().IsValueType)
{
dictionary[header.Key] = header.Value;
}
else
{
dictionary[header.Key] = formatValue.ToString();
}
break;
}
}
}
/// <summary>
/// Set the host headers on the SendContext (for error, dead-letter, etc.)
/// </summary>
/// <param name="headers"></param>
public static void SetHostHeaders(this SendHeaders headers)
{
headers.Set(MessageHeaders.Host.MachineName, HostMetadataCache.Host.MachineName);
headers.Set(MessageHeaders.Host.ProcessName, HostMetadataCache.Host.ProcessName);
headers.Set(MessageHeaders.Host.ProcessId, HostMetadataCache.Host.ProcessId.ToString("F0"));
headers.Set(MessageHeaders.Host.Assembly, HostMetadataCache.Host.Assembly);
headers.Set(MessageHeaders.Host.AssemblyVersion, HostMetadataCache.Host.AssemblyVersion);
headers.Set(MessageHeaders.Host.MassTransitVersion, HostMetadataCache.Host.MassTransitVersion);
headers.Set(MessageHeaders.Host.FrameworkVersion, HostMetadataCache.Host.FrameworkVersion);
headers.Set(MessageHeaders.Host.OperatingSystemVersion, HostMetadataCache.Host.OperatingSystemVersion);
}
/// <summary>
/// Set the host headers on the SendContext (for error, dead-letter, etc.)
/// </summary>
/// <param name="headers"></param>
public static void SetHostHeaders(this SendHeaders headers)
{
headers.Set("MT-Host-MachineName", HostMetadataCache.Host.MachineName);
headers.Set("MT-Host-ProcessName", HostMetadataCache.Host.ProcessName);
headers.Set("MT-Host-ProcessId", HostMetadataCache.Host.ProcessId.ToString("F0"));
headers.Set("MT-Host-Assembly", HostMetadataCache.Host.Assembly);
headers.Set("MT-Host-AssemblyVersion", HostMetadataCache.Host.AssemblyVersion);
headers.Set("MT-Host-MassTransitVersion", HostMetadataCache.Host.MassTransitVersion);
headers.Set("MT-Host-FrameworkVersion", HostMetadataCache.Host.FrameworkVersion);
headers.Set("MT-Host-OperatingSystemVersion", HostMetadataCache.Host.OperatingSystemVersion);
}
/// <summary>
/// Set the host headers on the SendContext (for error, dead-letter, etc.)
/// </summary>
/// <param name="headers"></param>
/// <param name="exception"></param>
/// <param name="exceptionTimestamp"></param>
public static void SetExceptionHeaders(this SendHeaders headers, Exception exception, DateTime exceptionTimestamp)
{
exception = exception.GetBaseException() ?? exception;
var exceptionMessage = ExceptionUtil.GetMessage(exception);
headers.Set(MessageHeaders.Reason, "fault");
headers.Set(MessageHeaders.FaultExceptionType, TypeMetadataCache.GetShortName(exception.GetType()));
headers.Set(MessageHeaders.FaultMessage, exceptionMessage);
headers.Set(MessageHeaders.FaultTimestamp, exceptionTimestamp.ToString("O"));
headers.Set(MessageHeaders.FaultStackTrace, ExceptionUtil.GetStackTrace(exception));
}
void SetHeaders(IDictionary<string, object> dictionary, SendHeaders headers)
{
foreach (var header in headers.GetAll())
{
if (header.Value == null)
{
if (dictionary.ContainsKey(header.Key))
dictionary.Remove(header.Key);
continue;
}
if (dictionary.ContainsKey(header.Key))
continue;
switch (header.Value)
{
case DateTimeOffset value:
if (_dateTimeOffsetConverter.TryConvert(value, out long result))
dictionary[header.Key] = new AmqpTimestamp(result);
else if (_dateTimeOffsetConverter.TryConvert(value, out string text))
dictionary[header.Key] = text;
break;
case DateTime value:
if (_dateTimeConverter.TryConvert(value, out result))
dictionary[header.Key] = new AmqpTimestamp(result);
else if (_dateTimeConverter.TryConvert(value, out string text))
dictionary[header.Key] = text;
break;
case string value:
dictionary[header.Key] = value;
break;
case IFormattable formatValue:
if (header.Value.GetType().IsValueType)
dictionary[header.Key] = header.Value;
else
dictionary[header.Key] = formatValue.ToString();
break;
}
}
}
/// <summary>
/// Set the host headers on the SendContext (for error, dead-letter, etc.)
/// </summary>
/// <param name="headers"></param>
/// <param name="exceptionContext"></param>
public static void SetExceptionHeaders(this SendHeaders headers, ExceptionReceiveContext exceptionContext)
{
var exception = exceptionContext.Exception.GetBaseException() ?? exceptionContext.Exception;
var exceptionMessage = ExceptionUtil.GetMessage(exception);
headers.Set(MessageHeaders.Reason, "fault");
headers.Set(MessageHeaders.FaultExceptionType, TypeMetadataCache.GetShortName(exception.GetType()));
headers.Set(MessageHeaders.FaultMessage, exceptionMessage);
headers.Set(MessageHeaders.FaultTimestamp, exceptionContext.ExceptionTimestamp.ToString("O"));
headers.Set(MessageHeaders.FaultStackTrace, ExceptionUtil.GetStackTrace(exception));
if (exceptionContext.TryGetPayload(out ConsumerFaultInfo info))
{
headers.Set(MessageHeaders.FaultConsumerType, info.ConsumerType);
headers.Set(MessageHeaders.FaultMessageType, info.MessageType);
}
}
public static void SetTextHeaders(this IPrimitiveMap dictionary, SendHeaders headers)
{
foreach (KeyValuePair <string, object> header in headers.GetAll())
{
if (header.Value == null)
{
continue;
}
if (dictionary.Contains(header.Key))
{
continue;
}
if (header.Value is string stringValue)
{
dictionary[header.Key] = stringValue;
}
else if (header.Value is IFormattable formatValue && formatValue.GetType().IsValueType)
{
dictionary[header.Key] = formatValue.ToString();
}
}
}
public static void SetHeaders(this IPrimitiveMap dictionary, SendHeaders headers)
{
foreach (KeyValuePair <string, object> header in headers.GetAll())
{
if (header.Value == null)
{
if (dictionary.Contains(header.Key))
{
dictionary.Remove(header.Key);
}
continue;
}
if (dictionary.Contains(header.Key))
{
continue;
}
switch (header.Value)
{
case DateTimeOffset dateTimeOffset:
if (_dateTimeOffsetConverter.TryConvert(dateTimeOffset, out long result))
{
dictionary[header.Key] = result;
}
else if (_dateTimeOffsetConverter.TryConvert(dateTimeOffset, out string text))
{
dictionary[header.Key] = text;
}
break;
case DateTime dateTime:
if (_dateTimeConverter.TryConvert(dateTime, out result))
{
dictionary[header.Key] = result;
}
else if (_dateTimeConverter.TryConvert(dateTime, out string text))
{
dictionary[header.Key] = text;
}
break;
case string s:
dictionary[header.Key] = s;
break;
case bool boolValue when boolValue:
dictionary[header.Key] = bool.TrueString;
break;
case IFormattable formatValue:
if (header.Value.GetType().IsValueType)
{
dictionary[header.Key] = header.Value;
}
else
{
dictionary[header.Key] = formatValue.ToString();
}
break;
}
if (header.Key == "AMQ_SCHEDULED_DELAY")
{
headers.Set(header.Key, null);
}
}
}
public static void SetTextHeaders <T>(this IDictionary <string, T> dictionary, SendHeaders headers, Func <string, string, T> converter)
{
foreach (var header in headers.GetAll())
{
if (header.Value == null)
{
continue;
}
if (dictionary.ContainsKey(header.Key))
{
continue;
}
if (header.Value is string stringValue)
{
dictionary[header.Key] = converter(header.Key, stringValue);
}
else if (header.Value is IFormattable formatValue && formatValue.GetType().IsValueType)
{
dictionary.Add(header.Key, converter(header.Key, formatValue.ToString()));
}
}
}
static void SetHeaders(IDictionary <string, object> dictionary, SendHeaders headers)
{
foreach (KeyValuePair <string, object> header in headers.GetAll())
{
if (header.Value == null)
{
if (dictionary.ContainsKey(header.Key))
{
dictionary.Remove(header.Key);
}
continue;
}
if (dictionary.ContainsKey(header.Key))
{
continue;
}
switch (header.Value)
{
case DateTimeOffset value:
if (_dateTimeOffsetConverter.TryConvert(value, out long result))
{
dictionary[header.Key] = new AmqpTimestamp(result);
}
else if (_dateTimeOffsetConverter.TryConvert(value, out string text))
{
dictionary[header.Key] = text;
}
break;
case DateTime value:
if (_dateTimeConverter.TryConvert(value, out result))
{
dictionary[header.Key] = new AmqpTimestamp(result);
}
else if (_dateTimeConverter.TryConvert(value, out string text))
{
dictionary[header.Key] = text;
}
break;
case string value when header.Key == "CC" || header.Key == "BCC":
dictionary[header.Key] = new[] { value };
break;
case IEnumerable <string> strings when header.Key == "CC" || header.Key == "BCC":
dictionary[header.Key] = strings.ToArray();
break;
case string value:
dictionary[header.Key] = value;
break;
case bool value when value:
dictionary[header.Key] = bool.TrueString;
break;
case IFormattable formatValue:
if (header.Value.GetType().IsValueType)
{
dictionary[header.Key] = header.Value;
}
else
{
dictionary[header.Key] = formatValue.ToString();
}
break;
}
}
}
public static void Set(this IDictionary <string, MessageAttributeValue> attributes, SendHeaders sendHeaders)
{
attributes.SetTextHeaders(sendHeaders, (key, text) => new MessageAttributeValue
{
StringValue = text,
DataType = "String"
});
}
internal static void SetSentTime(this SendHeaders headers, DateTimeOffset time)
{
headers.Set(SentTimeHeader, time);
}
private async Task ReadStream()
{
while (!Closing)
{
try
{
//try to read a header
var hdata = new byte[24];
await Stream.ReadAsyncExact(hdata, 0, hdata.Length);
var h = new MessageHeader();
h.ReadFromPayload(hdata, 0);
if (h != null)
{
//read the payload
var pl = new byte[h.PayloadSize];
await Stream.ReadAsyncExact(pl, 0, pl.Length);
bool checksumOk = false;
//verify hash
using (var sha = SHA256.Create())
{
var h1 = sha.ComputeHash(pl);
var h2 = sha.ComputeHash(h1);
checksumOk = h2[0] == h.Checksum[0] && h2[1] == h.Checksum[1] && h2[2] == h.Checksum[2] && h2[3] == h.Checksum[3];
}
if (checksumOk)
{
switch (h.Command)
{
case "addr\0\0\0\0\0\0\0\0":
{
if (OnAddr != null)
{
var a = new Addr();
a.ReadFromPayload(pl, 0);
await OnAddr?.Invoke(this, a);
}
break;
}
case "alert\0\0\0\0\0\0\0":
{
if (OnAlert != null)
{
var a = new Alert();
a.ReadFromPayload(pl, 0);
await OnAlert?.Invoke(this, a);
}
break;
}
case "feefilter\0\0\0":
{
if (OnFeeFilter != null)
{
var f = new FeeFilter();
f.ReadFromPayload(pl, 0);
await OnFeeFilter?.Invoke(this, f);
}
break;
}
case "filteradd\0\0\0":
{
if (OnFilterAdd != null)
{
var f = new FilterAdd();
f.ReadFromPayload(pl, 0);
await OnFilterAdd?.Invoke(this, f);
}
break;
}
case "filterclear\0":
{
if (OnFilterClear != null)
{
var f = new FilterClear();
f.ReadFromPayload(pl, 0);
await OnFilterClear?.Invoke(this, f);
}
break;
}
case "filterload\0\0":
{
if (OnFilterLoad != null)
{
var f = new FilterLoad();
f.ReadFromPayload(pl, 0);
await OnFilterLoad?.Invoke(this, f);
}
break;
}
case "getaddr\0\0\0\0\0":
{
if (OnGetAddr != null)
{
var ga = new GetAddr();
ga.ReadFromPayload(pl, 0);
await OnGetAddr?.Invoke(this, ga);
}
break;
}
case "getblocks\0\0\0":
{
if (OnGetBlocks != null)
{
var gb = new GetBlocks();
gb.ReadFromPayload(pl, 0);
await OnGetBlocks?.Invoke(this, gb);
}
break;
}
case "getdata\0\0\0\0\0":
{
if (OnGetData != null)
{
var gd = new GetData();
gd.ReadFromPayload(pl, 0);
await OnGetData?.Invoke(this, gd);
}
break;
}
case "getheaders\0\0":
{
if (OnGetHeaders != null)
{
var gh = new GetHeaders();
gh.ReadFromPayload(pl, 0);
await OnGetHeaders?.Invoke(this, gh);
}
break;
}
case "headers\0\0\0\0\0":
{
if (OnHeaders != null)
{
var hd = new Headers();
hd.ReadFromPayload(pl, 0);
await OnHeaders?.Invoke(this, hd);
}
break;
}
case "inv\0\0\0\0\0\0\0\0\0":
{
if (OnInv != null)
{
var iv = new Inv();
iv.ReadFromPayload(pl, 0);
await OnInv?.Invoke(this, iv);
}
break;
}
case "mempool\0\0\0\0\0":
{
if (OnMemPool != null)
{
var mp = new MemPool();
mp.ReadFromPayload(pl, 0);
await OnMemPool?.Invoke(this, mp);
}
break;
}
case "notfound\0\0\0\0":
{
if (OnNotFound != null)
{
var nf = new NotFound();
nf.ReadFromPayload(pl, 0);
await OnNotFound?.Invoke(this, nf);
}
break;
}
case "ping\0\0\0\0\0\0\0\0":
{
if (OnPing != null)
{
var ping = new Ping();
ping.ReadFromPayload(pl, 0);
await OnPing?.Invoke(this, ping);
}
break;
}
case "pong\0\0\0\0\0\0\0\0":
{
if (OnPong != null)
{
var pong = new Pong();
pong.ReadFromPayload(pl, 0);
await OnPong?.Invoke(this, pong);
}
break;
}
case "reject\0\0\0\0\0\0":
{
if (OnReject != null)
{
var re = new Reject();
re.ReadFromPayload(pl, 0);
await OnReject?.Invoke(this, re);
}
break;
}
case "sendheaders\0":
{
if (OnSendHeaders != null)
{
var sh = new SendHeaders();
sh.ReadFromPayload(pl, 0);
await OnSendHeaders?.Invoke(this, sh);
}
break;
}
case "verack\0\0\0\0\0\0":
{
if (OnVerAck != null)
{
var va = new VerAck();
va.ReadFromPayload(pl, 0);
await OnVerAck.Invoke(this, va);
}
break;
}
case "version\0\0\0\0\0":
{
if (OnVersion != null)
{
var v = new bitcoin_lib.P2P.Version("");
v.ReadFromPayload(pl, 0);
await OnVersion?.Invoke(this, v);
}
break;
}
default:
{
//Console.WriteLine($"Got cmd: {h.Command}");
break;
}
}
}
else
{
Closing = true;
}
}
}
catch (Exception ex)
{
Closing = true;
}
}
}
public AmazonSqsHeaderProvider(Message message)
{
_message = message;
_adapter = new AmazonSqsHeaderAdapter(message.MessageAttributes);
}
private Task Peer_OnSendHeaders(BitcoinPeer s, SendHeaders sh)
{
throw new NotImplementedException();
}
