public void AddSignature(BlockSignature signature)
{
lock (this)
{
_signatures[signature.Issuer] = signature;
}
}
/// <summary>
/// Create a SpecialFolderDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A SpecialFolderDataBlock object</returns>
public static SpecialFolderDataBlock FromByteArray(byte[] ba)
{
SpecialFolderDataBlock SpecialFolderDataBlock = new SpecialFolderDataBlock();
if (ba.Length < 0x10)
{
throw new ArgumentException(String.Format("Size of the SpecialFolderDataBlock Structure is less than 16 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, SpecialFolderDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != SpecialFolderDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, SpecialFolderDataBlock.BlockSignature));
}
SpecialFolderDataBlock.SpecialFolderID = (CSIDL)BitConverter.ToUInt32(ba, 8);
SpecialFolderDataBlock.Offset = BitConverter.ToUInt32(ba, 12);
return(SpecialFolderDataBlock);
}
/// <summary>
/// Create a PropertyStoreDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A PropertyStoreDataBlock object</returns>
public static PropertyStoreDataBlock FromByteArray(byte[] ba)
{
PropertyStoreDataBlock PropertyStoreDataBlock = new PropertyStoreDataBlock();
if (ba.Length < 0xC)
{
throw new ArgumentException(String.Format("Size of the PropertyStoreDataBlock Structure is less than 12 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, PropertyStoreDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != PropertyStoreDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, PropertyStoreDataBlock.BlockSignature));
}
byte[] data = new byte[BlockSize - 4];
Buffer.BlockCopy(BitConverter.GetBytes(BlockSize - 4), 0, data, 0, 4);
Buffer.BlockCopy(ba, 8, data, 4, (int)BlockSize - 8);
SerializedPropertyStore SerializedPropertyStore = SerializedPropertyStore.FromByteArray(data);
PropertyStoreDataBlock.PropertyStore = SerializedPropertyStore.PropertyStorage;
return(PropertyStoreDataBlock);
}
/// <summary>
/// Create a ShimDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A ShimDataBlock object</returns>
public static ShimDataBlock FromByteArray(byte[] ba)
{
ShimDataBlock ShimDataBlock = new ShimDataBlock();
if (ba.Length < 0x88)
{
throw new ArgumentException(String.Format("Size of the ShimDataBlock Structure is less than 136 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, ShimDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != ShimDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, ShimDataBlock.BlockSignature));
}
byte[] LayerName = new byte[BlockSize - 8];
Buffer.BlockCopy(ba, 8, LayerName, 0, (int)BlockSize - 8);
ShimDataBlock.LayerName = Encoding.Unicode.GetString(LayerName).TrimEnd(new char[] { (char)0 });
return(ShimDataBlock);
}
/// <summary>
/// Create an EnvironmentVariableDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>An EnvironmentVariableDataBlock object</returns>
public static EnvironmentVariableDataBlock FromByteArray(byte[] ba)
{
EnvironmentVariableDataBlock EnvironmentVariableDataBlock = new EnvironmentVariableDataBlock();
if (ba.Length < 0x314)
{
throw new ArgumentException(String.Format("Size of the EnvironmentVariableDataBlock Structure is less than 788 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, EnvironmentVariableDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != EnvironmentVariableDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, EnvironmentVariableDataBlock.BlockSignature));
}
byte[] TargetAnsi = new byte[260];
Buffer.BlockCopy(ba, 8, TargetAnsi, 0, 260);
EnvironmentVariableDataBlock.TargetAnsi = Encoding.Default.GetString(TargetAnsi).TrimEnd(new char[] { (char)0 });
byte[] TargetUnicode = new byte[520];
Buffer.BlockCopy(ba, 268, TargetUnicode, 0, 520);
EnvironmentVariableDataBlock.TargetUnicode = Encoding.Unicode.GetString(TargetUnicode).TrimEnd(new char[] { (char)0 });
return(EnvironmentVariableDataBlock);
}
/// <summary>
/// Create a ConsoleFEDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A ConsoleFEDataBlock object</returns>
public static ConsoleFEDataBlock FromByteArray(byte[] ba)
{
ConsoleFEDataBlock ConsoleFEDataBlock = new ConsoleFEDataBlock();
if (ba.Length < 0xC)
{
throw new ArgumentException(String.Format("Size of the ConsoleFEDataBlock Structure is less than 12 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, ConsoleFEDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != ConsoleFEDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, ConsoleFEDataBlock.BlockSignature));
}
ConsoleFEDataBlock.CodePage = BitConverter.ToUInt32(ba, 8);
return(ConsoleFEDataBlock);
}
/// <summary>
/// Create a KnownFolderDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A KnownFolderDataBlock object</returns>
public static KnownFolderDataBlock FromByteArray(byte[] ba)
{
KnownFolderDataBlock KnownFolderDataBlock = new KnownFolderDataBlock();
if (ba.Length < 0x1C)
{
throw new ArgumentException(String.Format("Size of the KnownFolderDataBlock Structure is less than 28 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, KnownFolderDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != KnownFolderDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, KnownFolderDataBlock.BlockSignature));
}
byte[] KnownFolderID = new byte[16];
Buffer.BlockCopy(ba, 8, KnownFolderID, 0, KnownFolderID.Length);
KnownFolderDataBlock.KnownFolderID = new Guid(KnownFolderID);
KnownFolderDataBlock.Offset = BitConverter.ToUInt32(ba, 24);
return(KnownFolderDataBlock);
}
/// <inheritdoc />
public bool CheckStakeSignature(BlockSignature signature, uint256 blockHash, Transaction coinStake)
{
if (signature.IsEmpty())
{
this.logger.LogTrace("(-)[EMPTY]:false");
return(false);
}
var txout = coinStake.Outputs[1];
if (PayToPubkeyTemplate.Instance.CheckScriptPubKey(txout.ScriptPubKey))
{
var pubKey = PayToPubkeyTemplate.Instance.ExtractScriptPubKeyParameters(txout.ScriptPubKey);
var res = pubKey.Verify(blockHash, new ECDSASignature(signature.Signature));
this.logger.LogTrace("(-)[P2PK]:{0}", res);
return(res);
}
// Block signing key also can be encoded in the nonspendable output.
// This allows to not pollute UTXO set with useless outputs e.g. in case of multisig staking.
var ops = txout.ScriptPubKey.ToOps().ToList();
if (!ops.Any())
{
this.logger.LogTrace("(-)[NO_OPS]:false");
return(false);
}
if (ops.ElementAt(0).Code != OpcodeType.OP_RETURN) // OP_RETURN)
{
this.logger.LogTrace("(-)[NO_OP_RETURN]:false");
return(false);
}
if (ops.Count != 2)
{
this.logger.LogTrace("(-)[INVALID_OP_COUNT]:false");
return(false);
}
var data = ops.ElementAt(1).PushData;
if (data.Length > MaxPushDataSize)
{
this.logger.LogTrace("(-)[PUSH_DATA_TOO_LARGE]:false");
return(false);
}
if (!ScriptEvaluationContext.IsCompressedOrUncompressedPubKey(data))
{
this.logger.LogTrace("(-)[NO_PUSH_DATA]:false");
return(false);
}
var verifyRes = new PubKey(data).Verify(blockHash, new ECDSASignature(signature.Signature));
return(verifyRes);
}
public bool IsSignatureValid(Key key, BlockSignature signature, Block block)
{
if (signature != null && block != null)
{
return(signature.IsValid(key, GetBlockHash(block)));
}
return(false);
}
public static bool EnsureLowS(BlockSignature blockSignature)
{
var signature = new ECDSASignature(blockSignature.Signature);
if (!signature.IsLowS)
{
blockSignature.Signature = signature.MakeCanonical().ToDER();
}
return(true);
}
public StoreError Set(string participant, BlockSignature sig)
{
var(id, err) = ParticipantId(participant);
if (err != null)
{
return(err);
}
return(Rim.Set(id, sig, sig.Index));
}
/// <inheritdoc />
public override void Run(RuleContext context)
{
BlockSignature expectedSignature = (context.ValidationContext.ChainedHeaderToValidate.Header as PoABlockHeader).BlockSignature;
BlockSignature actualSignature = (context.ValidationContext.BlockToValidate.Header as PoABlockHeader).BlockSignature;
if (expectedSignature != actualSignature)
{
this.Logger.LogTrace("(-)[INVALID_SIGNATURE]");
PoAConsensusErrors.InvalidBlockSignature.Throw();
}
}
public void AddSignature(short issuer, Block block, Key key)
{
if (block.BlockId != BlockId || block.Issuer != BlockIssuer)
{
throw new ArgumentException(nameof(block));
}
lock (this)
{
_signatures[issuer] = new BlockSignature(issuer, Signature.Generate(key, GetBlockHash(block)));
}
}
/// <summary>
/// Create a ConsoleDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A ConsoleDataBlock object</returns>
public static ConsoleDataBlock FromByteArray(byte[] ba)
{
ConsoleDataBlock ConsoleDataBlock = new ConsoleDataBlock();
if (ba.Length < 0xCC)
{
throw new ArgumentException(String.Format("Size of the ConsoleDataBlock Structure is less than 204 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, ConsoleDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != ConsoleDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, ConsoleDataBlock.BlockSignature));
}
ConsoleDataBlock.FillAttributes = (FillAttributes)BitConverter.ToUInt16(ba, 8);
ConsoleDataBlock.PopupFillAttributes = (FillAttributes)BitConverter.ToUInt16(ba, 10);
ConsoleDataBlock.ScreenBufferSizeX = BitConverter.ToUInt16(ba, 12);
ConsoleDataBlock.ScreenBufferSizeY = BitConverter.ToUInt16(ba, 14);
ConsoleDataBlock.WindowSizeX = BitConverter.ToUInt16(ba, 16);
ConsoleDataBlock.WindowSizeY = BitConverter.ToUInt16(ba, 18);
ConsoleDataBlock.WindowOriginX = BitConverter.ToUInt16(ba, 20);
ConsoleDataBlock.WindowOriginY = BitConverter.ToUInt16(ba, 22);
ConsoleDataBlock.Unused1 = BitConverter.ToUInt32(ba, 24);
ConsoleDataBlock.Unused2 = BitConverter.ToUInt32(ba, 28);
ConsoleDataBlock.FontSize = BitConverter.ToUInt32(ba, 32);
ConsoleDataBlock.FontFamily = (FontFamily)(BitConverter.ToUInt32(ba, 36) & 0xF0);
ConsoleDataBlock.FontPitch = (FontPitch)(BitConverter.ToUInt32(ba, 36) & 0xF);
ConsoleDataBlock.FontWeight = BitConverter.ToUInt32(ba, 40);
byte[] FaceName = new byte[64];
Buffer.BlockCopy(ba, 44, FaceName, 0, 64);
ConsoleDataBlock.FaceName = Encoding.Unicode.GetString(FaceName).TrimEnd(new char[] { (char)0 });
ConsoleDataBlock.CursorSize = BitConverter.ToUInt32(ba, 108);
ConsoleDataBlock.FullScreen = BitConverter.ToUInt32(ba, 112) != 0;
ConsoleDataBlock.QuickEdit = BitConverter.ToUInt32(ba, 116) != 0;
ConsoleDataBlock.InsertMode = BitConverter.ToUInt32(ba, 120) != 0;
ConsoleDataBlock.AutoPosition = BitConverter.ToUInt32(ba, 124) != 0;
ConsoleDataBlock.HistoryBufferSize = BitConverter.ToUInt32(ba, 128);
ConsoleDataBlock.NumberOfHistoryBuffers = BitConverter.ToUInt32(ba, 132);
ConsoleDataBlock.HistoryNoDup = BitConverter.ToUInt32(ba, 136) != 0;
Buffer.BlockCopy(ba, 140, ConsoleDataBlock.ColorTable, 0, 64);
return(ConsoleDataBlock);
}
/// <summary>
/// Create a TrackerDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A TrackerDataBlock object</returns>
public static TrackerDataBlock FromByteArray(byte[] ba)
{
TrackerDataBlock TrackerDataBlock = new TrackerDataBlock();
if (ba.Length < 0x60)
{
throw new ArgumentException(String.Format("Size of the TrackerDataBlock Structure is less than 96 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, TrackerDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != TrackerDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, TrackerDataBlock.BlockSignature));
}
UInt32 Length = BitConverter.ToUInt32(ba, 8);
if (Length < 0x58)
{
throw new ArgumentException(String.Format("Length is {0} is incorrect (expected 88)", Length));
}
TrackerDataBlock.Version = BitConverter.ToUInt32(ba, 12);
byte[] MachineID = new byte[Length - 0x48];
Buffer.BlockCopy(ba, 16, MachineID, 0, MachineID.Length);
TrackerDataBlock.MachineID = Encoding.Default.GetString(MachineID).TrimEnd(new char[] { (char)0 });
byte[] Guid = new byte[16];
Buffer.BlockCopy(ba, 16 + MachineID.Length, Guid, 0, Guid.Length);
TrackerDataBlock.Droid = new Guid[2];
TrackerDataBlock.Droid[0] = new Guid(Guid);
Buffer.BlockCopy(ba, 32 + MachineID.Length, Guid, 0, Guid.Length);
TrackerDataBlock.Droid[1] = new Guid(Guid);
Buffer.BlockCopy(ba, 48 + MachineID.Length, Guid, 0, Guid.Length);
TrackerDataBlock.DroidBirth = new Guid[2];
TrackerDataBlock.DroidBirth[0] = new Guid(Guid);
Buffer.BlockCopy(ba, 64 + MachineID.Length, Guid, 0, Guid.Length);
TrackerDataBlock.DroidBirth[1] = new Guid(Guid);
return(TrackerDataBlock);
}
public ExternalDataBlock Create(IB blockOffset, BID blockId, BinaryData data)
{
var obfuscatedData = dataObfuscator.Obfuscate(data, blockId);
return
(new ExternalDataBlock(
obfuscatedData,
BinaryData.OfSize(Utilities.GetExternalDataBlockPaddingSize(obfuscatedData.Length)),
new BlockTrailer(
obfuscatedData.Length,
BlockSignature.Calculate(blockOffset, blockId),
Crc32.ComputeCrc32(obfuscatedData),
blockId)));
}
internal static BlockSignature GenerateBlockSig(byte[] buffer, long offset, int blockSize, uint id)
{
var sig = new BlockSignature();
var rollingSig = CreateRollingSignature(buffer, blockSize);
var md5Sig = CreateMD5Signature(buffer, blockSize);
sig.RollingSig = rollingSig;
sig.MD5Signature = md5Sig;
sig.Offset = offset;
sig.BlockNumber = id;
sig.Size = (uint)blockSize;
return(sig);
}
/// <summary>
/// Create a VistaAndAboveIDListDataBlock from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>A VistaAndAboveIDListDataBlock object</returns>
public static VistaAndAboveIDListDataBlock FromByteArray(byte[] ba)
{
VistaAndAboveIDListDataBlock VistaAndAboveIDListDataBlock = new VistaAndAboveIDListDataBlock();
if (ba.Length < 0xA)
{
throw new ArgumentException(String.Format("Size of the VistaAndAboveIDListDataBlock Structure is less than 10 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (expected {1})", BlockSize, VistaAndAboveIDListDataBlock.BlockSize));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
if (BlockSignature != VistaAndAboveIDListDataBlock.BlockSignature)
{
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect (expected {1})", BlockSignature, VistaAndAboveIDListDataBlock.BlockSignature));
}
ba = ba.Skip(8).ToArray();
UInt32 Count = BlockSize - 8;
while (Count > 0)
{
UInt16 ItemIDSize = BitConverter.ToUInt16(ba, 0);
if (ItemIDSize != 0)
{
byte[] itemID = new byte[ItemIDSize - 2];
Buffer.BlockCopy(ba, 2, itemID, 0, itemID.Length);
Count -= ItemIDSize;
VistaAndAboveIDListDataBlock.IDList.ItemIDList.Add(new ItemID(itemID));
ba = ba.Skip(ItemIDSize).ToArray();
}
else
{
break;
}
}
return(VistaAndAboveIDListDataBlock);
}
// very manual writer... but want to see how small I can get the data.
public static CompleteSignature ReadBinaryCompleteSignature(Stream s)
{
var sig = new CompleteSignature();
var l = new List <BlockSignature>();
var reader = new BinaryReader(s);
int numberOfEntries = reader.ReadInt32();
for (var i = 0; i < numberOfEntries; i++)
{
var entry = new BlockSignature();
// 8 bytes. offset
long offset = reader.ReadInt64();
// 4 bytes. size
int size = reader.ReadInt32();
// 4 bytes. Block Number;
int blockNumber = reader.ReadInt32();
// 4 bytes. Rolling Signature.
decimal sig1 = reader.ReadDecimal();
decimal sig2 = reader.ReadDecimal();
RollingSignature rollingSig = new RollingSignature()
{
Sig1 = sig1, Sig2 = sig2
};
// should be 16 bytes.
byte[] md5 = reader.ReadBytes(16);
entry.BlockNumber = (UInt32)blockNumber;
entry.RollingSig = (RollingSignature)rollingSig;
entry.MD5Signature = md5;
entry.Offset = offset;
entry.Size = (uint)size;
l.Add(entry);
}
sig.SignatureList = l.ToArray <BlockSignature>();
return(sig);
}
public InternalDataBlock Create(
IB blockOffset,
BID blockId,
BlockIdsWithTotalNumberOfBytesInReferencedBlocks data)
{
var encodedExternalBlockIds = data.BlockIds.Encode(bidEncoder);
return
(new InternalDataBlock(
0x01,
blockLevel,
data.BlockIds.Length,
data.TotalNumberOfBytesInReferencedBlocks,
encodedExternalBlockIds,
BinaryData.OfSize(Utilities.GetInternalDataBlockPaddingSize(encodedExternalBlockIds.Length)),
new BlockTrailer(
encodedExternalBlockIds.Length + 8,
BlockSignature.Calculate(blockOffset, blockId),
Crc32.ComputeCrc32(GetDataToCalculateCrc32(encodedExternalBlockIds, data.BlockIds.Length, data.TotalNumberOfBytesInReferencedBlocks)),
blockId)));
}
public bool TryGetSignature(short issuer, out BlockSignature signature)
{
signature = GetSignature(issuer);
return(signature != null);
}
/// <summary>
/// Create an ExtraData from a given byte array
/// </summary>
/// <param name="ba">The byte array</param>
/// <returns>An ExtraData object</returns>
public static ExtraData FromByteArray(byte[] ba)
{
ExtraData ExtraData = new ExtraData();
if (ba.Length < 4)
{
throw new ArgumentException(String.Format("Size of the ExtraData Structure is less than 4 ({0})", ba.Length));
}
UInt32 BlockSize = BitConverter.ToUInt32(ba, 0);
while (BlockSize > 4)
{
if (BlockSize > ba.Length)
{
throw new ArgumentException(String.Format("BlockSize is {0} is incorrect (bytes left {1})", BlockSize, ba.Length));
}
BlockSignature BlockSignature = (BlockSignature)BitConverter.ToUInt32(ba, 4);
switch (BlockSignature)
{
case BlockSignature.CONSOLE_PROPS:
ExtraData.ConsoleDataBlock = ConsoleDataBlock.FromByteArray(ba);
break;
case BlockSignature.CONSOLE_FE_PROPS:
ExtraData.ConsoleFEDataBlock = ConsoleFEDataBlock.FromByteArray(ba);
break;
case BlockSignature.DARWIN_PROPS:
ExtraData.DarwinDataBlock = DarwinDataBlock.FromByteArray(ba);
break;
case BlockSignature.ENVIRONMENT_PROPS:
ExtraData.EnvironmentVariableDataBlock = EnvironmentVariableDataBlock.FromByteArray(ba);
break;
case BlockSignature.ICON_ENVIRONMENT_PROPS:
ExtraData.IconEnvironmentDataBlock = IconEnvironmentDataBlock.FromByteArray(ba);
break;
case BlockSignature.KNOWN_FOLDER_PROPS:
ExtraData.KnownFolderDataBlock = KnownFolderDataBlock.FromByteArray(ba);
break;
case BlockSignature.PROPERTY_STORE_PROPS:
ExtraData.PropertyStoreDataBlock = PropertyStoreDataBlock.FromByteArray(ba);
break;
case BlockSignature.SHIM_PROPS:
ExtraData.ShimDataBlock = ShimDataBlock.FromByteArray(ba);
break;
case BlockSignature.SPECIAL_FOLDER_PROPS:
ExtraData.SpecialFolderDataBlock = SpecialFolderDataBlock.FromByteArray(ba);
break;
case BlockSignature.TRACKER_PROPS:
ExtraData.TrackerDataBlock = TrackerDataBlock.FromByteArray(ba);
break;
case BlockSignature.VISTA_AND_ABOVE_IDLIST_PROPS:
ExtraData.VistaAndAboveIDListDataBlock = VistaAndAboveIDListDataBlock.FromByteArray(ba);
break;
default:
throw new ArgumentException(String.Format("BlockSignature is {0} is incorrect", BlockSignature));
}
ba = ba.Skip((int)BlockSize).ToArray();
BlockSize = BitConverter.ToUInt32(ba, 0);
}
return(ExtraData);
}
public void AddBlockSignature(BlockSignature bs)
{
BlockSignaturePool.Add(bs);
}
