IOSSecuritySuite

.package(url: "https://github.com/securing/IOSSecuritySuite.git", from: "1.5.0")

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

if IOSSecuritySuite.amIJailbroken() {
	print("यह डिवाइस जेलब्रोकन है")
} else {
	print("यह डिवाइस जेलब्रोकन नहीं है")
}

let jailbreakStatus = IOSSecuritySuite.amIJailbrokenWithFailMessage()
if jailbreakStatus.jailbroken {
	print("यह डिवाइस जेलब्रोकन है")
	print("क्योंकि: \(jailbreakStatus.failMessage)")
} else {
	print("यह डिवाइस जेलब्रोकन नहीं है")
}

let jailbreakStatus = IOSSecuritySuite.amIJailbrokenWithFailedChecks()
if jailbreakStatus.jailbroken {
   if (jailbreakStatus.failedChecks.contains { $0.check == .existenceOfSuspiciousFiles }) && (jailbreakStatus.failedChecks.contains { $0.check == .suspiciousFilesCanBeOpened }) {
         print("यह वास्तविक जेलब्रोकन डिवाइस है")
   }
}

let amIDebugged: Bool = IOSSecuritySuite.amIDebugged()

IOSSecuritySuite.denyDebugger()

let runInEmulator: Bool = IOSSecuritySuite.amIRunInEmulator()

if IOSSecuritySuite.amIReverseEngineered() {
  print("इस डिवाइस पर रिवर्स इंजीनियरिंग के सबूत हैं")
} else {
  print("इस डिवाइस पर रिवर्स इंजीनियरिंग के सबूत नहीं हैं")
}

let reverseStatus = IOSSecuritySuite.amIReverseEngineeredWithFailedChecks()
if reverseStatus.reverseEngineered {
   // अधिक जानकारी के लिए reverseStatus.failedChecks देखें
}

let amIProxied: Bool = IOSSecuritySuite.amIProxied(considerVPNConnectionAsProxy: true)

let amIInLockdownMode: Bool = IOSSecuritySuite.amIInLockdownMode()

let amIRuntimeHooked: Bool = amIRuntimeHook(dyldWhiteList: dylds, detectionClass: SomeClass.self, selector: #selector(SomeClass.someFunction), isClassMethod: false)

// यदि हम Swift फ़ंक्शन के सिंबल हुक को अस्वीकार करना चाहते हैं, तो हमें उस फ़ंक्शन का मैंगल्ड नाम पास करना होगा
denySymbolHook("$s10Foundation5NSLogyySS_s7CVarArg_pdtF")   // NSLog फ़ंक्शन के लिए हुकिंग अस्वीकार करना
NSLog("Hello Symbol Hook")
     
denySymbolHook("abort") 
abort()

// फ़ंक्शन घोषणा
func someFunction(takes: Int) -> Bool {
	return false
} 

// FunctionType परिभाषित करना : @convention(thin) एक "पतले" फ़ंक्शन संदर्भ को इंगित करता है, जो बिना किसी विशेष "self" या "context" पैरामीटर के Swift कॉलिंग कन्वेंशन का उपयोग करता है।
typealias FunctionType = @convention(thin) (Int) -> (Bool)

// उस फ़ंक्शन का पॉइंटर पता प्राप्त करना जिसे हम सत्यापित करना चाहते हैं
func getSwiftFunctionAddr(_ function: @escaping FunctionType) -> UnsafeMutableRawPointer {
	return unsafeBitCast(function, to: UnsafeMutableRawPointer.self)
}

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

// फ़ंक्शन घोषणा
func denyDebugger(value: Int) {
}

// FunctionType परिभाषित करना : @convention(thin) एक "पतले" फ़ंक्शन संदर्भ को इंगित करता है, जो बिना किसी विशेष "self" या "context" पैरामीटर के Swift कॉलिंग कन्वेंशन का उपयोग करता है।
typealias FunctionType = @convention(thin) (Int)->()

// मूल फ़ंक्शन का पता प्राप्त करना
let funcDenyDebugger: FunctionType = denyDebugger 
let funcAddr = unsafeBitCast(funcDenyDebugger, to: UnsafeMutableRawPointer.self)


if let originalDenyDebugger = denyMSHook(funcAddr) {
// मूल फ़ंक्शन को 1337 Int आर्गुमेंट के साथ कॉल करें
     unsafeBitCast(originalDenyDebugger, to: FunctionType.self)(1337)
 } else {
     denyDebugger()
 }

// निर्धारित करें कि एप्लिकेशन के साथ छेड़छाड़ की गई है या नहीं 
if IOSSecuritySuite.amITampered([.bundleID("biz.securing.FrameworkClientApp"),
    .mobileProvision("2976c70b56e9ae1e2c8e8b231bf6b0cff12bbbd0a593f21846d9a004dd181be3"),
    .machO("IOSSecuritySuite", "6d8d460b9a4ee6c0f378e30f137cebaf2ce12bf31a2eef3729c36889158aa7fc")]).result {
    print("मेरे साथ छेड़छाड़ की गई है।")
}
else {
    print("मेरे साथ छेड़छाड़ नहीं की गई है।")
}

// लोड की गई dylib के SHA256 हैश मान को मैन्युअल रूप से सत्यापित करें
if let hashValue = IOSSecuritySuite.getMachOFileHashValue(.custom("IOSSecuritySuite")), hashValue == "6d8d460b9a4ee6c0f378e30f137cebaf2ce12bf31a2eef3729c36889158aa7fc" {
    print("मेरे साथ छेड़छाड़ नहीं की गई है।")
}
else {
    print("मेरे साथ छेड़छाड़ की गई है।")
}
 
// मुख्य निष्पादन योग्य का SHA256 हैश मान जांचें
// सुझाव: आपका एप्लिकेशन यह मान सर्वर से प्राप्त कर सकता है
if let hashValue = IOSSecuritySuite.getMachOFileHashValue(.default), hashValue == "your-application-executable-hash-value" {
    print("मेरे साथ छेड़छाड़ नहीं की गई है।")
}
else {
    print("मेरे साथ छेड़छाड़ की गई है।")
}

func denyDebugger() {
    // यहाँ ब्रेकपॉइंट सेट करें
}
     
typealias FunctionType = @convention(thin) ()->()
let func_denyDebugger: FunctionType = denyDebugger   // `: FunctionType` अनिवार्य है
let func_addr = unsafeBitCast(func_denyDebugger, to: UnsafeMutableRawPointer.self)
let hasBreakpoint = IOSSecuritySuite.hasBreakpointAt(func_addr, functionSize: nil)

if hasBreakpoint {
    print("निर्दिष्ट फ़ंक्शन में ब्रेकपॉइंट पाया गया")
} else {
    print("निर्दिष्ट फ़ंक्शन में ब्रेकपॉइंट नहीं पाया गया")
}

// testWatchpoint फ़ंक्शन पर एक ब्रेकपॉइंट सेट करें
func testWatchpoint() -> Bool{
		// lldb: watchpoint set expression ptr
    var ptr = malloc(9)
    // lldb: watchpoint set variable count
    var count = 3
    return IOSSecuritySuite.hasWatchpoint()
}