[lld-macho] add code signature for native arm64 macOS

[gkm]

Summary

ARM64 macOS requires that a program have an ad hoc signature, otherwise the system will immediately reject it.

[int3]

hm is this that much more convenient than invoking codesign after LLD finishes running in whatever build we're testing?

[thakis]

I think codesign -s also doesn't set the magic "codesigned by linker" bit that makes strip etc work better (and if doesn't work in cross builds from non-mac hosts). I kind of agree that putting this in as is isn't super useful.

(Don't know if you've seen it, but golang has a from scratch impl of this for 1.16 -- and there's ld64 too of course.)

[gkm]

In D96164#2546549, @int3 wrote:

hm is this that much more convenient than invoking codesign after LLD finishes running in whatever build we're testing?

ld64 signs automatically. Config & build systems of all kinds assume that linked programs are runnable. On arm64 macOS, if lld doesn't sign, then programs don't run without explicit codesign -s - ..., and every config & build system needs to be taught that. No thank you.

In D96164#2546586, @thakis wrote:

I think codesign -s also doesn't set the magic "codesigned by linker" bit that makes strip etc work better (and if doesn't work in cross builds from non-mac hosts). I kind of agree that putting this in as is isn't super useful.

FYI, it is super useful for testing self-hosted native arm64 macOS builds of LLVM and other packages (e.g., GNU coreutils). If you don't want it committed to LLVM, that's fine with me. I have been using it productively as a local change and others who want to work on native arm64 macOS can place it at the base of their local diff stacks too.

(Don't know if you've seen it, but golang has a from scratch impl of this for 1.16 -- and there's ld64 too of course.)

I briefly looked at ld64-530 (the most recent Apple code drop), and could not find any code that generates LC_CODE_SIGNATURE. I will look harder this weekend.

[tschuett]

https://go-review.googlesource.com/c/scratch/+/271866/5/cherry/codesign.go

https://go-review.googlesource.com/c/go/+/272256/

[gkm]

In order to perform ad-hoc codesign, I will need to compute sha256 of the program's pages. I see no other part of LLVM that uses a sha256 library. What library should I use?

[tschuett]

Some cmake magic to look for OpenSSL? If you can't find it, give a warning and disable code-signing?

"strip and install_name_tool are aware that what they do will invalidate a code signature, so if they’re operating on a linker-signed Mach-O file, they’ll generate a new linker-signed signature."
https://github.com/golang/go/issues/42684#issuecomment-731594886

The code-signing functionality has to end up being in LLVM eventually for llvm-install-name-tool?

[thakis]

In D96164#2547158, @gkm wrote:

In order to perform ad-hoc codesign, I will need to compute sha256 of the program's pages. I see no other part of LLVM that uses a sha256 library. What library should I use?

LLVM tries to not depend on external libraries if possible. Given that sha256 isn't that much code (https://golang.org/src/crypto/sha256/), just adding a fresh implementation of it (to lld/MachO for now) is probably the way to go.

[smeenai]

In D96164#2547390, @thakis wrote:

In D96164#2547158, @gkm wrote:

In order to perform ad-hoc codesign, I will need to compute sha256 of the program's pages. I see no other part of LLVM that uses a sha256 library. What library should I use?

LLVM tries to not depend on external libraries if possible. Given that sha256 isn't that much code (https://golang.org/src/crypto/sha256/), just adding a fresh implementation of it (to lld/MachO for now) is probably the way to go.

Agreed. There's some prior art here too ... LLVM has a SHA1 implementation in llvm/include/llvm/Support/SHA1.h and llvm/lib/Support/SHA1.cpp. That was adapted from an existing public-domain implementation, and we could do the same here (find a SHA256 implementation with a license that allows it to copied into LLVM).

[gkm]

df>>! In D96164#2547480, @smeenai wrote:

In D96164#2547390, @thakis wrote:

LLVM tries to not depend on external libraries if possible. Given that sha256 isn't that much code (https://golang.org/src/crypto/sha256/), just adding a fresh implementation of it (to lld/MachO for now) is probably the way to go.

Agreed. There's some prior art here too ... LLVM has a SHA1 implementation in llvm/include/llvm/Support/SHA1.h and llvm/lib/Support/SHA1.cpp. That was adapted from an existing public-domain implementation, and we could do the same here (find a SHA256 implementation with a license that allows it to copied into LLVM).

Openssl has a C implementation of sha256 with Apache 2.0 license. Unless someone knows of a better candidate, I'll go with that.

[cynecx]

This comment was removed by cynecx.

[cynecx]

Perhaps this might help: SHA256 impl for LLVM. This is based on botan's sha256 implementation and mimics the current SHA1 api design. It should be compatible with LLVM's license since it's based on botan's implementation, which is BSD-2 licensed.

[gkm]

In D96164#2546586, @thakis wrote:

I think codesign -s also doesn't set the magic "codesigned by linker" bit that makes strip etc work better (and if doesn't work in cross builds from non-mac hosts). I kind of agree that putting this in as is isn't super useful.

Where can I learn about thsi magic "codesigned by linker" bit? My searches are coming-up dry.

[kristof.beyls]

In D96164#2547858, @gkm wrote:

df>>! In D96164#2547480, @smeenai wrote:

In D96164#2547390, @thakis wrote:

LLVM tries to not depend on external libraries if possible. Given that sha256 isn't that much code (https://golang.org/src/crypto/sha256/), just adding a fresh implementation of it (to lld/MachO for now) is probably the way to go.

Agreed. There's some prior art here too ... LLVM has a SHA1 implementation in llvm/include/llvm/Support/SHA1.h and llvm/lib/Support/SHA1.cpp. That was adapted from an existing public-domain implementation, and we could do the same here (find a SHA256 implementation with a license that allows it to copied into LLVM).

Openssl has a C implementation of sha256 with Apache 2.0 license. Unless someone knows of a better candidate, I'll go with that.

I'm afraid that just copying an Apache-2.0 licensed implementation is not an option.

As described at https://llvm.org/docs/DeveloperPolicy.html#relicensing, "....In the interim, all contributions to the project will be made under the terms of both the new license and the legacy license scheme...", so code contributions must be covered by both the new and legacy license scheme.
The SPDX identifier for the new license is "Apache-2.0 WITH LLVM-exception"; for the legacy license it is "NCSA".

Therefore, just copying code that is covered by an Apache-2.0 license into the LLVM code base is not an option I'm afraid.
Apache-2.0 is a different license to "Apache-2.0 with LLVM exception" and to "NCSA".
I guess the most obvious options to get a sha256 implementation into the code base are:

1. get the copyright holder of an existing implementation to contribute it to LLVM, under both the "Apache-2.0 WITH LLVM-exception" and "NCSA" license.
2. write an implementation from scratch and contribute that.

[gkm]

In D96164#2555222, @cynecx wrote:

Perhaps this might help: SHA256 impl for LLVM. This is based on botan's sha256 implementation and mimics the current SHA1 api design. It should be compatible with LLVM's license since it's based on botan's implementation, which is BSD-2 licensed.

This is super helpful! Is it ready to import into LLVM as-is alongside SHA1 ?

[cynecx]

@gkm Is it okay for you if I post a patch which adds a SHA-256 implementation to LLVM? I actually have a patchset ready here. But to answer your question, yes it should be possible to simply drop the files into the right locations.

[cynecx]

@gkm Re: the linker flag. I think they were talking about this (linkerSigned):

	cdir := CodeDirectory{
		magic:        CSMAGIC_CODEDIRECTORY,
		length:       uint32(sz) - uint32(unsafe.Sizeof(SuperBlob{})+unsafe.Sizeof(Blob{})),
		version:      0x20400,
		flags:        0x20002, // adhoc | linkerSigned (0b10)
		hashOffset:   uint32(hashOff),
		identOffset:  uint32(idOff),
		nCodeSlots:   uint32(nhashes),
		codeLimit:    uint32(sigOff),
		hashSize:     sha256.Size,
		hashType:     kSecCodeSignatureHashSHA256,
		pageSize:     uint8(pageSizeBits),
		execSegBase:  textSeg.Offset,
		execSegLimit: textSeg.Filesz,
	}

https://go-review.googlesource.com/c/scratch/+/271866/5/cherry/codesign.go#293

[tschuett]

flags:        0x20002, // adhoc | linkerSigned (0b10)

from cs_blobs.h

#define CS_ADHOC                    0x00000002  /* ad hoc signed */
#define CS_LINKER_SIGNED            0x00020000  /* Automatically signed by the linker */

[cynecx]

SHA256 patch is up here: https://reviews.llvm.org/D96540.

[gkm]

• drop the fork+exec of /usr/bin/codesign and rewrite in C++

[gkm]

• remove SHA256, which is added separately in D96540

[tschuett]

lld/MachO/SyntheticSections.cpp

927

Would it help readability to change this to:
CS_ADHOC | CS_LINKER_SIGNED ?

[tschuett]

Does codesign.go make any differences?

[cynecx]

Hmm, this is indeed very weird. I have seen "similar" behavior with codesign. codesign can actually fail. The only way to "get it working" again is to copy the file and codesign the copy, then replacing the original file (a different inode fixes codesigning).

Does the segfault happen with each linking step?

[gkm]

In D96164#2562426, @cynecx wrote:

Hmm, this is indeed very weird. I have seen "similar" behavior with codesign. codesign can actually fail. The only way to "get it working" again is to copy the file and codesign the copy, then replacing the original file (a different inode fixes codesigning).

Does the segfault happen with each linking step?

Not a segfault. SIGKILL, presumably dyld doing kill(0, SIGKILL) though I haven't yet run it under lldb to confirm.

[gkm]

In D96164#2562311, @tschuett wrote:

Does codesign.go make any differences?

I haven't tried, but I expect it would work. Resigning with /usr/bin/codesign works. Heck, just copying the binary causes it to work!

lld/MachO/SyntheticSections.cpp

927

Those are good things. I intend to find & import headers with those enums.

[thakis]

Re the copy stuff: See the CL desc and openradar link in https://reviews.llvm.org/rGba3bc2fd41b8428904fc779e353d3769074d8982

[gkm]

In D96164#2562655, @thakis wrote:

Re the copy stuff: See the CL desc and openradar link in https://reviews.llvm.org/rGba3bc2fd41b8428904fc779e353d3769074d8982

That is good to know. This case differs: LLD is not overwriting an existing file, so is not reusing an vnode.

There is something funky in FileOutputBuffer, which creates the LLD output file via mmap(2). When I force it to avoid mmap, all is well. For now, I will work-around by passing the flag F_no_mmap when signing.

[gkm]

In D96164#2562701, @gkm wrote:

In D96164#2562655, @thakis wrote:

Re the copy stuff: See the CL desc and openradar link in https://reviews.llvm.org/rGba3bc2fd41b8428904fc779e353d3769074d8982

That is good to know. This case differs: LLD is not overwriting an existing file, so is not reusing an vnode. There is something funky in FileOutputBuffer, which creates the LLD output file via mmap(2).

Travis Hill <[e-mail]> fed me the answer. The Go peeps had the same problem: https://go-review.googlesource.com/c/go/+/272258
The Darwin kernel caches signature verification results by vnode. mmap(2) creates the cache entry, before we have written anything to the output. The fix is to invalidate the cache after writing via msync(..., MS_INVALIDATE);

[gkm]

• Invalidate signature-verification cache after writing hashes.
• replace CodeSigningTypes.h with augmented cs_blobs.h
• use appropriate constant symbols from cs_blobs.h rather than magic integers

[thakis]

In D96164#2562720, @gkm wrote:

In D96164#2562701, @gkm wrote:

In D96164#2562655, @thakis wrote:

Re the copy stuff: See the CL desc and openradar link in https://reviews.llvm.org/rGba3bc2fd41b8428904fc779e353d3769074d8982

That is good to know. This case differs: LLD is not overwriting an existing file, so is not reusing an vnode. There is something funky in FileOutputBuffer, which creates the LLD output file via mmap(2).

Travis Hill <[e-mail]> fed me the answer. The Go peeps had the same problem: https://go-review.googlesource.com/c/go/+/272258
The Darwin kernel caches signature verification results by vnode. mmap(2) creates the cache entry, before we have written anything to the output. The fix is to invalidate the cache after writing via msync(..., MS_INVALIDATE);

Ah, the mmap one is https://openradar.appspot.com/FB8914231 :)

[gkm]

I could use some advice regarding import of the the Apple C (not C++) header cs_blobs.h:

• Some struct decls contain zero-length array members as offset markers. These are invalid C++, and LLD doesn't need them.
• Some struct decls contain flexible array members. These are invalid C++, and LLD doesn't need them.
• Some flag bit sets are specified via sequences of #define. LLVM prefers enum.
• All struct decls have __attribute__((aligned(1))). LLD does not need or want these.
• Struct definition pattern is typedef struct __TAG { ... } NAME; C++ prefers struct NAME { ... };
• The linter complains about case style for struct names.

Questions:

• Should we make minimal edits to get proper compilation & semantics and leave all the other warts as-is?
• Or, should we be boldly invasive and make it conform to C++ and LLVM style, silencing the linter?
• What is best practice regarding header imports that require surgery? It seems wise to import the unaltered Apple header first via a preparatory commit (without a diff? unreviewed?), and then commit this diff with the changes to make it conform to C++ & LLVM style.

[tschuett]

Feel free to ignore me, but:
https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/BinaryFormat/MachO.h
seems to be inspired by the Apple headers. It is not a one-to-one copy.

[gkm]

In D96164#2563794, @tschuett wrote:

https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/BinaryFormat/MachO.h
seems to be inspired by the Apple headers. It is not a one-to-one copy.

This seems like a good option to me: don't import cs_blobs.h at all, but rather adapt & append the necessary codesigning definitions to existing llvm/include/llvm/BinaryFormat/MachO.h.

[thakis]

• What is best practice regarding header imports that require surgery? It seems wise to import the unaltered Apple header first via a preparatory commit (without a diff? unreviewed?), and then commit this diff with the changes to make it conform to C++ & LLVM style.

There are currently 0 hits for APPLE_LICENSE_HEADER in llvm's codebase. I'm guessing that's not a coincidence :)

[gkm]

• import code signing structs & enums into llvm/include/llvm/BinaryFormat/MachO.h

[cynecx]

lld/MachO/SyntheticSections.h

489

constexpr?

491

Since we are currently hard-wiring sha256, we should just use the appropriate constant here.

llvm/include/llvm/BinaryFormat/MachO.h

2151

Can we add some static_asserts for these structs to ensure that they have the correct size? (In case the compiler does weird things)

[cynecx]

lld/MachO/SyntheticSections.h

491

Oh crap. The constant is actually private. Nvm then. Perhaps add a comment then?

[gkm]

lld/MachO/SyntheticSections.h

491

SHA256::HASH_LENGTH is defined as 20, which is 160 bits. I am confused.

[cynecx]

lld/MachO/SyntheticSections.h

491

No? See https://github.com/llvm/llvm-project/blob/9fa11201618d8ad3a978815d90d3e64d8e0fa310/llvm/include/llvm/Support/SHA256.h#L65

[gkm]

lld/MachO/SyntheticSections.h

491

Better. I had a stale version of SHA256.cpp loaded in emacs. No clue where that came from.

[gkm]

lld/MachO/SyntheticSections.h

489

Comments elsewhere say that static constexpr members are broken in MSC, so I avoided them.

[cynecx]

lld/MachO/SyntheticSections.h

489

I think those comments are outdated because according to https://llvm.org/docs/GettingStarted.html#host-c-toolchain-both-compiler-and-standard-library, llvm requires >= Visual Studio 2017, which iirc properly supports constexpr. Also there are many places where llvm code utilizes "static constexpr".

[gkm]

• revise according to review feedback

[int3]

lgtm, will like @cynecx sign off

lld/MachO/SyntheticSections.cpp

882

FWIW, StringRef::size() is O(1), so storing it isn't really necessary. But if you did this because it looks more uniform, that's fine too

910–912

would be good to link to https://openradar.appspot.com/FB8914231

917

I think we already included this namespace at the top of the file

943

JFYI, there are several other places in the code that assume that the mmap'ed buf is initialized to all zeroes. I couldn't find any docs that guarantee that behavior, but it seems to work in practice. That said it doesn't hurt to be explicit

lld/MachO/Writer.cpp

790–794

is this necessary? I don't think hashing a few extra zero bytes makes a difference

[gkm]

• revise according to review feedback

[gkm]

• set version as ... s/0x20400/CS_SUPPORTSEXECSEG/

[int3]

lld/MachO/Writer.cpp

790–794

this doesn't seem done

[gkm]

lld/MachO/Writer.cpp

790–794

Yes. codeEnd abuts the code-signature header, which is not hashed. "A few extra bytes" are significant, whether zero or not, and influence the hash. We stop hashing at codeEnd in order to honor the contract between signer and runtime.

790–794

Oh, sorry. I was confused. This is for UUID, not code-signature. I am playing it safe here: only compute UUID for the image as it is before code signature is added.

How do you prefer I handle this?

[cynecx]

lld/MachO/Writer.cpp

790–794

Isn't codesign doing the exact same thing? So, I guess the current approach is alright.

[gkm]

I won't complain if someone accepts the diff! ;)

lld/MachO/Writer.cpp

790–794

The mechanisms are similar:

• LC_UUID has a minimal header and signs with md5
• LC_CODE_SIGNATURE has a more elaborate header and signs with sha256

The precise use(s) of the UUID is unclear to me, due to lack of documentation. As best I can tell, it is used as a unique identifier for program & library content, i.e., it morphs with every code change. I do not see it used to verify content.

[int3]

lld/MachO/Writer.cpp

790–794

@gkm you forgot to hit submit the first time you replied ;)

yeah the UUID is just used to match .dSYM files with their corresponding executables. It doesn't matter what the value is, or how it's computed, as long as it's deterministic. So I think it's fine to just hash the whole buffer, including the unwritten codesign bits.

[gkm]

• revise according to review feedback

[gkm]

• wrap #if defined(__APPLE__) around <sys/mman.h> and msync()

[int3]

lgtm

[gkm]

• expand some comments, improve some alignment expressions

[gkm]

• final alignment & comment tweaks

[thakis]

Did this land without any tests?

[smeenai]

In D96164#2605092, @thakis wrote:

Did this land without any tests?

Yes, this was an oversight. Thanks for adding a test in D97994.

lld/MachO/OutputSegment.h

void sortOutputSections(
       llvm::function_ref<bool(OutputSection *, OutputSection *)> comparator) {
     llvm::stable_sort(sections, comparator);
   }
 
   const std::vector<OutputSection *> &getSections() const { return sections; }
   size_t numNonHiddenSections() const;
 
   uint64_t fileOff = 0;
+  uint64_t fileSize = 0;
   StringRef name;
   uint32_t maxProt = 0;
   uint32_t initProt = 0;
   uint8_t index;
 
 private:
   std::vector<OutputSection *> sections;
 };

lld/MachO/SyntheticSections.h

 constexpr const char rebase[] = "__rebase";
 constexpr const char binding[] = "__binding";
 constexpr const char weakBinding[] = "__weak_binding";
 constexpr const char lazyBinding[] = "__lazy_binding";
 constexpr const char export_[] = "__export";
 constexpr const char symbolTable[] = "__symbol_table";
 constexpr const char indirectSymbolTable[] = "__ind_sym_tab";
 constexpr const char stringTable[] = "__string_table";
+constexpr const char codeSignature[] = "__code_signature";
 constexpr const char got[] = "__got";
 constexpr const char threadPtrs[] = "__thread_ptrs";
 constexpr const char unwindInfo[] = "__unwind_info";
 // these are not synthetic, but in service of synthetic __unwind_info
 constexpr const char compactUnwind[] = "__compact_unwind";
 constexpr const char ehFrame[] = "__eh_frame";
 // these are not synthetic, but need to be sorted
 constexpr const char text[] = "__text";
public:
 
   // codesign (or more specifically libstuff) checks that each section in
   // __LINKEDIT ends where the next one starts -- no gaps are permitted. We
   // therefore align every section's start and end points to WordSize.
   //
   // NOTE: This assumes that the extra bytes required for alignment can be
   // zero-valued bytes.
   uint64_t getSize() const override final {
-    return llvm::alignTo(getRawSize(), WordSize);
+    return llvm::alignTo(getRawSize(), align);
   }
 };
 
 // The header of the Mach-O file, which must have a file offset of zero.
 class MachHeaderSection : public SyntheticSection {
 public:
   MachHeaderSection();
   void addLoadCommand(LoadCommand *);
public:
   uint32_t getNumSymbols() const;
   uint64_t getRawSize() const override {
     return getNumSymbols() * sizeof(uint32_t);
   }
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 };
 
+// The code signature comes at the very end of the linked output file.
+class CodeSignatureSection : public LinkEditSection {
+public:
+  static constexpr uint8_t blockSizeShift = 12;
+  static constexpr size_t blockSize = (1 << blockSizeShift); // 4 KiB
+  static constexpr size_t hashSize = 256 / sizeof(uint8_t);
+  static constexpr uint32_t blobHeadersSize =
+      sizeof(llvm::MachO::CS_SuperBlob) + sizeof(llvm::MachO::CS_BlobIndex);
+  static constexpr uint32_t fixedHeadersSize =
+      blobHeadersSize + sizeof(llvm::MachO::CS_CodeDirectory);
+
+  uint32_t fileNamePad = 0;
+  uint32_t allHeadersSize = 0;
+  StringRef fileName;
+
+  CodeSignatureSection();
+  uint64_t getRawSize() const override;
+  bool isNeeded() const override { return true; }
+  void writeTo(uint8_t *buf) const override;
+  uint32_t getBlockCount() const;
+  void writeHashes(uint8_t *buf) const;
+};
+
 struct InStruct {
   MachHeaderSection *header = nullptr;
   RebaseSection *rebase = nullptr;
   BindingSection *binding = nullptr;
   WeakBindingSection *weakBinding = nullptr;
   LazyBindingSection *lazyBinding = nullptr;
   ExportSection *exports = nullptr;
   GotSection *got = nullptr;

lld/MachO/SyntheticSections.cpp

 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/SHA256.h"
+
+#include <sys/mman.h>
 
 using namespace llvm;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::macho;
 
 InStruct macho::in;

 
 void StringTableSection::writeTo(uint8_t *buf) const {
   uint32_t off = 0;
   for (StringRef str : strings) {
     memcpy(buf + off, str.data(), str.size());
     off += str.size() + 1; // account for null terminator
   }
 }
+
+CodeSignatureSection::CodeSignatureSection()
+    : LinkEditSection(segment_names::linkEdit, section_names::codeSignature) {
+  align = 16; // required by libstuff
+  fileName = config->outputFile;
+  size_t slashIndex = fileName.rfind("/");
+  if (slashIndex != std::string::npos)
+    fileName = fileName.drop_front(slashIndex + 1);
+  allHeadersSize = alignTo(fixedHeadersSize + fileName.size() + 1, WordSize);
+  fileNamePad = allHeadersSize - fixedHeadersSize - fileName.size();
+}
+
+uint32_t CodeSignatureSection::getBlockCount() const {
+  return (fileOff + blockSize - 1) / blockSize;
+}
+
+uint64_t CodeSignatureSection::getRawSize() const {
+  return allHeadersSize + getBlockCount() * hashSize;
+}
+
+void CodeSignatureSection::writeHashes(uint8_t *buf) const {
+  uint8_t *code = buf;
+  uint8_t *codeEnd = buf + fileOff;
+  uint8_t *hashes = codeEnd + allHeadersSize;
+  while (code < codeEnd) {
+    StringRef block(reinterpret_cast<char *>(code),
+                    std::min(codeEnd - code, static_cast<ssize_t>(blockSize)));
+    SHA256 hasher;
+    hasher.update(block);
+    StringRef hash = hasher.final();
+    assert(hash.size() == hashSize);
+    memcpy(hashes, hash.data(), hashSize);
+    code += blockSize;
+    hashes += hashSize;
+  }
+  // The kernel creates a signature-verification cache entry at
+  // mmap(2) time, before the signature exists. Now that the
+  // signature is written, invalidate the bogus cache entry.
+  // See https://openradar.appspot.com/FB8914231
+  msync(buf, fileOff + getSize(), MS_INVALIDATE);
+}
+
+void CodeSignatureSection::writeTo(uint8_t *buf) const {
+  using namespace llvm::MachO;
+  uint32_t blobHeadersSize = sizeof(CS_SuperBlob) + sizeof(CS_BlobIndex);
+  uint32_t signatureSize = static_cast<uint32_t>(getSize());
+  auto *superBlob = reinterpret_cast<CS_SuperBlob *>(buf);
+  write32be(&superBlob->magic, CSMAGIC_EMBEDDED_SIGNATURE);
+  write32be(&superBlob->length, signatureSize);
+  write32be(&superBlob->count, 1);
+  auto *blobIndex = reinterpret_cast<CS_BlobIndex *>(&superBlob[1]);
+  write32be(&blobIndex->type, CSSLOT_CODEDIRECTORY);
+  write32be(&blobIndex->offset, blobHeadersSize);
+  auto *codeDirectory = reinterpret_cast<CS_CodeDirectory *>(&blobIndex[1]);
+  write32be(&codeDirectory->magic, CSMAGIC_CODEDIRECTORY);
+  write32be(&codeDirectory->length, signatureSize - blobHeadersSize);
+  write32be(&codeDirectory->version, CS_SUPPORTSEXECSEG);
+  write32be(&codeDirectory->flags, CS_ADHOC | CS_LINKER_SIGNED);
+  write32be(&codeDirectory->hashOffset,
+            sizeof(CS_CodeDirectory) + fileName.size() + fileNamePad);
+  write32be(&codeDirectory->identOffset, sizeof(CS_CodeDirectory));
+  codeDirectory->nSpecialSlots = 0;
+  write32be(&codeDirectory->nCodeSlots, getBlockCount());
+  write32be(&codeDirectory->codeLimit, fileOff);
+  codeDirectory->hashSize = static_cast<uint8_t>(hashSize);
+  codeDirectory->hashType = kSecCodeSignatureHashSHA256;
+  codeDirectory->platform = 0;
+  codeDirectory->pageSize = blockSizeShift;
+  codeDirectory->spare2 = 0;
+  codeDirectory->scatterOffset = 0;
+  codeDirectory->teamOffset = 0;
+  codeDirectory->spare3 = 0;
+  codeDirectory->codeLimit64 = 0;
+  OutputSegment *textSeg = getOrCreateOutputSegment(segment_names::text);
+  write64be(&codeDirectory->execSegBase, textSeg->fileOff);
+  write64be(&codeDirectory->execSegLimit, textSeg->fileSize);
+  write64be(&codeDirectory->execSegFlags,
+            config->outputType == MH_EXECUTE ? CS_EXECSEG_MAIN_BINARY : 0);
+  auto *id = reinterpret_cast<char *>(&codeDirectory[1]);
+  memcpy(id, fileName.begin(), fileName.size());
+  memset(id + fileName.size(), 0, fileNamePad);
+}

lld/MachO/Writer.cpp

public:
   void scanSymbols();
   void createOutputSections();
   void createLoadCommands();
   void assignAddresses(OutputSegment *);
 
   void openFile();
   void writeSections();
   void writeUuid();
+  void writeCodeSignature();
 
   void run();
 
   std::unique_ptr<FileOutputBuffer> &buffer;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
   MachHeaderSection *header = nullptr;
   StringTableSection *stringTableSection = nullptr;
   SymtabSection *symtabSection = nullptr;
   IndirectSymtabSection *indirectSymtabSection = nullptr;
+  CodeSignatureSection *codeSignatureSection = nullptr;
   UnwindInfoSection *unwindInfoSection = nullptr;
   LCUuid *uuidCommand = nullptr;
 };
 
 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
 class LCDyldInfo : public LoadCommand {
 public:
   LCDyldInfo(RebaseSection *rebaseSection, BindingSection *bindingSection,
void writeUuid(uint64_t digest) const {
     // bad lie we can put here.
     assert((uuidBuf[6] & 0xf0) == 0x30 && "See RFC 4122 Sections 4.2.2, 4.1.3");
     assert((uuidBuf[8] & 0xc0) == 0x80 && "See RFC 4122 Section 4.2.2");
   }
 
   mutable uint8_t *uuidBuf;
 };
 
+// TODO(gkm): write block comment
+class LCCodeSignature : public LoadCommand {
+public:
+  LCCodeSignature(CodeSignatureSection *section) : section(section) {}
+
+  uint32_t getSize() const override { return sizeof(linkedit_data_command); }
+
+  void writeTo(uint8_t *buf) const override {
+    auto *c = reinterpret_cast<linkedit_data_command *>(buf);
+    c->cmd = LC_CODE_SIGNATURE;
+    c->cmdsize = getSize();
+    c->dataoff = static_cast<uint32_t>(section->fileOff);
+    c->datasize = section->getSize();
+  }
+
+  CodeSignatureSection *section;
+};
+
 } // namespace
 
 static void prepareSymbolRelocation(lld::macho::Symbol *sym,
                                     const InputSection *isec, const Reloc &r) {
   const TargetInfo::RelocAttrs &relocAttrs = target->getRelocAttrs(r.type);
 
   if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
     prepareBranchTarget(sym);
if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       dylibFile->ordinal = dylibOrdinal++;
 
       if (dylibFile->reexport)
         in.header->addLoadCommand(
             make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->dylibName));
     }
   }
 
+  if (codeSignatureSection)
+    in.header->addLoadCommand(make<LCCodeSignature>(codeSignatureSection));
+
   const uint32_t MACOS_MAXPATHLEN = 1024;
   config->headerPad = std::max(
       config->headerPad, (config->headerPadMaxInstallNames
                               ? LCDylib::getInstanceCount() * MACOS_MAXPATHLEN
                               : 0));
 }
 
 static size_t getSymbolPriority(const SymbolPriorityEntry &entry,
return StringSwitch<int>(osec->name)
         .Case(section_names::rebase, -8)
         .Case(section_names::binding, -7)
         .Case(section_names::weakBinding, -6)
         .Case(section_names::lazyBinding, -5)
         .Case(section_names::export_, -4)
         .Case(section_names::symbolTable, -3)
         .Case(section_names::indirectSymbolTable, -2)
         .Case(section_names::stringTable, -1)
+        .Case(section_names::codeSignature, std::numeric_limits<int>::max())
         .Default(0);
   }
   // ZeroFill sections must always be the at the end of their segments,
   // otherwise subsequent sections may get overwritten with zeroes at runtime.
   if (sectionType(osec->flags) == S_ZEROFILL)
     return std::numeric_limits<int>::max();
   return 0;
 }

 }
 
 void Writer::createOutputSections() {
   // First, create hidden sections
   stringTableSection = make<StringTableSection>();
   unwindInfoSection = make<UnwindInfoSection>(); // TODO(gkm): only when no -r
   symtabSection = make<SymtabSection>(*stringTableSection);
   indirectSymtabSection = make<IndirectSymtabSection>();
+  if (config->outputType == MH_EXECUTE &&
+      (config->arch == AK_arm64 || config->arch == AK_arm64e))
+    codeSignatureSection = make<CodeSignatureSection>();
 
   switch (config->outputType) {
   case MH_EXECUTE:
     make<PageZeroSection>();
     break;
   case MH_DYLIB:
   case MH_BUNDLE:
     break;
for (OutputSection *osec : seg->getSections()) {
     fileOff = alignTo(fileOff, osec->align);
     osec->addr = addr;
     osec->fileOff = isZeroFill(osec->flags) ? 0 : fileOff;
     osec->finalize();
 
     addr += osec->getSize();
     fileOff += osec->getFileSize();
   }
+  seg->fileSize = fileOff - seg->fileOff;
 }
 
 void Writer::openFile() {
   Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
       FileOutputBuffer::create(config->outputFile, fileOff,
                                FileOutputBuffer::F_executable);
 
   if (!bufferOrErr)
     error("failed to open " + config->outputFile + ": " +
           llvm::toString(bufferOrErr.takeError()));
   else
     buffer = std::move(*bufferOrErr);
 }
 
 void Writer::writeSections() {
   uint8_t *buf = buffer->getBufferStart();
   for (OutputSegment *seg : outputSegments)
     for (OutputSection *osec : seg->getSections())
       osec->writeTo(buf + osec->fileOff);
 }
 
 void Writer::writeUuid() {
-  uint64_t digest =
-      xxHash64({buffer->getBufferStart(), buffer->getBufferEnd()});
+  uint8_t *codeEnd =
+      buffer->getBufferEnd() -
+      (codeSignatureSection ? codeSignatureSection->getSize() : 0);
+  uint64_t digest = xxHash64({buffer->getBufferStart(), codeEnd});
   uuidCommand->writeUuid(digest);
 }
 
+void Writer::writeCodeSignature() {
+  if (codeSignatureSection)
+    codeSignatureSection->writeHashes(buffer->getBufferStart());
+}
+
 void Writer::run() {
   // dyld requires __LINKEDIT segment to always exist (even if empty).
   OutputSegment *linkEditSegment =
       getOrCreateOutputSegment(segment_names::linkEdit);
 
   prepareBranchTarget(config->entry);
   scanRelocations();
   if (in.stubHelper->isNeeded())
void Writer::run() {
   assignAddresses(linkEditSegment);
 
   openFile();
   if (errorCount())
     return;
 
   writeSections();
   writeUuid();
+  writeCodeSignature();
 
   if (auto e = buffer->commit())
     error("failed to write to the output file: " + toString(std::move(e)));
 }
 
 void macho::writeResult() { Writer().run(); }
 
 void macho::createSyntheticSections() {

llvm/include/llvm/BinaryFormat/MachO.h

 #define LOAD_COMMAND_STRUCT(LCStruct) LCStruct LCStruct##_data;
 
 LLVM_PACKED_START
 union alignas(4) macho_load_command {
 #include "llvm/BinaryFormat/MachO.def"
 };
 LLVM_PACKED_END
 
+/* code signing attributes of a process */
+
+enum CodeSignAttrs {
+  CS_VALID = 0x00000001,          /* dynamically valid */
+  CS_ADHOC = 0x00000002,          /* ad hoc signed */
+  CS_GET_TASK_ALLOW = 0x00000004, /* has get-task-allow entitlement */
+  CS_INSTALLER = 0x00000008,      /* has installer entitlement */
+
+  CS_FORCED_LV =
+      0x00000010, /* Library Validation required by Hardened System Policy */
+  CS_INVALID_ALLOWED = 0x00000020, /* (macOS Only) Page invalidation allowed by
+                                      task port policy */
+
+  CS_HARD = 0x00000100,             /* don't load invalid pages */
+  CS_KILL = 0x00000200,             /* kill process if it becomes invalid */
+  CS_CHECK_EXPIRATION = 0x00000400, /* force expiration checking */
+  CS_RESTRICT = 0x00000800,         /* tell dyld to treat restricted */
+
+  CS_ENFORCEMENT = 0x00001000, /* require enforcement */
+  CS_REQUIRE_LV = 0x00002000,  /* require library validation */
+  CS_ENTITLEMENTS_VALIDATED =
+      0x00004000, /* code signature permits restricted entitlements */
+  CS_NVRAM_UNRESTRICTED =
+      0x00008000, /* has com.apple.rootless.restricted-nvram-variables.heritable
+                     entitlement */
+
+  CS_RUNTIME = 0x00010000,       /* Apply hardened runtime policies */
+  CS_LINKER_SIGNED = 0x00020000, /* Automatically signed by the linker */
+
+  CS_ALLOWED_MACHO =
+      (CS_ADHOC | CS_HARD | CS_KILL | CS_CHECK_EXPIRATION | CS_RESTRICT |
+       CS_ENFORCEMENT | CS_REQUIRE_LV | CS_RUNTIME | CS_LINKER_SIGNED),
+
+  CS_EXEC_SET_HARD = 0x00100000, /* set CS_HARD on any exec'ed process */
+  CS_EXEC_SET_KILL = 0x00200000, /* set CS_KILL on any exec'ed process */
+  CS_EXEC_SET_ENFORCEMENT =
+      0x00400000, /* set CS_ENFORCEMENT on any exec'ed process */
+  CS_EXEC_INHERIT_SIP =
+      0x00800000, /* set CS_INSTALLER on any exec'ed process */
+
+  CS_KILLED = 0x01000000, /* was killed by kernel for invalidity */
+  CS_DYLD_PLATFORM =
+      0x02000000, /* dyld used to load this is a platform binary */
+  CS_PLATFORM_BINARY = 0x04000000, /* this is a platform binary */
+  CS_PLATFORM_PATH =
+      0x08000000, /* platform binary by the fact of path (osx only) */
+
+  CS_DEBUGGED = 0x10000000, /* process is currently or has previously been
+                debugged and allowed to run with invalid pages */
+  CS_SIGNED = 0x20000000, /* process has a signature (may have gone invalid) */
+  CS_DEV_CODE =
+      0x40000000, /* code is dev signed, cannot be loaded into prod signed code
+                     (will go away with rdar://problem/28322552) */
+  CS_DATAVAULT_CONTROLLER =
+      0x80000000, /* has Data Vault controller entitlement */
+
+  CS_ENTITLEMENT_FLAGS = (CS_GET_TASK_ALLOW | CS_INSTALLER |
+                          CS_DATAVAULT_CONTROLLER | CS_NVRAM_UNRESTRICTED),
+};
+
+/* executable segment flags */
+
+enum CodeSignExecSegFlags {
+
+  CS_EXECSEG_MAIN_BINARY = 0x1,     /* executable segment denotes main binary */
+  CS_EXECSEG_ALLOW_UNSIGNED = 0x10, /* allow unsigned pages (for debugging) */
+  CS_EXECSEG_DEBUGGER = 0x20,       /* main binary is debugger */
+  CS_EXECSEG_JIT = 0x40,            /* JIT enabled */
+  CS_EXECSEG_SKIP_LV = 0x80,        /* OBSOLETE: skip library validation */
+  CS_EXECSEG_CAN_LOAD_CDHASH = 0x100, /* can bless cdhash for execution */
+  CS_EXECSEG_CAN_EXEC_CDHASH = 0x200, /* can execute blessed cdhash */
+
+};
+
+/* Magic numbers used by Code Signing */
+
+enum CodeSignMagic {
+  CSMAGIC_REQUIREMENT = 0xfade0c00, /* single Requirement blob */
+  CSMAGIC_REQUIREMENTS =
+      0xfade0c01, /* Requirements vector (internal requirements) */
+  CSMAGIC_CODEDIRECTORY = 0xfade0c02,      /* CodeDirectory blob */
+  CSMAGIC_EMBEDDED_SIGNATURE = 0xfade0cc0, /* embedded form of signature data */
+  CSMAGIC_EMBEDDED_SIGNATURE_OLD = 0xfade0b02, /* XXX */
+  CSMAGIC_EMBEDDED_ENTITLEMENTS = 0xfade7171,  /* embedded entitlements */
+  CSMAGIC_DETACHED_SIGNATURE =
+      0xfade0cc1, /* multi-arch collection of embedded signatures */
+  CSMAGIC_BLOBWRAPPER = 0xfade0b01, /* CMS Signature, among other things */
+
+  CS_SUPPORTSSCATTER = 0x20100,
+  CS_SUPPORTSTEAMID = 0x20200,
+  CS_SUPPORTSCODELIMIT64 = 0x20300,
+  CS_SUPPORTSEXECSEG = 0x20400,
+  CS_SUPPORTSRUNTIME = 0x20500,
+  CS_SUPPORTSLINKAGE = 0x20600,
+
+  CSSLOT_CODEDIRECTORY = 0, /* slot index for CodeDirectory */
+  CSSLOT_INFOSLOT = 1,
+  CSSLOT_REQUIREMENTS = 2,
+  CSSLOT_RESOURCEDIR = 3,
+  CSSLOT_APPLICATION = 4,
+  CSSLOT_ENTITLEMENTS = 5,
+
+  CSSLOT_ALTERNATE_CODEDIRECTORIES =
+      0x1000, /* first alternate CodeDirectory, if any */
+  CSSLOT_ALTERNATE_CODEDIRECTORY_MAX = 5, /* max number of alternate CD slots */
+  CSSLOT_ALTERNATE_CODEDIRECTORY_LIMIT =
+      CSSLOT_ALTERNATE_CODEDIRECTORIES +
+      CSSLOT_ALTERNATE_CODEDIRECTORY_MAX, /* one past the last */
+
+  CSSLOT_SIGNATURESLOT = 0x10000, /* CMS Signature */
+  CSSLOT_IDENTIFICATIONSLOT = 0x10001,
+  CSSLOT_TICKETSLOT = 0x10002,
+
+  CSTYPE_INDEX_REQUIREMENTS = 0x00000002, /* compat with amfi */
+  CSTYPE_INDEX_ENTITLEMENTS = 0x00000005, /* compat with amfi */
+
+  CS_HASHTYPE_SHA1 = 1,
+  CS_HASHTYPE_SHA256 = 2,
+  CS_HASHTYPE_SHA256_TRUNCATED = 3,
+  CS_HASHTYPE_SHA384 = 4,
+
+  CS_SHA1_LEN = 20,
+  CS_SHA256_LEN = 32,
+  CS_SHA256_TRUNCATED_LEN = 20,
+
+  CS_CDHASH_LEN = 20,    /* always - larger hashes are truncated */
+  CS_HASH_MAX_SIZE = 48, /* max size of the hash we'll support */
+
+  /*
+   * Currently only to support Legacy VPN plugins, and Mac App Store
+   * but intended to replace all the various platform code, dev code etc. bits.
+   */
+  CS_SIGNER_TYPE_UNKNOWN = 0,
+  CS_SIGNER_TYPE_LEGACYVPN = 5,
+  CS_SIGNER_TYPE_MAC_APP_STORE = 6,
+
+  CS_SUPPL_SIGNER_TYPE_UNKNOWN = 0,
+  CS_SUPPL_SIGNER_TYPE_TRUSTCACHE = 7,
+  CS_SUPPL_SIGNER_TYPE_LOCAL = 8,
+};
+
+struct CS_CodeDirectory {
+  uint32_t magic;         /* magic number (CSMAGIC_CODEDIRECTORY) */
+  uint32_t length;        /* total length of CodeDirectory blob */
+  uint32_t version;       /* compatibility version */
+  uint32_t flags;         /* setup and mode flags */
+  uint32_t hashOffset;    /* offset of hash slot element at index zero */
+  uint32_t identOffset;   /* offset of identifier string */
+  uint32_t nSpecialSlots; /* number of special hash slots */
+  uint32_t nCodeSlots;    /* number of ordinary (code) hash slots */
+  uint32_t codeLimit;     /* limit to main image signature range */
+  uint8_t hashSize;       /* size of each hash in bytes */
+  uint8_t hashType;       /* type of hash (cdHashType* constants) */
+  uint8_t platform;       /* platform identifier; zero if not platform binary */
+  uint8_t pageSize;       /* log2(page size in bytes); 0 => infinite */
+  uint32_t spare2;        /* unused (must be zero) */
+
+  /* Version 0x20100 */
+  uint32_t scatterOffset; /* offset of optional scatter vector */
+
+  /* Version 0x20200 */
+  uint32_t teamOffset; /* offset of optional team identifier */
+
+  /* Version 0x20300 */
+  uint32_t spare3;      /* unused (must be zero) */
+  uint64_t codeLimit64; /* limit to main image signature range, 64 bits */
+
+  /* Version 0x20400 */
+  uint64_t execSegBase;  /* offset of executable segment */
+  uint64_t execSegLimit; /* limit of executable segment */
+  uint64_t execSegFlags; /* executable segment flags */
+};
+
+static_assert(sizeof(CS_CodeDirectory) == 88, "");
+
+struct CS_BlobIndex {
+  uint32_t type;   /* type of entry */
+  uint32_t offset; /* offset of entry */
+};
+
+struct CS_SuperBlob {
+  uint32_t magic;  /* magic number */
+  uint32_t length; /* total length of SuperBlob */
+  uint32_t count;  /* number of index entries following */
+  /* followed by Blobs in no particular order as indicated by index offsets */
+};
+
+enum SecCSDigestAlgorithm {
+  kSecCodeSignatureNoHash = 0,     /* null value */
+  kSecCodeSignatureHashSHA1 = 1,   /* SHA-1 */
+  kSecCodeSignatureHashSHA256 = 2, /* SHA-256 */
+  kSecCodeSignatureHashSHA256Truncated =
+      3,                           /* SHA-256 truncated to first 20 bytes */
+  kSecCodeSignatureHashSHA384 = 4, /* SHA-384 */
+  kSecCodeSignatureHashSHA512 = 5, /* SHA-512 */
+};
+
 } // end namespace MachO
 } // end namespace llvm
 
 #endif