macOS MACF

Reading time: 16 minutes

Basiese Inligting

MACF staan vir Mandatory Access Control Framework, wat 'n sekuriteitstelsel is ingebou in die bedryfstelsel om jou rekenaar te help beskerm. Dit werk deur streng reëls te stel oor wie of wat sekere dele van die stelsel kan benader, soos lêers, toepassings en stelselhulpbronne. Deur hierdie reëls outomaties af te dwing, verseker MACF dat slegs gemagtigde gebruikers en prosesse sekere aksies kan uitvoer, wat die risiko van ongemagtigde toegang of kwaadwillige aktiwiteite verminder.

Neem kennis dat MACF nie regtig besluite neem nie — dit vang aksies af en laat die besluite aan die policy modules (kernel extensions) oor, soos AppleMobileFileIntegrity.kext, Quarantine.kext, Sandbox.kext, TMSafetyNet.kext en mcxalr.kext.

• 'n Beleid kan afdwingend wees (keer 0 of nie-nul terug op 'n operasie)
• 'n Beleid kan moniterend wees (keer 0 terug, sodat dit nie beswaar maak nie maar die hook gebruik om iets te doen)
• 'n MACF statiese beleid word tydens boot geïnstalleer en sal NOOIT verwyder word nie
• 'n MACF dinamiese beleid word deur 'n KEXT geïnstalleer (kextload) en mag hipoteties kextunloaded word
• In iOS is slegs statiese beleide toegelaat, en in macOS statiese + dinamiese.
• https://newosxbook.com/xxr/index.php

Vloei

1. Proses voer 'n syscall/mach trap uit
2. Die relevante funksie word binne die kernel aangeroep
3. Funksie roep MACF aan
4. MACF kontroleer policy modules wat versoek het om daardie funksie in hul beleid te hook
5. MACF roep die relevante beleide aan
6. Beleide dui aan of hulle die aksie toelaat of weier

Gewoonlik sal die funksies wat toestemmings met MACF nagaan die macro MAC_CHECK aanroep. Soos in die geval van 'n syscall om 'n socket te skep, wat die funksie mac_socket_check_create sal aanroep en wat op sy beurt MAC_CHECK(socket_check_create, cred, domain, type, protocol); aanroep. Verder word die macro MAC_CHECK in security/mac_internal.h gedefinieer as:

Resolver tambien MAC_POLICY_ITERATE, MAC_CHECK_CALL, MAC_CHECK_RSLT


#define MAC_CHECK(check, args...) do {                                   \
error = 0;                                                           \
MAC_POLICY_ITERATE({                                                 \
if (mpc->mpc_ops->mpo_ ## check != NULL) {                   \
MAC_CHECK_CALL(check, mpc);                          \
int __step_err = mpc->mpc_ops->mpo_ ## check (args); \
MAC_CHECK_RSLT(check, mpc);                          \
error = mac_error_select(__step_err, error);         \
}                                                            \
});                                                                  \
} while (0)

Let daarop dat deur check na socket_check_create te transformeer en args... in (cred, domain, type, protocol) te verander, kry jy:

// Note the "##" just get the param name and append it to the prefix
#define MAC_CHECK(socket_check_create, args...) do {                                   \
error = 0;                                                           \
MAC_POLICY_ITERATE({                                                 \
if (mpc->mpc_ops->mpo_socket_check_create != NULL) {                   \
MAC_CHECK_CALL(socket_check_create, mpc);                          \
int __step_err = mpc->mpc_ops->mpo_socket_check_create (args); \
MAC_CHECK_RSLT(socket_check_create, mpc);                          \
error = mac_error_select(__step_err, error);         \
}                                                            \
});                                                                  \
} while (0)

Deur die hulpmakros uit te brei, word die konkrete beheervloei getoon:

do {                                                // MAC_CHECK
error = 0;
do {                                            // MAC_POLICY_ITERATE
struct mac_policy_conf *mpc;
u_int i;
for (i = 0; i < mac_policy_list.staticmax; i++) {
mpc = mac_policy_list.entries[i].mpc;
if (mpc == NULL) {
continue;
}
if (mpc->mpc_ops->mpo_socket_check_create != NULL) {
DTRACE_MACF3(mac__call__socket_check_create,
void *, mpc, int, error, int, MAC_ITERATE_CHECK); // MAC_CHECK_CALL
int __step_err = mpc->mpc_ops->mpo_socket_check_create(args);
DTRACE_MACF2(mac__rslt__socket_check_create,
void *, mpc, int, __step_err);                    // MAC_CHECK_RSLT
error = mac_error_select(__step_err, error);
}
}
if (mac_policy_list_conditional_busy() != 0) {
for (; i <= mac_policy_list.maxindex; i++) {
mpc = mac_policy_list.entries[i].mpc;
if (mpc == NULL) {
continue;
}
if (mpc->mpc_ops->mpo_socket_check_create != NULL) {
DTRACE_MACF3(mac__call__socket_check_create,
void *, mpc, int, error, int, MAC_ITERATE_CHECK);
int __step_err = mpc->mpc_ops->mpo_socket_check_create(args);
DTRACE_MACF2(mac__rslt__socket_check_create,
void *, mpc, int, __step_err);
error = mac_error_select(__step_err, error);
}
}
mac_policy_list_unbusy();
}
} while (0);
} while (0);

Met ander woorde, MAC_CHECK(socket_check_create, ...) deurloop eers die statiese beleide, sluit voorwaardelik en deurloop dinamiese beleide, stuur die DTrace probes rondom elke hook uit, en vou elke hook se terugkeerwaarde saam tot die enkele error resultaat via mac_error_select().

Labels

MACF gebruik labels wat deur die beleide gebruik word wanneer hulle nagaan of hulle toegang moet verleen of nie. Die kode van die labels struct-deklarasie kan hier gevind word, wat dan gebruik word binne die struct ucred in hier in die cr_label gedeelte. Die label bevat flags en 'n aantal slots wat deur MACF policies to allocate pointers gebruik kan word. Byvoorbeeld sal Sandbox na die container profile wys

MACF Policies

A MACF Policy definieer reëls en voorwaardes wat toegepas moet word op sekere kernel-operasies.

A kernel extension could configure a mac_policy_conf struct and then register it calling mac_policy_register. From here:

#define mpc_t	struct mac_policy_conf *

/**
@brief Mac policy configuration

This structure specifies the configuration information for a
MAC policy module.  A policy module developer must supply
a short unique policy name, a more descriptive full name, a list of label
namespaces and count, a pointer to the registered enty point operations,
any load time flags, and optionally, a pointer to a label slot identifier.

The Framework will update the runtime flags (mpc_runtime_flags) to
indicate that the module has been registered.

If the label slot identifier (mpc_field_off) is NULL, the Framework
will not provide label storage for the policy.  Otherwise, the
Framework will store the label location (slot) in this field.

The mpc_list field is used by the Framework and should not be
modified by policies.
*/
/* XXX - reorder these for better aligment on 64bit platforms */
struct mac_policy_conf {
const char		*mpc_name;		/** policy name */
const char		*mpc_fullname;		/** full name */
const char		**mpc_labelnames;	/** managed label namespaces */
unsigned int		 mpc_labelname_count;	/** number of managed label namespaces */
struct mac_policy_ops	*mpc_ops;		/** operation vector */
int			 mpc_loadtime_flags;	/** load time flags */
int			*mpc_field_off;		/** label slot */
int			 mpc_runtime_flags;	/** run time flags */
mpc_t			 mpc_list;		/** List reference */
void			*mpc_data;		/** module data */
};

Dit is maklik om die kernel extensions wat hierdie beleide konfigureer te identifiseer deur na oproepe na mac_policy_register te kyk. Boonop, deur die disassemble van die uitbreiding na te gaan, is dit ook moontlik om die gebruikte mac_policy_conf struct te vind.

Let daarop dat MACF-beleide ook dynamies geregistreer en af-geregistreer kan word.

Een van die hoofvelde van die mac_policy_conf is die mpc_ops. Hierdie veld spesifiseer in watter operasies die beleid belangstel. Let wel dat daar honderde daarvan is, dus is dit moontlik om almal op nul te stel en dan net dié te kies waarin die beleid belangstel. Van hier:

struct mac_policy_ops {
mpo_audit_check_postselect_t		*mpo_audit_check_postselect;
mpo_audit_check_preselect_t		*mpo_audit_check_preselect;
mpo_bpfdesc_label_associate_t		*mpo_bpfdesc_label_associate;
mpo_bpfdesc_label_destroy_t		*mpo_bpfdesc_label_destroy;
mpo_bpfdesc_label_init_t		*mpo_bpfdesc_label_init;
mpo_bpfdesc_check_receive_t		*mpo_bpfdesc_check_receive;
mpo_cred_check_label_update_execve_t	*mpo_cred_check_label_update_execve;
mpo_cred_check_label_update_t		*mpo_cred_check_label_update;
[...]

Byna al die hooks sal deur MACF teruggeroep word wanneer een van daardie operasies onderskep word. Daarteenoor is die mpo_policy_* hooks 'n uitsondering omdat mpo_hook_policy_init() 'n callback is wat by registrasie aangeroep word (dus ná mac_policy_register()) en mpo_hook_policy_initbsd() aangeroep word gedurende latere registrasie sodra die BSD-substelsel behoorlik geïnitialiseer is.

Verder kan die mpo_policy_syscall hook deur enige kext geregistreer word om 'n private ioctl style call interface bloot te lê. Dan sal 'n user client in staat wees om mac_syscall (#381) aan te roep deur as parameters die policy name met 'n integer code en opsionele arguments te spesifiseer.
Byvoorbeeld, die Sandbox.kext gebruik dit baie.

Deur die kext se __DATA.__const* te kontroleer is dit moontlik om die mac_policy_ops struktuur te identifiseer wat gebruik is tydens die registrasie van die policy. Dit is te vind omdat sy pointer by 'n offset binne mpo_policy_conf is en ook weens die aantal NULL pointers wat in daardie area sal wees.

Daarbenewens is dit ook moontlik om die lys kexts wat 'n policy gekonfigureer het te kry deur die struct _mac_policy_list uit geheue te dump wat bygewerk word met elke geregistreerde policy.

Jy kan ook die tool xnoop gebruik om al die policies geregistreer in die stelsel te dump:

xnoop offline .

Xn👀p> macp
mac_policy_list(@0xfffffff0447159b8): 3 Mac Policies@0xfffffff0447153f0
0: 0xfffffff044886f18:
mpc_name: AppleImage4
mpc_fullName: AppleImage4 hooks
mpc_ops: mac_policy_ops@0xfffffff044886f68
1: 0xfffffff0448d7d40:
mpc_name: AMFI
mpc_fullName: Apple Mobile File Integrity
mpc_ops: mac_policy_ops@0xfffffff0448d72c8
2: 0xfffffff044b0b950:
mpc_name: Sandbox
mpc_fullName: Seatbelt sandbox policy
mpc_ops: mac_policy_ops@0xfffffff044b0b9b0
Xn👀p> dump mac_policy_opns@0xfffffff0448d72c8
Type 'struct mac_policy_opns' is unrecognized - dumping as raw 64 bytes
Dumping 64 bytes from 0xfffffff0448d72c8

En dan dump al die checks van check policy met:

Xn👀p> dump mac_policy_ops@0xfffffff044b0b9b0
Dumping 2696 bytes from 0xfffffff044b0b9b0 (as struct mac_policy_ops)

mpo_cred_check_label_update_execve(@0x30): 0xfffffff046d7fb54(PACed)
mpo_cred_check_label_update(@0x38): 0xfffffff046d7348c(PACed)
mpo_cred_label_associate(@0x58): 0xfffffff046d733f0(PACed)
mpo_cred_label_destroy(@0x68): 0xfffffff046d733e4(PACed)
mpo_cred_label_update_execve(@0x90): 0xfffffff046d7fb60(PACed)
mpo_cred_label_update(@0x98): 0xfffffff046d73370(PACed)
mpo_file_check_fcntl(@0xe8): 0xfffffff046d73164(PACed)
mpo_file_check_lock(@0x110): 0xfffffff046d7309c(PACed)
mpo_file_check_mmap(@0x120): 0xfffffff046d72fc4(PACed)
mpo_file_check_set(@0x130): 0xfffffff046d72f2c(PACed)
mpo_reserved08(@0x168): 0xfffffff046d72e3c(PACed)
mpo_reserved09(@0x170): 0xfffffff046d72e34(PACed)
mpo_necp_check_open(@0x1f0): 0xfffffff046d72d9c(PACed)
mpo_necp_check_client_action(@0x1f8): 0xfffffff046d72cf8(PACed)
mpo_vnode_notify_setextattr(@0x218): 0xfffffff046d72ca4(PACed)
mpo_vnode_notify_setflags(@0x220): 0xfffffff046d72c84(PACed)
mpo_proc_check_get_task_special_port(@0x250): 0xfffffff046d72b98(PACed)
mpo_proc_check_set_task_special_port(@0x258): 0xfffffff046d72ab4(PACed)
mpo_vnode_notify_unlink(@0x268): 0xfffffff046d72958(PACed)
mpo_vnode_check_copyfile(@0x290): 0xfffffff046d726c0(PACed)
mpo_mount_check_quotactl(@0x298): 0xfffffff046d725c4(PACed)
...

MACF-initialisering in XNU

Vroeë bootstrap en mac_policy_init()

• MACF word baie vroeg geïnitialiseer. In bootstrap_thread (in XNU opstartkode), na ipc_bootstrap roep XNU mac_policy_init() (in mac_base.c).
• mac_policy_init() inicialiseer die globale mac_policy_list (ʼn array of lys van beleidslots) en stel die infrastruktuur vir MAC (Mandatory Access Control) binne XNU op.
• Later word mac_policy_initmach() aangeroep, wat die kernel-kant van beleid-registrasie vir ingeboude of gebundelde beleide hanteer.

mac_policy_initmach() en die laai van “sekuriteitsuitbreidings”

• mac_policy_initmach() ondersoek kernel extensions (kexts) wat vooraf gelaai is (of in ʼn “policy injection” lys) en kyk na hul Info.plist vir die sleutel AppleSecurityExtension.

• Kexts wat <key>AppleSecurityExtension</key> (of true) in hul Info.plist verklaar, word beskou as “sekuriteitsuitbreidings” — d.w.s. dié wat ʼn MAC-beleid implementeer of aan die MACF-infrastruktuur koppel.

• Voorbeelde van Apple kexts met daardie sleutel sluit in ALF.kext, AppleMobileFileIntegrity.kext (AMFI), Sandbox.kext, Quarantine.kext, TMSafetyNet.kext, CoreTrust.kext, AppleSystemPolicy.kext, en ander (soos jy reeds genoem het).

• Die kernel verseker dat daardie kexts vroeg gelaai word, en roep dan hul registrasieroutines aan (via mac_policy_register) tydens boot, en voeg hulle in die mac_policy_list in.

• Elke beleidmodule (kext) verskaf ʼn mac_policy_conf struktuur, met hooks (mpc_ops) vir verskeie MAC-operasies (vnode checks, exec checks, label updates, ens.).

• Die load-time vlae mag MPC_LOADTIME_FLAG_NOTLATE insluit, wat beteken “must be loaded early” (sodat laat registrasiepogings verwerp word).

• Sodra geregistreer, kry elke module ʼn hanteer en neem ʼn slot in mac_policy_list in.

• Wanneer ʼn MAC-hook later aangeroep word (byvoorbeeld vnode access, exec, ens.), loop MACF deur al die geregistreerde beleide om kollektiewe besluite te neem.

• In besonder is AMFI (Apple Mobile File Integrity) so ʼn sekuriteitsuitbreiding. Sy Info.plist sluit AppleSecurityExtension in wat dit as ʼn sekuriteitsbeleid merk.

• As deel van kernel-boot verseker die kernel se laailogika dat die “security policy” (AMFI, ens.) reeds aktief is voordat baie subsisteme daarvan afhanklik raak. Byvoorbeeld, die kernel “prepares for tasks ahead by loading … security policy, including AppleMobileFileIntegrity (AMFI), Sandbox, Quarantine policy.”

cd /System/Library/Extensions
find . -name Info.plist | xargs grep AppleSecurityExtension 2>/dev/null

./AppleImage4.kext/Contents/Info.plist:	<key>AppleSecurityExtension</key>
./ALF.kext/Contents/Info.plist:	<key>AppleSecurityExtension</key>
./CoreTrust.kext/Contents/Info.plist:	<key>AppleSecurityExtension</key>
./AppleMobileFileIntegrity.kext/Contents/Info.plist:	<key>AppleSecurityExtension</key>
./Quarantine.kext/Contents/Info.plist:	<key>AppleSecurityExtension</key>
./Sandbox.kext/Contents/Info.plist:	<key>AppleSecurityExtension</key>
./AppleSystemPolicy.kext/Contents/Info.plist:	<key>AppleSecurityExtension</key>

KPI-afhanklikheid & com.apple.kpi.dsep in MAC policy kexts

Wanneer jy 'n kext skryf wat die MAC framework gebruik (bv. deur mac_policy_register() ens.), moet jy afhanklikhede op KPIs (Kernel Programming Interfaces) verklaar sodat die kext-linker (kxld) daardie simbole kan oplos. Dus, om te verklaar dat 'n kext van MACF afhanklik is, moet jy dit in die Info.plist aandui met com.apple.kpi.dsep (find . Info.plist | grep AppleSecurityExtension), dan sal die kext verwys na simbole soos mac_policy_register, mac_policy_unregister, en MAC hook function pointers. Om daardie simbole op te los, moet jy com.apple.kpi.dsep as 'n afhanklikheid lys.

Example Info.plist snippet (inside your .kext):

<key>OSBundleLibraries</key>
<dict>
<key>com.apple.kpi.dsep</key>
<string>18.0</string>
<key>com.apple.kpi.libkern</key>
<string>18.0</string>
<key>com.apple.kpi.bsd</key>
<string>18.0</string>
<key>com.apple.kpi.mach</key>
<string>18.0</string>
… (other kpi dependencies as needed)
</dict>

MACF Oproepe

Dit is algemeen om oproepe na MACF te vind wat in kode gedefinieer is soos: #if CONFIG_MAC voorwaardelike blokke. Verder is dit moontlik om binne hierdie blokke oproepe na mac_proc_check* te vind, wat MACF aanroep om te kontroleer vir toestemming om sekere aksies uit te voer. Verder is die formaat van die MACF-oproepe: mac_<object>_<opType>_opName.

Die object is een van die volgende: bpfdesc, cred, file, proc, vnode, mount, devfs, ifnet, inpcb, mbuf, ipq, pipe, sysv[msg/msq/shm/sem], posix[shm/sem], socket, kext.
Die opType is gewoonlik check, wat gebruik sal word om die aksie toe te laat of te weier. Dit is egter ook moontlik om notify te vind, wat die kext sal toelaat om op die gegewe aksie te reageer.

Jy kan 'n voorbeeld vind by https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/bsd/kern/kern_mman.c#L621:

int
mmap(proc_t p, struct mmap_args *uap, user_addr_t *retval)
{
[...]
#if CONFIG_MACF
			error = mac_file_check_mmap(vfs_context_ucred(ctx),
			    fp->fp_glob, prot, flags, file_pos + pageoff,
&maxprot);
if (error) {
(void)vnode_put(vp);
goto bad;
}
#endif /* MAC */
[...]

Dan is dit moontlik om die kode van mac_file_check_mmap te vind in https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac_file.c#L174

mac_file_check_mmap(struct ucred *cred, struct fileglob *fg, int prot,
int flags, uint64_t offset, int *maxprot)
{
int error;
int maxp;

maxp = *maxprot;
MAC_CHECK(file_check_mmap, cred, fg, NULL, prot, flags, offset, &maxp);
if ((maxp | *maxprot) != *maxprot) {
panic("file_check_mmap increased max protections");
}
*maxprot = maxp;
return error;
}

Wat die MAC_CHECK macro aanroep, waarvan die kode gevind kan word in https://github.com/apple-oss-distributions/xnu/blob/94d3b452840153a99b38a3a9659680b2a006908e/security/mac_internal.h#L261

/*
* MAC_CHECK performs the designated check by walking the policy
* module list and checking with each as to how it feels about the
* request.  Note that it returns its value via 'error' in the scope
* of the caller.
*/
#define MAC_CHECK(check, args...) do {                              \
error = 0;                                                      \
MAC_POLICY_ITERATE({                                            \
if (mpc->mpc_ops->mpo_ ## check != NULL) {              \
DTRACE_MACF3(mac__call__ ## check, void *, mpc, int, error, int, MAC_ITERATE_CHECK); \
int __step_err = mpc->mpc_ops->mpo_ ## check (args); \
DTRACE_MACF2(mac__rslt__ ## check, void *, mpc, int, __step_err); \
error = mac_error_select(__step_err, error);         \
}                                                           \
});                                                             \
} while (0)

Wat oor al die geregistreerde mac-polisies sal gaan, hul funksies sal aanroep en die uitslag in die error-veranderlike sal stoor, wat slegs deur mac_error_select met sukses-kodes oorskrybaar is — dus as enige check misluk sal die hele toets misluk en sal die aksie nie toegelaat word nie.

/*
* MAC_GRANT performs the designated check by walking the policy
* module list and checking with each as to how it feels about the
* request.  Unlike MAC_CHECK, it grants if any policies return '0',
* and otherwise returns EPERM.  Note that it returns its value via
* 'error' in the scope of the caller.
*/
#define MAC_GRANT(check, args...) do {                              \
   error = EPERM;                                                  \
   MAC_POLICY_ITERATE({                                            \
	if (mpc->mpc_ops->mpo_ ## check != NULL) {                  \
	        DTRACE_MACF3(mac__call__ ## check, void *, mpc, int, error, int, MAC_ITERATE_GRANT); \
	        int __step_res = mpc->mpc_ops->mpo_ ## check (args); \
	        if (__step_res == 0) {                              \
	                error = 0;                                  \
	        }                                                   \
	        DTRACE_MACF2(mac__rslt__ ## check, void *, mpc, int, __step_res); \
	    }                                                           \
   });                                                             \
} while (0)

priv_check & priv_grant

Hierdie callouts is bedoel om (tientalle) voorregte te kontroleer en te verskaf wat gedefinieer is in bsd/sys/priv.h.
Sommige kernelkode sal priv_check_cred() aanroep vanaf bsd/kern/kern_priv.c met die KAuth-credentials van die proses en een van die voorregkodes, wat mac_priv_check sal aanroep om te kyk of enige beleid die toekenning van die voorreg weier, en dan mac_priv_grant aanroep om te sien of enige beleid die privilege toeken.

proc_check_syscall_unix

Hierdie hook maak dit moontlik om alle system calls te onderskep. In bsd/dev/[i386|arm]/systemcalls.c is dit moontlik om die verklaarde funksie unix_syscall te sien, wat hierdie kode bevat:

#if CONFIG_MACF
if (__improbable(proc_syscall_filter_mask(proc) != NULL && !bitstr_test(proc_syscall_filter_mask(proc), syscode))) {
error = mac_proc_check_syscall_unix(proc, syscode);
if (error) {
goto skip_syscall;
}
}
#endif /* CONFIG_MACF */

Dit sal in die oproepende proses se bitmask nagaan of die huidige syscall mac_proc_check_syscall_unix aangeroep moet word. Dit is omdat syscalls so gereeld aangeroep word dat dit sinvol is om te vermy dat mac_proc_check_syscall_unix elke keer aangeroep word.

Neem kennis dat die funksie proc_set_syscall_filter_mask(), wat die bitmask vir syscalls in 'n proses instel, deur Sandbox aangeroep word om maskers op sandboxed processes te stel.

Blootgestelde MACF syscalls

Dit is moontlik om met MACF te kommunikeer deur sommige syscalls wat in security/mac.h gedefinieer is:

/*
* Extended non-POSIX.1e interfaces that offer additional services
* available from the userland and kernel MAC frameworks.
*/
#ifdef __APPLE_API_PRIVATE
__BEGIN_DECLS
int      __mac_execve(char *fname, char **argv, char **envv, mac_t _label);
int      __mac_get_fd(int _fd, mac_t _label);
int      __mac_get_file(const char *_path, mac_t _label);
int      __mac_get_link(const char *_path, mac_t _label);
int      __mac_get_pid(pid_t _pid, mac_t _label);
int      __mac_get_proc(mac_t _label);
int      __mac_set_fd(int _fildes, const mac_t _label);
int      __mac_set_file(const char *_path, mac_t _label);
int      __mac_set_link(const char *_path, mac_t _label);
int      __mac_mount(const char *type, const char *path, int flags, void *data,
struct mac *label);
int      __mac_get_mount(const char *path, struct mac *label);
int      __mac_set_proc(const mac_t _label);
int      __mac_syscall(const char *_policyname, int _call, void *_arg);
__END_DECLS
#endif /*__APPLE_API_PRIVATE*/

Verwysings

• *OS Internals Volume III