public void Test()
{
var manifest = new Manifest
{
PayloadItems = new List <PayloadItem>(),
PayloadOffset = 69,
PayloadConfiguration = PayloadLayoutConfigurationFactory.CreateDefault(PayloadLayoutSchemes.Frameshift)
};
manifest.PayloadItems.Add(new PayloadItem()
{
Encryption = SymmetricCipherConfigurationFactory.CreateBlockCipherConfiguration
(SymmetricBlockCipher.AES, BlockCipherModes.CTR, BlockCipherPaddings.None)
});
var stream = StratCom.SerialiseDto(manifest);
stream.Seek(0, SeekOrigin.Begin);
var outputObj = StratCom.DeserialiseDTO <Manifest>(stream.ToArray());
bool equal = manifest.Equals(outputObj);
Assert.IsTrue(equal);
}
/// <summary>
/// Reads a package manifest header from a stream.
/// </summary>
/// <param name="sourceStream">Stream to read the header from.</param>
/// <param name="cryptoScheme">Manifest cryptography scheme parsed from the header.</param>
/// <param name="cryptoConfig">Manifest cryptography configuration deserialised from the header.</param>
/// <returns>Package manifest header.</returns>
/// <exception cref="DataLengthException">End of stream encountered unexpectedly (contents truncated).</exception>
/// <exception cref="InvalidDataException">Package data structure is out of specification or otherwise malformed.</exception>
/// <exception cref="NotSupportedException">Version format specified is unknown to the local version.</exception>
private static ManifestHeader ReadManifestHeader(Stream sourceStream,
out ManifestCryptographyScheme cryptoScheme,
out IManifestCryptographySchemeConfiguration cryptoConfig)
{
Debug.Print(DebugUtility.CreateReportString("PackageReader", "ReadManifestHeader",
"[* PACKAGE START* ] Header offset (absolute)",
sourceStream.Position));
byte[] referenceHeaderTag = Athena.Packaging.GetPackageHeaderTag();
var readHeaderTag = new byte[referenceHeaderTag.Length];
int headerTagBytesRead = sourceStream.Read(readHeaderTag, 0, readHeaderTag.Length);
if (readHeaderTag.SequenceEqualShortCircuiting(referenceHeaderTag) == false)
{
if (headerTagBytesRead != referenceHeaderTag.Length)
{
throw new DataLengthException("Insufficient data to read package header tag.");
}
throw new InvalidDataException(
"Package is malformed. Expected header tag is either absent or malformed.");
}
Debug.Print(DebugUtility.CreateReportString("PackageReader", "ReadManifestHeader",
"Manifest header offset (absolute)",
sourceStream.Position));
var manifestHeader = StratCom.DeserialiseDataTransferObject <ManifestHeader>(sourceStream, true);
if (manifestHeader.FormatVersion <= 0)
{
throw new InvalidDataException("Package format descriptor is 0 or less (must be 1 or more).");
}
if (manifestHeader.FormatVersion > Athena.Packaging.PackageFormatVersion)
{
throw new NotSupportedException(
String.Format("Package version {0} as specified by the manifest header is unsupported/unknown.\n" +
"The local version of ObscurCore supports up to version {1}.",
manifestHeader.FormatVersion, Athena.Packaging.PackageFormatVersion));
// In later versions, can redirect to diff. behaviour (and DTO objects) for diff. versions.
}
cryptoScheme = manifestHeader.CryptographyScheme;
switch (cryptoScheme)
{
case ManifestCryptographyScheme.SymmetricOnly:
cryptoConfig =
manifestHeader.CryptographySchemeConfiguration
.DeserialiseDto <SymmetricManifestCryptographyConfiguration>();
break;
case ManifestCryptographyScheme.Um1Hybrid:
cryptoConfig =
manifestHeader.CryptographySchemeConfiguration
.DeserialiseDto <Um1HybridManifestCryptographyConfiguration>();
break;
default:
throw new NotSupportedException(String.Format(
"Package manifest cryptography scheme \"{0}\" as specified by the manifest header is unsupported.",
manifestHeader.CryptographyScheme));
}
return(manifestHeader);
}
