lolo859/vystem
2
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
vystem/vybuild/vybuild-fat32.cpp
lolo859 d238606b75 Vystem 0.2
2026-05-27 19:34:54 +02:00

490 lines
22 KiB
C++
Raw Permalink Blame History

// SPDX-License-Identifier: MPL-2.0
// Some parts of the following driver is made using this guide: https://elm-chan.org/docs/fat_e.html
#include "vybuild.hpp"
#include "common/versions.h"
#include "api.h"
#include <dlfcn.h>
#include <map>
using namespace std;
typedef int (*crypto_sign_func_ptr)(uint8_t*,size_t*,const uint8_t*,size_t,const uint8_t*);
typedef void* (*sha3_512_func_ptr)(const void*,size_t,void*,int);
struct common_crypto_struct {
crypto_sign_func_ptr crypto_sign;
sha3_512_func_ptr sha3_512;
};
bool is_crypto_lib_available=false;
struct common_crypto_struct common_crypto;
uint64_t vftm_target_offset=0;
vector<uint8_t> vftm_target_content;
uint8_t manifest_keypair[CRYPTO_PUBLICKEYBYTES+CRYPTO_SECRETKEYBYTES]={0};
bool vybuild::fat32::is_crypto_lib_loaded() {
return is_crypto_lib_available;
}
bool vybuild::fat32::is_vftm_target_set() {
return vftm_target_offset!=0;
}
uint8_t* vybuild::fat32::get_manifest_keypair_buffer() {
return manifest_keypair;
}
void vybuild::fat32::load_crypto_lib(string path) {
void *handle;
handle=dlopen(path.c_str(),RTLD_LAZY | RTLD_LOCAL);
if (!handle) {
throw std::runtime_error("Something went wrong during the loading of libcommoncrypto.so: "+string(dlerror()));
}
struct common_crypto_struct crypto;
crypto.crypto_sign=reinterpret_cast<crypto_sign_func_ptr>(dlsym(handle,"crypto_sign_signature"));
crypto.sha3_512=reinterpret_cast<sha3_512_func_ptr>(dlsym(handle,"sha3"));
char *error=dlerror();
if (error!=NULL) {
dlclose(handle);
throw std::runtime_error("Something went wrong during the loading of symbols from libcommoncrypto.so: "+string(error));
}
common_crypto=crypto;
is_crypto_lib_available=true;
return;
}
#pragma pack(1)
struct vystem_fat_trusted_manifest {
uint8_t sig[8]={'V','y','F','a','t','S','i','g'};
uint16_t manifest_version=VY_COMMON_VERSIONS_MANIFEST;
uint16_t bootloader_version=VY_COMMON_VERSIONS_BOOTLOADER;
uint32_t os_version=VY_COMMON_VERSIONS_OS;
uint8_t fat_hash[64];
uint8_t fat_build_id[32];
uint64_t clusters_count;
uint64_t bytes_per_sector;
uint64_t sectors_per_cluster;
uint64_t fat_size_bytes;
uint64_t fat_offset_bytes;
uint64_t bootloader_cluster_count;
uint64_t bootloader_cluster_offset;
uint64_t bootloader_build_id;
uint8_t fat_header_hash[64];
uint8_t bootloader_binary_hash[64];
uint64_t signature_offset_bytes;
uint64_t signature_size;
uint8_t gpt_disk_guid[16];
uint8_t gpt_efi_part_unique_guid[16];
uint8_t manifest_hash[64];
};
#pragma pack()
#pragma pack(1)
struct fat32_header {
uint8_t BS_JmpBoot[3]={0xeb,0x58,0x90};
uint8_t BS_OEMName[8]={'V','Y','B','U','I','L','D','1'};
uint16_t BPB_BytsPerSec=512;
uint8_t BPB_SecPerClus=1;
uint16_t BPB_RsvdSecCnt=32; // equivalent to 32 clusters
uint8_t BPB_NumFATs=2;
uint16_t BPB_RootEntCnt=0; // always 0 for FAT32
uint16_t BPB_TotSec16=0;
uint8_t BPB_Media=0xF8;
uint16_t BPB_FATSz16=0;
uint16_t BPB_SecPerTrk=0; // set to 0 because guide didn't indicate anything
uint16_t BPB_NumHeads=0; // also set to 0 for same reason, useless on modern hardware
uint32_t BPB_HiddSec=0; // i honestly don't know what value the UEFI firmware expect here, but i pray for it to work
uint32_t BPB_TotSec32; // finally a useful field, amount of SECTORS in the whole fs
uint32_t BPB_FATSz32; // amount of SECTORS in each FAT
uint16_t BPB_ExtFlags=0; // too complicated for now
uint16_t BPB_FSVer=0; // apparentaly not only FAT32 is very old and will never be updated, but current version is 0.0
uint32_t BPB_RootClus=2; // root directory cluster
uint16_t BPB_FSInfo=1; // this is an offset
uint16_t BPB_BkBootSec=6; // this is also an offset
uint8_t BPB_Reserved[12]={0}; // i wonder why so much useles space waster into reserved fields
uint8_t BS_DrvNum=0x80; // hope this will work on UEFI firmware, i hate retrocompatibility, it lead to useles thing
uint8_t BS_Reserved=0; // another useles field
uint8_t BS_BootSig=0x29; // another signature
uint32_t BS_VolID=0; // the guide want me to put a date and time here, but too bad, i'm lazy
uint8_t BS_VolLab[11]={'V','Y','A','U','T','O','F','A','T','3','2'}; // yay, my custom volume label fit!
uint8_t BS_FilSysType[8]={'F','A','T','3','2',' ',' ',' '}; // ok why not
uint8_t BS_BootCode32[420]={0}; // who the fuck think this is a good idea to put a field so large into a fs header ?!
uint16_t BS_Sign=0xAA55; // another signature
}; // yeah, exactly 512 bytes
#pragma pack()
#define ENTRY_FLAG_RO 0x01
#define ENTRY_FLAG_HIDDEN 0x02
#define ENTRY_FLAG_SYSTEM 0x04
#define ENTRY_FLAG_VOL_ID 0x08
#define ENTRY_FLAG_IS_DIR 0x10
#define ENTRY_FLAG_ARCHIVE 0x20
#define ENTRY_FLAG_LFN 0x0F
#pragma pack(1)
struct dir_entry {
char name[11];
uint8_t attributes;
uint8_t sfn_flags=0;
uint8_t creation_time_tenth=0;
uint16_t creation_time=0;
uint16_t creation_date=0;
uint16_t last_access_date=0;
uint16_t upper_part_first_cluster;
uint16_t last_time_change=0;
uint16_t last_data_change=0;
uint16_t lower_part_first_cluster=0;
uint32_t file_size=0;
};
#pragma pack()
#pragma pack(1)
struct fat32_fsinfo {
uint32_t FSI_LeadSig=0x41615252;
uint8_t FSI_Reserved1[480]={0}; // what the actual fuck is this... i think we have a new record
uint32_t FSI_StrucSig=0x61417272;
uint32_t FSI_Free_Count=0xFFFFFFFF;
uint32_t FSI_Nxt_Free=0xFFFFFFFF;
uint8_t FSI_Reserved2[12]={0};
uint32_t FSI_TrailSig=0xAA550000;
};
#pragma pack()
struct fat32_container {
fat32_header header;
uint64_t fat_start_sector=header.BPB_RsvdSecCnt;
uint64_t fat_total_sectors; // complete it with header.BPB_FATSz32 * header.BPB_NumFATs, amount of sectors in all FATs
uint64_t data_start_sector; // complete with header.BPB_RsvdSecCnt + fat_total_sectors
uint64_t data_total_sectors; // complete with header.BPB_TotSec32 - data_start_sector
uint64_t clusters_count; // complete with data_total_sectors / header.BPB_SecPerClus
uint64_t root_clusters_sector;
vector<uint8_t> fat;
vector<uint8_t> data;
fat32_fsinfo fsinfo;
};
map<string,fat32_container> fs_map;
vector<uint8_t> get_urandom(size_t n) {
vector<uint8_t> out(n);
ifstream urandom("/dev/urandom",ios::binary);
if (!urandom.is_open()) {
throw runtime_error("Couldn't open /dev/urandom.");
}
urandom.read(reinterpret_cast<char*>(out.data()),n);
if (urandom.gcount()!=static_cast<streamsize>(n)) {
throw runtime_error("Coudln't open /dev/urandom.");
}
return out;
}
void read_sector(uint8_t *buf_start_ptr,size_t sector_index,uint8_t* out_buf) {
size_t byte_offset=sector_index*512;
memcpy(out_buf,buf_start_ptr+byte_offset,512);
return;
}
void write_sector(uint8_t *buf_start_ptr,size_t sector_index,uint8_t* in_buf) {
size_t byte_offset=sector_index*512;
memcpy(buf_start_ptr+byte_offset,in_buf,512);
return;
}
uint32_t fat_read_entry(fat32_container& cont,uint32_t cluster) {
if (cluster>=cont.clusters_count+2) throw std::runtime_error("FAT cluster out of bounds");
size_t offset=cluster*4;
uint32_t value;
memcpy(&value,cont.fat.data()+offset,4);
return value & 0x0FFFFFFF;
}
void fat_write_entry(fat32_container& cont,uint32_t cluster,uint32_t value) {
if (cluster>=cont.clusters_count+2) throw std::runtime_error("FAT cluster out of bounds");
size_t offset=cluster*4;
value&=0x0FFFFFFF;
memcpy(cont.fat.data()+offset,&value,4);
return;
}
vystem_fat_trusted_manifest generate_manifest(fat32_container& cont,string disk_guid_var,string efi_part_unique_guid_var) {
if (!is_crypto_lib_available) throw std::runtime_error("Crypto library isn't available.");
if (vftm_target_offset==0) throw std::runtime_error("VFTM target isn't set.");
int zero_bytes=0;
for (int i=0;i<sizeof(manifest_keypair);i++) {
if (manifest_keypair[i]==0) {
zero_bytes++;
} else {
break;
}
}
if (zero_bytes==sizeof(manifest_keypair)) throw std::runtime_error("VFTM keypair isn't set.");
vystem_fat_trusted_manifest vftm;
uint32_t *f1=(uint32_t*)cont.fat.data();
f1[0]=f1[1]=0;
common_crypto.sha3_512(cont.fat.data(),cont.fat.size(),vftm.fat_hash,sizeof(vftm.fat_hash));
fat_write_entry(cont,0,0x0FFFFFF8);
fat_write_entry(cont,1,0xFFFFFFFF);
auto fat_build_id=get_urandom(sizeof(vftm.fat_build_id));
memcpy(vftm.fat_build_id,fat_build_id.data(),fat_build_id.size());
vftm.clusters_count=cont.clusters_count;
vftm.bytes_per_sector=cont.header.BPB_BytsPerSec;
vftm.sectors_per_cluster=cont.header.BPB_SecPerClus;
vftm.fat_size_bytes=cont.fat.size();
vftm.fat_offset_bytes=cont.header.BPB_RsvdSecCnt*cont.header.BPB_BytsPerSec;
vftm.bootloader_cluster_count=vftm_target_content.size()/(cont.header.BPB_BytsPerSec*cont.header.BPB_SecPerClus);
vftm.bootloader_cluster_offset=vftm_target_offset;
auto bootloader_build_id=get_urandom(8);
memcpy(&vftm.bootloader_build_id,&bootloader_build_id,8);
common_crypto.sha3_512(&cont.header,sizeof(cont.header),vftm.fat_header_hash,sizeof(vftm.fat_header_hash));
common_crypto.sha3_512(vftm_target_content.data(),vftm_target_content.size(),vftm.bootloader_binary_hash,sizeof(vftm.bootloader_binary_hash));
vftm.signature_offset_bytes=cont.header.BPB_TotSec32*cont.header.BPB_BytsPerSec;
vftm.signature_size=CRYPTO_BYTES;
auto disk_guid=vybuild::vars::get_global_variable("\\$"+disk_guid_var+"\\$");
auto disk_guid_bytes=vybuild::disk::uuid4_to_bytes(disk_guid);
memcpy(vftm.gpt_disk_guid,disk_guid_bytes.data(),disk_guid_bytes.size());
auto efi_part_unique_guid=vybuild::vars::get_global_variable("\\$"+efi_part_unique_guid_var+"\\$");
auto efi_part_unique_guid_bytes=vybuild::disk::uuid4_to_bytes(efi_part_unique_guid);
memcpy(vftm.gpt_efi_part_unique_guid,efi_part_unique_guid_bytes.data(),efi_part_unique_guid_bytes.size());
common_crypto.sha3_512(&vftm,sizeof(vftm)-64,vftm.manifest_hash,sizeof(vftm.manifest_hash));
return vftm;
}
uint8_t* cluster_ptr(fat32_container& cont,uint32_t cluster) {
size_t sector=(cluster-2)*cont.header.BPB_SecPerClus;
return (uint8_t*)cont.data.data()+sector*512;
}
uint32_t fat_allocate_cluster(fat32_container& cont) {
for (uint32_t i=2;i<cont.clusters_count+2;i++) {
if (fat_read_entry(cont,i)==0) {
fat_write_entry(cont,i,0x0FFFFFFF);
memset(cluster_ptr(cont,i),0,cont.header.BPB_SecPerClus*512);
return i;
}
}
throw std::runtime_error("Fat32 image full.");
}
bool dir_add_entry(fat32_container& cont,uint32_t dir_cluster,dir_entry& entry) {
if (dir_cluster<2 || dir_cluster>=cont.clusters_count+2) throw std::runtime_error("Directory cluster out of bounds.");
dir_entry* entries=reinterpret_cast<dir_entry*>(cluster_ptr(cont,dir_cluster));
size_t max_entries=(cont.header.BPB_SecPerClus*512)/sizeof(dir_entry);
for (size_t i=0;i<max_entries;i++) {
if (entries[i].name[0]==0) {
entries[i]=entry;
return true;
}
}
return false;
}
void vybuild::fat32::create_fat32(string key,size_t size) {
if (size%512!=0) throw std::runtime_error("Fat32 image size isn't a multiple of 512 bytes.");
fat32_container cont;
cont.header.BPB_TotSec32=size/512;
uint32_t fat_sectors=1;
while (true) {
uint64_t data_sectors=cont.header.BPB_TotSec32-cont.header.BPB_RsvdSecCnt-fat_sectors*cont.header.BPB_NumFATs;
uint64_t clusters=data_sectors/cont.header.BPB_SecPerClus;
uint32_t new_fat_sectors=((clusters+2)*4+511)/512;
if (new_fat_sectors==fat_sectors) break;
fat_sectors=new_fat_sectors;
}
cont.header.BPB_FATSz32=fat_sectors;
cont.fat_total_sectors=cont.header.BPB_FATSz32*cont.header.BPB_NumFATs;
cont.data_start_sector=cont.header.BPB_RsvdSecCnt+cont.fat_total_sectors;
cont.data_total_sectors=cont.header.BPB_TotSec32-cont.data_start_sector;
cont.clusters_count=cont.data_total_sectors/cont.header.BPB_SecPerClus;
cont.root_clusters_sector=cont.data_start_sector+(cont.header.BPB_RootClus-2)*cont.header.BPB_SecPerClus;
cont.fat.resize(cont.header.BPB_FATSz32*512);
memset(cont.fat.data(),0,cont.fat.size());
fat_write_entry(cont,0,0x0FFFFFF8);
fat_write_entry(cont,1,0xFFFFFFFF);
fat_write_entry(cont,2,0x0FFFFFFF);
cont.data.resize(cont.data_total_sectors*512);
memset(cont.data.data(),0,cont.data.size());
memset(cluster_ptr(cont,2),0,cont.header.BPB_SecPerClus*512);
dir_entry label{};
memset(label.name,' ',11);
memcpy(label.name,"VYAUTOFAT32",11);
label.attributes=ENTRY_FLAG_VOL_ID;
label.lower_part_first_cluster=0;
label.upper_part_first_cluster=0;
label.file_size=0;
dir_add_entry(cont,2,label);
fs_map[key]=cont;
return;
}
uint32_t path_find_dir_cluster(fat32_container& cont,string& path) {
if (path.empty() || path[0]!='/') throw std::runtime_error("Path must be absolute.");
if (path=="/") return 2;
uint32_t current_cluster=2;
size_t pos=1;
while (pos<path.size()) {
size_t next=path.find('/',pos);
string part=(next==string::npos)?path.substr(pos):path.substr(pos,next-pos);
char fat_name[11];
memset(fat_name,' ',11);
memcpy(fat_name,part.c_str(),min<size_t>(part.size(),8));
dir_entry* entries=reinterpret_cast<dir_entry*>(cluster_ptr(cont,current_cluster));
size_t max_entries=(cont.header.BPB_SecPerClus*512)/sizeof(dir_entry);
bool found=false;
for (size_t i=0;i<max_entries;i++) {
if (entries[i].name[0]==0) break;
if (!(entries[i].attributes & ENTRY_FLAG_IS_DIR)) continue;
if (memcmp(entries[i].name,fat_name,11)==0) {
current_cluster=(uint32_t(entries[i].upper_part_first_cluster)<<16)|entries[i].lower_part_first_cluster;
found=true;
break;
}
}
if (!found) return 0;
if (next==string::npos) break;
pos=next+1;
}
return current_cluster;
}
uint32_t create_dir_path(fat32_container& cont,string& parent_folder,string& dir_name) {
uint32_t parent_cluster=path_find_dir_cluster(cont,parent_folder);
if (parent_cluster==0) throw std::runtime_error("Parent folder not found: "+parent_folder);
uint32_t new_cluster=fat_allocate_cluster(cont);
dir_entry entry{};
memset(entry.name,' ', 11);
memcpy(entry.name,dir_name.c_str(),min<size_t>(dir_name.size(),8));
memcpy(entry.name+8," ",3);
entry.attributes=ENTRY_FLAG_IS_DIR;
entry.lower_part_first_cluster=new_cluster&0xFFFF;
entry.upper_part_first_cluster=new_cluster>>16;
entry.file_size=0;
if (!dir_add_entry(cont,parent_cluster,entry)) throw std::runtime_error("Parent directory full.");
dir_entry dot{};
memset(dot.name,' ',11);
memcpy(dot.name,". ",11);
dot.attributes=ENTRY_FLAG_IS_DIR;
dot.lower_part_first_cluster=new_cluster&0xFFFF;
dot.upper_part_first_cluster=new_cluster>>16;
dot.file_size=0;
dir_entry dotdot{};
memset(dotdot.name,' ',11);
memcpy(dotdot.name,".. ",11);
dotdot.attributes=ENTRY_FLAG_IS_DIR;
dotdot.lower_part_first_cluster=parent_cluster&0xFFFF;
dotdot.upper_part_first_cluster=parent_cluster>>16;
dotdot.file_size=0;
dir_add_entry(cont,new_cluster,dot);
dir_add_entry(cont,new_cluster,dotdot);
return new_cluster;
}
uint32_t create_dir(fat32_container& cont,string& full_path) {
if (full_path.empty() || full_path[0]!='/') throw std::runtime_error("Path must be absolute.");
size_t last_slash=full_path.find_last_of('/');
if (last_slash==string::npos) throw std::runtime_error("Invalid path.");
string parent=(last_slash==0)?"/":full_path.substr(0,last_slash);
string dir_name=full_path.substr(last_slash+1);
if (dir_name.empty()) throw std::runtime_error("Directory name is empty.");
return create_dir_path(cont, parent, dir_name);
}
void vybuild::fat32::add_directory_fat32(string key,string full_path) {
if (fs_map.find(key)==fs_map.end()) throw std::runtime_error(key+" isn't a valid Fat32 image key.");
fat32_container& fat=fs_map[key];
create_dir(fat,full_path);
return;
}
uint32_t fat_allocate_chain(fat32_container& cont,uint32_t count) {
if (count==0) throw std::runtime_error("Cluster chain size cannot be zero.");
uint32_t max_cluster=cont.clusters_count+2;
for (uint32_t start=2;start+count<=max_cluster;start++) {
bool free=true;
for (uint32_t i=0;i<count;i++) {
if (fat_read_entry(cont,start+i)!=0) {
free=false;
break;
}
}
if (!free) continue;
for (uint32_t i=0;i<count-1;i++) {
fat_write_entry(cont,start+i,start+i+1);
}
fat_write_entry(cont,start+count-1,0x0FFFFFFF);
size_t cluster_size=cont.header.BPB_SecPerClus*512;
memset(cluster_ptr(cont,start),0,cluster_size*count);
return start;
}
throw std::runtime_error("Not enough contiguous clusters.");
}
uint32_t create_file(fat32_container& cont,string full_path,uint8_t *buffer_in,size_t file_size,bool is_vftm_target) {
if (file_size!=0 && buffer_in==nullptr) throw std::runtime_error("Input buffer is null.");
if (full_path.empty() || full_path[0]!='/') throw std::runtime_error("Path must be absolute.");
size_t last_slash=full_path.find_last_of('/');
if (last_slash==string::npos) throw std::runtime_error("Invalid path.");
string parent=(last_slash==0)?"/":full_path.substr(0,last_slash);
string file_name=full_path.substr(last_slash+1);
if (file_name.empty()) throw std::runtime_error("File name is empty.");
if (file_name.size()>12) throw std::runtime_error("File name including extension is too long.");
size_t dot=file_name.find_last_of('.');
if (dot==string::npos || dot==0) throw std::runtime_error("Invalid file name.");
string name=file_name.substr(0,dot);
string ext=file_name.substr(dot+1);
if (ext.size()>3 || ext.size()==0) throw std::runtime_error("Invalid extension.");
if (name.size()>8 || ext.size()==0) throw std::runtime_error("Invalid file name.");
transform(name.begin(),name.end(),name.begin(),::toupper);
transform(ext.begin(),ext.end(),ext.begin(),::toupper);
uint32_t parent_cluster=path_find_dir_cluster(cont,parent);
if (parent_cluster==0) throw std::runtime_error("Parent folder doesn't exist.");
uint32_t cluster_size=cont.header.BPB_SecPerClus*512;
uint32_t cluster_count=max<uint32_t>(1,(file_size+cluster_size-1)/cluster_size);
uint32_t start_cluster=fat_allocate_chain(cont,cluster_count);
dir_entry entry{};
memset(entry.name,' ',11);
memcpy(entry.name,name.c_str(),min<size_t>(name.size(),8));
memcpy(entry.name+8,ext.data(),min<size_t>(ext.size(),3));
entry.attributes=ENTRY_FLAG_ARCHIVE;
entry.lower_part_first_cluster=start_cluster&0xFFFF;
entry.upper_part_first_cluster=start_cluster>>16;
entry.file_size=file_size;
if (!dir_add_entry(cont,parent_cluster,entry)) throw std::runtime_error("Parent directory full.");
memcpy(cluster_ptr(cont,start_cluster),buffer_in,file_size);
if (is_vftm_target) {
vftm_target_content.resize(cluster_count*cluster_size,0);
memcpy(vftm_target_content.data(),buffer_in,file_size);
vftm_target_offset=start_cluster;
}
return start_cluster;
}
void vybuild::fat32::add_file_fat32(string key,string full_path,uint8_t *buffer_in,size_t file_size,bool is_vftm_target) {
if (fs_map.find(key)==fs_map.end()) throw std::runtime_error(key+" isn't a valid Fat32 image key.");
fat32_container& fat=fs_map[key];
create_file(fat,full_path,buffer_in,file_size,is_vftm_target);
return;
}
void generate_vftm_sectors(const uint8_t* part_guid,int* s1,int* s2) {
uint32_t h=0x811c9dc5;
for (int i=0;i<16;i++) h=(h^part_guid[i])*0x01000193;
*s1=8+(h%24);
*s2=8+(((h>>16)%23+(*s1-7))%24);
}
void secure_erase(void *address,size_t size) {
explicit_bzero(address,size);
}
vector<uint8_t> export_fat32(fat32_container& cont,bool generate_vftm,string disk_guid_var,string efi_part_unique_guid_var) {
uint32_t total_sectors=cont.header.BPB_TotSec32;
vector<uint8_t> img(total_sectors*512,0);
auto write_sector=[&](uint32_t sector,const void* data,size_t size) {
memcpy(img.data()+sector*512,data,size);
};
write_sector(0,&cont.header,sizeof(cont.header));
write_sector(cont.header.BPB_BkBootSec,&cont.header,sizeof(cont.header));
write_sector(1,&cont.fsinfo,sizeof(cont.fsinfo));
write_sector(cont.header.BPB_BkBootSec+1,&cont.fsinfo,sizeof(cont.fsinfo));
uint32_t fat_size_bytes=cont.header.BPB_FATSz32*512;
uint32_t fat_sector_start=cont.header.BPB_RsvdSecCnt;
memcpy(img.data()+fat_sector_start*512,cont.fat.data(),fat_size_bytes);
uint32_t fat2_sector_start=fat_sector_start+cont.header.BPB_FATSz32;
memcpy(img.data()+fat2_sector_start*512,cont.fat.data(),fat_size_bytes);
uint32_t data_sector_start=cont.data_start_sector;
memcpy(img.data()+data_sector_start*512,cont.data.data(),cont.data.size());
if (generate_vftm) {
auto efi_part_unique_guid=vybuild::vars::get_global_variable("\\$"+efi_part_unique_guid_var+"\\$");
auto efi_part_unique_guid_bytes=vybuild::disk::uuid4_to_bytes(efi_part_unique_guid);
auto vftm=generate_manifest(cont,disk_guid_var,efi_part_unique_guid_var);
int manifest_sector,pk_manifest_sector;
generate_vftm_sectors((uint8_t*)efi_part_unique_guid_bytes.data(),&manifest_sector,&pk_manifest_sector);
uint8_t signature_manifest[CRYPTO_BYTES];
size_t siglen;
if (common_crypto.crypto_sign(signature_manifest,&siglen,(uint8_t*)&vftm,sizeof(vftm),manifest_keypair+CRYPTO_PUBLICKEYBYTES)) {
secure_erase(manifest_keypair,sizeof(manifest_keypair));
throw std::runtime_error("Couldn't sign VFTM.");
}
if (siglen!=CRYPTO_BYTES) {
secure_erase(manifest_keypair,sizeof(manifest_keypair));
throw std::runtime_error("The returned signature isn't the expected size.");
}
secure_erase(manifest_keypair+CRYPTO_PUBLICKEYBYTES,CRYPTO_SECRETKEYBYTES);
memcpy(img.data()+manifest_sector*cont.header.BPB_BytsPerSec,&vftm,sizeof(vftm));
memcpy(img.data()+pk_manifest_sector*cont.header.BPB_BytsPerSec,manifest_keypair,CRYPTO_PUBLICKEYBYTES);
img.resize(img.size()+CRYPTO_BYTES);
memcpy(img.data()+vftm.signature_offset_bytes,signature_manifest,CRYPTO_BYTES);
}
return img;
}
vector<uint8_t> vybuild::fat32::export_fat32(string key,bool generate_vftm,string disk_guid_var,string efi_part_unique_guid_var) {
if (fs_map.find(key)==fs_map.end()) throw std::runtime_error(key+" isn't a valid Fat32 image key.");
fat32_container& fat=fs_map[key];
return export_fat32(fat,generate_vftm,disk_guid_var,efi_part_unique_guid_var);
}
Reference in New Issue View Git Blame Copy Permalink