private static void GenerateFFU(string ImageFile, string FFUFile, string PlatformId, UInt32 chunkSize, string AntiTheftVersion, string Osversion, string[] excluded, UInt32 BlankSectorBufferSize)
{
Logging.Log("Input image: " + ImageFile);
Logging.Log("Destination image: " + FFUFile);
Logging.Log("Platform ID: " + PlatformId);
Logging.Log("");
Stream stream;
if (ImageFile.ToLower().Contains(@"\\.\physicaldrive"))
{
stream = new DeviceStream(ImageFile, FileAccess.Read);
}
else
{
stream = new FileStream(ImageFile, FileMode.Open);
}
(FlashPart[] flashParts, ulong PlatEnd, List <GPT.Partition> partitions) = ImageSplitter.GetImageSlices(stream, chunkSize, excluded);
IOrderedEnumerable <FlashingPayload> payloads = FlashingPayloadGenerator.GetOptimizedPayloads(flashParts, chunkSize, BlankSectorBufferSize).OrderBy(x => x.TargetLocations.First()); // , PlatEnd
Logging.Log("");
Logging.Log("Building image headers...");
string header1 = Path.GetTempFileName();
FileStream Headerstream1 = new FileStream(header1, FileMode.OpenOrCreate);
// ==============================
// Header 1 start
ImageHeader image = new ImageHeader();
FullFlash ffimage = new FullFlash();
Store simage = new Store();
// Todo make this read the image itself
ffimage.OSVersion = Osversion;
ffimage.DevicePlatformId0 = PlatformId;
ffimage.AntiTheftVersion = AntiTheftVersion;
simage.SectorSize = 512;
simage.MinSectorCount = (UInt32)(stream.Length / 512);
Logging.Log("Generating image manifest...");
string manifest = ManifestIni.BuildUpManifest(ffimage, simage, partitions);
byte[] TextBytes = System.Text.Encoding.ASCII.GetBytes(manifest);
image.ManifestLength = (UInt32)TextBytes.Length;
byte[] ImageHeaderBuffer = new byte[0x18];
ByteOperations.WriteUInt32(ImageHeaderBuffer, 0, image.Size);
ByteOperations.WriteAsciiString(ImageHeaderBuffer, 0x04, image.Signature);
ByteOperations.WriteUInt32(ImageHeaderBuffer, 0x10, image.ManifestLength);
ByteOperations.WriteUInt32(ImageHeaderBuffer, 0x14, image.ChunkSize);
Headerstream1.Write(ImageHeaderBuffer, 0, 0x18);
Headerstream1.Write(TextBytes, 0, TextBytes.Length);
RoundUpToChunks(Headerstream1, chunkSize);
// Header 1 stop + round
// ==============================
string header2 = Path.GetTempFileName();
FileStream Headerstream2 = new FileStream(header2, FileMode.OpenOrCreate);
// ==============================
// Header 2 start
StoreHeader store = new StoreHeader();
store.WriteDescriptorCount = (UInt32)payloads.Count();
store.FinalTableIndex = (UInt32)payloads.Count() - store.FinalTableCount;
store.PlatformId = PlatformId;
foreach (FlashingPayload payload in payloads)
{
store.WriteDescriptorLength += payload.GetStoreHeaderSize();
}
foreach (FlashingPayload payload in payloads)
{
if (payload.TargetLocations.First() > PlatEnd)
{
break;
}
store.FlashOnlyTableIndex += 1;
}
byte[] StoreHeaderBuffer = new byte[0xF8];
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0, store.UpdateType);
ByteOperations.WriteUInt16(StoreHeaderBuffer, 0x04, store.MajorVersion);
ByteOperations.WriteUInt16(StoreHeaderBuffer, 0x06, store.MinorVersion);
ByteOperations.WriteUInt16(StoreHeaderBuffer, 0x08, store.FullFlashMajorVersion);
ByteOperations.WriteUInt16(StoreHeaderBuffer, 0x0A, store.FullFlashMinorVersion);
ByteOperations.WriteAsciiString(StoreHeaderBuffer, 0x0C, store.PlatformId);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xCC, store.BlockSizeInBytes);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xD0, store.WriteDescriptorCount);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xD4, store.WriteDescriptorLength);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xD8, store.ValidateDescriptorCount);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xDC, store.ValidateDescriptorLength);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xE0, store.InitialTableIndex);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xE4, store.InitialTableCount);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xE8, store.FlashOnlyTableIndex);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xEC, store.FlashOnlyTableCount);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xF0, store.FinalTableIndex);
ByteOperations.WriteUInt32(StoreHeaderBuffer, 0xF4, store.FinalTableCount);
Headerstream2.Write(StoreHeaderBuffer, 0, 0xF8);
byte[] descriptorsBuffer = new byte[store.WriteDescriptorLength];
UInt32 NewWriteDescriptorOffset = 0;
foreach (FlashingPayload payload in payloads)
{
ByteOperations.WriteUInt32(descriptorsBuffer, NewWriteDescriptorOffset + 0x00, (UInt32)payload.TargetLocations.Count()); // Location count
ByteOperations.WriteUInt32(descriptorsBuffer, NewWriteDescriptorOffset + 0x04, payload.ChunkCount); // Chunk count
NewWriteDescriptorOffset += 0x08;
foreach (UInt32 location in payload.TargetLocations)
{
ByteOperations.WriteUInt32(descriptorsBuffer, NewWriteDescriptorOffset + 0x00, 0x00000000); // Disk access method (0 = Begin, 2 = End)
ByteOperations.WriteUInt32(descriptorsBuffer, NewWriteDescriptorOffset + 0x04, location); // Chunk index
NewWriteDescriptorOffset += 0x08;
}
}
Headerstream2.Write(descriptorsBuffer, 0, (Int32)store.WriteDescriptorLength);
RoundUpToChunks(Headerstream2, chunkSize);
// Header 2 stop + round
// ==============================
SecurityHeader security = new SecurityHeader();
Headerstream1.Seek(0, SeekOrigin.Begin);
Headerstream2.Seek(0, SeekOrigin.Begin);
security.HashTableSize = 0x20 * (UInt32)((Headerstream1.Length + Headerstream2.Length) / chunkSize);
foreach (FlashingPayload payload in payloads)
{
security.HashTableSize += payload.GetSecurityHeaderSize();
}
byte[] HashTable = new byte[security.HashTableSize];
BinaryWriter bw = new BinaryWriter(new MemoryStream(HashTable));
SHA256 crypto = SHA256.Create();
for (int i = 0; i < Headerstream1.Length / chunkSize; i++)
{
byte[] buffer = new byte[chunkSize];
Headerstream1.Read(buffer, 0, (Int32)chunkSize);
byte[] hash = crypto.ComputeHash(buffer);
bw.Write(hash, 0, hash.Length);
}
for (int i = 0; i < Headerstream2.Length / chunkSize; i++)
{
byte[] buffer = new byte[chunkSize];
Headerstream2.Read(buffer, 0, (Int32)chunkSize);
byte[] hash = crypto.ComputeHash(buffer);
bw.Write(hash, 0, hash.Length);
}
foreach (FlashingPayload payload in payloads)
{
bw.Write(payload.ChunkHashes[0], 0, payload.ChunkHashes[0].Length);
}
bw.Close();
Logging.Log("Generating image catalog...");
byte[] catalog = GenerateCatalogFile(HashTable);
security.CatalogSize = (UInt32)catalog.Length;
byte[] SecurityHeaderBuffer = new byte[0x20];
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0, security.Size);
ByteOperations.WriteAsciiString(SecurityHeaderBuffer, 0x04, security.Signature);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x10, security.ChunkSizeInKb);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x14, security.HashAlgorithm);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x18, security.CatalogSize);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x1C, security.HashTableSize);
FileStream retstream = new FileStream(FFUFile, FileMode.CreateNew);
retstream.Write(SecurityHeaderBuffer, 0, 0x20);
retstream.Write(catalog, 0, (Int32)security.CatalogSize);
retstream.Write(HashTable, 0, (Int32)security.HashTableSize);
RoundUpToChunks(retstream, chunkSize);
Headerstream1.Seek(0, SeekOrigin.Begin);
Headerstream2.Seek(0, SeekOrigin.Begin);
byte[] buff = new byte[Headerstream1.Length];
Headerstream1.Read(buff, 0, (Int32)Headerstream1.Length);
Headerstream1.Close();
File.Delete(header1);
retstream.Write(buff, 0, buff.Length);
buff = new byte[Headerstream2.Length];
Headerstream2.Read(buff, 0, (Int32)Headerstream2.Length);
Headerstream2.Close();
File.Delete(header2);
retstream.Write(buff, 0, buff.Length);
Logging.Log("Writing payloads...");
UInt64 counter = 0;
DateTime startTime = DateTime.Now;
foreach (FlashingPayload payload in payloads)
{
UInt32 StreamIndex = payload.StreamIndexes.First();
FlashPart flashPart = flashParts[StreamIndex];
Stream Stream = flashPart.Stream;
Stream.Seek(payload.StreamLocations.First(), SeekOrigin.Begin);
byte[] buffer = new byte[chunkSize];
Stream.Read(buffer, 0, (Int32)chunkSize);
retstream.Write(buffer, 0, (Int32)chunkSize);
counter++;
ShowProgress((UInt64)payloads.Count() * chunkSize, startTime, counter * chunkSize, counter * chunkSize, payload.TargetLocations.First() * chunkSize < PlatEnd);
}
retstream.Close();
Logging.Log("");
}
internal static string BuildUpManifest(FullFlash fullFlash, Store store, List <GPT.Partition> partitions)
{
return(BuildUpManifest(fullFlash, store, GPTPartitionsToPartitions(partitions)));
}
internal static string BuildUpManifest(FullFlash fullFlash, Store store, List <Partition> partitions)
{
string Manifest = "[FullFlash]\r\n";
if (!string.IsNullOrEmpty(fullFlash.AntiTheftVersion))
{
Manifest += "AntiTheftVersion = " + fullFlash.AntiTheftVersion + "\r\n";
}
if (!string.IsNullOrEmpty(fullFlash.OSVersion))
{
Manifest += "OSVersion = " + fullFlash.OSVersion + "\r\n";
}
if (!string.IsNullOrEmpty(fullFlash.Description))
{
Manifest += "Description = " + fullFlash.Description + "\r\n";
}
if (!string.IsNullOrEmpty(fullFlash.Version))
{
Manifest += "Version = " + fullFlash.Version + "\r\n";
}
if (!string.IsNullOrEmpty(fullFlash.DevicePlatformId0))
{
Manifest += "DevicePlatformId0 = " + fullFlash.DevicePlatformId0 + "\r\n";
}
Manifest += "\r\n[Store]\r\n";
Manifest += "SectorSize = " + store.SectorSize + "\r\n";
Manifest += "MinSectorCount = " + store.MinSectorCount + "\r\n";
Manifest += "\r\n";
foreach (Partition partition in partitions)
{
Manifest += "[Partition]\r\n";
if (partition.RequiredToFlash.HasValue)
{
Manifest += "RequiredToFlash = " + (partition.RequiredToFlash.Value ? "True" : "False") + "\r\n";
}
if (!string.IsNullOrEmpty(partition.Name))
{
Manifest += "Name = " + partition.Name + "\r\n";
}
Manifest += "UsedSectors = " + partition.UsedSectors + "\r\n";
if (partition.Type != null)
{
Manifest += "Type = " + partition.Type + "\r\n";
}
Manifest += "TotalSectors = " + partition.TotalSectors + "\r\n";
if (!string.IsNullOrEmpty(partition.Primary))
{
Manifest += "Primary = " + partition.Primary + "\r\n";
}
if (!string.IsNullOrEmpty(partition.FileSystem))
{
Manifest += "FileSystem = " + partition.FileSystem + "\r\n";
}
if (partition.ByteAlignment.HasValue)
{
Manifest += "ByteAlignment = " + partition.ByteAlignment.Value + "\r\n";
}
if (partition.ClusterSize.HasValue)
{
Manifest += "ClusterSize = " + partition.ClusterSize.Value + "\r\n";
}
if (partition.UseAllSpace.HasValue)
{
Manifest += "UseAllSpace = " + (partition.UseAllSpace.Value ? "True" : "False") + "\r\n";
}
Manifest += "\r\n";
}
return(Manifest);
}
private static void GenerateFFU(string ImageFile, string FFUFile, string PlatformId, UInt32 chunkSize, string AntiTheftVersion, string Osversion, string[] excluded, UInt32 BlankSectorBufferSize)
{
Logging.Log("Input image: " + ImageFile);
Logging.Log("Destination image: " + FFUFile);
Logging.Log("Platform ID: " + PlatformId);
Logging.Log("");
Stream stream;
VirtualDisk destDisk = null;
if (ImageFile.ToLower().Contains(@"\\.\physicaldrive"))
{
stream = new DeviceStream(ImageFile, FileAccess.Read);
}
else if (File.Exists(ImageFile) && Path.GetExtension(ImageFile).ToLowerInvariant() == ".vhd")
{
DiscUtils.Setup.SetupHelper.RegisterAssembly(typeof(DiscUtils.Vhd.Disk).Assembly);
DiscUtils.Setup.SetupHelper.RegisterAssembly(typeof(DiscUtils.Vhdx.Disk).Assembly);
destDisk = VirtualDisk.OpenDisk(ImageFile, FileAccess.Read);
stream = destDisk.Content;
}
else if (File.Exists(ImageFile) && Path.GetExtension(ImageFile).ToLowerInvariant() == ".vhdx")
{
DiscUtils.Setup.SetupHelper.RegisterAssembly(typeof(DiscUtils.Vhd.Disk).Assembly);
DiscUtils.Setup.SetupHelper.RegisterAssembly(typeof(DiscUtils.Vhdx.Disk).Assembly);
destDisk = VirtualDisk.OpenDisk(ImageFile, FileAccess.Read);
stream = destDisk.Content;
}
else if (File.Exists(ImageFile))
{
stream = new FileStream(ImageFile, FileMode.Open);
}
else
{
Logging.Log("Unknown input specified");
return;
}
(FlashPart[] flashParts, ulong PlatEnd, List <GPT.Partition> partitions) = ImageSplitter.GetImageSlices(stream, chunkSize, excluded);
IOrderedEnumerable <FlashingPayload> payloads = FlashingPayloadGenerator.GetOptimizedPayloads(flashParts, chunkSize, BlankSectorBufferSize).OrderBy(x => x.TargetLocations.First());
Logging.Log("");
Logging.Log("Building image headers...");
string header1 = Path.GetTempFileName();
FileStream Headerstream1 = new FileStream(header1, FileMode.OpenOrCreate);
// ==============================
// Header 1 start
ImageHeader image = new ImageHeader();
FullFlash ffimage = new FullFlash();
Store simage = new Store();
// Todo make this read the image itself
ffimage.OSVersion = Osversion;
ffimage.DevicePlatformId0 = PlatformId;
ffimage.AntiTheftVersion = AntiTheftVersion;
simage.SectorSize = 512;
simage.MinSectorCount = (UInt32)(stream.Length / 512);
Logging.Log("Generating image manifest...");
string manifest = ManifestIni.BuildUpManifest(ffimage, simage, partitions);
byte[] TextBytes = System.Text.Encoding.ASCII.GetBytes(manifest);
image.ManifestLength = (UInt32)TextBytes.Length;
byte[] ImageHeaderBuffer = new byte[0x18];
ByteOperations.WriteUInt32(ImageHeaderBuffer, 0, image.Size);
ByteOperations.WriteAsciiString(ImageHeaderBuffer, 0x04, image.Signature);
ByteOperations.WriteUInt32(ImageHeaderBuffer, 0x10, image.ManifestLength);
ByteOperations.WriteUInt32(ImageHeaderBuffer, 0x14, image.ChunkSize);
Headerstream1.Write(ImageHeaderBuffer, 0, 0x18);
Headerstream1.Write(TextBytes, 0, TextBytes.Length);
RoundUpToChunks(Headerstream1, chunkSize);
// Header 1 stop + round
// ==============================
string header2 = Path.GetTempFileName();
FileStream Headerstream2 = new FileStream(header2, FileMode.OpenOrCreate);
// ==============================
// Header 2 start
StoreHeader store = new StoreHeader();
store.WriteDescriptorCount = (UInt32)payloads.Count();
store.FinalTableIndex = (UInt32)payloads.Count() - store.FinalTableCount;
store.PlatformId = PlatformId;
byte[] WriteDescriptorBuffer = GetResultingBuffer(payloads);
store.WriteDescriptorLength = (UInt32)WriteDescriptorBuffer.Length;
foreach (FlashingPayload payload in payloads)
{
if (payload.TargetLocations.First() > PlatEnd)
{
break;
}
store.FlashOnlyTableIndex += 1;
}
Headerstream2.Write(store.GetResultingBuffer(), 0, 0xF8);
Headerstream2.Write(WriteDescriptorBuffer, 0, (Int32)store.WriteDescriptorLength);
RoundUpToChunks(Headerstream2, chunkSize);
// Header 2 stop + round
// ==============================
SecurityHeader security = new SecurityHeader();
Headerstream1.Seek(0, SeekOrigin.Begin);
Headerstream2.Seek(0, SeekOrigin.Begin);
security.HashTableSize = 0x20 * (UInt32)((Headerstream1.Length + Headerstream2.Length) / chunkSize);
foreach (FlashingPayload payload in payloads)
{
security.HashTableSize += payload.GetSecurityHeaderSize();
}
byte[] HashTable = new byte[security.HashTableSize];
BinaryWriter bw = new BinaryWriter(new MemoryStream(HashTable));
SHA256 crypto = SHA256.Create();
for (int i = 0; i < Headerstream1.Length / chunkSize; i++)
{
byte[] buffer = new byte[chunkSize];
Headerstream1.Read(buffer, 0, (Int32)chunkSize);
byte[] hash = crypto.ComputeHash(buffer);
bw.Write(hash, 0, hash.Length);
}
for (int i = 0; i < Headerstream2.Length / chunkSize; i++)
{
byte[] buffer = new byte[chunkSize];
Headerstream2.Read(buffer, 0, (Int32)chunkSize);
byte[] hash = crypto.ComputeHash(buffer);
bw.Write(hash, 0, hash.Length);
}
foreach (FlashingPayload payload in payloads)
{
foreach (var chunkHash in payload.ChunkHashes)
{
bw.Write(chunkHash, 0, chunkHash.Length);
}
}
bw.Close();
Logging.Log("Generating image catalog...");
byte[] catalog = GenerateCatalogFile(HashTable);
security.CatalogSize = (UInt32)catalog.Length;
byte[] SecurityHeaderBuffer = new byte[0x20];
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0, security.Size);
ByteOperations.WriteAsciiString(SecurityHeaderBuffer, 0x04, security.Signature);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x10, security.ChunkSizeInKb);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x14, security.HashAlgorithm);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x18, security.CatalogSize);
ByteOperations.WriteUInt32(SecurityHeaderBuffer, 0x1C, security.HashTableSize);
FileStream retstream = new FileStream(FFUFile, FileMode.CreateNew);
retstream.Write(SecurityHeaderBuffer, 0, 0x20);
retstream.Write(catalog, 0, (Int32)security.CatalogSize);
retstream.Write(HashTable, 0, (Int32)security.HashTableSize);
RoundUpToChunks(retstream, chunkSize);
Headerstream1.Seek(0, SeekOrigin.Begin);
Headerstream2.Seek(0, SeekOrigin.Begin);
byte[] buff = new byte[Headerstream1.Length];
Headerstream1.Read(buff, 0, (Int32)Headerstream1.Length);
Headerstream1.Close();
File.Delete(header1);
retstream.Write(buff, 0, buff.Length);
buff = new byte[Headerstream2.Length];
Headerstream2.Read(buff, 0, (Int32)Headerstream2.Length);
Headerstream2.Close();
File.Delete(header2);
retstream.Write(buff, 0, buff.Length);
Logging.Log("Writing payloads...");
UInt64 counter = 0;
DateTime startTime = DateTime.Now;
foreach (FlashingPayload payload in payloads)
{
for (int i = 0; i < payload.StreamIndexes.Length; i++)
{
UInt32 StreamIndex = payload.StreamIndexes[i];
FlashPart flashPart = flashParts[StreamIndex];
Stream Stream = flashPart.Stream;
Stream.Seek(payload.StreamLocations[i], SeekOrigin.Begin);
byte[] buffer = new byte[chunkSize];
Stream.Read(buffer, 0, (Int32)chunkSize);
retstream.Write(buffer, 0, (Int32)chunkSize);
counter++;
ShowProgress((UInt64)payloads.Count() * chunkSize, startTime, counter * chunkSize, counter * chunkSize, payload.TargetLocations[i] * chunkSize < PlatEnd);
}
}
retstream.Close();
if (destDisk != null)
{
destDisk.Dispose();
}
Logging.Log("");
}