Slightly improve prototypes for Sign and Allocate.

[ldid.git] / ldid.cpp

diff --git a/ldid.cpp b/ldid.cpp
index bf828058419dab13cb0824413c8ae42150b94aae..db0209a887842d0d54239d75878d8e32e9778263 100644 (file)
--- a/ldid.cpp
+++ b/ldid.cpp
@@ -45,19 +45,22 @@
 
 #include <plist/plist.h>
 
 
 #include <plist/plist.h>
 

+#include "ldid.hpp"
+

 #define _assert___(line) \
     #line
 #define _assert__(line) \
     _assert___(line)
 #define _assert___(line) \
     #line
 #define _assert__(line) \
     _assert___(line)

-#define _assert_(e) \
-    throw __FILE__ "(" _assert__(__LINE__) "): _assert(" e ")"

 
 

-#define _assert(expr) \
+#define _assert_(expr, format, ...) \

     do if (!(expr)) { \
     do if (!(expr)) { \

-        fprintf(stderr, "%s(%u): _assert(%s); errno=%u\n", __FILE__, __LINE__, #expr, errno); \
-        _assert_(#expr); \
+        fprintf(stderr, "%s(%u): _assert(): " format "\n", __FILE__, __LINE__, ## __VA_ARGS__); \
+        throw __FILE__ "(" _assert__(__LINE__) "): _assert(" #expr ")"; \

     } while (false)
 
     } while (false)
 

+#define _assert(expr) \
+    _assert_(expr, "%s", #expr)
+

 #define _syscall(expr) ({ \
     __typeof__(expr) _value; \
     do if ((long) (_value = (expr)) != -1) \
 #define _syscall(expr) ({ \
     __typeof__(expr) _value; \
     do if ((long) (_value = (expr)) != -1) \


@@ -66,7 +69,7 @@
         case EINTR: \
             continue; \
         default: \
         case EINTR: \
             continue; \
         default: \

-            _assert(false); \
+            _assert_(false, "errno=%u", errno); \

     } while (true); \
     _value; \
 })
     } while (true); \
     _value; \
 })


@@ -376,6 +379,9 @@ Type_ Align(Type_ value, size_t align) {
     return value;
 }
 
     return value;
 }
 

+static const uint8_t PageShift_(0x0c);
+static const uint32_t PageSize_(1 << PageShift_);
+

 static inline uint16_t Swap_(uint16_t value) {
     return
         ((value >>  8) & 0x00ff) |
 static inline uint16_t Swap_(uint16_t value) {
     return
         ((value >>  8) & 0x00ff) |


@@ -836,7 +842,7 @@ class File {
 
     void open(const char *path, int flags) {
         _assert(file_ == -1);
 
     void open(const char *path, int flags) {
         _assert(file_ == -1);

-        _syscall(file_ = ::open(path, flags));
+        file_ = _syscall(::open(path, flags));

     }
 
     int file() const {
     }
 
     int file() const {


@@ -881,6 +887,10 @@ class Map {
         clear();
     }
 
         clear();
     }
 

+    bool empty() const {
+        return data_ == NULL;
+    }
+

     void open(const char *path, int oflag, int pflag, int mflag) {
         clear();
 
     void open(const char *path, int oflag, int pflag, int mflag) {
         clear();
 


@@ -891,7 +901,7 @@ class Map {
         _syscall(fstat(file, &stat));
         size_ = stat.st_size;
 
         _syscall(fstat(file, &stat));
         size_ = stat.st_size;
 

-        _syscall(data_ = mmap(NULL, size_, pflag, mflag, file, 0));
+        data_ = _syscall(mmap(NULL, size_, pflag, mflag, file, 0));

     }
 
     void open(const char *path, bool edit) {
     }
 
     void open(const char *path, bool edit) {


@@ -914,50 +924,10 @@ class Map {
     }
 };
 
     }
 };
 

-// I wish Apple cared about providing quality toolchains :/
+namespace ldid {

 
 

-template <typename Function_>
-class Functor;
-
-template <typename Type_, typename... Args_>
-class Functor<Type_ (Args_...)> {
-  public:
-    virtual Type_ operator ()(Args_... args) const = 0;
-};
-
-template <typename Function_>
-class FunctorImpl;
-
-template <typename Value_, typename Type_, typename... Args_>
-class FunctorImpl<Type_ (Value_::*)(Args_...) const> :
-    public Functor<Type_ (Args_...)>
-{
-  private:
-    const Value_ *value_;
-
-  public:
-    FunctorImpl() :
-        value_(NULL)
-    {
-    }
-
-    FunctorImpl(const Value_ &value) :
-        value_(&value)
-    {
-    }
-
-    virtual Type_ operator ()(Args_... args) const {
-        return (*value_)(args...);
-    }
-};
-
-template <typename Function_>
-FunctorImpl<decltype(&Function_::operator())> fun(const Function_ &value) {
-    return value;
-}
-
-static void resign(void *idata, size_t isize, std::streambuf &output, const Functor<size_t (size_t)> &allocate, const Functor<size_t (std::streambuf &output, size_t, const std::string &, const char *)> &save) {
-    FatHeader source(idata, isize);
+static void Allocate(const void *idata, size_t isize, std::streambuf &output, const Functor<size_t (size_t)> &allocate, const Functor<size_t (std::streambuf &output, size_t, const std::string &, const char *)> &save) {
+    FatHeader source(const_cast<void *>(idata), isize);

 
     size_t offset(0);
     if (source.IsFat())
 
     size_t offset(0);
     if (source.IsFat())


@@ -1004,7 +974,7 @@ static void resign(void *idata, size_t isize, std::streambuf &output, const Func
 
         allocations.push_back(CodesignAllocation(mach_header, offset, size, limit, alloc, align));
         offset += size + alloc;
 
         allocations.push_back(CodesignAllocation(mach_header, offset, size, limit, alloc, align));
         offset += size + alloc;

-        offset = Align(offset, 16);
+        offset = Align(offset, 0x10);

     }
 
     size_t position(0);
     }
 
     size_t position(0);


@@ -1052,7 +1022,7 @@ static void resign(void *idata, size_t isize, std::streambuf &output, const Func
                         break;
                     size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
                     segment_command->filesize = size;
                         break;
                     size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
                     segment_command->filesize = size;

-                    segment_command->vmsize = Align(size, 0x1000);
+                    segment_command->vmsize = Align(size, PageSize_);

                 } break;
 
                 case LC_SEGMENT_64: {
                 } break;
 
                 case LC_SEGMENT_64: {


@@ -1061,7 +1031,7 @@ static void resign(void *idata, size_t isize, std::streambuf &output, const Func
                         break;
                     size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
                     segment_command->filesize = size;
                         break;
                     size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
                     segment_command->filesize = size;

-                    segment_command->vmsize = Align(size, 0x1000);
+                    segment_command->vmsize = Align(size, PageSize_);

                 } break;
             }
 
                 } break;
             }
 


@@ -1130,6 +1100,8 @@ static void resign(void *idata, size_t isize, std::streambuf &output, const Func
     }
 }
 
     }
 }
 

+}
+

 typedef std::map<uint32_t, std::string> Blobs;
 
 static void insert(Blobs &blobs, uint32_t slot, const std::stringbuf &buffer) {
 typedef std::map<uint32_t, std::string> Blobs;
 
 static void insert(Blobs &blobs, uint32_t slot, const std::stringbuf &buffer) {


@@ -1287,11 +1259,10 @@ class Signature {
     }
 };
 
     }
 };
 

-void resign(void *idata, size_t isize, std::streambuf &output, const std::string &name, const std::string &entitlements, const std::string &key) {
-    uint8_t pageshift(0x0c);
-    uint32_t pagesize(1 << pageshift);
+namespace ldid {

 
 

-    resign(idata, isize, output, fun([&](size_t size) -> size_t {
+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) {
+    Allocate(idata, isize, output, fun([&](size_t size) -> size_t {

         size_t alloc(sizeof(struct SuperBlob));
 
         uint32_t special(0);
         size_t alloc(sizeof(struct SuperBlob));
 
         uint32_t special(0);


@@ -1311,7 +1282,7 @@ void resign(void *idata, size_t isize, std::streambuf &output, const std::string
         alloc += sizeof(struct BlobIndex);
         alloc += sizeof(struct Blob);
         alloc += sizeof(struct CodeDirectory);
         alloc += sizeof(struct BlobIndex);
         alloc += sizeof(struct Blob);
         alloc += sizeof(struct CodeDirectory);

-        alloc += name.size() + 1;
+        alloc += identifier.size() + 1;

 
         if (!key.empty()) {
             alloc += sizeof(struct BlobIndex);
 
         if (!key.empty()) {
             alloc += sizeof(struct BlobIndex);


@@ -1320,7 +1291,10 @@ void resign(void *idata, size_t isize, std::streambuf &output, const std::string
             alloc += 0x3000;
         }
 
             alloc += 0x3000;
         }
 

-        uint32_t normal((size + pagesize - 1) / pagesize);
+        _foreach (slot, slots)
+            special = std::max(special, slot.first);
+
+        uint32_t normal((size + PageSize_ - 1) / PageSize_);

         alloc = Align(alloc + (special + normal) * SHA_DIGEST_LENGTH, 16);
         return alloc;
     }), fun([&](std::streambuf &output, size_t limit, const std::string &overlap, const char *top) -> size_t {
         alloc = Align(alloc + (special + normal) * SHA_DIGEST_LENGTH, 16);
         return alloc;
     }), fun([&](std::streambuf &output, size_t limit, const std::string &overlap, const char *top) -> size_t {


@@ -1347,12 +1321,14 @@ void resign(void *idata, size_t isize, std::streambuf &output, const std::string
             uint32_t special(0);
             _foreach (blob, blobs)
                 special = std::max(special, blob.first);
             uint32_t special(0);
             _foreach (blob, blobs)
                 special = std::max(special, blob.first);

-            uint32_t normal((limit + pagesize - 1) / pagesize);
+            _foreach (slot, slots)
+                special = std::max(special, slot.first);
+            uint32_t normal((limit + PageSize_ - 1) / PageSize_);

 
             CodeDirectory directory;
             directory.version = Swap(uint32_t(0x00020001));
             directory.flags = Swap(uint32_t(0));
 
             CodeDirectory directory;
             directory.version = Swap(uint32_t(0x00020001));
             directory.flags = Swap(uint32_t(0));

-            directory.hashOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory) + name.size() + 1 + SHA_DIGEST_LENGTH * special));
+            directory.hashOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory) + identifier.size() + 1 + SHA_DIGEST_LENGTH * special));

             directory.identOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory)));
             directory.nSpecialSlots = Swap(special);
             directory.codeLimit = Swap(uint32_t(limit));
             directory.identOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory)));
             directory.nSpecialSlots = Swap(special);
             directory.codeLimit = Swap(uint32_t(limit));


@@ -1360,11 +1336,11 @@ void resign(void *idata, size_t isize, std::streambuf &output, const std::string
             directory.hashSize = SHA_DIGEST_LENGTH;
             directory.hashType = CS_HASHTYPE_SHA1;
             directory.spare1 = 0x00;
             directory.hashSize = SHA_DIGEST_LENGTH;
             directory.hashType = CS_HASHTYPE_SHA1;
             directory.spare1 = 0x00;

-            directory.pageSize = pageshift;
+            directory.pageSize = PageShift_;

             directory.spare2 = Swap(uint32_t(0));
             put(data, &directory, sizeof(directory));
 
             directory.spare2 = Swap(uint32_t(0));
             put(data, &directory, sizeof(directory));
 

-            put(data, name.c_str(), name.size() + 1);
+            put(data, identifier.c_str(), identifier.size() + 1);

 
             uint8_t storage[special + normal][SHA_DIGEST_LENGTH];
             uint8_t (*hashes)[SHA_DIGEST_LENGTH] = storage + special;
 
             uint8_t storage[special + normal][SHA_DIGEST_LENGTH];
             uint8_t (*hashes)[SHA_DIGEST_LENGTH] = storage + special;


@@ -1376,11 +1352,16 @@ void resign(void *idata, size_t isize, std::streambuf &output, const std::string
                 sha1((uint8_t *) (hashes - blob.first), local, Swap(local->length));
             }
 
                 sha1((uint8_t *) (hashes - blob.first), local, Swap(local->length));
             }
 

+            _foreach (slot, slots) {
+                _assert(sizeof(*hashes) == slot.second.size());
+                memcpy(hashes - slot.first, slot.second.data(), slot.second.size());
+            }
+

             if (normal != 1)
                 for (size_t i = 0; i != normal - 1; ++i)
             if (normal != 1)
                 for (size_t i = 0; i != normal - 1; ++i)

-                    sha1(hashes[i], (pagesize * i < overlap.size() ? overlap.data() : top) + pagesize * i, pagesize);
+                    sha1(hashes[i], (PageSize_ * i < overlap.size() ? overlap.data() : top) + PageSize_ * i, PageSize_);

             if (normal != 0)
             if (normal != 0)

-                sha1(hashes[normal - 1], top + pagesize * (normal - 1), ((limit - 1) % pagesize) + 1);
+                sha1(hashes[normal - 1], top + PageSize_ * (normal - 1), ((limit - 1) % PageSize_) + 1);

 
             put(data, storage, sizeof(storage));
 
 
             put(data, storage, sizeof(storage));
 


@@ -1406,14 +1387,16 @@ void resign(void *idata, size_t isize, std::streambuf &output, const std::string
     }));
 }
 
     }));
 }
 

-static void resign(void *idata, size_t isize, std::streambuf &output) {
-    resign(idata, isize, output, fun([](size_t size) -> size_t {
+static void Unsign(void *idata, size_t isize, std::streambuf &output) {
+    Allocate(idata, isize, output, fun([](size_t size) -> size_t {

         return 0;
     }), fun([](std::streambuf &output, size_t limit, const std::string &overlap, const char *top) -> size_t {
         return 0;
     }));
 }
 
         return 0;
     }), fun([](std::streambuf &output, size_t limit, const std::string &overlap, const char *top) -> size_t {
         return 0;
     }));
 }
 

+}
+

 int main(int argc, char *argv[]) {
     OpenSSL_add_all_algorithms();
 
 int main(int argc, char *argv[]) {
     OpenSSL_add_all_algorithms();
 


@@ -1447,6 +1430,7 @@ int main(int argc, char *argv[]) {
 
     Map entitlements;
     Map key;
 
     Map entitlements;
     Map key;

+    ldid::Slots slots;

 
     std::vector<std::string> files;
 
 
     std::vector<std::string> files;
 


@@ -1462,14 +1446,33 @@ int main(int argc, char *argv[]) {
         if (argv[argi][0] != '-')
             files.push_back(argv[argi]);
         else switch (argv[argi][1]) {
         if (argv[argi][0] != '-')
             files.push_back(argv[argi]);
         else switch (argv[argi][1]) {

-            case 'r': flag_r = true; break;
+            case 'r':
+                _assert(!flag_s);
+                _assert(!flag_S);
+                flag_r = true;
+            break;
+

             case 'e': flag_e = true; break;
 
             case 'e': flag_e = true; break;
 

+            case 'E': {
+                const char *slot = argv[argi] + 2;
+                const char *colon = strchr(slot, ':');
+                _assert(colon != NULL);
+                Map file(colon + 1, O_RDONLY, PROT_READ, MAP_PRIVATE);
+                char *arge;
+                unsigned number(strtoul(slot, &arge, 0));
+                _assert(arge == colon);
+                std::string &hash(slots[number]);
+                hash.resize(SHA_DIGEST_LENGTH);
+                sha1(reinterpret_cast<uint8_t *>(&hash[0]), file.data(), file.size());
+            } break;
+

             case 'D': flag_D = true; break;
 
             case 'a': flag_a = true; break;
 
             case 'A':
             case 'D': flag_D = true; break;
 
             case 'a': flag_a = true; break;
 
             case 'A':

+                _assert(!flag_A);

                 flag_A = true;
                 if (argv[argi][2] != '\0') {
                     const char *cpu = argv[argi] + 2;
                 flag_A = true;
                 if (argv[argi][2] != '\0') {
                     const char *cpu = argv[argi] + 2;


@@ -1484,11 +1487,13 @@ int main(int argc, char *argv[]) {
             break;
 
             case 's':
             break;
 
             case 's':

+                _assert(!flag_r);

                 _assert(!flag_S);
                 flag_s = true;
             break;
 
             case 'S':
                 _assert(!flag_S);
                 flag_s = true;
             break;
 
             case 'S':

+                _assert(!flag_r);

                 _assert(!flag_s);
                 flag_S = true;
                 if (argv[argi][2] != '\0') {
                 _assert(!flag_s);
                 flag_S = true;
                 if (argv[argi][2] != '\0') {


@@ -1521,7 +1526,8 @@ int main(int argc, char *argv[]) {
             break;
         }
 
             break;
         }
 

-    _assert(!flag_S || !flag_r);
+    _assert(flag_S || key.empty());
+    _assert(flag_S || flag_I == NULL);

 
     if (files.empty()) usage: {
         exit(0);
 
     if (files.empty()) usage: {
         exit(0);


@@ -1530,32 +1536,40 @@ int main(int argc, char *argv[]) {
     size_t filei(0), filee(0);
     _foreach (file, files) try {
         const char *path(file.c_str());
     size_t filei(0), filee(0);
     _foreach (file, files) try {
         const char *path(file.c_str());

-        const char *base = strrchr(path, '/');
-
-        std::string dir;
-        if (base != NULL)
-            dir.assign(path, base++ - path + 1);
-        else
-            base = path;
-
-        const char *name(flag_I ?: base);
-        std::string temp;

 
         if (flag_S || flag_r) {
             Map input(path, O_RDONLY, PROT_READ, MAP_PRIVATE);
 
 
         if (flag_S || flag_r) {
             Map input(path, O_RDONLY, PROT_READ, MAP_PRIVATE);
 

-            temp = dir + "." + base + ".cs";
+            std::string dir;
+            const char *base = strrchr(path, '/');
+
+            if (base != NULL)
+                dir.assign(path, base++ - path + 1);
+            else
+                base = path;
+
+            std::string temp(dir + "." + base + ".cs");

             std::filebuf output;
             _assert(output.open(temp.c_str(), std::ios::out | std::ios::trunc | std::ios::binary) == &output);
 
             if (flag_r)
             std::filebuf output;
             _assert(output.open(temp.c_str(), std::ios::out | std::ios::trunc | std::ios::binary) == &output);
 
             if (flag_r)

-                resign(input.data(), input.size(), output);
+                ldid::Unsign(input.data(), input.size(), output);

             else {
             else {

-                resign(input.data(), input.size(), output, name, entitlements, key);
+                std::string identifier(flag_I ?: base);
+                ldid::Sign(input.data(), input.size(), output, identifier, entitlements, key, slots);

             }
             }

+
+            struct stat info;
+            _syscall(stat(path, &info));
+#ifndef __WIN32__
+            _syscall(chown(temp.c_str(), info.st_uid, info.st_gid));
+#endif
+            _syscall(chmod(temp.c_str(), info.st_mode));
+            _syscall(unlink(path));
+            _syscall(rename(temp.c_str(), path));

         }
 
         }
 

-        Map mapping(!temp.empty() ? temp.c_str() : path, flag_T || flag_s);
+        Map mapping(path, flag_T || flag_s);

         FatHeader fat_header(mapping.data(), mapping.size());
 
         _foreach (mach_header, fat_header.GetMachHeaders()) {
         FatHeader fat_header(mapping.data(), mapping.size());
 
         _foreach (mach_header, fat_header.GetMachHeaders()) {


@@ -1616,7 +1630,7 @@ int main(int argc, char *argv[]) {
                     if (Swap(super->index[index].type) == CSSLOT_ENTITLEMENTS) {
                         uint32_t begin = Swap(super->index[index].offset);
                         struct Blob *entitlements = reinterpret_cast<struct Blob *>(blob + begin);
                     if (Swap(super->index[index].type) == CSSLOT_ENTITLEMENTS) {
                         uint32_t begin = Swap(super->index[index].offset);
                         struct Blob *entitlements = reinterpret_cast<struct Blob *>(blob + begin);

-                        fwrite(entitlements + 1, 1, Swap(entitlements->length) - sizeof(struct Blob), stdout);
+                        fwrite(entitlements + 1, 1, Swap(entitlements->length) - sizeof(*entitlements), stdout);

                     }
             }
 
                     }
             }
 


@@ -1639,24 +1653,13 @@ int main(int argc, char *argv[]) {
 
                         if (pages != 1)
                             for (size_t i = 0; i != pages - 1; ++i)
 
                         if (pages != 1)
                             for (size_t i = 0; i != pages - 1; ++i)

-                                sha1(hashes[i], top + 0x1000 * i, 0x1000);
+                                sha1(hashes[i], top + PageSize_ * i, PageSize_);

                         if (pages != 0)
                         if (pages != 0)

-                            sha1(hashes[pages - 1], top + 0x1000 * (pages - 1), ((data - 1) % 0x1000) + 1);
+                            sha1(hashes[pages - 1], top + PageSize_ * (pages - 1), ((data - 1) % PageSize_) + 1);

                     }
             }
         }
 
                     }
             }
         }
 

-        if (!temp.empty()) {
-            struct stat info;
-            _syscall(stat(path, &info));
-#ifndef __WIN32__
-            _syscall(chown(temp.c_str(), info.st_uid, info.st_gid));
-#endif
-            _syscall(chmod(temp.c_str(), info.st_mode));
-            _syscall(unlink(path));
-            _syscall(rename(temp.c_str(), path));
-        }
-

         ++filei;
     } catch (const char *) {
         ++filee;
         ++filei;
     } catch (const char *) {
         ++filee;