MacOS Security & Privilege Escalation

Support HackTricks and get benefits!
First of all, please note that most of the tricks about privilege escalation affecting Linux/Unix will affect also MacOS machines. So see:
Linux Privilege Escalation
Basic MacOS
OS X Specific Extensions
.dmg: Apple Disk Image files are very frequent for installers.
.kext: It must follow a specific structure and it's the OS X version of a driver.
.plist: Also known as property list stores information in XML or binary format.
Can be XML or binary. Binary ones can be read with:
defaults read config.plist
/usr/libexec/PlistBuddy -c print config.plsit
plutil -p config.plist
.app: Apple applications that follows directory structure.
.dylib: Dynamic libraries (like Windows DLL files)
.pkg: Are the same as xar (eXtensible Archive format). The installer command can be use to install the contents of these files.
File hierarchy layout
/Applications: The installed apps should be here. All the users will be able to access them.
/bin: Command line binaries
/cores: If exists, it's used to store core dumps
/dev: Everything is treated as a file so you may see hardware devices stored here.
/etc: Configuration files
/Library: A lot of subdirectories and files related to preferences, caches and logs can be found here. A Library folder exists in root and on each user's directory.
/private: Undocumented but a lot of the mentioned folders are symbolic links to the private directory.
/sbin: Essential system binaries (related to administration)
/System: File fo making OS X run. You should find mostly only Apple specific files here (not third party).
/tmp: Files are deleted after 3 days (it's a soft link to /private/tmp)
/Users: Home directory for users.
/usr: Config and system binaries
/var: Log files
/Volumes: The mounted drives will apear here.
/.vol: Running stat a.txt you obtain something like 16777223 7545753 -rw-r--r-- 1 username wheel ... where the first number is the id number of the volume where the file exists and the second one is the inode number. You can access the content of this file through /.vol/ with that information running cat /.vol/16777223/7545753
Special MacOS files and folders
.DS_Store: This file is on each directory, it saves the attributes and customisations of the directory.
.Spotlight-V100: This folder appears on the root directory of every volume on the system.
.metadata_never_index: If this file is at the root of a volume Spotlight won't index that volume.
<name>.noindex: Files and folder with this extension won't be indexed by Spotlight.
**$HOME/Library/Preferences/com.apple.LaunchServices.QuarantineEventsV**2: Contains information about downloaded files, like the URL from where they were downloaded.
/var/log/system.log: Main log of OSX systems. com.apple.syslogd.plist is responsible for the execution of syslogging (you can check if it's disabled looking for "com.apple.syslogd" in launchctl list.
/private/var/log/asl/*.asl: These are the Apple System Logs which may contain interesting information.
$HOME/Library/Preferences/com.apple.recentitems.plist: Stores recently accessed files and applications through "Finder".
$HOME/Library/Preferences/com.apple.loginitems.plsit: Stores items to launch upon system startup
$HOME/Library/Logs/DiskUtility.log: Log file for thee DiskUtility App (info about drives, including USBs)
/Library/Preferences/SystemConfiguration/com.apple.airport.preferences.plist: Data about wireless access points.
/private/var/db/launchd.db/com.apple.launchd/overrides.plist: List of daemons deactivated.
/private/etc/kcpassword: If autologin is enabled this file will contain the users login password XORed with a key.
Common users
Daemon: User reserved for system daemons. The default daemon account names usually start with a "_":
_amavisd, _analyticsd, _appinstalld, _appleevents, _applepay, _appowner, _appserver, _appstore, _ard, _assetcache, _astris, _atsserver, _avbdeviced, _calendar, _captiveagent, _ces, _clamav, _cmiodalassistants, _coreaudiod, _coremediaiod, _coreml, _ctkd, _cvmsroot, _cvs, _cyrus, _datadetectors, _demod, _devdocs, _devicemgr, _diskimagesiod, _displaypolicyd, _distnote, _dovecot, _dovenull, _dpaudio, _driverkit, _eppc, _findmydevice, _fpsd, _ftp, _fud, _gamecontrollerd, _geod, _hidd, _iconservices, _installassistant, _installcoordinationd, _installer, _jabber, _kadmin_admin, _kadmin_changepw, _knowledgegraphd, _krb_anonymous, _krb_changepw, _krb_kadmin, _krb_kerberos, _krb_krbtgt, _krbfast, _krbtgt, _launchservicesd, _lda, _locationd, _logd, _lp, _mailman, _mbsetupuser, _mcxalr, _mdnsresponder, _mobileasset, _mysql, _nearbyd, _netbios, _netstatistics, _networkd, _nsurlsessiond, _nsurlstoraged, _oahd, _ondemand, _postfix, _postgres, _qtss, _reportmemoryexception, _rmd, _sandbox, _screensaver, _scsd, _securityagent, _softwareupdate, _spotlight, _sshd, _svn, _taskgated, _teamsserver, _timed, _timezone, _tokend, _trustd, _trustevaluationagent, _unknown, _update_sharing, _usbmuxd, _uucp, _warmd, _webauthserver, _windowserver, _www, _wwwproxy, _xserverdocs
Guest: Account for guests with very strict permissions
state=("automaticTime" "afpGuestAccess" "filesystem" "guestAccount" "smbGuestAccess"); for i in "${state[@]}"; do sysadminctl -"${i}" status; done;
Nobody: Processes are executed with this user when minimal permissions are required
Root
User Privileges
Standard User: The most basic of users. This user needs permissions granted from an admin user when attempting to install software or perform other advanced tasks. They are not able to do it on their own.
Admin User: A user who operates most of the time as a standard user but is also allowed to perform root actions such as install software and other administrative tasks. All users belonging to the admin group are given access to root via the sudoers file.
Root: Root is a user allowed to perform almost any action (there are limitations imposed by protections like System Integrity Protection).
For example root won't be able to place a file inside /System
File ACLs
When the file contains ACLs you will find a "+" when listing the permissions like in:
ls -ld Movies
drwx------+   7 username  staff     224 15 Apr 19:42 Movies
You can read the ACLs of the file with:
ls -lde Movies
drwx------+ 7 username  staff  224 15 Apr 19:42 Movies
 0: group:everyone deny delete
You can find all the files with ACLs with (this is veeery slow):
ls -RAle / 2>/dev/null | grep -E -B1 "\d: "
Resource Forks or MacOS ADS
This is a way to obtain Alternate Data Streams in MacOS machines. You can save content inside an extended attribute called com.apple.ResourceFork inside a file by saving it in file/..namedfork/rsrc.
echo "Hello" > a.txt
echo "Hello Mac ADS" > a.txt/..namedfork/rsrc
​
xattr -l a.txt #Read extended attributes
com.apple.ResourceFork: Hello Mac ADS
​
ls -l a.txt #The file length is still q
[email protected] 1 username  wheel  6 17 Jul 01:15 a.txt
You can find all the files containing this extended attribute with:
find / -type f -exec ls -ld {} \; 2>/dev/null | grep -E "[x\-]@ " | awk '{printf $9; printf "\n"}' | xargs -I {} xattr -lv {} | grep "com.apple.ResourceFork"
Risk Files Mac OS
The files /System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/System contains the risk associated to files depending on the file extension.
The possible categories include the following:
LSRiskCategorySafe: Totally safe; Safari will auto-open after download
LSRiskCategoryNeutral: No warning, but not auto-opened
LSRiskCategoryUnsafeExecutable: Triggers a warning “This file is an application...”
LSRiskCategoryMayContainUnsafeExecutable: This is for things like archives that contain an executable. It triggers a warning unless Safari can determine all the contents are safe or neutral.
Remote Access Services
You can enable/disable these services in "System Preferences" --> Sharing
VNC, known as “Screen Sharing”
SSH, called “Remote Login”
Apple Remote Desktop (ARD), or “Remote Management”
AppleEvent, known as “Remote Apple Event”
Check if any is enabled running:
rmMgmt=$(netstat -na | grep LISTEN | grep tcp46 | grep "*.3283" | wc -l);
scrShrng=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.5900" | wc -l);
flShrng=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | egrep "\*.88|\*.445|\*.548" | wc -l);
rLgn=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.22" | wc -l);
rAE=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.3031" | wc -l);
bmM=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.4488" | wc -l);
printf "\nThe following services are OFF if '0', or ON otherwise:\nScreen Sharing: %s\nFile Sharing: %s\nRemote Login: %s\nRemote Mgmt: %s\nRemote Apple Events: %s\nBack to My Mac: %s\n\n" "$scrShrng" "$flShrng" "$rLgn" "$rmMgmt" "$rAE" "$bmM";
MacOS Architecture
Mac OS Architecture
MacOS Serial Number
MacOS Serial Number
MacOS MDM
MacOS MDM
MacOS Protocols
MacOS Protocols
MacOS - Inspecting, Debugging and Fuzzing
MacOS Apps - Inspecting, debugging and Fuzzing
MacOS Security Mechanisms
Gatekeeper
​In this talk Jeremy Brown talks about this protections and a bug that allowed to bypass them.
Gatekeeper is designed to ensure that, by default, only trusted software runs on a user’s Mac. Gatekeeper is used when a user downloads and opens an app, a plug-in or an installer package from outside the App Store. Gatekeeper verifies that the software is signed by an identified developer, is notarised by Apple to be free of known malicious content, and hasn’t been altered. Gatekeeper also requests user approval before opening downloaded software for the first time to make sure the user hasn’t been tricked into running executable code they believed to simply be a data file.
Notarizing
In order for an app to be notarised by Apple, the developer needs to send the app for review. Notarization is not App Review. The Apple notary service is an automated system that scans your software for malicious content, checks for code-signing issues, and returns the results to you quickly. If there are no issues, the notary service generates a ticket for you to staple to your software; the notary service also publishes that ticket online where Gatekeeper can find it.
When the user first installs or runs your software, the presence of a ticket (either online or attached to the executable) tells Gatekeeper that Apple notarized the software. Gatekeeper then places descriptive information in the initial launch dialog indicating that Apple has already checked for malicious content.
File Quarantine
Gatekeeper builds upon File Quarantine.
Upon download of an application, a particular extended file attribute ("quarantine flag") can be added to the downloaded file. This attribute is added by the application that downloads the file, such as a web browser or email client, but is not usually added by others like common BitTorrent client software.
When a user executes a "quarantined" file, Gatekeeper is the one that performs the mentioned actions to allow the execution of the file.
Checking the validity of code signatures is a resource-intensive process that includes generating cryptographic hashes of the code and all its bundled resources. Furthermore, checking certificate validity involves doing an online check to Apple's servers to see if it has been revoked after it was issued. For these reasons, a full code signature and notarization check is impractical to run every time an app is launched.
Therefore, these checks are only run when executing apps with the quarantined attribute.
Safari and other web browsers and applications are the ones that
It's possible to check it's status and enable/disable (root required) with:
spctl --status
assessments enabled
​
spctl --enable
spctl --disable
#You can also allow nee identifies to execute code using the binary "spctl"
You can also find if a file has the quarantine extended attribute with:
xattr portada.png
com.apple.macl
com.apple.quarantine
Check the value of the extended attributes with:
xattr -l portada.png
com.apple.macl:
00000000  03 00 53 DA 55 1B AE 4C 4E 88 9D CA B7 5C 50 F3  |..S.U..LN.....P.|
00000010  16 94 03 00 27 63 64 97 98 FB 4F 02 84 F3 D0 DB  |....'cd...O.....|
00000020  89 53 C3 FC 03 00 27 63 64 97 98 FB 4F 02 84 F3  |.S....'cd...O...|
00000030  D0 DB 89 53 C3 FC 00 00 00 00 00 00 00 00 00 00  |...S............|
00000040  00 00 00 00 00 00 00 00                          |........|
00000048
com.apple.quarantine: 0081;607842eb;Brave;F643CD5F-6071-46AB-83AB-390BA944DEC5
And remove that attribute with:
xattr -d com.apple.quarantine portada.png
#You can also remove this attribute from every file with
find . -iname '*' -print0 | xargs -0 xattr -d com.apple.quarantine
And find all the quarantined files with:
find / -exec ls -ld {} \; 2>/dev/null | grep -E "[x\-]@ " | awk '{printf $9; printf "\n"}' | xargs -I {} xattr -lv {} | grep "com.apple.quarantine"
XProtect
X-Protect is also part of Gatekeeper. It's Apple’s built in malware scanner. It keeps track of known malware hashes and patterns.
You can get information about the latest XProtect update running:
system_profiler SPInstallHistoryDataType 2>/dev/null | grep -A 4 "XProtectPlistConfigData" | tail -n 5
MRT: Malware Removal Tool
Should malware make its way onto a Mac, macOS also includes technology to remediate infections. The Malware Removal Tool (MRT) is an engine in macOS that remediates infections based on updates automatically delivered from Apple (as part of automatic updates of system data files and security updates). MRT removes malware upon receiving updated information and it continues to check for infections on restart and login. MRT doesn’t automatically reboot the Mac. (From here)
Automatic Security Updates
Apple issues the updates for XProtect and MRT automatically based on the latest threat intelligence available. By default, macOS checks for these updates daily. Notarisation updates are distributed using CloudKit sync and are much more frequent.
TCC
TCC (Transparency, Consent, and Control) is a mechanism in macOS to limit and control application access to certain features, usually from a privacy perspective. This can include things such as location services, contacts, photos, microphone, camera, accessibility, full disk access, and a bunch more.
From a user’s perspective, they see TCC in action when an application wants access to one of the features protected by TCC. When this happens the user is prompted with a dialog asking them whether they want to allow access or not. This response is then stored in the TCC database.
An example of a TCC prompt
Check some of the already given permissions to apps in System Preferences --> Security & Privacy --> Privacy --> Files and Folders.
The TCC database is just a sqlite3 database, which makes the task of investigating it much simpler. There are two different databases, a global one in /Library/Application Support/com.apple.TCC/TCC.db and a per-user one located in /Users/<username>/Library/Application Support/com.apple.TCC/TCC.db. The first database is protected from editing with SIP(System Integrity Protection), but you can read them by granting terminal(or your editor) full disk access.
This information was taken from here (read the original source for more information).
Some protected directories:
$HOME/Desktop
$HOME/Documents
$HOME/Downloads
iCloud Drive
...
Unprotected directories:
$HOME (itself)
$HOME/.ssh, $HOME/.aws, etc
/tmp
Bypasses
By default an access via SSH will have "Full Disk Access". In order to disable this you need to have it listed but disabled (removing it from the list won't remove those privileges):
Here you can find examples of how some malwares have been able to bypass this protection:
​https://www.jamf.com/blog/zero-day-tcc-bypass-discovered-in-xcsset-malware/​
Seatbelt Sandbox
MacOS Sandbox works with the kernel extension Seatbelt. It makes applications run inside the sandbox need to request access to resources outside of the limited sandbox. This helps to ensure that the application will be accessing only expected resources and if it wants to access anything else it will need to ask for permissions to the user.
Important system services also run inside their own custom sandbox such as the mdnsresponder service. You can view these custom sandbox profiles inside the /usr/share/sandbox directory. Other sandbox profiles can be checked in https://github.com/s7ephen/OSX-Sandbox--Seatbelt--Profiles.
To start an application with a sandbox config you can use:
sandbox-exec -f example.sb /Path/To/The/Application
Note that the Apple-authored software that runs on Windows doesn’t have additional security precautions, such as application sandboxing.
Bypasses examples:
​https://lapcatsoftware.com/articles/sandbox-escape.html​
​https://desi-jarvis.medium.com/office365-macos-sandbox-escape-fcce4fa4123c (they are able to write files outside the sandbox whose name starts with ~$).
SIP - System Integrity Protection
This protection was enabled to help keep root level malware from taking over certain parts of the operating system. Although this means applying limitations to the root user many find it to be worthwhile trade off.
The most notable of these limitations are that users can no longer create, modify, or delete files inside of the following four directories in general:
/System
/bin
/sbin
/usr
Note that there are exceptions specified by Apple: The file /System/Library/Sandbox/rootless.conf holds a list of files and directories that cannot be modified. But if the line starts with an asterisk it means that it can be modified as exception.
For example, the config lines:
        /usr
*				/usr/libexec/cups
*				/usr/local
*				/usr/share/man
Means that /usr cannot be modified except for the 3 allowed folders allowed.
The final exception to these rules is that any installer package signed with the Apple’s certificate can bypass SIP protection, but only Apple’s certificate. Packages signed by standard developers will still be rejected when trying to modify SIP protected directories.
Note that if a file is specified in the previous config file but it doesn't exist, it can be created. This might be used by malware to obtain stealth persistence. For example, imagine that a .plist in /System/Library/LaunchDaemons appears listed but it doesn't exist. A malware may create one and use it as persistence mechanism.
Also, note how files and directories specified in rootless.conf have a rootless extended attribute:
xattr /System/Library/LaunchDaemons/com.apple.UpdateSettings.plist
com.apple.rootless
​
ls -lO /System/Library/LaunchDaemons/com.apple.UpdateSettings.plist
[email protected] 1 root  wheel  restricted,compressed 412  1 Jan  2020 /System/Library/LaunchDaemons/com.apple.UpdateSettings.plist
SIP handles a number of other limitations as well. Like it doesn't allows for the loading of unsigned kexts. SIP is also responsible for ensuring that no OS X system processes are debugged. This also means that Apple put a stop to dtrace inspecting system processes.
Check if SIP is enabled with:
csrutil status
System Integrity Protection status: enabled.
If you want to disable it, you need to put the computer in recovery mode (start it pressing command+R) and execute: csrutil disable
You can also maintain it enable but without debugging protections doing:
csrutil enable --without debug
For more information about SIP read the following response: https://apple.stackexchange.com/questions/193368/what-is-the-rootless-feature-in-el-capitan-really​
This post about a SIP bypass vulnerability is also very interesting: https://www.microsoft.com/security/blog/2021/10/28/microsoft-finds-new-macos-vulnerability-shrootless-that-could-bypass-system-integrity-protection/​
More bypasses in https://jhftss.github.io/CVE-2022-26712-The-POC-For-SIP-Bypass-Is-Even-Tweetable/​
Apple Binary Signatures
When checking some malware sample you should always check the signature of the binary as the developer that signed it may be already related with malware.
#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
​
#Check if the app’s contents have been modified
codesign --verify --verbose /Applications/Safari.app
​
#Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app
Installed Software & Services
Check for suspicious applications installed and privileges over the.installed resources:
system_profiler SPApplicationsDataType #Installed Apps
system_profiler SPFrameworksDataType #Instaled framework
lsappinfo list #Installed Apps
launchtl list #Services
User Processes
# will print all the running services under that particular user domain.
launchctl print gui/<users UID>
​
# will print all the running services under root
launchctl print system
​
# will print detailed information about the specific launch agent. And if it’s not running or you’ve mistyped, you will get some output with a non-zero exit code: Could not find service “com.company.launchagent.label” in domain for login
launchctl print gui/<user's UID>/com.company.launchagent.label
Auto Start Extensibility Point (ASEP)
An ASEP is a location on the system that could lead to the execution of a binary without user interaction. The main ones used in OS X take the form of plists.
Launchd
launchd is the first process executed by OX S kernel at startup and the last one to finish at shut down. It should always have the PID 1. This process will read and execute the configurations indicated in the ASEP plists in:
/Library/LaunchAgents: Per-user agents installed by the admin
/Library/LaunchDaemons: System-wide daemons installed by the admin
/System/Library/LaunchAgents: Per-user agents provided by Apple.
/System/Library/LaunchDaemons: System-wide daemons provided by Apple.
When a user logs in the plists located in /Users/$USER/Library/LaunchAgents and /Users/$USER/Library/LaunchDemons are started with the logged users permissions.
The main difference between agents and daemons is that agents are loaded when the user logs in and the daemons are loaded at system startup (as there are services like ssh that needs to be executed before any user access the system). Also agents may use GUI while daemons need to run in the background.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN">
<plist version="1.0">
<dict>
    <key>Label</key>
        <string>com.apple.someidentifier</string>
    <key>ProgramArguments</key>
    <array>
        <string>/Users/username/malware</string>
    </array>
    <key>RunAtLoad</key><true/> <!--Execute at system startup-->
    <key>StartInterval</key>
    <integer>800</integer> <!--Execute each 800s-->
    <key>KeepAlive</key>
    <dict>
        <key>SuccessfulExit</key></false> <!--Re-execute if exit unsuccessful-->
        <!--If previous is true, then re-execute in successful exit-->
    </dict>
</dict>
</plist>
There are cases where an agent needs to be executed before the user logins, these are called PreLoginAgents. For example, this is useful to provide assistive technology at login. They can be found also in /Library/LaunchAgents(see here an example).
New Daemons or Agents config files will be loaded after next reboot or using launchctl load <target.plist> It's also possible to load .plist files without that extension with launchctl -F <file> (however those plist files won't be automatically loaded after reboot).
It's also possible to unload with launchctl unload <target.plist> (the process pointed by it will be terminated),
To ensure that there isn't anything (like an override) preventing an Agent or Daemon from running run: sudo launchctl load -w /System/Library/LaunchDaemos/com.apple.smdb.plist
List all the agents and daemons loaded by the current user:
launchctl list
Cron
List the cron jobs of the current user with:
crontab -l
You can also see all the cron jobs of the users in /usr/lib/cron/tabs/ and /var/at/tabs/ (needs root).
In MacOS several folders executing scripts with certain frequency can be found in:
ls -lR /usr/lib/cron/tabs/ /private/var/at/jobs /etc/periodic/
There you can find the regular cron jobs, the at jobs (not very used) and the periodic jobs (mainly used for cleaning temporary files). The daily periodic jobs can be executed for example with: periodic daily.
kext
In order to install a KEXT as a startup item, it needs to be installed in one of the following locations:
/System/Library/Extensions
KEXT files built into the OS X operating system.
/Library/Extensions
KEXT files installed by 3rd party software
You can list currently loaded kext files with:
kextstat #List loaded kext
kextload /path/to/kext.kext #Load a new one based on path
kextload -b com.apple.driver.ExampleBundle #Load a new one based on path
kextunload /path/to/kext.kext
kextunload -b com.apple.driver.ExampleBundle
For more information about kernel extensions check this section.
Login Items
In System Preferences -> Users & Groups -> Login Items you can find items to be executed when the user logs in.
It it's possible to list them, add and remove from the command line:
#List all items:
osascript -e 'tell application "System Events" to get the name of every login item'
​
#Add an item:
osascript -e 'tell application "System Events" to make login item at end with properties {path:"/path/to/itemname", hidden:false}' 
​
#Remove an item:
osascript -e 'tell application "System Events" to delete login item "itemname"' 
These items are stored in the file /Users/<username>/Library/Application Support/com.apple.backgroundtaskmanagementagent
At
“At tasks” are used to schedule tasks at specific times.
These tasks differ from cron in that they are one time tasks that get removed after executing. However, they will survive a system restart so they can’t be ruled out as a potential threat.
By default they are disabled but the root user can enable them with:
sudo launchctl load -F /System/Library/LaunchDaemons/com.apple.atrun.plist
This will create a file at 13:37:
echo hello > /tmp/hello | at 1337
If AT tasks aren't enabled the created tasks won't be executed.
Login/Logout Hooks
They are deprecated but can be used to execute commands when a user logs in.
cat > $HOME/hook.sh << EOF
#!/bin/bash
echo 'My is: \`id\`' > /tmp/login_id.txt
EOF
chmod +x $HOME/hook.sh
defaults write com.apple.loginwindow LoginHook /Users/$USER/hook.sh
This setting is stored in /Users/$USER/Library/Preferences/com.apple.loginwindow.plist
defaults read /Users/$USER/Library/Preferences/com.apple.loginwindow.plist
{
    LoginHook = "/Users/username/hook.sh";
    MiniBuddyLaunch = 0;
    TALLogoutReason = "Shut Down";
    TALLogoutSavesState = 0;
    oneTimeSSMigrationComplete = 1;
}
To delete it:
defaults delete com.apple.loginwindow LoginHook
In the previous example we have created and deleted a LoginHook, it's also possible to create a LogoutHook.
The root user one is stored in /private/var/root/Library/Preferences/com.apple.loginwindow.plist
Emond
Apple introduced a logging mechanism called emond. It appears it was never fully developed, and development may have been abandoned by Apple for other mechanisms, but it remains available.
This little-known service may not be much use to a Mac admin, but to a threat actor one very good reason would be to use it as a persistence mechanism that most macOS admins probably wouldn't know to look for. Detecting malicious use of emond shouldn't be difficult, as the System LaunchDaemon for the service looks for scripts to run in only one place:
ls -l /private/var/db/emondClients
As this isn't used much, anything in that folder should be suspicious
Startup Items
This is deprecated, so nothing should be found in the following directories.
A StartupItem is a directory that gets placed in one of these two folders. /Library/StartupItems/ or /System/Library/StartupItems/
After placing a new directory in one of these two locations, two more items need to be placed inside that directory. These two items are a rc script and a plist that holds a few settings. This plist must be called “StartupParameters.plist”.
StartupParameters.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Description</key>
        <string>This is a description of this service</string>
    <key>OrderPreference</key>
        <string>None</string> <!--Other req services to execute before this -->
    <key>Provides</key>
    <array>
        <string>superservicename</string> <!--Name of the services provided by this file -->
    </array>
</dict>
</plist>
superservicename
#!/bin/sh
. /etc/rc.common
​
StartService(){
    touch /tmp/superservicestarted
}
​
StopService(){
    rm /tmp/superservicestarted
}
​
RestartService(){
    echo "Restarting"
}
​
RunService "$1"
/etc/rc.common
This isn't working in modern MacOS versions
It's also possible to place here commands that will be executed at startup. Example os regular rc.common script:
#
# Common setup for startup scripts.
#
# Copyright 1998-2002 Apple Computer, Inc.
#
​
######################
# Configure the shell #
######################
​
#
# Be strict
#
#set -e
set -u
​
#
# Set command search path
#
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/libexec:/System/Library/CoreServices; export PATH
​
#
# Set the terminal mode
#
#if [ -x /usr/bin/tset ] && [ -f /usr/share/misc/termcap ]; then
#    TERM=$(tset - -Q); export TERM
#fi
​
###################
# Useful functions #
###################
​
#
# Determine if the network is up by looking for any non-loopback
# internet network interfaces.
#
CheckForNetwork()
{
    local test
​
    if [ -z "${NETWORKUP:=}" ]; then
	test=$(ifconfig -a inet 2>/dev/null | sed -n -e '/127.0.0.1/d' -e '/0.0.0.0/d' -e '/inet/p' | wc -l)
	if [ "${test}" -gt 0 ]; then
	    NETWORKUP="-YES-"
	else
	    NETWORKUP="-NO-"
	fi
    fi
}
​
alias ConsoleMessage=echo
​
#
# Process management
#
GetPID ()
{
    local program="$1"
    local pidfile="${PIDFILE:=/var/run/${program}.pid}"
    local     pid=""
​
    if [ -f "${pidfile}" ]; then
	pid=$(head -1 "${pidfile}")
	if ! kill -0 "${pid}" 2> /dev/null; then
	    echo "Bad pid file $pidfile; deleting."
	    pid=""
	    rm -f "${pidfile}"
	fi
    fi
​
    if [ -n "${pid}" ]; then
	echo "${pid}"
	return 0
    else
	return 1
    fi
}
​
#
# Generic action handler
#
RunService ()
{
    case $1 in
      start  ) StartService   ;;
      stop   ) StopService    ;;
      restart) RestartService ;;
      *      ) echo "$0: unknown argument: $1";;
    esac
}
Profiles
Configuration profiles can force a user to use certain browser settings, DNS proxy settings, or VPN settings. Many other payloads are possible which make them ripe for abuse.
You can enumerate them running:
ls -Rl /Library/Managed\ Preferences/
Other persistence techniques and tools
​https://github.com/cedowens/Persistent-Swift​
​https://github.com/D00MFist/PersistentJXA​
Memory Artifacts
Swap Files
/private/var/vm/swapfile0: This file is used as a cache when physical memory fills up. Data in physical memory will be pushed to the swapfile and then swapped back into physical memory if it’s needed again. More than one file can exist in here. For example, you might see swapfile0, swapfile1, and so on.
/private/var/vm/sleepimage: When OS X goes into hibernation, data stored in memory is put into the sleepimage file. When the user comes back and wakes the computer, memory is restored from the sleepimage and the user can pick up where they left off.
By default in modern MacOS systems this file will be encrypted, so it might be not recuperable.
However, the encryption of this file might be disabled. Check the out of sysctl vm.swapusage.
Dumping memory with osxpmem
In order to dump the memory in a MacOS machine you can use osxpmem.
#Dump raw format
sudo osxpmem.app/osxpmem --format raw -o /tmp/dump_mem
​
#Dump aff4 format
sudo osxpmem.app/osxpmem -o /tmp/dump_mem.aff4
If you find this error: osxpmem.app/MacPmem.kext failed to load - (libkern/kext) authentication failure (file ownership/permissions); check the system/kernel logs for errors or try kextutil(8) You can fix it doing:
sudo cp -r osxpmem.app/MacPmem.kext "/tmp/"
sudo kextutil "/tmp/MacPmem.kext"
#Allow the kext in "Security & Privacy --> General"
sudo osxpmem.app/osxpmem --format raw -o /tmp/dump_mem
Other errors might be fixed by allowing the load of the kext in "Security & Privacy --> General", just allow it.
You can also use this oneliner to download the application, load the kext and dump the memory:
sudo su
cd /tmp; wget https://github.com/google/rekall/releases/download/v1.5.1/osxpmem-2.1.post4.zip; unzip osxpmem-2.1.post4.zip; chown -R root:wheel osxpmem.app/MacPmem.kext; kextload osxpmem.app/MacPmem.kext; osxpmem.app/osxpmem --format raw -o /tmp/dump_mem
Passwords
Shadow Passwords
Shadow password is stored with the user's configuration in plists located in /var/db/dslocal/nodes/Default/users/.
The following oneliner can be use to dump all the information about the users (including hash info):
for l in /var/db/dslocal/nodes/Default/users/*; do if [ -r "$l" ];then echo "$l"; defaults read "$l"; fi; done
​Scripts like this one or this one can be used to transform the hash to hashcat format.
An alternative one-liner which will dump creds of all non-service accounts in hashcat format -m 7100 (macOS PBKDF2-SHA512):
sudo bash -c 'for i in $(find /var/db/dslocal/nodes/Default/users -type f -regex "[^_]*"); do plutil -extract name.0 raw $i | awk "{printf \$0\":\$ml\$\"}"; for j in {iterations,salt,entropy}; do l=$(k=$(plutil -extract ShadowHashData.0 raw $i) && base64 -d <<< $k | plutil -extract SALTED-SHA512-PBKDF2.$j raw -); if [[ $j == iterations ]]; then echo -n $l; else base64 -d <<< $l | xxd -p -c 0 | awk "{printf \"$\"\$0}"; fi; done; echo ""; done'
Keychain Dump
Note that when using the security binary to dump the passwords decrypted, several prompts will ask the user to allow this operation.
#security
secuirty dump-trust-settings [-s] [-d] #List certificates
security list-keychains #List keychain dbs
security list-smartcards #List smartcards
security dump-keychain | grep -A 5 "keychain" | grep -v "version" #List keychains entries
security dump-keychain -d #Dump all the info, included secrets (the user will be asked for his password, even if root)
​Keychaindump​
The attacker still needs to gain access to the system as well as escalate to root privileges in order to run keychaindump. This approach comes with its own conditions. As mentioned earlier, upon login your keychain is unlocked by default and remains unlocked while you use your system. This is for convenience so that the user doesn’t need to enter their password every time an application wishes to access the keychain. If the user has changed this setting and chosen to lock the keychain after every use, keychaindump will no longer work; it relies on an unlocked keychain to function.
It’s important to understand how Keychaindump extracts passwords out of memory. The most important process in this transaction is the ”securityd“ process. Apple refers to this process as a security context daemon for authorization and cryptographic operations. The Apple developer libraries don’t say a whole lot about it; however, they do tell us that securityd handles access to the keychain. In his research, Juuso refers to the key needed to decrypt the keychain as ”The Master Key“. A number of steps need to be taken to acquire this key as it is derived from the user’s OS X login password. If you want to read the keychain file you must have this master key. The following steps can be done to acquire it. Perform a scan of securityd’s heap (keychaindump does this with the vmmap command). Possible master keys are stored in an area flagged as MALLOC_TINY. You can see the locations of these heaps yourself with the following command:
sudo vmmap <securityd PID> | grep MALLOC_TINY
Keychaindump will then search the returned heaps for occurrences of 0x0000000000000018. If the following 8-byte value points to the current heap, we’ve found a potential master key. From here a bit of deobfuscation still needs to occur which can be seen in the source code, but as an analyst the most important part to note is that the necessary data to decrypt this information is stored in securityd’s process memory. Here’s an example of keychain dump output.
sudo ./keychaindump
Based on this comment https://github.com/juuso/keychaindump/issues/10#issuecomment-751218760 it looks like these tools aren't working anymore in Big Sur.

Basic MacOS

OS X Specific Extensions

File hierarchy layout

Special MacOS files and folders

Common users

User Privileges

File ACLs

Resource Forks or MacOS ADS

Risk Files Mac OS

Remote Access Services

MacOS Architecture

MacOS Serial Number

MacOS MDM

MacOS Protocols

MacOS - Inspecting, Debugging and Fuzzing

MacOS Security Mechanisms

Gatekeeper

Notarizing

File Quarantine

XProtect

MRT: Malware Removal Tool

Automatic Security Updates

TCC

Bypasses

Seatbelt Sandbox

SIP - System Integrity Protection

Apple Binary Signatures

Installed Software & Services

User Processes

Auto Start Extensibility Point (ASEP)

Launchd

Cron

kext

Login Items

At

Login/Logout Hooks

Emond

Startup Items

/etc/rc.common

Profiles

Other persistence techniques and tools

Memory Artifacts

Swap Files

Dumping memory with osxpmem

Passwords

Shadow Passwords

Keychain Dump

​Keychaindump​

Keychaindump