/// <summary>
/// Initializes a new instance of a stream multiplexer.
/// </summary>
/// <param name="writing">If set to <c>true</c>, writing a multiplexed stream.</param>
/// <param name="multiplexedStream">
/// Stream being written to (destination; multiplexing) or read from (source;
/// demultiplexing).
/// </param>
/// <param name="payloadItems">Payload items to write.</param>
/// <param name="itemPreKeys">Pre-keys for items (indexed by item identifiers).</param>
/// <param name="config">Configuration of stream selection and padding scheme.</param>
public FrameshiftPayloadMux(bool writing, Stream multiplexedStream, IReadOnlyList <PayloadItem> payloadItems,
IReadOnlyDictionary <Guid, byte[]> itemPreKeys, PayloadConfiguration config)
: base(writing, multiplexedStream, payloadItems, itemPreKeys, config)
{
var frameshiftConfig =
config.SchemeConfiguration.DeserialiseDto <RangeConfiguration>();
if (frameshiftConfig.Minimum < MinimumPaddingLength)
{
throw new ArgumentOutOfRangeException("config",
"Minimum padding length is below specification minimum.");
}
if (frameshiftConfig.Maximum < MaximumPaddingLength)
{
throw new ArgumentOutOfRangeException("config",
"Maximum padding length is above specification maximum.");
}
_minPadding = frameshiftConfig.Minimum;
_maxPadding = frameshiftConfig.Maximum;
_paddingMode = _minPadding == _maxPadding
? FrameshiftPaddingMode.FixedLength
: FrameshiftPaddingMode.VariableLength;
_paddingBuffer = new byte[_maxPadding];
}
public static PayloadConfiguration CreateFrameshiftPrecomputedVariable(int items, int?minPadding = null,
int?maxPadding = null)
{
if (items < 1)
{
throw new ArgumentOutOfRangeException("items");
}
CheckFrameshiftArgumentsValid(minPadding, maxPadding);
int min = minPadding ?? FrameshiftPayloadMux.MinimumPaddingLength;
int max = maxPadding ?? FrameshiftPayloadMux.MaximumPaddingLength;
byte[] entropy = GeneratePreallocatedEntropy(PayloadLayoutScheme.Frameshift, items, min, max);
var config = new PayloadConfiguration {
SchemeName = PayloadLayoutScheme.Frameshift.ToString(),
SchemeConfiguration = new RangeConfiguration {
Minimum = min,
Maximum = max
}.SerialiseDto(),
EntropyScheme = PayloadMuxEntropyScheme.Preallocation,
EntropySchemeData = entropy
};
return(config);
}
public static PayloadConfiguration CreateSimple(CsPseudorandomNumberGenerator csprngEnum)
{
var config = new PayloadConfiguration {
SchemeName = PayloadLayoutScheme.Simple.ToString(),
EntropyScheme = PayloadMuxEntropyScheme.StreamCipherCsprng,
EntropySchemeData = CsPrngFactory.CreateStreamCipherCsprngConfiguration(csprngEnum).SerialiseDto()
};
return(config);
}
/// <summary>
/// Initializes a new instance of a payload multiplexer.
/// </summary>
/// <param name="writing">If set to <c>true</c>, writing a multiplexed stream (payload); otherwise, reading.</param>
/// <param name="multiplexedStream">
/// Stream being written to (destination; multiplexing) or read from (source;
/// demultiplexing).
/// </param>
/// <param name="payloadItems">Payload items to write.</param>
/// <param name="itemPreKeys">Pre-keys for items (indexed by item identifiers).</param>
/// <param name="config">Configuration of stream selection.</param>
public SimplePayloadMux(bool writing, Stream multiplexedStream, IReadOnlyList <PayloadItem> payloadItems,
IReadOnlyDictionary <Guid, byte[]> itemPreKeys, PayloadConfiguration config)
: base(writing, multiplexedStream, payloadItems, itemPreKeys)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
EntropySource = new MuxEntropySourceFacade(writing, config);
}
public static PayloadConfiguration CreateSimplePreallocated(int items)
{
byte[] entropy = GeneratePreallocatedEntropy(PayloadLayoutScheme.Simple, items, -1, -1);
var config = new PayloadConfiguration {
SchemeName = PayloadLayoutScheme.Simple.ToString(),
EntropyScheme = PayloadMuxEntropyScheme.Preallocation,
EntropySchemeData = entropy
};
return(config);
}
public static PayloadConfiguration CreateFabricVariable(CsPseudorandomNumberGenerator csprngEnum, int?minStripe = null,
int?maxStripe = null)
{
CheckFabricArgumentsValid(minStripe, maxStripe);
var config = new PayloadConfiguration {
SchemeName = PayloadLayoutScheme.Fabric.ToString(),
SchemeConfiguration = new RangeConfiguration {
Minimum = (minStripe == null ? FabricPayloadMux.MinimumStripeLength : minStripe.Value),
Maximum = (maxStripe == null ? FabricPayloadMux.MaximumStripeLength : maxStripe.Value)
}.SerialiseDto(),
EntropyScheme = PayloadMuxEntropyScheme.StreamCipherCsprng,
EntropySchemeData = CsPrngFactory.CreateStreamCipherCsprngConfiguration(csprngEnum).SerialiseDto()
};
return(config);
}
public static PayloadConfiguration CreateFrameshiftFixed(CsPseudorandomNumberGenerator csprngEnum, int?paddingSize = null)
{
int fixedSize = paddingSize == null ? FrameshiftPayloadMux.DefaultFixedPaddingLength : paddingSize.Value;
if (fixedSize.IsBetween(FrameshiftPayloadMux.MinimumPaddingLength, FrameshiftPayloadMux.MaximumPaddingLength) == false)
{
throw new ArgumentOutOfRangeException("paddingSize", "Padding size not within specification.");
}
var config = new PayloadConfiguration {
SchemeName = PayloadLayoutScheme.Frameshift.ToString(),
SchemeConfiguration = new RangeConfiguration {
Minimum = fixedSize,
Maximum = fixedSize,
}.SerialiseDto(),
EntropyScheme = PayloadMuxEntropyScheme.StreamCipherCsprng,
EntropySchemeData = CsPrngFactory.CreateStreamCipherCsprngConfiguration(csprngEnum).SerialiseDto()
};
return(config);
}
/// <summary>
/// Initializes a new instance of a payload multiplexer.
/// </summary>
/// <param name="writing">If set to <c>true</c>, writing a multiplexed stream.</param>
/// <param name="multiplexedStream">
/// Stream being written to (destination; multiplexing) or read from (source;
/// demultiplexing).
/// </param>
/// <param name="payloadItems">Payload items to write.</param>
/// <param name="itemPreKeys">Pre-keys for items (indexed by item identifiers).</param>
/// <param name="config">Configuration of stream selection and stripe scheme.</param>
/// <exception cref="ArgumentOutOfRangeException">Stripe size not within specification range.</exception>
public FabricPayloadMux(bool writing, Stream multiplexedStream, IReadOnlyList <PayloadItem> payloadItems,
IReadOnlyDictionary <Guid, byte[]> itemPreKeys, PayloadConfiguration config)
: base(writing, multiplexedStream, payloadItems, itemPreKeys, config)
{
var fabricConfig = config.SchemeConfiguration.DeserialiseDto <RangeConfiguration>();
if (fabricConfig.Minimum < MinimumStripeLength)
{
throw new ArgumentOutOfRangeException("config",
"Minimum stripe length is below specification minimum.");
}
if (fabricConfig.Maximum > MaximumStripeLength)
{
throw new ArgumentOutOfRangeException("config",
"Maximum stripe length is above specification minimum.");
}
_minStripe = fabricConfig.Minimum;
_maxStripe = fabricConfig.Maximum;
_stripeMode = _minStripe == _maxStripe ? FabricStripeMode.FixedLength : FabricStripeMode.VariableLength;
}
/// <summary>
/// Instantiates and returns a payload I/O module implementing the mode of operation that the
/// instance this method was called from describes.
/// </summary>
/// <param name="schemeEnum">Payload layout scheme to choose the correspknding multiplexer.</param>
/// <param name="writing">Whether the multiplexer will be multiplexing or demultiplexing.</param>
/// <param name="multiplexedStream">Stream to multiplex/demultiplex to/from.</param>
/// <param name="payloadItems"></param>
/// <param name="itemPreKeys"></param>
/// <param name="config">Configuration of the layout module/multiplexer.</param>
/// <returns>
/// An module object deriving from PayloadMultiplexer.
/// </returns>
public static PayloadMux CreatePayloadMultiplexer(PayloadLayoutScheme schemeEnum, bool writing,
Stream multiplexedStream, List <PayloadItem> payloadItems,
IReadOnlyDictionary <Guid, byte[]> itemPreKeys,
PayloadConfiguration config)
{
switch (schemeEnum)
{
case PayloadLayoutScheme.Simple:
return(new SimplePayloadMux(writing, multiplexedStream, payloadItems, itemPreKeys, config));
case PayloadLayoutScheme.Frameshift:
return(new FrameshiftPayloadMux(writing, multiplexedStream, payloadItems, itemPreKeys, config));
#if INCLUDE_FABRIC
case PayloadLayoutScheme.Fabric:
return(new FabricPayloadMux(writing, multiplexedStream, payloadItems, itemPreKeys, config));
#endif
default:
throw new ArgumentException("Scheme unsupported.", "schemeEnum");
}
}
public void Fabric_Fixed()
{
var inputObj = new PayloadConfiguration()
{
SchemeName = PayloadLayoutScheme.Fabric.ToString(),
SchemeConfiguration = new RangeConfiguration {
Minimum = FabricPayloadMux.DefaultFixedStripeLength,
Maximum = FabricPayloadMux.DefaultFixedStripeLength
}.SerialiseDto(),
EntropyScheme = PayloadMuxEntropyScheme.StreamCipherCsprng,
EntropySchemeData = CsPrngFactory.CreateStreamCipherCsprngConfiguration(
CsPseudorandomNumberGenerator.Sosemanuk).SerialiseDto <StreamCipherCsprngConfiguration>()
};
var stream = SerialiseToMemory(inputObj);
stream.Seek(0, SeekOrigin.Begin);
var outputObj = DeserialiseFromMemory <PayloadConfiguration>(stream);
bool equal = inputObj.Equals(outputObj);
Assert.IsTrue(equal);
}
protected void DoMux(PayloadConfiguration payloadConfig, List <PayloadItem> items, List <FileInfo> files, bool outputPayload = false)
{
var ms = new MemoryStream();
for (var index = 0; index < items.Count; index++)
{
var index1 = index;
items[index].SetStreamBinding(() => new FileStream(files[index1].FullName, FileMode.Open));
items[index].ExternalLength = items[index].StreamBinding.Length;
}
var itemPreKeys = new Dictionary <Guid, byte[]> ();
var mux = PayloadMuxFactory.CreatePayloadMultiplexer(payloadConfig.SchemeName.ToEnum <PayloadLayoutScheme>(), true, ms,
items, itemPreKeys, payloadConfig);
Assert.DoesNotThrow(mux.Execute);
Debug.Print("\n##### END OF MUXING OPERATION #####\n");
foreach (var item in items)
{
item.StreamBinding.Close();
}
// Write out muxed payload - optional
if (outputPayload)
{
if (!DestinationDirectory.Exists)
{
DestinationDirectory.Create();
}
var path = DestinationDirectory.FullName + Path.DirectorySeparatorChar +
payloadConfig.SchemeName.ToLower() + IOTestBase.RawPayloadExtension;
using (var fs = new FileStream(path, FileMode.Create)) {
ms.WriteTo(fs);
}
}
// DEMUX
var demuxPath = DestinationDirectory.FullName + Path.DirectorySeparatorChar + DemuxDir;
if (!Directory.Exists(demuxPath))
{
Directory.CreateDirectory(demuxPath);
}
foreach (var payloadItem in items)
{
PayloadItem item = payloadItem;
payloadItem.SetStreamBinding(() => new FileStream(demuxPath + Path.DirectorySeparatorChar + item.Path, FileMode.Create));
}
ms.Seek(0, SeekOrigin.Begin);
mux = PayloadMuxFactory.CreatePayloadMultiplexer(payloadConfig.SchemeName.ToEnum <PayloadLayoutScheme>(), false, ms,
items, itemPreKeys, payloadConfig);
Assert.DoesNotThrow(mux.Execute);
Debug.Print("\n##### END OF DEMUXING OPERATION #####\n");
foreach (var item in items)
{
item.StreamBinding.Close();
}
if (mux is FrameshiftPayloadMux)
{
Assert.Pass("Overhead: {0} bytes", ((FrameshiftPayloadMux)mux).Overhead);
}
else
{
Assert.Pass();
}
}
