IOSSecuritySuite

## ⭐️ Möchten Sie ein zertifizierter iOS Application Security Engineer werden? ⭐️

Schauen Sie sich unseren praktischen & komplett online Kurs an unter: [https://courses.securing.pl/courses/iase](https://courses.securing.pl/courses/iase?utm_source=githubiosss&utm_medium=githubiosss&utm_campaign=githubiosss&utm_id=githubiosss)

![iASE logo](https://assets.kitploit.com/production/public/readmes/5249/32a5ed83a074890e108696e8d409a60131045c9fb4fbaeec742c8a5cc505ddb3.png)


## ISS Beschreibung

![ISS logo](https://assets.kitploit.com/production/public/readmes/5249/f1509c19032617bb06212f44e6b353e12a142811dcecdc783b8e266836f1ed72.png)
### von [@_r3ggi](https://twitter.com/_r3ggi)

🌏 iOS Security Suite ist eine fortschrittliche und benutzerfreundliche Plattform-Sicherheits- und Anti-Manipulations-Bibliothek, die in reinem Swift geschrieben ist! Wenn Sie für iOS entwickeln und Ihre App gemäß dem OWASP [MASVS](https://github.com/OWASP/owasp-masvs) Standard, Kapitel v8, schützen möchten, dann könnte diese Bibliothek Ihnen viel Zeit sparen. 🚀

Was ISS erkennt:

* Jailbreak 🧨
* Angehängter Debugger 👨🏻‍🚀
* Wenn eine App in einem Emulator ausgeführt wurde 👽
* Gängige Reverse-Engineering-Tools, die auf dem Gerät laufen 🔭

## Einrichtung
Es gibt 4 Möglichkeiten, IOSSecuritySuite zu verwenden

### 1. Quelle hinzufügen
Fügen Sie die Dateien `IOSSecuritySuite/*.swift` zu Ihrem Projekt hinzu

### 2. Einrichtung mit CocoaPods
`pod 'IOSSecuritySuite'`

### 3. Einrichtung mit Carthage
`github "securing/IOSSecuritySuite"`

### 4. Einrichtung mit Swift Package Manager
```swift
.package(url: "https://github.com/securing/IOSSecuritySuite.git", from: "1.5.0")
```

### Info.plist aktualisieren
Nachdem Sie ISS zu Ihrem Projekt hinzugefügt haben, müssen Sie auch Ihre Haupt-Info.plist aktualisieren. Es gibt eine Prüfung im Jailbreak-Erkennungsmodul, die die Methode ```canOpenURL(_:)``` verwendet und [erfordert](https://developer.apple.com/documentation/uikit/uiapplication/1622952-canopenurl), dass die URLs angegeben werden, die abgefragt werden.

```xml
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>undecimus</string>
    <string>sileo</string>
    <string>zbra</string>
    <string>filza</string>
</array>
```

### Preisgestaltung

Überprüfen Sie unsere EULA-Lizenz für die Details.

TLDR:
Wenn Ihr Unternehmen beschäftigt:
* 0-99 Personen - **kostenlos nutzbar**
* 100-1000 - 3.000 EUR/Jahr
* 1000+ - 10.000 EUR/Jahr

Wenn Sie ein Modul verkaufen möchten, das die iOS Security Suite verwendet (es wird nicht direkt in Ihrer App verwendet) - 10.000 EUR/Jahr

### Hinweis

iOS Security Suite ist für die Verwendung auf iOS/iPadOS vorgesehen. Es sollte nicht auf Macs mit Apple Silicon verwendet werden.

## Verwendung

### Jailbreak-Erkennungsmodul

* **Die einfachste Methode** gibt True/False zurück, wenn Sie nur wissen möchten, ob das Gerät jailbroken oder nicht jailbroken ist

```Swift
if IOSSecuritySuite.amIJailbroken() {
	print("This device is jailbroken")
} else {
	print("This device is not jailbroken")
}
```

* **Ausführlich**, wenn Sie auch wissen möchten, welche Indikatoren identifiziert wurden

```Swift
let jailbreakStatus = IOSSecuritySuite.amIJailbrokenWithFailMessage()
if jailbreakStatus.jailbroken {
	print("This device is jailbroken")
	print("Because: \(jailbreakStatus.failMessage)")
} else {
	print("This device is not jailbroken")
}
```
Die failMessage ist ein String, der durch Kommas getrennte Indikatoren enthält, wie im folgenden Beispiel gezeigt:
`sileo:// URL-Schema erkannt, Verdächtige Datei existiert: /Library/MobileSubstrate/MobileSubstrate.dylib, Fork konnte einen neuen Prozess erstellen`

* **Ausführlich & filterbar**, wenn Sie zum Beispiel Geräte identifizieren möchten, die früher jailbroken waren, aber jetzt nicht mehr jailbroken sind

```Swift
let jailbreakStatus = IOSSecuritySuite.amIJailbrokenWithFailedChecks()
if jailbreakStatus.jailbroken {
   if (jailbreakStatus.failedChecks.contains { $0.check == .existenceOfSuspiciousFiles }) && (jailbreakStatus.failedChecks.contains { $0.check == .suspiciousFilesCanBeOpened }) {
         print("This is real jailbroken device")
   }
}
```

### Debugger-Erkennungsmodul
```Swift
let amIDebugged: Bool = IOSSecuritySuite.amIDebugged()
```

### Debugger vollständig verweigern
```Swift
IOSSecuritySuite.denyDebugger()
```

### Emulator-Erkennungsmodul
```Swift
let runInEmulator: Bool = IOSSecuritySuite.amIRunInEmulator()
```

### Reverse-Engineering-Tools-Erkennungsmodul

* **Die einfachste Methode** gibt True/False zurück, wenn Sie nur wissen möchten, ob das Gerät Anzeichen von Reverse Engineering aufweist

```Swift
if IOSSecuritySuite.amIReverseEngineered() {
  print("This device has evidence of reverse engineering")
} else {
  print("This device hasn't evidence of reverse engineering")
}
```

* **Ausführlich & filterbar**, wenn Sie auch die Liste der durchgeführten Prüfungen möchten

```Swift
let reverseStatus = IOSSecuritySuite.amIReverseEngineeredWithFailedChecks()
if reverseStatus.reverseEngineered {
   // check for reverseStatus.failedChecks for more details
}
```

### System-Proxy-Erkennungsmodul

Jetzt können Sie auch erkennen, ob eine App mit einem VPN verbunden ist
```Swift
let amIProxied: Bool = IOSSecuritySuite.amIProxied(considerVPNConnectionAsProxy: true)
```

### Lockdown-Modus-Erkennungsmodul
```Swift
let amIInLockdownMode: Bool = IOSSecuritySuite.amIInLockdownMode()
```

## Experimentelle Funktionen

### Laufzeit-Hook-Erkennungsmodul
```Swift
let amIRuntimeHooked: Bool = amIRuntimeHook(dyldWhiteList: dylds, detectionClass: SomeClass.self, selector: #selector(SomeClass.someFunction), isClassMethod: false)
```
### Symbol-Hook-Verweigerungsmodul
```Swift
// If we want to deny symbol hook of Swift function, we have to pass mangled name of that function
denySymbolHook("$s10Foundation5NSLogyySS_s7CVarArg_pdtF")   // denying hooking for the NSLog function
NSLog("Hello Symbol Hook")
     
denySymbolHook("abort") 
abort()
```

### MSHook-Erkennungsmodul
```Swift
// Function declaration
func someFunction(takes: Int) -> Bool {
	return false
} 

// Defining FunctionType : @convention(thin) indicates a “thin” function reference, which uses the Swift calling convention with no special “self” or “context” parameters.
typealias FunctionType = @convention(thin) (Int) -> (Bool)

// Getting pointer address of function we want to verify
func getSwiftFunctionAddr(_ function: @escaping FunctionType) -> UnsafeMutableRawPointer {
	return unsafeBitCast(function, to: UnsafeMutableRawPointer.self)
}

let funcAddr = getSwiftFunctionAddr(someFunction)
let amIMSHooked = IOSSecuritySuite.amIMSHooked(funcAddr)
```

### MSHook-Verweigerungsmodul
```Swift
// Function declaration
func denyDebugger(value: Int) {
}

// Defining FunctionType : @convention(thin) indicates a “thin” function reference, which uses the Swift calling convention with no special “self” or “context” parameters.
typealias FunctionType = @convention(thin) (Int)->()

// Getting original function address
let funcDenyDebugger: FunctionType = denyDebugger 
let funcAddr = unsafeBitCast(funcDenyDebugger, to: UnsafeMutableRawPointer.self)


if let originalDenyDebugger = denyMSHook(funcAddr) {
// Call the original function with 1337 as Int argument
     unsafeBitCast(originalDenyDebugger, to: FunctionType.self)(1337)
 } else {
     denyDebugger()
 }
```

### Dateiintegritätsprüfungsmodul

```Swift
// Determine if application has been tampered with 
if IOSSecuritySuite.amITampered([.bundleID("biz.securing.FrameworkClientApp"),
    .mobileProvision("2976c70b56e9ae1e2c8e8b231bf6b0cff12bbbd0a593f21846d9a004dd181be3"),
    .machO("IOSSecuritySuite", "6d8d460b9a4ee6c0f378e30f137cebaf2ce12bf31a2eef3729c36889158aa7fc")]).result {
    print("I have been Tampered.")
}
else {
    print("I have not been Tampered.")
}

// Manually verify SHA256 hash value of a loaded dylib
if let hashValue = IOSSecuritySuite.getMachOFileHashValue(.custom("IOSSecuritySuite")), hashValue == "6d8d460b9a4ee6c0f378e30f137cebaf2ce12bf31a2eef3729c36889158aa7fc" {
    print("I have not been Tampered.")
}
else {
    print("I have been Tampered.")
}
 
// Check SHA256 hash value of the main executable
// Tip: Your application may retrieve this value from the server
if let hashValue = IOSSecuritySuite.getMachOFileHashValue(.default), hashValue == "your-application-executable-hash-value" {
    print("I have not been Tampered.")
}
else {
    print("I have been Tampered.")
}
```

### Haltepunkt-Erkennungsmodul

```Swift
func denyDebugger() {
    // Set breakpoint here
}
     
typealias FunctionType = @convention(thin) ()->()
let func_denyDebugger: FunctionType = denyDebugger   // `: FunctionType` is a must
let func_addr = unsafeBitCast(func_denyDebugger, to: UnsafeMutableRawPointer.self)
let hasBreakpoint = IOSSecuritySuite.hasBreakpointAt(func_addr, functionSize: nil)

if hasBreakpoint {
    print("Breakpoint found in the specified function")
} else {
    print("Breakpoint not found in the specified function")
}
```

### Überwachungspunkt-Erkennungsmodul

```Swift
// Set a breakpoint at the testWatchpoint function
func testWatchpoint() -> Bool{
		// lldb: watchpoint set expression ptr
    var ptr = malloc(9)
    // lldb: watchpoint set variable count
    var count = 3
    return IOSSecuritySuite.hasWatchpoint()
}
```



## Sicherheitshinweise

Bevor Sie dieses und andere Plattform-Sicherheitsprüfungen verwenden, müssen Sie verstehen, dass:

* Die Einbindung dieses Tools in Ihr Projekt ist nicht das Einzige, was Sie tun sollten, um die Sicherheit Ihrer App zu verbessern! Sie können ein allgemeines Whitepaper zur mobilen Sicherheit [hier](https://www.securing.biz/en/mobile-application-security-best-practices/index.html) lesen.
* Die Erkennung, ob ein Gerät jailbroken ist, erfolgt lokal auf dem Gerät. Das bedeutet, dass jeder Jailbreak-Detektor umgangen werden kann (auch dieser)!
* Swift-Code gilt als schwieriger dynamisch zu manipulieren als Objective-C. Da diese Bibliothek in reinem Swift geschrieben wurde, sollten die IOSSecuritySuite-Methoden nicht dem Objective-C-Laufzeitsystem ausgesetzt sein (was die Umgehung erschwert ✅). Sie müssen wissen, dass ein Angreifer dennoch in der Lage ist, MSHookFunction/MSFindSymbol auf Swift-Symbole anzuwenden und den Ausführungsfluss von Swift-Code dynamisch zu ändern.

## Beitrag ❤️
Ja, bitte! Wenn Sie eine bessere Idee haben oder dieses Projekt einfach verbessern möchten, schreiben Sie mir bitte auf [Twitter](https://twitter.com/_r3ggi) oder [LinkedIn](https://www.linkedin.com/in/wojciech-regula/). Pull-Requests sind mehr als willkommen!

### Besonderer Dank: 👏🏻

* [kubajakowski](https://github.com/kubajakowski) für den Hinweis auf das Problem mit der Methode ```canOpenURL(_:)```
* [olbartek](https://github.com/olbartek) für Code-Review und Pull-Request
* [benbahrenburg](https://github.com/benbahrenburg) für verschiedene ISS-Verbesserungen
* [fotiDim](https://github.com/fotiDim) für das Hinzufügen neuer Dateipfade zur Überprüfung
* [gcharita](https://github.com/gcharita) für das Hinzufügen der Swift Package Manager Unterstützung
* [rynaardb](https://github.com/rynaardb) für die Erstellung der Methode `amIJailbrokenWithFailedChecks()`
* [undeaDD](https://github.com/undeaDD) für verschiedene ISS-Verbesserungen
* [fnxpt](https://github.com/fnxpt) für das Hinzufügen mehrerer JB-Erkennungen
* [TannerJin](https://github.com/TannerJin) für die MSHook-, RuntimeHook-, SymbolHook- und Watchpoint-Erkennungsmodule
* [NikoXu](https://github.com/NikoXu) für das Hinzufügen des Dateiintegritätsmoduls
* [hellpf](https://github.com/hellpf) für die Behebung eines Problems mit einem hängenden Socket
* [Ant-tree](https://github.com/Ant-tree) für die Verbesserung der Hooking-Resistenz
* [izmcm](https://github.com/izmcm) für die Implementierung der Methode `amIReverseEngineeredWithFailedChecks()`
* [sanu](https://github.com/sanu) für die Bereitstellung neuer Dateiprüfungen
* [marsepu](https://github.com/marsepu) für einen gut gemachten PR mit neuen Verbesserungen
* [mkj-is](https://github.com/mkj-is) für einen PR zur Verbesserung der ISS-Leistung 🚄
* [LongXiangGuo](https://github.com/LongXiangGuo) für einen PR zum Hinzufügen des Datenschutz-Manifests
* [Coeur](https://github.com/Coeur) für ISS-Verbesserungen und Fehlerbehebungen
* [Adobels](https://github.com/Adobels) für die Anpassung von ISS an die neuen Anforderungen von Apple


## TODO

* [ ] Recherche zur Erkennung von Installer5 und Zebra Package Manager (Cydia-Alternativen)
* [ ] Dopamine hidejb Detektor

## Lizenz
Siehe die LICENSE-Datei.

## Referenzen
Während der Erstellung dieses Tools habe ich Folgendes verwendet:

* 🔗 https://github.com/TheSwiftyCoder/JailBreak-Detection
* 🔗 https://github.com/abhinashjain/jailbreakdetection 
* 🔗 https://gist.github.com/ddrccw/8412847
* 🔗 https://gist.github.com/bugaevc/4307eaf045e4b4264d8e395b5878a63b
* 📚 "iOS Application Security" von David Thiel