mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
343 lines
15 KiB
Markdown
343 lines
15 KiB
Markdown
# iOS Frida Configuration
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|
|
|
|
|
|
## Installing Frida
|
|
|
|
**Jailbroken डिवाइस पर Frida स्थापित करने के चरण:**
|
|
|
|
1. Cydia/Sileo ऐप खोलें।
|
|
2. Manage -> Sources -> Edit -> Add पर जाएं।
|
|
3. URL के रूप में "https://build.frida.re" दर्ज करें।
|
|
4. नए जोड़े गए Frida स्रोत पर जाएं।
|
|
5. Frida पैकेज स्थापित करें।
|
|
|
|
यदि आप **Corellium** का उपयोग कर रहे हैं, तो आपको [https://github.com/frida/frida/releases](https://github.com/frida/frida/releases) से Frida रिलीज़ डाउनलोड करनी होगी (`frida-gadget-[yourversion]-ios-universal.dylib.gz`) और इसे अनपैक करके Frida द्वारा मांगे गए dylib स्थान पर कॉपी करना होगा, जैसे: `/Users/[youruser]/.cache/frida/gadget-ios.dylib`
|
|
|
|
स्थापित करने के बाद, आप अपने PC पर **`frida-ls-devices`** कमांड का उपयोग कर सकते हैं और जांच सकते हैं कि डिवाइस दिखाई दे रहा है (आपके PC को इसे एक्सेस करने में सक्षम होना चाहिए)।\
|
|
इसके अलावा **`frida-ps -Uia`** चलाएं ताकि फोन की चल रही प्रक्रियाओं की जांच की जा सके।
|
|
|
|
## Frida बिना Jailbroken डिवाइस और बिना ऐप को पैच किए
|
|
|
|
बिना पैच किए गैर-जेलब्रोकन डिवाइस पर Frida का उपयोग करने के बारे में इस ब्लॉग पोस्ट को देखें: [https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07](https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07)
|
|
|
|
## Frida Client Installation
|
|
|
|
**frida tools** स्थापित करें:
|
|
```bash
|
|
pip install frida-tools
|
|
pip install frida
|
|
```
|
|
Frida सर्वर स्थापित होने और डिवाइस चालू और कनेक्टेड होने के साथ, **जांचें** कि क्लाइंट **काम कर रहा** है:
|
|
```bash
|
|
frida-ls-devices # List devices
|
|
frida-ps -Uia # Get running processes
|
|
```
|
|
## फ्रिडा ट्रेस
|
|
```bash
|
|
# Functions
|
|
## Trace all functions with the word "log" in their name
|
|
frida-trace -U <program> -i "*log*"
|
|
frida-trace -U <program> -i "*log*" | swift demangle # Demangle names
|
|
|
|
# Objective-C
|
|
## Trace all methods of all classes
|
|
frida-trace -U <program> -m "*[* *]"
|
|
|
|
## Trace all methods with the word "authentication" from classes that start with "NE"
|
|
frida-trace -U <program> -m "*[NE* *authentication*]"
|
|
|
|
# Plug-In
|
|
## To hook a plugin that is momentarely executed prepare Frida indicating the ID of the Plugin binary
|
|
frida-trace -U -W <if-plugin-bin> -m '*[* *]'
|
|
```
|
|
### सभी कक्षाएँ और विधियाँ प्राप्त करें
|
|
|
|
- ऑटो पूर्ण: बस `frida -U <program>` चलाएँ
|
|
|
|
<figure><img src="../../images/image (1159).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
- **सभी** उपलब्ध **कक्षाएँ** प्राप्त करें (स्ट्रिंग द्वारा फ़िल्टर करें)
|
|
```javascript:/tmp/script.js
|
|
// frida -U <program> -l /tmp/script.js
|
|
|
|
var filterClass = "filterstring"
|
|
|
|
if (ObjC.available) {
|
|
for (var className in ObjC.classes) {
|
|
if (ObjC.classes.hasOwnProperty(className)) {
|
|
if (!filterClass || className.includes(filterClass)) {
|
|
console.log(className)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
console.log("Objective-C runtime is not available.")
|
|
}
|
|
```
|
|
- एक **क्लास** के **सभी** **विधियों** को प्राप्त करें (स्ट्रिंग द्वारा फ़िल्टर करें)
|
|
```javascript:/tmp/script.js
|
|
// frida -U <program> -l /tmp/script.js
|
|
|
|
var specificClass = "YourClassName"
|
|
var filterMethod = "filtermethod"
|
|
|
|
if (ObjC.available) {
|
|
if (ObjC.classes.hasOwnProperty(specificClass)) {
|
|
var methods = ObjC.classes[specificClass].$ownMethods
|
|
for (var i = 0; i < methods.length; i++) {
|
|
if (!filterMethod || methods[i].includes(filterClass)) {
|
|
console.log(specificClass + ": " + methods[i])
|
|
}
|
|
}
|
|
} else {
|
|
console.log("Class not found.")
|
|
}
|
|
} else {
|
|
console.log("Objective-C runtime is not available.")
|
|
}
|
|
```
|
|
- **एक फ़ंक्शन कॉल करें**
|
|
```javascript
|
|
// Find the address of the function to call
|
|
const func_addr = Module.findExportByName("<Prog Name>", "<Func Name>")
|
|
// Declare the function to call
|
|
const func = new NativeFunction(
|
|
func_addr,
|
|
"void",
|
|
["pointer", "pointer", "pointer"],
|
|
{}
|
|
)
|
|
|
|
var arg0 = null
|
|
|
|
// In this case to call this function we need to intercept a call to it to copy arg0
|
|
Interceptor.attach(wg_log_addr, {
|
|
onEnter: function (args) {
|
|
arg0 = new NativePointer(args[0])
|
|
},
|
|
})
|
|
|
|
// Wait untill a call to the func occurs
|
|
while (!arg0) {
|
|
Thread.sleep(1)
|
|
console.log("waiting for ptr")
|
|
}
|
|
|
|
var arg1 = Memory.allocUtf8String("arg1")
|
|
var txt = Memory.allocUtf8String("Some text for arg2")
|
|
wg_log(arg0, arg1, txt)
|
|
|
|
console.log("loaded")
|
|
```
|
|
## Frida Fuzzing
|
|
|
|
### Frida Stalker
|
|
|
|
[From the docs](https://frida.re/docs/stalker/): Stalker Frida का कोड **ट्रेसिंग इंजन** है। यह थ्रेड्स को **अनुसरण** करने की अनुमति देता है, **हर फ़ंक्शन**, **हर ब्लॉक**, यहां तक कि हर निर्देश जो निष्पादित होता है, को **कैप्चर** करता है।
|
|
|
|
आपके पास Frida Stalker को लागू करने का एक उदाहरण है [https://github.com/poxyran/misc/blob/master/frida-stalker-example.py](https://github.com/poxyran/misc/blob/master/frida-stalker-example.py)
|
|
|
|
यह एक और उदाहरण है Frida Stalker को हर बार संलग्न करने के लिए जब एक फ़ंक्शन को कॉल किया जाता है:
|
|
```javascript
|
|
console.log("loading")
|
|
const wg_log_addr = Module.findExportByName("<Program>", "<function_name>")
|
|
const wg_log = new NativeFunction(
|
|
wg_log_addr,
|
|
"void",
|
|
["pointer", "pointer", "pointer"],
|
|
{}
|
|
)
|
|
|
|
Interceptor.attach(wg_log_addr, {
|
|
onEnter: function (args) {
|
|
console.log(`logging the following message: ${args[2].readCString()}`)
|
|
|
|
Stalker.follow({
|
|
events: {
|
|
// only collect coverage for newly encountered blocks
|
|
compile: true,
|
|
},
|
|
onReceive: function (events) {
|
|
const bbs = Stalker.parse(events, {
|
|
stringify: false,
|
|
annotate: false,
|
|
})
|
|
console.log(
|
|
"Stalker trace of write_msg_to_log: \n" +
|
|
bbs.flat().map(DebugSymbol.fromAddress).join("\n")
|
|
)
|
|
},
|
|
})
|
|
},
|
|
onLeave: function (retval) {
|
|
Stalker.unfollow()
|
|
Stalker.flush() // this is important to get all events
|
|
},
|
|
})
|
|
```
|
|
> [!CAUTION]
|
|
> यह डिबगिंग उद्देश्यों के लिए दिलचस्प है लेकिन फज़िंग के लिए, लगातार **`.follow()`** और **`.unfollow()`** करना बहुत अप्रभावी है।
|
|
|
|
## [Fpicker](https://github.com/ttdennis/fpicker)
|
|
|
|
[**fpicker**](https://github.com/ttdennis/fpicker) एक **Frida-आधारित फज़िंग सूट** है जो इन-प्रोसेस फज़िंग के लिए विभिन्न फज़िंग मोड प्रदान करता है, जैसे AFL++ मोड या एक पैसिव ट्रेसिंग मोड। इसे सभी प्लेटफार्मों पर चलाना चाहिए जो Frida द्वारा समर्थित हैं।
|
|
|
|
- [**Install fpicker**](https://github.com/ttdennis/fpicker#requirements-and-installation) **& radamsa**
|
|
```bash
|
|
# Get fpicker
|
|
git clone https://github.com/ttdennis/fpicker
|
|
cd fpicker
|
|
|
|
# Get Frida core devkit and prepare fpicker
|
|
wget https://github.com/frida/frida/releases/download/16.1.4/frida-core-devkit-16.1.4-[yourOS]-[yourarchitecture].tar.xz
|
|
# e.g. https://github.com/frida/frida/releases/download/16.1.4/frida-core-devkit-16.1.4-macos-arm64.tar.xz
|
|
tar -xf ./*tar.xz
|
|
cp libfrida-core.a libfrida-core-[yourOS].a #libfrida-core-macos.a
|
|
|
|
# Install fpicker
|
|
make fpicker-[yourOS] # fpicker-macos
|
|
# This generates ./fpicker
|
|
|
|
# Install radamsa (fuzzer generator)
|
|
brew install radamsa
|
|
```
|
|
- **FS तैयार करें:**
|
|
```bash
|
|
# From inside fpicker clone
|
|
mkdir -p examples/wg-log # Where the fuzzing script will be
|
|
mkdir -p examples/wg-log/out # For code coverage and crashes
|
|
mkdir -p examples/wg-log/in # For starting inputs
|
|
|
|
# Create at least 1 input for the fuzzer
|
|
echo Hello World > examples/wg-log/in/0
|
|
```
|
|
- **Fuzzer स्क्रिप्ट** (`examples/wg-log/myfuzzer.js`):
|
|
```javascript:examples/wg-log/myfuzzer.js
|
|
// Import the fuzzer base class
|
|
import { Fuzzer } from "../../harness/fuzzer.js"
|
|
|
|
class WGLogFuzzer extends Fuzzer {
|
|
constructor() {
|
|
console.log("WGLogFuzzer constructor called")
|
|
|
|
// Get and declare the function we are going to fuzz
|
|
var wg_log_addr = Module.findExportByName(
|
|
"<Program name>",
|
|
"<func name to fuzz>"
|
|
)
|
|
var wg_log_func = new NativeFunction(
|
|
wg_log_addr,
|
|
"void",
|
|
["pointer", "pointer", "pointer"],
|
|
{}
|
|
)
|
|
|
|
// Initialize the object
|
|
super("<Program nane>", wg_log_addr, wg_log_func)
|
|
this.wg_log_addr = wg_log_addr // We cannot use "this" before calling "super"
|
|
|
|
console.log("WGLogFuzzer in the middle")
|
|
|
|
// Prepare the second argument to pass to the fuzz function
|
|
this.tag = Memory.allocUtf8String("arg2")
|
|
|
|
// Get the first argument we need to pass from a call to the functino we want to fuzz
|
|
var wg_log_global_ptr = null
|
|
console.log(this.wg_log_addr)
|
|
Interceptor.attach(this.wg_log_addr, {
|
|
onEnter: function (args) {
|
|
console.log("Entering in the function to get the first argument")
|
|
wg_log_global_ptr = new NativePointer(args[0])
|
|
},
|
|
})
|
|
|
|
while (!wg_log_global_ptr) {
|
|
Thread.sleep(1)
|
|
}
|
|
this.wg_log_global_ptr = wg_log_global_ptr
|
|
console.log("WGLogFuzzer prepare ended")
|
|
}
|
|
|
|
// This function is called by the fuzzer with the first argument being a pointer into memory
|
|
// where the payload is stored and the second the length of the input.
|
|
fuzz(payload, len) {
|
|
// Get a pointer to payload being a valid C string (with a null byte at the end)
|
|
var payload_cstring = payload.readCString(len)
|
|
this.payload = Memory.allocUtf8String(payload_cstring)
|
|
|
|
// Debug and fuzz
|
|
this.debug_log(this.payload, len)
|
|
// Pass the 2 first arguments we know the function needs and finally the payload to fuzz
|
|
this.target_function(this.wg_log_global_ptr, this.tag, this.payload)
|
|
}
|
|
}
|
|
|
|
const f = new WGLogFuzzer()
|
|
rpc.exports.fuzzer = f
|
|
```
|
|
- **फज़्ज़र** को संकलित करें:
|
|
```bash
|
|
# From inside fpicker clone
|
|
## Compile from "myfuzzer.js" to "harness.js"
|
|
frida-compile examples/wg-log/myfuzzer.js -o harness.js
|
|
```
|
|
- **`radamsa`** का उपयोग करके फज़्ज़र **`fpicker`** को कॉल करें:
|
|
```bash
|
|
# Indicate fpicker to fuzz a program with the harness.js script and which folders to use
|
|
fpicker -v --fuzzer-mode active -e attach -p <Program to fuzz> -D usb -o examples/wg-log/out/ -i examples/wg-log/in/ -f harness.js --standalone-mutator cmd --mutator-command "radamsa"
|
|
# You can find code coverage and crashes in examples/wg-log/out/
|
|
```
|
|
> [!CAUTION]
|
|
> इस मामले में हम **हर payload के बाद ऐप को फिर से शुरू नहीं कर रहे हैं या स्थिति को बहाल नहीं कर रहे हैं**। इसलिए, यदि Frida एक **crash** पाती है, तो उसके बाद के **inputs** भी ऐप को **crash** कर सकते हैं (क्योंकि ऐप अस्थिर स्थिति में है) भले ही **input को ऐप को crash नहीं करना चाहिए**।
|
|
>
|
|
> इसके अलावा, Frida iOS के अपवाद संकेतों में हुक करेगा, इसलिए जब **Frida एक crash पाती है**, तो शायद **iOS crash रिपोर्ट उत्पन्न नहीं होगी**।
|
|
>
|
|
> इसे रोकने के लिए, उदाहरण के लिए, हम हर Frida crash के बाद ऐप को फिर से शुरू कर सकते हैं।
|
|
|
|
### Logs & Crashes
|
|
|
|
आप **macOS कंसोल** या **`log`** cli की जांच कर सकते हैं macOS लॉग की जांच करने के लिए।\
|
|
आप **`idevicesyslog`** का उपयोग करके iOS से भी लॉग की जांच कर सकते हैं।\
|
|
कुछ लॉग जानकारी को छोड़ देंगे **`<private>`** जोड़कर। सभी जानकारी दिखाने के लिए आपको [https://developer.apple.com/bug-reporting/profiles-and-logs/](https://developer.apple.com/bug-reporting/profiles-and-logs/) से कुछ प्रोफ़ाइल स्थापित करनी होगी ताकि उस निजी जानकारी को सक्षम किया जा सके।
|
|
|
|
यदि आप नहीं जानते कि क्या करना है:
|
|
```sh
|
|
vim /Library/Preferences/Logging/com.apple.system.logging.plist
|
|
<?xml version="1.0" encoding="UTF-8"?>
|
|
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
|
<plist version="1.0">
|
|
<dict>
|
|
<key>Enable-Private-Data</key>
|
|
<true/>
|
|
</dict>
|
|
</plist>
|
|
|
|
killall -9 logd
|
|
```
|
|
आप क्रैश की जांच कर सकते हैं:
|
|
|
|
- **iOS**
|
|
- सेटिंग्स → गोपनीयता → विश्लेषण और सुधार → विश्लेषण डेटा
|
|
- `/private/var/mobile/Library/Logs/CrashReporter/`
|
|
- **macOS**:
|
|
- `/Library/Logs/DiagnosticReports/`
|
|
- `~/Library/Logs/DiagnosticReports`
|
|
|
|
> [!WARNING]
|
|
> iOS केवल एक ही ऐप के 25 क्रैश को स्टोर करता है, इसलिए आपको इसे साफ करना होगा या iOS क्रैश बनाना बंद कर देगा।
|
|
|
|
## Frida Android Tutorials
|
|
|
|
{{#ref}}
|
|
../android-app-pentesting/frida-tutorial/
|
|
{{#endref}}
|
|
|
|
## References
|
|
|
|
- [https://www.briskinfosec.com/blogs/blogsdetail/Getting-Started-with-Frida](https://www.briskinfosec.com/blogs/blogsdetail/Getting-Started-with-Frida)
|
|
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|