#ifdef __APPLE__
#include <CommonCrypto/CommonDigest.h>
+
#define LDID_SHA1_DIGEST_LENGTH CC_SHA1_DIGEST_LENGTH
#define LDID_SHA1 CC_SHA1
#define LDID_SHA1_CTX CC_SHA1_CTX
#define LDID_SHA1_Init CC_SHA1_Init
#define LDID_SHA1_Update CC_SHA1_Update
#define LDID_SHA1_Final CC_SHA1_Final
+
+#define LDID_SHA256_DIGEST_LENGTH CC_SHA256_DIGEST_LENGTH
+#define LDID_SHA256 CC_SHA256
+#define LDID_SHA256_CTX CC_SHA256_CTX
+#define LDID_SHA256_Init CC_SHA256_Init
+#define LDID_SHA256_Update CC_SHA256_Update
+#define LDID_SHA256_Final CC_SHA256_Final
#else
#include <openssl/sha.h>
+
#define LDID_SHA1_DIGEST_LENGTH SHA_DIGEST_LENGTH
#define LDID_SHA1 SHA1
#define LDID_SHA1_CTX SHA_CTX
#define LDID_SHA1_Init SHA1_Init
#define LDID_SHA1_Update SHA1_Update
#define LDID_SHA1_Final SHA1_Final
+
+#define LDID_SHA256_DIGEST_LENGTH SHA256_DIGEST_LENGTH
+#define LDID_SHA256 SHA256
+#define LDID_SHA256_CTX SHA256_CTX
+#define LDID_SHA256_Init SHA256_Init
+#define LDID_SHA256_Update SHA256_Update
+#define LDID_SHA256_Final SHA256_Final
#endif
#ifndef LDID_NOPLIST
#define BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED 0xb0
#define BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB 0xc0
-inline void get(std::streambuf &stream, void *data, size_t size) {
- _assert(stream.sgetn(static_cast<char *>(data), size) == size);
+static std::streamsize read(std::streambuf &stream, void *data, size_t size) {
+ auto writ(stream.sgetn(static_cast<char *>(data), size));
+ _assert(writ >= 0);
+ return writ;
+}
+
+static inline void get(std::streambuf &stream, void *data, size_t size) {
+ _assert(read(stream, data, size) == size);
}
-inline void put(std::streambuf &stream, const void *data, size_t size) {
+static inline void put(std::streambuf &stream, const void *data, size_t size) {
_assert(stream.sputn(static_cast<const char *>(data), size) == size);
}
-inline void pad(std::streambuf &stream, size_t size) {
+static size_t most(std::streambuf &stream, void *data, size_t size) {
+ size_t total(size);
+ while (size > 0)
+ if (auto writ = read(stream, data, size))
+ size -= writ;
+ else break;
+ return total - size;
+}
+
+static inline void pad(std::streambuf &stream, size_t size) {
char padding[size];
memset(padding, 0, size);
put(stream, padding, size);
uint8_t spare1;
uint8_t pageSize;
uint32_t spare2;
+ uint32_t scatterOffset;
+ uint32_t teamIDOffset;
+ uint32_t spare3;
+ uint64_t codeLimit64;
} _packed;
#ifndef LDID_NOFLAGT
}
};
+class Hash {
+ public:
+ char sha1_[LDID_SHA1_DIGEST_LENGTH];
+ char sha256_[LDID_SHA256_DIGEST_LENGTH];
+
+ operator std::vector<char>() const {
+ return {sha1_, sha1_ + sizeof(sha1_)};
+ }
+};
+
class HashBuffer :
public std::streambuf
{
private:
- std::vector<char> &hash_;
- LDID_SHA1_CTX context_;
+ Hash &hash_;
+
+ LDID_SHA1_CTX sha1_;
+ LDID_SHA256_CTX sha256_;
public:
- HashBuffer(std::vector<char> &hash) :
+ HashBuffer(Hash &hash) :
hash_(hash)
{
- LDID_SHA1_Init(&context_);
+ LDID_SHA1_Init(&sha1_);
+ LDID_SHA256_Init(&sha256_);
}
~HashBuffer() {
- hash_.resize(LDID_SHA1_DIGEST_LENGTH);
- LDID_SHA1_Final(reinterpret_cast<uint8_t *>(hash_.data()), &context_);
+ LDID_SHA1_Final(reinterpret_cast<uint8_t *>(hash_.sha1_), &sha1_);
+ LDID_SHA256_Final(reinterpret_cast<uint8_t *>(hash_.sha256_), &sha256_);
}
virtual std::streamsize xsputn(const char_type *data, std::streamsize size) {
- LDID_SHA1_Update(&context_, data, size);
+ LDID_SHA1_Update(&sha1_, data, size);
+ LDID_SHA256_Update(&sha256_, data, size);
return size;
}
std::streambuf &buffer_;
public:
- HashProxy(std::vector<char> &hash, std::streambuf &buffer) :
+ HashProxy(Hash &hash, std::streambuf &buffer) :
HashBuffer(hash),
buffer_(buffer)
{
namespace ldid {
-void Sign(const void *idata, size_t isize, std::streambuf &output, const std::string &identifier, const std::string &entitlements, const std::string &key, const Slots &slots) {
+void Sign(const void *idata, size_t isize, std::streambuf &output, const std::string &identifier, const std::string &entitlements, const std::string &requirement, const std::string &key, const Slots &slots) {
+ std::string team;
+
+#ifndef LDID_NOSMIME
+ if (!key.empty()) {
+ Stuff stuff(key);
+ auto name(X509_get_subject_name(stuff));
+ _assert(name != NULL);
+ auto index(X509_NAME_get_index_by_NID(name, NID_organizationalUnitName, -1));
+ _assert(index >= 0);
+ auto next(X509_NAME_get_index_by_NID(name, NID_organizationalUnitName, index));
+ _assert(next == -1);
+ auto entry(X509_NAME_get_entry(name, index));
+ _assert(entry != NULL);
+ auto asn(X509_NAME_ENTRY_get_data(entry));
+ _assert(asn != NULL);
+ team.assign(reinterpret_cast<char *>(ASN1_STRING_data(asn)), ASN1_STRING_length(asn));
+ }
+#endif
+
Allocate(idata, isize, output, fun([&](const MachHeader &mach_header, size_t size) -> size_t {
size_t alloc(sizeof(struct SuperBlob));
special = std::max(special, CSSLOT_REQUIREMENTS);
alloc += sizeof(struct BlobIndex);
- alloc += 0xc;
+ if (!requirement.empty())
+ alloc += 0xc;
+ else
+ alloc += requirement.size();
if (!entitlements.empty()) {
special = std::max(special, CSSLOT_ENTITLEMENTS);
alloc += sizeof(struct CodeDirectory);
alloc += identifier.size() + 1;
+ if (!team.empty())
+ alloc += team.size() + 1;
+
if (!key.empty()) {
alloc += sizeof(struct BlobIndex);
alloc += sizeof(struct Blob);
if (true) {
std::stringbuf data;
- Blobs requirements;
- put(data, CSMAGIC_REQUIREMENTS, requirements);
+ if (requirement.empty()) {
+ Blobs requirements;
+ put(data, CSMAGIC_REQUIREMENTS, requirements);
+ } else {
+ put(data, requirement.data(), requirement.size());
+ }
insert(blobs, CSSLOT_REQUIREMENTS, data);
}
uint32_t normal((limit + PageSize_ - 1) / PageSize_);
CodeDirectory directory;
- directory.version = Swap(uint32_t(0x00020001));
+ directory.version = Swap(uint32_t(0x00020200));
directory.flags = Swap(uint32_t(0));
- directory.hashOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory) + identifier.size() + 1 + LDID_SHA1_DIGEST_LENGTH * special));
- directory.identOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory)));
directory.nSpecialSlots = Swap(special);
directory.codeLimit = Swap(uint32_t(limit));
directory.nCodeSlots = Swap(normal);
directory.spare1 = 0x00;
directory.pageSize = PageShift_;
directory.spare2 = Swap(uint32_t(0));
+ directory.scatterOffset = Swap(uint32_t(0));
+ directory.spare3 = Swap(uint32_t(0));
+ directory.codeLimit64 = Swap(uint64_t(0));
+
+ uint32_t offset(sizeof(Blob) + sizeof(CodeDirectory));
+
+ directory.identOffset = Swap(uint32_t(offset));
+ offset += identifier.size() + 1;
+
+ if (team.empty())
+ directory.teamIDOffset = Swap(uint32_t(0));
+ else {
+ directory.teamIDOffset = Swap(uint32_t(offset));
+ offset += team.size() + 1;
+ }
+
+ offset += LDID_SHA1_DIGEST_LENGTH * special;
+ directory.hashOffset = Swap(uint32_t(offset));
+ offset += LDID_SHA1_DIGEST_LENGTH * normal;
+
put(data, &directory, sizeof(directory));
put(data, identifier.c_str(), identifier.size() + 1);
+ put(data, team.c_str(), team.size() + 1);
uint8_t storage[special + normal][LDID_SHA1_DIGEST_LENGTH];
uint8_t (*hashes)[LDID_SHA1_DIGEST_LENGTH] = storage + special;
Commit(commit.first, commit.second);
}
-void DiskFolder::Find(const std::string &root, const std::string &base, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)>&code) {
+#ifndef __WIN32__
+std::string readlink(const std::string &path) {
+ for (size_t size(1024); ; size *= 2) {
+ std::string data;
+ data.resize(size);
+
+ int writ(_syscall(::readlink(path.c_str(), &data[0], data.size())));
+ if (size_t(writ) >= size)
+ continue;
+
+ data.resize(writ);
+ return data;
+ }
+}
+#endif
+
+void DiskFolder::Find(const std::string &root, const std::string &base, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)> &code, const Functor<void (const std::string &, const Functor<std::string ()> &)> &link) {
std::string path(Path(root) + base);
DIR *dir(opendir(path.c_str()));
#ifdef __WIN32__
struct stat info;
- _syscall(stat(path.c_str(), &info));
+ _syscall(stat((path + name).c_str(), &info));
if (false);
else if (S_ISDIR(info.st_mode))
directory = true;
case DT_REG:
directory = false;
break;
+ case DT_LNK:
+ link(base + name, fun([&]() { return readlink(path + name); }));
+ continue;
default:
_assert_(false, "d_type=%u", child->d_type);
}
#endif
if (directory)
- Find(root, base + name + "/", code);
+ Find(root, base + name + "/", code, link);
else
code(base + name, fun([&](const Functor<void (std::streambuf &, std::streambuf &)> &code) {
std::string access(root + base + name);
- _assert_(Open(access, fun([&](std::streambuf &data) {
- NullBuffer save;
+ _assert_(Open(access, fun([&](std::streambuf &data, const void *flag) {
+ auto from(path + name);
+ std::filebuf save;
+ commit_[from] = Temporary(save, from);
code(data, save);
})), "open(): %s", access.c_str());
}));
}
}
-void DiskFolder::Save(const std::string &path, const Functor<void (std::streambuf &)> &code) {
+void DiskFolder::Save(const std::string &path, const void *flag, const Functor<void (std::streambuf &)> &code) {
std::filebuf save;
auto from(Path(path));
commit_[from] = Temporary(save, from);
code(save);
}
-bool DiskFolder::Open(const std::string &path, const Functor<void (std::streambuf &)> &code) {
+bool DiskFolder::Open(const std::string &path, const Functor<void (std::streambuf &, const void *)> &code) {
std::filebuf data;
auto result(data.open(Path(path).c_str(), std::ios::binary | std::ios::in));
if (result == NULL)
return false;
_assert(result == &data);
- code(data);
+ code(data, NULL);
return true;
}
-void DiskFolder::Find(const std::string &path, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)>&code) {
- Find(path, "", code);
+void DiskFolder::Find(const std::string &path, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)> &code, const Functor<void (const std::string &, const Functor<std::string ()> &)> &link) {
+ Find(path, "", code, link);
}
#endif
{
}
-void SubFolder::Save(const std::string &path, const Functor<void (std::streambuf &)> &code) {
- return parent_.Save(path_ + path, code);
+void SubFolder::Save(const std::string &path, const void *flag, const Functor<void (std::streambuf &)> &code) {
+ return parent_.Save(path_ + path, flag, code);
}
-bool SubFolder::Open(const std::string &path, const Functor<void (std::streambuf &)> &code) {
+bool SubFolder::Open(const std::string &path, const Functor<void (std::streambuf &, const void *)> &code) {
return parent_.Open(path_ + path, code);
}
-void SubFolder::Find(const std::string &path, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)> &code) {
- return parent_.Find(path_ + path, code);
+void SubFolder::Find(const std::string &path, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)> &code, const Functor<void (const std::string &, const Functor<std::string ()> &)> &link) {
+ return parent_.Find(path_ + path, code, link);
+}
+
+std::string UnionFolder::Map(const std::string &path) {
+ auto remap(remaps_.find(path));
+ if (remap == remaps_.end())
+ return path;
+ return remap->second;
+}
+
+void UnionFolder::Map(const std::string &path, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)> &code, const std::string &file, const Functor<void (const Functor<void (std::streambuf &, const void *)> &)> &save) {
+ if (file.size() >= path.size() && file.substr(0, path.size()) == path)
+ code(file.substr(path.size()), fun([&](const Functor<void (std::streambuf &, std::streambuf &)> &code) {
+ save(fun([&](std::streambuf &data, const void *flag) {
+ parent_.Save(file, flag, fun([&](std::streambuf &save) {
+ code(data, save);
+ }));
+ }));
+ }));
}
UnionFolder::UnionFolder(Folder &parent) :
{
}
-void UnionFolder::Save(const std::string &path, const Functor<void (std::streambuf &)> &code) {
- return parent_.Save(path, code);
+void UnionFolder::Save(const std::string &path, const void *flag, const Functor<void (std::streambuf &)> &code) {
+ return parent_.Save(Map(path), flag, code);
}
-bool UnionFolder::Open(const std::string &path, const Functor<void (std::streambuf &)> &code) {
- auto file(files_.find(path));
- if (file == files_.end())
- return parent_.Open(path, code);
+bool UnionFolder::Open(const std::string &path, const Functor<void (std::streambuf &, const void *)> &code) {
+ auto file(resets_.find(path));
+ if (file == resets_.end())
+ return parent_.Open(Map(path), code);
+ auto &entry(file->second);
- auto &data(file->second);
+ auto &data(entry.first);
data.pubseekpos(0, std::ios::in);
- code(data);
+ code(data, entry.second);
return true;
}
-void UnionFolder::Find(const std::string &path, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)> &code) {
+void UnionFolder::Find(const std::string &path, const Functor<void (const std::string &, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &)> &code, const Functor<void (const std::string &, const Functor<std::string ()> &)> &link) {
parent_.Find(path, fun([&](const std::string &name, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &save) {
- if (files_.find(path + name) == files_.end())
+ if (deletes_.find(path + name) == deletes_.end())
code(name, save);
+ }), fun([&](const std::string &name, const Functor<std::string ()> &read) {
+ if (deletes_.find(path + name) == deletes_.end())
+ link(name, read);
}));
- for (auto &file : files_)
- if (file.first.size() >= path.size() && file.first.substr(0, path.size()) == path)
- code(file.first.substr(path.size()), fun([&](const Functor<void (std::streambuf &, std::streambuf &)> &code) {
- parent_.Save(file.first, fun([&](std::streambuf &save) {
- file.second.pubseekpos(0, std::ios::in);
- code(file.second, save);
- }));
+ for (auto &reset : resets_)
+ Map(path, code, reset.first, fun([&](const Functor<void (std::streambuf &, const void *)> &code) {
+ auto &entry(reset.second);
+ entry.first.pubseekpos(0, std::ios::in);
+ code(entry.first, entry.second);
+ }));
+
+ for (auto &remap : remaps_)
+ Map(path, code, remap.first, fun([&](const Functor<void (std::streambuf &, const void *)> &code) {
+ parent_.Open(remap.second, fun([&](std::streambuf &data, const void *flag) {
+ code(data, flag);
}));
+ }));
}
#ifndef LDID_NOTOOLS
};
#ifndef LDID_NOPLIST
-std::string Bundle(const std::string &root, Folder &folder, const std::string &key, std::map<std::string, std::vector<char>> &remote, const std::string &entitlements) {
+static void Sign(const uint8_t *prefix, size_t size, std::streambuf &buffer, Hash &hash, std::streambuf &save, const std::string &identifier, const std::string &entitlements, const std::string &requirement, const std::string &key, const Slots &slots) {
+ // XXX: this is a miserable fail
+ std::stringbuf temp;
+ put(temp, prefix, size);
+ copy(buffer, temp);
+ auto data(temp.str());
+
+ HashProxy proxy(hash, save);
+ Sign(data.data(), data.size(), proxy, identifier, entitlements, requirement, key, slots);
+}
+
+std::string Bundle(const std::string &root, Folder &folder, const std::string &key, std::set<std::string> &remote, const std::string &entitlements, const std::string &requirement) {
std::string executable;
std::string identifier;
static const std::string info("Info.plist");
- _assert_(folder.Open(info, fun([&](std::streambuf &buffer) {
+ _assert_(folder.Open(info, fun([&](std::streambuf &buffer, const void *flag) {
plist_d(buffer, fun([&](plist_t node) {
executable = plist_s(plist_dict_get_item(node, "CFBundleExecutable"));
identifier = plist_s(plist_dict_get_item(node, "CFBundleIdentifier"));
auto &rules1(versions[""]);
auto &rules2(versions["2"]);
- folder.Open(signature, fun([&](std::streambuf &buffer) {
+ folder.Open(signature, fun([&](std::streambuf &buffer, const void *) {
plist_d(buffer, fun([&](plist_t node) {
// XXX: maybe attempt to preserve existing rules
}));
rules2.insert(Rule{20, NoMode, "^version\\.plist$"});
}
- std::map<std::string, std::vector<char>> local;
+ std::map<std::string, Hash> hashes;
+ std::set<std::string> local;
static Expression nested("^PlugIns/[^/]*\\.appex/Info\\.plist$");
return;
auto bundle(root + Split(name).dir);
SubFolder subfolder(folder, bundle);
- Bundle(bundle, subfolder, key, local, "");
+ Bundle(bundle, subfolder, key, local, "", "");
+ }), fun([&](const std::string &name, const Functor<std::string ()> &read) {
}));
+ std::map<std::string, std::string> links;
+
folder.Find("", fun([&](const std::string &name, const Functor<void (const Functor<void (std::streambuf &, std::streambuf &)> &)> &code) {
// BundleDiskRep::adjustResources -> builder.addExclusion
if (name == executable || Starts(name, directory) || Starts(name, "_MASReceipt/") || name == "CodeResources")
return;
- auto &hash(local[name]);
- if (!hash.empty())
+ if (local.find(name) != local.end())
return;
+ local.insert(name);
+
+ auto &hash(hashes[name]);
code(fun([&](std::streambuf &data, std::streambuf &save) {
+ union {
+ struct {
+ uint32_t magic;
+ uint32_t count;
+ };
+
+ uint8_t bytes[8];
+ } header;
+
+ auto size(most(data, &header.bytes, sizeof(header.bytes)));
+ if (size == sizeof(header.bytes))
+ switch (Swap(header.magic)) {
+ case FAT_MAGIC:
+ // Java class file format
+ if (Swap(header.count) >= 40)
+ break;
+ case FAT_CIGAM:
+ case MH_MAGIC: case MH_MAGIC_64:
+ case MH_CIGAM: case MH_CIGAM_64:
+ Slots slots;
+ Sign(header.bytes, size, data, hash, save, identifier, "", "", key, slots);
+ return;
+ }
+
HashProxy proxy(hash, save);
+ put(proxy, header.bytes, size);
copy(data, proxy);
}));
-
- _assert(hash.size() == LDID_SHA1_DIGEST_LENGTH);
+ }), fun([&](const std::string &name, const Functor<std::string ()> &read) {
+ links[name] = read();
+ local.insert(name);
}));
auto plist(plist_new_dict());
for (const auto &rule : version.second)
rule.Compile();
- for (const auto &hash : local)
+ bool old(&version.second == &rules1);
+
+ for (const auto &hash : hashes)
for (const auto &rule : version.second)
if (rule(hash.first)) {
- if (rule.mode_ == NoMode)
- plist_dict_set_item(files, hash.first.c_str(), plist_new_data(hash.second.data(), hash.second.size()));
- else if (rule.mode_ == OptionalMode) {
+ if (rule.mode_ == NestedMode) {
+ // XXX: implement
+ } else if (rule.mode_ == NoMode && old)
+ plist_dict_set_item(files, hash.first.c_str(), plist_new_data(hash.second.sha1_, sizeof(hash.second.sha1_)));
+ else if (rule.mode_ != OmitMode) {
auto entry(plist_new_dict());
- plist_dict_set_item(entry, "hash", plist_new_data(hash.second.data(), hash.second.size()));
- plist_dict_set_item(entry, "optional", plist_new_bool(true));
+ plist_dict_set_item(entry, "hash", plist_new_data(hash.second.sha1_, sizeof(hash.second.sha1_)));
+ if (!old)
+ plist_dict_set_item(entry, "hash2", plist_new_data(hash.second.sha256_, sizeof(hash.second.sha256_)));
+ if (rule.mode_ == OptionalMode)
+ plist_dict_set_item(entry, "optional", plist_new_bool(true));
plist_dict_set_item(files, hash.first.c_str(), entry);
}
+ break;
+ }
+
+ for (const auto &link : links)
+ for (const auto &rule : version.second)
+ if (rule(link.first)) {
+ if (rule.mode_ == NestedMode) {
+ // XXX: implement
+ } else if (rule.mode_ != OmitMode) {
+ auto entry(plist_new_dict());
+ plist_dict_set_item(entry, "symlink", plist_new_string(link.second.c_str()));
+ if (rule.mode_ == OptionalMode)
+ plist_dict_set_item(entry, "optional", plist_new_bool(true));
+ plist_dict_set_item(files, link.first.c_str(), entry);
+ }
+
break;
}
}
}
}
- folder.Save(signature, fun([&](std::streambuf &save) {
- HashProxy proxy(local[signature], save);
+ folder.Save(signature, NULL, fun([&](std::streambuf &save) {
+ HashProxy proxy(hashes[signature], save);
char *xml(NULL);
uint32_t size;
plist_to_xml(plist, &xml, &size);
put(proxy, xml, size);
}));
- folder.Open(executable, fun([&](std::streambuf &buffer) {
- // XXX: this is a miserable fail
- std::stringbuf temp;
- copy(buffer, temp);
- auto data(temp.str());
-
- folder.Save(executable, fun([&](std::streambuf &save) {
+ folder.Open(executable, fun([&](std::streambuf &buffer, const void *flag) {
+ folder.Save(executable, flag, fun([&](std::streambuf &save) {
Slots slots;
- slots[1] = local.at(info);
- slots[3] = local.at(signature);
-
- HashProxy proxy(local[executable], save);
- Sign(data.data(), data.size(), proxy, identifier, entitlements, key, slots);
+ slots[1] = hashes.at(info);
+ slots[3] = hashes.at(signature);
+ Sign(NULL, 0, buffer, hashes[executable], save, identifier, entitlements, requirement, key, slots);
}));
}));
- for (const auto &hash : local)
- remote[root + hash.first] = hash.second;
+ local.insert(signature);
+ local.insert(executable);
+
+ for (const auto &name : local)
+ remote.insert(root + name);
return executable;
}
+
+std::string Bundle(const std::string &root, Folder &folder, const std::string &key, const std::string &entitlements, const std::string &requirement) {
+ std::set<std::string> local;
+ return Bundle(root, folder, key, local, entitlements, requirement);
+}
#endif
#endif
bool flag_r(false);
bool flag_e(false);
+ bool flag_q(false);
#ifndef LDID_NOFLAGT
bool flag_T(false);
#endif
Map entitlements;
+ Map requirement;
Map key;
ldid::Slots slots;
sha1(slots[number], file.data(), file.size());
} break;
+ case 'q': flag_q = true; break;
+
+ case 'Q': {
+ const char *xml = argv[argi] + 2;
+ requirement.open(xml, O_RDONLY, PROT_READ, MAP_PRIVATE);
+ } break;
+
case 'D': flag_D = true; break;
case 'a': flag_a = true; break;
#ifndef LDID_NOPLIST
_assert(!flag_r);
ldid::DiskFolder folder(path);
- std::map<std::string, std::vector<char>> hashes;
- path += "/" + Bundle("", folder, key, hashes, entitlements);
+ path += "/" + Bundle("", folder, key, entitlements, requirement);
#else
_assert(false);
#endif
ldid::Unsign(input.data(), input.size(), output);
else {
std::string identifier(flag_I ?: split.base.c_str());
- ldid::Sign(input.data(), input.size(), output, identifier, entitlements, key, slots);
+ ldid::Sign(input.data(), input.size(), output, identifier, entitlements, requirement, key, slots);
}
Commit(path, temp);
}
}
+ if (flag_q) {
+ _assert(signature != NULL);
+
+ uint32_t data = mach_header.Swap(signature->dataoff);
+
+ uint8_t *top = reinterpret_cast<uint8_t *>(mach_header.GetBase());
+ uint8_t *blob = top + data;
+ struct SuperBlob *super = reinterpret_cast<struct SuperBlob *>(blob);
+
+ for (size_t index(0); index != Swap(super->count); ++index)
+ if (Swap(super->index[index].type) == CSSLOT_REQUIREMENTS) {
+ uint32_t begin = Swap(super->index[index].offset);
+ struct Blob *requirement = reinterpret_cast<struct Blob *>(blob + begin);
+ fwrite(requirement, 1, Swap(requirement->length), stdout);
+ }
+ }
+
if (flag_s) {
_assert(signature != NULL);
for (size_t index(0); index != Swap(super->count); ++index)
if (Swap(super->index[index].type) == CSSLOT_CODEDIRECTORY) {
uint32_t begin = Swap(super->index[index].offset);
- struct CodeDirectory *directory = reinterpret_cast<struct CodeDirectory *>(blob + begin);
+ struct CodeDirectory *directory = reinterpret_cast<struct CodeDirectory *>(blob + begin + sizeof(Blob));
uint8_t (*hashes)[LDID_SHA1_DIGEST_LENGTH] = reinterpret_cast<uint8_t (*)[LDID_SHA1_DIGEST_LENGTH]>(blob + begin + Swap(directory->hashOffset));
uint32_t pages = Swap(directory->nCodeSlots);
git.ckatri.com / ldid.git / blobdiff