macOS Code Signing
Reading time: 13 minutes
tip
Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Leer en oefen Azure Hacking:
HackTricks Training Azure Red Team Expert (AzRTE)
Ondersteun HackTricks
- Kyk na die subskripsie planne!
- Sluit aan by die 💬 Discord groep of die telegram groep of volg ons op Twitter 🐦 @hacktricks_live.
- Deel hacking truuks deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.
Basiese Inligting
Mach O Entitlements And Ipsw Indexing
Mach-o binaries bevat 'n load command genaamd LC_CODE_SIGNATURE
wat die offset en size van die signatures binne die binary aandui. Met die GUI-instrument MachOView is dit moontlik om aan die einde van die binary 'n afdeling met die naam Code Signature te vind met hierdie inligting:
 (1) (1) (1).png)
Die magic header van die Code Signature is 0xFADE0CC0
. Daarna is daar inligting soos die lengte en die aantal blobs van die superBlob wat hulle bevat.
Dit is moontlik om hierdie inligting in die source code here:
/*
* Structure of an embedded-signature SuperBlob
*/
typedef struct __BlobIndex {
uint32_t type; /* type of entry */
uint32_t offset; /* offset of entry */
} CS_BlobIndex
__attribute__ ((aligned(1)));
typedef struct __SC_SuperBlob {
uint32_t magic; /* magic number */
uint32_t length; /* total length of SuperBlob */
uint32_t count; /* number of index entries following */
CS_BlobIndex index[]; /* (count) entries */
/* followed by Blobs in no particular order as indicated by offsets in index */
} CS_SuperBlob
__attribute__ ((aligned(1)));
#define KERNEL_HAVE_CS_GENERICBLOB 1
typedef struct __SC_GenericBlob {
uint32_t magic; /* magic number */
uint32_t length; /* total length of blob */
char data[];
} CS_GenericBlob
__attribute__ ((aligned(1)));
Gereelde blobs wat ingesluit is, is Code Directory, Requirements en Entitlements en 'n Cryptographic Message Syntax (CMS).
Let ook daarop dat die data in die blobs in Big Endian.
Verder kan handtekeninge van die binaries afgekoppel wees en in /var/db/DetachedSignatures
gestoor word (gebruik deur iOS).
Code Directory Blob
Dit is moontlik om die deklarasie van die Code Directory Blob in the code:
typedef struct __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) */
char end_earliest[0];
/* Version 0x20100 */
uint32_t scatterOffset; /* offset of optional scatter vector */
char end_withScatter[0];
/* Version 0x20200 */
uint32_t teamOffset; /* offset of optional team identifier */
char end_withTeam[0];
/* Version 0x20300 */
uint32_t spare3; /* unused (must be zero) */
uint64_t codeLimit64; /* limit to main image signature range, 64 bits */
char end_withCodeLimit64[0];
/* Version 0x20400 */
uint64_t execSegBase; /* offset of executable segment */
uint64_t execSegLimit; /* limit of executable segment */
uint64_t execSegFlags; /* executable segment flags */
char end_withExecSeg[0];
/* Version 0x20500 */
uint32_t runtime;
uint32_t preEncryptOffset;
char end_withPreEncryptOffset[0];
/* Version 0x20600 */
uint8_t linkageHashType;
uint8_t linkageApplicationType;
uint16_t linkageApplicationSubType;
uint32_t linkageOffset;
uint32_t linkageSize;
char end_withLinkage[0];
/* followed by dynamic content as located by offset fields above */
} CS_CodeDirectory
__attribute__ ((aligned(1)));
Let wel dat daar verskillende weergawes van hierdie struct is, en ouer weergawes kan minder inligting bevat.
Ondertekening van Code Pages
Hashing van die volle binary sou ondoeltreffend wees en selfs nutteloos wees as dit slegs gedeeltelik in geheue gelaai word. Daarom is die code signature eintlik 'n hash of hashes waar elke binary page individueel gehashed word.
In werklikheid kan jy in die vorige Code Directory code sien dat die page size is specified in een van sy velde. Verder, as die grootte van die binary nie 'n veelvoud van die grootte van 'n page is nie, spesifiseer die veld CodeLimit waar die einde van die signature is.
# Get all hashes of /bin/ps
codesign -d -vvvvvv /bin/ps
[...]
CandidateCDHash sha256=c46e56e9490d93fe35a76199bdb367b3463c91dc
CandidateCDHashFull sha256=c46e56e9490d93fe35a76199bdb367b3463c91dcdb3c46403ab8ba1c2d13fd86
Hash choices=sha256
CMSDigest=c46e56e9490d93fe35a76199bdb367b3463c91dcdb3c46403ab8ba1c2d13fd86
CMSDigestType=2
Executable Segment base=0
Executable Segment limit=32768
Executable Segment flags=0x1
Page size=4096
-7=a542b4dcbc134fbd950c230ed9ddb99a343262a2df8e0c847caee2b6d3b41cc8
-6=0000000000000000000000000000000000000000000000000000000000000000
-5=2bb2de519f43b8e116c7eeea8adc6811a276fb134c55c9c2e9dcbd3047f80c7d
-4=0000000000000000000000000000000000000000000000000000000000000000
-3=0000000000000000000000000000000000000000000000000000000000000000
-2=4ca453dc8908dc7f6e637d6159c8761124ae56d080a4a550ad050c27ead273b3
-1=0000000000000000000000000000000000000000000000000000000000000000
0=a5e6478f89812c0c09f123524cad560a9bf758d16014b586089ddc93f004e39c
1=ad7facb2586fc6e966c004d7d1d16b024f5805ff7cb47c7a85dabd8b48892ca7
2=93d476eeace15a5ad14c0fb56169fd080a04b99582b4c7a01e1afcbc58688f
[...]
# Calculate the hasehs of each page manually
BINARY=/bin/ps
SIZE=`stat -f "%Z" $BINARY`
PAGESIZE=4096 # From the previous output
PAGES=`expr $SIZE / $PAGESIZE`
for i in `seq 0 $PAGES`; do
dd if=$BINARY of=/tmp/`basename $BINARY`.page.$i bs=$PAGESIZE skip=$i count=1
done
openssl sha256 /tmp/*.page.*
Entitlements Blob
Let op dat toepassings ook 'n entitlement blob kan bevat waar al die entitlements gedefinieer is. Boonop kan sommige iOS-binaries hul entitlements spesifiseer in die spesiale slot -7 (in plaas van in die -5 entitlements spesiale slot).
Special Slots
MacOS-toepassings het nie alles wat hulle nodig het om binne die binary uit te voer nie; hulle gebruik ook external resources (gewoonlik binne die toepassing se bundle). Daarom is daar sekere slots binne die binary wat die hashes van sommige belangrike eksterne hulpbronne sal bevat om te verifieer dat dit nie verander is nie.
Dit is moontlik om in die Code Directory structs 'n parameter genaamd nSpecialSlots
te sien wat die aantal spesiale slots aandui. Daar is nie 'n spesiale slot 0 nie en die mees algemene (van -1 tot -6) is:
- Hash van
info.plist
(of die een binne__TEXT.__info__plist
). - Hash van die Requirements
- Hash van die Resource Directory (hash van die
_CodeSignature/CodeResources
-lêer binne die bundle). - Toepassingspesifiek (nie gebruik nie)
- Hash van die entitlements
- Slegs DMG code signatures
- DER Entitlements
Code Signing Flags
Elke proses het 'n verwante bitmasker bekend as die status
wat deur die kernel gestel word, en sommige kan oorrompel word deur die code signature. Hierdie vlae wat in die code signing ingesluit kan word, is in die kode gedefinieer:
/* code signing attributes of a process */
#define CS_VALID 0x00000001 /* dynamically valid */
#define CS_ADHOC 0x00000002 /* ad hoc signed */
#define CS_GET_TASK_ALLOW 0x00000004 /* has get-task-allow entitlement */
#define CS_INSTALLER 0x00000008 /* has installer entitlement */
#define CS_FORCED_LV 0x00000010 /* Library Validation required by Hardened System Policy */
#define CS_INVALID_ALLOWED 0x00000020 /* (macOS Only) Page invalidation allowed by task port policy */
#define CS_HARD 0x00000100 /* don't load invalid pages */
#define CS_KILL 0x00000200 /* kill process if it becomes invalid */
#define CS_CHECK_EXPIRATION 0x00000400 /* force expiration checking */
#define CS_RESTRICT 0x00000800 /* tell dyld to treat restricted */
#define CS_ENFORCEMENT 0x00001000 /* require enforcement */
#define CS_REQUIRE_LV 0x00002000 /* require library validation */
#define CS_ENTITLEMENTS_VALIDATED 0x00004000 /* code signature permits restricted entitlements */
#define CS_NVRAM_UNRESTRICTED 0x00008000 /* has com.apple.rootless.restricted-nvram-variables.heritable entitlement */
#define CS_RUNTIME 0x00010000 /* Apply hardened runtime policies */
#define CS_LINKER_SIGNED 0x00020000 /* Automatically signed by the linker */
#define CS_ALLOWED_MACHO (CS_ADHOC | CS_HARD | CS_KILL | CS_CHECK_EXPIRATION | \
CS_RESTRICT | CS_ENFORCEMENT | CS_REQUIRE_LV | CS_RUNTIME | CS_LINKER_SIGNED)
#define CS_EXEC_SET_HARD 0x00100000 /* set CS_HARD on any exec'ed process */
#define CS_EXEC_SET_KILL 0x00200000 /* set CS_KILL on any exec'ed process */
#define CS_EXEC_SET_ENFORCEMENT 0x00400000 /* set CS_ENFORCEMENT on any exec'ed process */
#define CS_EXEC_INHERIT_SIP 0x00800000 /* set CS_INSTALLER on any exec'ed process */
#define CS_KILLED 0x01000000 /* was killed by kernel for invalidity */
#define CS_NO_UNTRUSTED_HELPERS 0x02000000 /* kernel did not load a non-platform-binary dyld or Rosetta runtime */
#define CS_DYLD_PLATFORM CS_NO_UNTRUSTED_HELPERS /* old name */
#define CS_PLATFORM_BINARY 0x04000000 /* this is a platform binary */
#define CS_PLATFORM_PATH 0x08000000 /* platform binary by the fact of path (osx only) */
#define CS_DEBUGGED 0x10000000 /* process is currently or has previously been debugged and allowed to run with invalid pages */
#define CS_SIGNED 0x20000000 /* process has a signature (may have gone invalid) */
#define CS_DEV_CODE 0x40000000 /* code is dev signed, cannot be loaded into prod signed code (will go away with rdar://problem/28322552) */
#define CS_DATAVAULT_CONTROLLER 0x80000000 /* has Data Vault controller entitlement */
#define CS_ENTITLEMENT_FLAGS (CS_GET_TASK_ALLOW | CS_INSTALLER | CS_DATAVAULT_CONTROLLER | CS_NVRAM_UNRESTRICTED)
Let daarop dat die funksie exec_mach_imgact ook die CS_EXEC_*
vlagte dinamies kan byvoeg wanneer dit die uitvoering begin.
Vereistes vir kodehandtekening
Elke toepassing stoor sekere vereistes wat dit moet bevredig om uitgevoer te kan word. As die vereistes wat in die toepassing vervat is nie deur die toepassing bevredig word nie, sal dit nie uitgevoer word nie (aangesien dit waarskynlik verander is).
Die vereistes van 'n binêre gebruik 'n spesiale grammatika wat 'n stroom van uitdrukkings is en word gekodeer as blobs wat 0xfade0c00
as die magiese waarde gebruik, waarvan die hash in 'n spesiale code slot gestoor word.
Die vereistes van 'n binêre kan gesien word deur dit uit te voer:
codesign -d -r- /bin/ls
Executable=/bin/ls
designated => identifier "com.apple.ls" and anchor apple
codesign -d -r- /Applications/Signal.app/
Executable=/Applications/Signal.app/Contents/MacOS/Signal
designated => identifier "org.whispersystems.signal-desktop" and anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] /* exists */ and certificate leaf[field.1.2.840.113635.100.6.1.13] /* exists */ and certificate leaf[subject.OU] = U68MSDN6DR
tip
Let op hoe hierdie signatures dinge kan nagaan soos sertifiseringsinligting, TeamID, IDs, entitlements en baie ander data.
Verder is dit moontlik om sekere gekompileerde vereistes te genereer met die csreq
-tool:
# Generate compiled requirements
csreq -b /tmp/output.csreq -r='identifier "org.whispersystems.signal-desktop" and anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] /* exists */ and certificate leaf[field.1.2.840.113635.100.6.1.13] /* exists */ and certificate leaf[subject.OU] = U68MSDN6DR'
# Get the compiled bytes
od -A x -t x1 /tmp/output.csreq
0000000 fa de 0c 00 00 00 00 b0 00 00 00 01 00 00 00 06
0000010 00 00 00 06 00 00 00 06 00 00 00 06 00 00 00 02
0000020 00 00 00 21 6f 72 67 2e 77 68 69 73 70 65 72 73
[...]
Dit is moontlik om toegang tot hierdie inligting te kry en vereistes te skep of te wysig met sommige API's van die Security.framework
soos:
Checking Validity
Sec[Static]CodeCheckValidity
: Kontroleer die geldigheid vanSecCodeRef
volgens 'n vereiste.SecRequirementEvaluate
: Valideer 'n vereiste in die sertifikaatkonteks.SecTaskValidateForRequirement
: Valideer 'n lopendeSecTask
teen 'nCFString
vereiste.
Creating and Managing Code Requirements
SecRequirementCreateWithData
: Skep 'nSecRequirementRef
vanaf binêre data wat die vereiste voorstel.SecRequirementCreateWithString
: Skep 'nSecRequirementRef
vanaf 'n stringuitdrukking van die vereiste.SecRequirementCopy[Data/String]
: Haal die binêre datarepresentasie van 'nSecRequirementRef
.SecRequirementCreateGroup
: Skep 'n vereiste vir app-groep lidmaatskap.
Accessing Code Signing Information
SecStaticCodeCreateWithPath
: Initialiseer 'nSecStaticCodeRef
objek vanaf 'n lêerstelselpad om kodehandtekeninge te ondersoek.SecCodeCopySigningInformation
: Verkry ondertekeningsinligting vanaf 'nSecCodeRef
ofSecStaticCodeRef
.
Modifying Code Requirements
SecCodeSignerCreate
: Skep 'nSecCodeSignerRef
objek vir die uitvoering van kodeondertekeningsoperasies.SecCodeSignerSetRequirement
: Stel 'n nuwe vereiste vir die kode-signer wat tydens ondertekening toegepas moet word.SecCodeSignerAddSignature
: Voeg 'n handtekening by die kode wat met die gespesifiseerde signer onderteken word.
Validating Code with Requirements
SecStaticCodeCheckValidity
: Valideer 'n statiese kode-objek teen gespesifiseerde vereistes.
Additional Useful APIs
SecCodeCopy[Internal/Designated]Requirement
: Get SecRequirementRef from SecCodeRefSecCodeCopyGuestWithAttributes
: Skep 'nSecCodeRef
wat 'n kode-objek voorstel gebaseer op spesifieke eienskappe, nuttig vir sandboxing.SecCodeCopyPath
: Haal die lêerstelselpad wat by 'nSecCodeRef
hoort.SecCodeCopySigningIdentifier
: Verkry die ondertekeningsidentifiseerder (bv. Team ID) vanaf 'nSecCodeRef
.SecCodeGetTypeID
: Gee die tipe-identifiseerder virSecCodeRef
-objekte terug.SecRequirementGetTypeID
: Kry 'n CFTypeID van 'nSecRequirementRef
.
Code Signing Flags and Constants
kSecCSDefaultFlags
: Verstekvlae wat in baie Security.framework-funksies vir kodeondertekeningsoperasies gebruik word.kSecCSSigningInformation
: Vlae wat gebruik word om te spesifiseer dat ondertekeningsinligting verkry moet word.
Code Signature Enforcement
Die kernel is die een wat die kodehandtekening nagaan voordat die app se kode toegelaat word om uit te voer. Verder is een manier om nuwe kode in geheue te kan skryf en uitvoer deur misbruik van JIT indien mprotect
met die MAP_JIT
vlag aangeroep word. Let wel dat die toepassing 'n spesiale entitlement nodig het om dit te kan doen.
cs_blobs
& cs_blob
cs_blob struct bevat die inligting oor die entitlement van die lopende proses daarop. csb_platform_binary
dui ook aan of die toepassing 'n platform-binary is (wat op verskillende oomblikke deur die OS nagegaan word om sekuriteitsmeganismes toe te pas, soos die beskerming van die SEND rights na die task ports van hierdie prosesse).
struct cs_blob {
struct cs_blob *csb_next;
vnode_t csb_vnode;
void *csb_ro_addr;
__xnu_struct_group(cs_cpu_info, csb_cpu_info, {
cpu_type_t csb_cpu_type;
cpu_subtype_t csb_cpu_subtype;
});
__xnu_struct_group(cs_signer_info, csb_signer_info, {
unsigned int csb_flags;
unsigned int csb_signer_type;
});
off_t csb_base_offset; /* Offset of Mach-O binary in fat binary */
off_t csb_start_offset; /* Blob coverage area start, from csb_base_offset */
off_t csb_end_offset; /* Blob coverage area end, from csb_base_offset */
vm_size_t csb_mem_size;
vm_offset_t csb_mem_offset;
void *csb_mem_kaddr;
unsigned char csb_cdhash[CS_CDHASH_LEN];
const struct cs_hash *csb_hashtype;
#if CONFIG_SUPPLEMENTAL_SIGNATURES
unsigned char csb_linkage[CS_CDHASH_LEN];
const struct cs_hash *csb_linkage_hashtype;
#endif
int csb_hash_pageshift;
int csb_hash_firstlevel_pageshift; /* First hash this many bytes, then hash the hashes together */
const CS_CodeDirectory *csb_cd;
const char *csb_teamid;
#if CONFIG_SUPPLEMENTAL_SIGNATURES
char *csb_supplement_teamid;
#endif
const CS_GenericBlob *csb_entitlements_blob; /* raw blob, subrange of csb_mem_kaddr */
const CS_GenericBlob *csb_der_entitlements_blob; /* raw blob, subrange of csb_mem_kaddr */
/*
* OSEntitlements pointer setup by AMFI. This is PAC signed in addition to the
* cs_blob being within RO-memory to prevent modifications on the temporary stack
* variable used to setup the blob.
*/
void *XNU_PTRAUTH_SIGNED_PTR("cs_blob.csb_entitlements") csb_entitlements;
unsigned int csb_reconstituted; /* signature has potentially been modified after validation */
__xnu_struct_group(cs_blob_platform_flags, csb_platform_flags, {
/* The following two will be replaced by the csb_signer_type. */
unsigned int csb_platform_binary:1;
unsigned int csb_platform_path:1;
});
/* Validation category used for TLE */
unsigned int csb_validation_category;
#if CODE_SIGNING_MONITOR
void *XNU_PTRAUTH_SIGNED_PTR("cs_blob.csb_csm_obj") csb_csm_obj;
bool csb_csm_managed;
#endif
};
Verwysings
tip
Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Leer en oefen Azure Hacking:
HackTricks Training Azure Red Team Expert (AzRTE)
Ondersteun HackTricks
- Kyk na die subskripsie planne!
- Sluit aan by die 💬 Discord groep of die telegram groep of volg ons op Twitter 🐦 @hacktricks_live.
- Deel hacking truuks deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.