iOS Pentesting
Last updated
Last updated
Use Trickest to easily build and automate workflows powered by the world's most advanced community tools. Get Access Today:
In this page you can find information about the iOS simulator, emulators and jailbreaking:
During the testing several operations are going to be suggested (connect to the device, read/write/upload/download files, use some tools...). Therefore, if you don't know how to perform any of these actions please, start reading the page:
For the following steps the app should be installed in the device and should have already obtained the IPA file of the application. Read the Basic iOS Testing Operations page to learn how to do this.
It's recommended to use the tool MobSF to perform an automatic Static Analysis to the IPA file.
Identification of protections are present in the binary:
PIE (Position Independent Executable): When enabled, the application loads into a random memory address every-time it launches, making it harder to predict its initial memory address.
Stack Canaries: To validate the integrity of the stack, a ‘canary’ value is placed on the stack before calling a function and is validated again once the function ends.
ARC (Automatic Reference Counting): To prevent common memory corruption flaws
Encrypted Binary: The binary should be encrypted
Identification of Sensitive/Insecure Funcions
Weak Hashing Algorithms
Insecure Random Functions
Insecure ‘Malloc’ Function
Insecure and Vulnerable Functions
Check out the dynamic analysis that MobSF perform. You will need to navigate through the different views and interact with them but it will be hooking several classes on doing other things and will prepare a report once you are done.
Use the command frida-ps -Uai to determine the bundle identifier of the installed apps:
Learn how to enumerate the components of the application and how to easily hook methods and classes with objection:
The structure of an IPA file is essentially that of a zipped package. By renaming its extension to .zip, it can be decompressed to reveal its contents. Within this structure, a Bundle represents a fully packaged application ready for installation. Inside, you will find a directory named <NAME>.app, which encapsulates the application's resources.
Info.plist: This file holds specific configuration details of the application.
_CodeSignature/: This directory includes a plist file that contains a signature, ensuring the integrity of all files in the bundle.
Assets.car: A compressed archive that stores asset files like icons.
Frameworks/: This folder houses the application's native libraries, which may be in the form of .dylib or .framework files.
PlugIns/: This may include extensions to the application, known as .appex files, although they are not always present. * Core Data: It is used to save your application’s permanent data for offline use, to cache temporary data, and to add undo functionality to your app on a single device. To sync data across multiple devices in a single iCloud account, Core Data automatically mirrors your schema to a CloudKit container.
PkgInfo: The PkgInfo file is an alternate way to specify the type and creator codes of your application or bundle.
en.lproj, fr.proj, Base.lproj: Are the language packs that contains resources for those specific languages, and a default resource in case a language isn' t supported.
Security: The _CodeSignature/ directory plays a critical role in the app's security by verifying the integrity of all bundled files through digital signatures.
Asset Management: The Assets.car file uses compression to efficiently manage graphical assets, crucial for optimizing application performance and reducing its overall size.
Frameworks and PlugIns: These directories underscore the modularity of iOS applications, allowing developers to include reusable code libraries (Frameworks/) and extend app functionality (PlugIns/).
Localization: The structure supports multiple languages, facilitating global application reach by including resources for specific language packs.
Info.plist
The Info.plist serves as a cornerstone for iOS applications, encapsulating key configuration data in the form of key-value pairs. This file is a requisite for not only applications but also for app extensions and frameworks bundled within. It's structured in either XML or a binary format and holds critical information ranging from app permissions to security configurations. For a detailed exploration of available keys, one can refer to the Apple Developer Documentation.
For those looking to work with this file in a more accessible format, the XML conversion can be achieved effortlessly through the use of plutil on macOS (available natively on versions 10.2 and later) or plistutil on Linux. The commands for conversion are as follows:
For macOS:
For Linux:
Among the myriad of information that the Info.plist file can divulge, notable entries include app permission strings (UsageDescription), custom URL schemes (CFBundleURLTypes), and configurations for App Transport Security (NSAppTransportSecurity). These entries, along with others like exported/imported custom document types (UTExportedTypeDeclarations / UTImportedTypeDeclarations), can be effortlessly located by inspecting the file or employing a simple grep command:
Data Paths
In the iOS environment, directories are designated specifically for system applications and user-installed applications. System applications reside in the /Applications directory, while user-installed apps are placed under /var/mobile/containers/Data/Application/. These applications are assigned a unique identifier known as a 128-bit UUID, making the task of manually locating an app's folder challenging due to the randomness of the directory names.
As applications in iOS must be sandboxed, each app will have also a folder inside $HOME/Library/Containers with app's CFBundleIdentifier as the folder name.
However, both folders (data & container folders) have the file .com.apple.mobile_container_manager.metadata.plist that links both files in the key MCMetadataIdentifier).
To facilitate the discovery of a user-installed app's installation directory, the objection tool provides a useful command, env. This command reveals detailed directory information for the app in question. Below is an example of how to use this command:
Alternatively, the app name can be searched within the /private/var/containers using the find command:
Commands such as ps and lsof can also be utilized to identify the app's process and list open files, respectively, providing insights into the application's active directory paths:
Bundle directory:
AppName.app
This is the Application Bundle as seen before in the IPA, it contains essential application data, static content as well as the application's compiled binary.
This directory is visible to users, but users can't write to it.
Content in this directory is not backed up.
The contents of this folder are used to validate the code signature.
Data directory:
Documents/
Contains all the user-generated data. The application end user initiates the creation of this data.
Visible to users and users can write to it.
Content in this directory is backed up.
The app can disable paths by setting NSURLIsExcludedFromBackupKey.
Library/
Contains all files that aren't user-specific, such as caches, preferences, cookies, and property list (plist) configuration files.
iOS apps usually use the Application Support and Caches subdirectories, but the app can create custom subdirectories.
Library/Caches/
Contains semi-persistent cached files.
Invisible to users and users can't write to it.
Content in this directory is not backed up.
The OS may delete this directory's files automatically when the app is not running and storage space is running low.
Library/Application Support/
Contains persistent files necessary for running the app.
Invisible to users and users can't write to it.
Content in this directory is backed up.
The app can disable paths by setting NSURLIsExcludedFromBackupKey.
Library/Preferences/
Used for storing properties that can persist even after an application is restarted.
Information is saved, unencrypted, inside the application sandbox in a plist file called [BUNDLE_ID].plist.
All the key/value pairs stored using NSUserDefaults can be found in this file.
tmp/
Use this directory to write temporary files that do not need to persist between app launches.
Contains non-persistent cached files.
Invisible to users.
Content in this directory is not backed up.
The OS may delete this directory's files automatically when the app is not running and storage space is running low.
Let's take a closer look at iGoat-Swift's Application Bundle (.app) directory inside the Bundle directory (/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app):
Inside the <application-name>.app folder you will find a binary file called <application-name>. This is the file that will be executed. You can perform a basic inspection of the binary with the tool otool:
Check if the app is encrypted
See if there is any output for:
Disassembling the binary
Disassemble the text section:
To print the Objective-C segment of the sample application one can use:
In order to obtain a more compact Objective-C code you can use class-dump:
However, the best options to disassemble the binary are: Hopper and IDA.
Use Trickest to easily build and automate workflows powered by the world's most advanced community tools. Get Access Today:
To learn about how iOS stores data in the device read this page:
The following places to store information should be checked right after installing the application, after checking all the functionalities of the application and even after login out from one user and login into a different one. The goal is to find unprotected sensitive information of the application (passwords, tokens), of the current user and of previously logged users.
plist files are structured XML files that contains key-value pairs. It's a way to store persistent data, so sometimes you may find sensitive information in these files. It's recommended to check these files after installing the app and after using intensively it to see if new data is written.
The most common way to persist data in plist files is through the usage of NSUserDefaults. This plist file is saved inside the app sandbox in Library/Preferences/<appBundleID>.plist
The NSUserDefaults class provides a programmatic interface for interacting with the default system. The default system allows an application to customize its behaviour according to user preferences. Data saved by NSUserDefaults can be viewed in the application bundle. This class stores data in a plist file, but it's meant to be used with small amounts of data.
This data cannot be longer accessed directly via a trusted computer, but can be accessed performing a backup.
You can dump the information saved using NSUserDefaults using objection's ios nsuserdefaults get
To find all the plist of used by the application you can access to /private/var/mobile/Containers/Data/Application/{APPID} and run:
To convert files from XML or binary (bplist) format to XML, various methods depending on your operating system are available:
For macOS Users: Utilize the plutil command. It's a built-in tool in macOS (10.2+), designed for this purpose:
For Linux Users: Install libplist-utils first, then use plistutil to convert your file:
Within an Objection Session: For analyzing mobile applications, a specific command allows you to convert plist files directly:
Core Data is a framework for managing the model layer of objects in your application. Core Data can use SQLite as its persistent store, but the framework itself is not a database.
CoreData does not encrypt it's data by default. However, an additional encryption layer can be added to CoreData. See the GitHub Repo for more details.
You can find the SQLite Core Data information of an application in the path /private/var/mobile/Containers/Data/Application/{APPID}/Library/Application Support
If you can open the SQLite and access sensitive information, then you found a miss-configuration.
YapDatabase is a key/value store built on top of SQLite. As the Yap databases are sqlite databases you can find them using the purposed commend in the previous section.
It's common for applications to create their own sqlite database. They may be storing sensitive data on them and leaving it unencrypted. Therefore, it's always interesting to check every database inside the applications directory. Therefore go to the application directory where the data is saved (/private/var/mobile/Containers/Data/Application/{APPID})
Developers are enabled to store and sync data within a NoSQL cloud-hosted database through Firebase Real-Time Databases. Stored in JSON format, the data gets synchronized to all connected clients in real time.
You can find how to check for misconfigured Firebase databases here:
Realm Objective-C and Realm Swift offer a powerful alternative for data storage, not provided by Apple. By default, they store data unencrypted, with encryption available through specific configuration.
The databases are located at: /private/var/mobile/Containers/Data/Application/{APPID}. To explore these files, one can utilize commands like:
For viewing these database files, the Realm Studio tool is recommended.
To implement encryption within a Realm database, the following code snippet can be used:
Couchbase Lite is described as a lightweight and embedded database engine that follows the document-oriented (NoSQL) approach. Designed to be native to iOS and macOS, it offers the capability to sync data seamlessly.
To identify potential Couchbase databases on a device, the following directory should be inspected:
iOS store the cookies of the apps in the Library/Cookies/cookies.binarycookies inside each apps folder. However, developers sometimes decide to save them in the keychain as the mentioned cookie file can be accessed in backups.
To inspect the cookies file you can use this python script or use objection's ios cookies get.
You can also use objection to convert these files to a JSON format and inspect the data.
By default NSURLSession stores data, such as HTTP requests and responses in the Cache.db database. This database can contain sensitive data, if tokens, usernames or any other sensitive information has been cached. To find the cached information open the data directory of the app (/var/mobile/Containers/Data/Application/<UUID>) and go to /Library/Caches/<Bundle Identifier>. The WebKit cache is also being stored in the Cache.db file. Objection can open and interact with the database with the command sqlite connect Cache.db, as it is a normal SQLite database.
It is recommended to disable Caching this data, as it may contain sensitive information in the request or response. The following list below shows different ways of achieving this:
It is recommended to remove Cached responses after logout. This can be done with the provided method by Apple called removeAllCachedResponses You can call this method as follows:
URLCache.shared.removeAllCachedResponses()
This method will remove all cached requests and responses from Cache.db file.
If you don't need to use the advantage of cookies it would be recommended to just use the .ephemeral configuration property of URLSession, which will disable saving cookies and Caches.
An ephemeral session configuration object is similar to a default session configuration (see default), except that the corresponding session object doesn’t store caches, credential stores, or any session-related data to disk. Instead, session-related data is stored in RAM. The only time an ephemeral session writes data to disk is when you tell it to write the contents of a URL to a file.
Cache can be also disabled by setting the Cache Policy to .notAllowed. It will disable storing Cache in any fashion, either in memory or on disk.
Whenever you press the home button, iOS takes a snapshot of the current screen to be able to do the transition to the application on a much smoother way. However, if sensitive data is present in the current screen, it will be saved in the image (which persists across reboots). These are the snapshots that you can also access double tapping the home screen to switch between apps.
Unless the iPhone is jailbroken, the attacker needs to have access to the device unblocked to see these screenshots. By default the last snapshot is stored in the application's sandbox in Library/Caches/Snapshots/ or Library/SplashBoard/Snapshots folder (the trusted computers can' t access the filesystem from iOX 7.0).
Once way to prevent this bad behaviour is to put a blank screen or remove the sensitive data before taking the snapshot using the ApplicationDidEnterBackground() function.
The following is a sample remediation method that will set a default screenshot.
Swift:
Objective-C:
This sets the background image to overlayImage.png whenever the application is backgrounded. It prevents sensitive data leaks because overlayImage.png will always override the current view.
For accessing and managing the iOS keychain, tools like Keychain-Dumper are available, suitable for jailbroken devices. Additionally, Objection provides the command ios keychain dump for similar purposes.
The NSURLCredential class is ideal for saving sensitive information directly in the keychain, bypassing the need for NSUserDefaults or other wrappers. To store credentials after login, the following Swift code is used:
To extract these stored credentials, Objection's command ios nsurlcredentialstorage dump is utilized.
With iOS 8.0 onwards, users can install custom keyboard extensions, which are manageable under Settings > General > Keyboard > Keyboards. While these keyboards offer extended functionality, they pose a risk of keystroke logging and transmitting data to external servers, though users are notified about keyboards requiring network access. Apps can, and should, restrict the use of custom keyboards for sensitive information entry.
Security Recommendations:
It's advised to disable third-party keyboards for enhanced security.
Be aware of the autocorrect and auto-suggestions features of the default iOS keyboard, which could store sensitive information in cache files located in Library/Keyboard/{locale}-dynamic-text.dat or /private/var/mobile/Library/Keyboard/dynamic-text.dat. These cache files should be regularly checked for sensitive data. Resetting the keyboard dictionary via Settings > General > Reset > Reset Keyboard Dictionary is recommended for clearing cached data.
Intercepting network traffic can reveal whether a custom keyboard is transmitting keystrokes remotely.
The UITextInputTraits protocol offers properties to manage autocorrection and secure text entry, essential for preventing sensitive information caching. For example, disabling autocorrection and enabling secure text entry can be achieved with:
Additionally, developers should ensure that text fields, especially those for entering sensitive information like passwords and PINs, disable caching by setting autocorrectionType to UITextAutocorrectionTypeNo and secureTextEntry to YES.
Debugging code often involves the use of logging. There's a risk involved as logs may contain sensitive information. Previously, in iOS 6 and earlier versions, logs were accessible to all apps, posing a risk of sensitive data leakage. Now, applications are restricted to accessing only their logs.
Despite these restrictions, an attacker with physical access to an unlocked device can still exploit this by connecting the device to a computer and reading the logs. It is important to note that logs remain on the disk even after the app's uninstallation.
To mitigate risks, it is advised to thoroughly interact with the app, exploring all its functionalities and inputs to ensure no sensitive information is being logged inadvertently.
When reviewing the app's source code for potential leaks, look for both predefined and custom logging statements using keywords such as NSLog, NSAssert, NSCAssert, fprintf for built-in functions, and any mentions of Logging or Logfile for custom implementations.
Apps log various pieces of information which can be sensitive. To monitor these logs, tools and commands like:
are useful. Additionally, Xcode provides a way to collect console logs:
Open Xcode.
Connect the iOS device.
Navigate to Window -> Devices and Simulators.
Select your device.
Trigger the issue you're investigating.
Use the Open Console button to view logs in a new window.
For more advanced logging, connecting to the device shell and using socat can provide real-time log monitoring:
Followed by commands to observe log activities, which can be invaluable for diagnosing issues or identifying potential data leakage in logs.
Use Trickest to easily build and automate workflows powered by the world's most advanced community tools. Get Access Today:
Auto-backup features are integrated into iOS, facilitating the creation of device data copies through iTunes (up to macOS Catalina), Finder (from macOS Catalina onward), or iCloud. These backups encompass almost all device data, excluding highly sensitive elements like Apple Pay details and Touch ID configurations.
The inclusion of installed apps and their data in backups raises the issue of potential data leakage and the risk that backup modifications could alter app functionality. It's advised to not store sensitive information in plaintext within any app's directory or its subdirectories to mitigate these risks.
Files in Documents/ and Library/Application Support/ are backed up by default. Developers can exclude specific files or directories from backups using NSURL setResourceValue:forKey:error: with the NSURLIsExcludedFromBackupKey. This practice is crucial for protecting sensitive data from being included in backups.
To assess an app's backup security, start by creating a backup using Finder, then locate it using guidance from Apple's official documentation. Analyze the backup for sensitive data or configurations that could be altered to affect app behavior.
Sensitive information can be sought out using command-line tools or applications like iMazing. For encrypted backups, the presence of encryption can be confirmed by checking the "IsEncrypted" key in the "Manifest.plist" file at the backup's root.
For dealing with encrypted backups, Python scripts available in DinoSec's GitHub repo, like backup_tool.py and backup_passwd.py, may be useful, albeit potentially requiring adjustments for compatibility with the latest iTunes/Finder versions. The iOSbackup tool is another option for accessing files within password-protected backups.
An example of altering app behavior through backup modifications is demonstrated in the Bither bitcoin wallet app, where the UI lock PIN is stored within net.bither.plist under the pin_code key. Removing this key from the plist and restoring the backup removes the PIN requirement, providing unrestricted access.
When dealing with sensitive information stored in an application's memory, it is crucial to limit the exposure time of this data. There are two primary approaches to investigate memory content: creating a memory dump and analyzing the memory in real time. Both methods have their challenges, including the potential to miss critical data during the dump process or analysis.
For both jailbroken and non-jailbroken devices, tools like objection and Fridump allow for the dumping of an app's process memory. Once dumped, analyzing this data requires various tools, depending on the nature of the information you're searching for.
To extract strings from a memory dump, commands such as strings or rabin2 -zz can be used:
For more detailed analysis, including searching for specific data types or patterns, radare2 offers extensive search capabilities:
r2frida provides a powerful alternative for inspecting an app's memory in real time, without needing a memory dump. This tool enables the execution of search commands directly on the running application's memory:
Some developers save sensitive data in the local storage and encrypt it with a key hardcoded/predictable in the code. This shouldn't be done as some reversing could allow attackers to extract the confidential information.
Developers shouldn't use deprecated algorithms to perform authorisation checks, store or send data. Some of these algorithms are: RC4, MD4, MD5, SHA1... If hashes are used to store passwords for example, hashes brute-force resistant should be used with salt.
The main checks to perform if to find if you can find hardcoded passwords/secrets in the code, or if those are predictable, and if the code is using some king of weak cryptography algorithms.
It's interesting to know that you can monitor some crypto libraries automatically using objection with:
For more information about iOS cryptographic APIs and libraries access https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06e-testing-cryptography
Local authentication plays a crucial role, especially when it concerns safeguarding access at a remote endpoint through cryptographic methods. The essence here is that without proper implementation, local authentication mechanisms can be circumvented.
Apple's Local Authentication framework and the keychain provide robust APIs for developers to facilitate user authentication dialogs and securely handle secret data, respectively. The Secure Enclave secures fingerprint ID for Touch ID, whereas Face ID relies on facial recognition without compromising biometric data.
To integrate Touch ID/Face ID, developers have two API choices:
LocalAuthentication.framework for high-level user authentication without access to biometric data.
Security.framework for lower-level keychain services access, securing secret data with biometric authentication. Various open-source wrappers make keychain access simpler.
However, both LocalAuthentication.framework and Security.framework present vulnerabilities, as they primarily return boolean values without transmitting data for authentication processes, making them susceptible to bypassing (refer to Don't touch me that way, by David Lindner et al).
To prompt users for authentication, developers should utilize the evaluatePolicy method within the LAContext class, choosing between:
deviceOwnerAuthentication: Prompts for Touch ID or device passcode, failing if neither is enabled.
deviceOwnerAuthenticationWithBiometrics: Exclusively prompts for Touch ID.
A successful authentication is indicated by a boolean return value from evaluatePolicy, highlighting a potential security flaw.
Implementing local authentication in iOS apps involves the use of keychain APIs to securely store secret data such as authentication tokens. This process ensures that the data can only be accessed by the user, using their device passcode or biometric authentication like Touch ID.
The keychain offers the capability to set items with the SecAccessControl attribute, which restricts access to the item until the user successfully authenticates via Touch ID or device passcode. This feature is crucial for enhancing security.
Below are code examples in Swift and Objective-C demonstrating how to save and retrieve a string to/from the keychain, leveraging these security features. The examples specifically show how to set up access control to require Touch ID authentication and ensure the data is accessible only on the device it was set up on, under the condition that a device passcode is configured.
Now we can request the saved item from the keychain. Keychain services will present the authentication dialog to the user and return data or nil depending on whether a suitable fingerprint was provided or not.
Usage of frameworks in an app can also be detected by analyzing the app binary's list of shared dynamic libraries. This can be done by using otool:
If LocalAuthentication.framework is used in an app, the output will contain both of the following lines (remember that LocalAuthentication.framework uses Security.framework under the hood):
If Security.framework is used, only the second one will be shown.
Through the Objection Biometrics Bypass, located at this GitHub page, a technique is available for overcoming the LocalAuthentication mechanism. The core of this approach involves leveraging Frida to manipulate the evaluatePolicy function, ensuring it consistently yields a True outcome, irrespective of the actual authentication success. This is particularly useful for circumventing flawed biometric authentication processes.
To activate this bypass, the following command is employed:
This command sets off a sequence where Objection registers a task that effectively alters the outcome of the evaluatePolicy check to True.
An example of a use of evaluatePolicy from DVIA-v2 application:
To achieve the bypass of Local Authentication, a Frida script is written. This script targets the evaluatePolicy check, intercepting its callback to ensure it returns success=1. By altering the callback's behavior, the authentication check is effectively bypassed.
The script below is injected to modify the result of the evaluatePolicy method. It changes the callback's result to always indicate success.
To inject the Frida script and bypass the biometric authentication, the following command is used:
It's important to check that no communication is occurring without encryption and also that the application is correctly validating the TLS certificate of the server. To check these kind of issues you can use a proxy like Burp:
One common issue validating the TLS certificate is to check that the certificate was signed by a trusted CA, but not check if the hostname of the certificate is the hostname being accessed. In order to check this issue using Burp, after trusting Burp CA in the iPhone, you can create a new certificate with Burp for a different hostname and use it. If the application still works, then, something it's vulnerable.
If an application is correctly using SSL Pinning, then the application will only works if the certificate is the once expected to be. When testing an application this might be a problem as Burp will serve it's own certificate. In order to bypass this protection inside a jailbroken device, you can install the application SSL Kill Switch or install Burp Mobile Assistant
You can also use objection's ios sslpinning disable
In /System/Library you can find the frameworks installed in the phone used by system applications
The applications installed by the user from the App Store are located inside /User/Applications
And the /User/Library contains data saved by the user level applications
You can access /User/Library/Notes/notes.sqlite to read the notes saved inside the application.
Inside the folder of an installed application (/User/Applications/<APP ID>/) you can find some interesting files:
iTunesArtwork: The icon used by the app
iTunesMetadata.plist: Info of the app used in the App Store
/Library/*: Contains the preferences and cache. In /Library/Cache/Snapshots/* you can find the snapshot performed to the application before sending it to the background.
The developers can remotely patch all installations of their app instantly without having to resubmit the application to the App store and wait until it's approved. For this purpose it's usually use JSPatch. But there are other options also such as Siren and react-native-appstore-version-checker. This is a dangerous mechanism that could be abused by malicious third party SDKs therefore it's recommended to check which method is used to automatic updating (if any) and test it. You could try to download a previous version of the app for this purpose.
A significant challenge with 3rd party SDKs is the lack of granular control over their functionalities. Developers are faced with a choice: either integrate the SDK and accept all its features, including potential security vulnerabilities and privacy concerns, or forego its benefits entirely. Often, developers are unable to patch vulnerabilities within these SDKs themselves. Furthermore, as SDKs gain trust within the community, some may start to contain malware.
The services provided by third-party SDKs may include user behavior tracking, advertisement displays, or user experience enhancements. However, this introduces a risk as developers may not be fully aware of the code executed by these libraries, leading to potential privacy and security risks. It's crucial to limit the information shared with third-party services to what is necessary and ensure that no sensitive data is exposed.
Implementation of third-party services usually comes in two forms: a standalone library or a full SDK. To protect user privacy, any data shared with these services should be anonymized to prevent the disclosure of Personal Identifiable Information (PII).
To identify the libraries an application uses, the otool command can be employed. This tool should be run against the application and each shared library it uses to discover additional libraries.
OWASP iGoat https://github.com/OWASP/igoat <<< Objective-C version https://github.com/OWASP/iGoat-Swift <<< Swift version
Use Trickest to easily build and automate workflows powered by the world's most advanced community tools. Get Access Today:
Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
