स्विफ्ट में सुरक्षित आईओएस विकास:सामान्य नुकसान से बचें और अपने ऐप को मजबूत करें

आवश्यकताएँ

• <पी> स्विफ्ट और आईओएस विकास का कार्यसाधक ज्ञान।

• <पी> Xcode तक पहुंच.

• <पी> iOS ऐप्स सर्वर के साथ कैसे संचार करते हैं इसकी बुनियादी समझ।

• <पी> टर्मिनल/कमांड लाइन की बुनियादी बातों से परिचित।

हम क्या कवर करेंगे:

• स्विफ्ट आईओएस अनुप्रयोगों में सबसे प्रचलित सुरक्षा जाल क्या हैं?
  • 1. असुरक्षित डेटा संग्रहण
  • 2. कमजोर नेटवर्क संचार
  • 3. अनुचित इनपुट सत्यापन
  • 4. हार्डकोडिंग रहस्य
  • 5. अपर्याप्त प्रमाणीकरण और प्राधिकरण
  • 6. असुरक्षित लॉगिंग और त्रुटि प्रबंधन
  • 7. कोड अस्पष्टता और रिवर्स इंजीनियरिंग को नजरअंदाज करना
  • 8. असुरक्षित तृतीय-पक्ष लाइब्रेरी
  • 9. अपर्याप्त बायोमेट्रिक और मल्टी-फैक्टर प्रमाणीकरण
  • 10. आवधिक सुरक्षा परीक्षण की अवहेलना

स्विफ्ट iOS अनुप्रयोगों में सबसे प्रचलित सुरक्षा जाल क्या हैं?

1. असुरक्षित डेटा संग्रहण

कैसे ठीक करें:

do {
try keychain.set("userPassword123", key: "userPassword")
} catch {
 print("Error saving to Keychain: \(error)")
}

import Security
class KeychainManager {
 func set(_ value: String, key: String) throws {
 // 1. Convert string to Data
 guard let data = value.data(using: .utf8) else {
 throw NSError(domain: "KeychainManager", code: -1)
 }
 // 2. Build the query dictionary
 let query: [String: Any] = [
 // Store as password
 kSecClass as String: kSecClassGenericPassword,
 // Your app's bundle identifier
 kSecAttrService as String: "com.yourapp.keychain",
 // "userPassword"
 kSecAttrAccount as String: key,
 // "userPassword123" encrypted
 kSecValueData as String: data,
 kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock
 ]
 // 3. Save to keychain (iOS encrypts it automatically)
 let status = SecItemAdd(query as CFDictionary, nil)
 // 4. Check if successful
 guard status == errSecSuccess else {
 throw NSError(domain: "KeychainManager", code: Int(status))
 }
 }
}

2. कमजोर नेटवर्क संचार

• <पी> संवेदनशील जानकारी (पासवर्ड, व्यक्तिगत डेटा, भुगतान विवरण) पढ़ें

• <पी> अनुरोधों और प्रतिक्रियाओं को संशोधित करें

• <पी> अपने वैध सर्वर का प्रतिरूपण करें

कैसे ठीक करें:

// ❌ INSECURE - HTTP connection (blocked by ATS by default)
let url = URL(string: "http://api.example.com/login")
// ✅ SECURE - HTTPS connection
let url = URL(string: "https://api.example.com/login")

class SecureNetworkManager: NSObject, URLSessionDelegate {
 // Store your server's certificate hash
 // Get this by running: openssl x509 -in certificate.crt -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | base64
 private let expectedPublicKeyHash = "YOUR_CERTIFICATE_HASH_HERE"
 func urlSession(
 _ session: URLSession,
 didReceive challenge: URLAuthenticationChallenge,
 completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
 ) {
 // Step 1: Check if this is a server trust challenge (certificate validation)
 guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
 let serverTrust = challenge.protectionSpace.serverTrust
 else {
 // Not a certificate challenge; use default handling
 completionHandler(.performDefaultHandling, nil)
 return
 }
 // Step 2: Validate that the server's certificate matches our pinned certificate
 if isValidServerTrust(serverTrust) {
 // Certificate matches - proceed with the connection
 completionHandler(.useCredential, URLCredential(trust: serverTrust))
 } else {
 // Certificate doesn't match - reject the connection to prevent MITM attack
 completionHandler(.cancelAuthenticationChallenge, nil)
 }
 }
 // Validates the server's certificate against our pinned hash
 private func isValidServerTrust(_ serverTrust: SecTrust) -> Bool {
 // Extract the server's certificate
 guard let serverCertificate = SecTrustGetCertificateAtIndex(serverTrust, 0) else {
 return false
 }
 // Get the public key from the certificate
 let serverPublicKey = SecCertificateCopyKey(serverCertificate)
 guard let publicKey = serverPublicKey else {
 return false
 }
 // Convert the public key to data and hash it
 var error: Unmanaged<CFError>?
 guard let publicKeyData = SecKeyCopyExternalRepresentation(publicKey, &error) as Data? else {
 return false
 }
 // Hash the public key using SHA-256
 let publicKeyHash = SHA256.hash(data: publicKeyData)
 let publicKeyHashString = Data(publicKeyHash).base64EncodedString()
 // Compare with our expected hash
 return publicKeyHashString == expectedPublicKeyHash
 }
}

1. <पी> urlSession(_:didReceive:completionHandler:) - जब भी आपका ऐप HTTPS कनेक्शन बनाता है तो इस विधि को कॉल किया जाता है। iOS पूछता है:"क्या मुझे इस सर्वर के प्रमाणपत्र पर भरोसा करना चाहिए?"

2. <पी> प्रमाणीकरण विधि की जाँच करें - हम सत्यापित करते हैं कि यह एक सर्वर ट्रस्ट चुनौती (प्रमाणपत्र सत्यापन) है, किसी अन्य प्रकार का प्रमाणीकरण नहीं।

3. <पी> प्रमाणपत्र सत्यापित करें - हम isValidServerTrust() पर कॉल करते हैं , जो:
   • <पी> कनेक्शन से सर्वर का प्रमाणपत्र निकालता है

   • <पी> उस प्रमाणपत्र से सार्वजनिक कुंजी प्राप्त करता है

   • <पी> SHA-256
     का उपयोग करके सार्वजनिक कुंजी को हैश करता है
   • <पी> हैश की तुलना हमारे संग्रहीत, अपेक्षित हैश से करता है

1. निर्णय लें:

• <पी> यदि हैश मेल खाता है, तो सर्वर वैध है। .useCredential के साथ आगे बढ़ें .

• <पी> यदि हैश मेल नहीं खाता है, तो हमारे पास संभावित MITM हमला है। .cancelAuthenticationChallenge के साथ रद्द करें .

3. अनुचित इनपुट सत्यापन

कैसे ठीक करें:

func isValidEmail(_ email: String) -> Bool {
 let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
 let emailPredicate = NSPredicate(format: "SELF MATCHES %@", emailRegex)
 return emailPredicate.evaluate(with: email)
}
// Only accept properly formatted data
guard isValidEmail(userEmail) else {
 // Reject invalid input
 return
}

if let userAge = apiResponse["age"] as? Int,
 userAge >= 0 && userAge <= 150 {
 // Safe to use
 user.age = userAge
} else {
 // Handle invalid data appropriately
 throw ValidationError.invalidAge
}

// ❌ NEVER DO THIS - Vulnerable to SQL Injection
let username = userInput // Could be: "admin' OR '1'='1"
let query = "SELECT * FROM users WHERE username = '\(username)'"
database.execute(query)

SELECT * FROM users WHERE username = 'admin' OR '1'='1'

// ✅ SAFE - Using parameterized queries
let query = "SELECT * FROM users WHERE username = ?"
database.execute(query, withArgumentsIn: [username])

4. हार्डकोडिंग रहस्य

समस्या - हार्डकोडेड रहस्य:

// NEVER DO THIS
class APIClient {
 private let apiKey = "1234567890abcdef"
 private let secretToken = "sk_live_51H..."
 func makeRequest() {
 // These secrets are embedded in your binary
 let headers = ["Authorization": "Bearer \(apiKey)"]
 }
}

class APIClient {
 private var sessionToken: String?
 // User logs in and receives a temporary session token
 func authenticateUser(email: String, password: String) async throws {
 let response = try await backend.login(email: email, password: password)
 // Store only a temporary, user-specific session token
 self.sessionToken = response.sessionToken
 }
 // Backend handles the actual API calls with the real API key
 func fetchUserData() async throws -> UserData {
 guard let token = sessionToken else {
 throw AuthError.notAuthenticated
 }
 // Your backend receives this request, validates the session token,
 // then uses its own API keys to fetch data from third-party services
 return try await backend.getUserData(sessionToken: token)
 }
}

// Secrets.xcconfig (add to .gitignore!)
API_KEY = your_dev_api_key_here
API_SECRET = your_dev_secret_here
// Access in your code through Info.plist
class Config {
 static let apiKey: String = {
 guard let key = Bundle.main.object(forInfoDictionaryKey: "API_KEY") as? String else {
 fatalError("API_KEY not found in configuration")
 }
 return key
 }()
}

5. अपर्याप्त प्रमाणीकरण और प्राधिकरण

कैसे ठीक करें:

• <पी> प्रमाणीकरण और प्राधिकरण क्लाइंट-साइड के बजाय सर्वर साइड पर करें।

• <पी> प्रमाणित उपयोगकर्ता लॉगिन के लिए JWT (JSON वेब टोकन) या OAuth 2.0 का उपयोग करें।

• <पी> टोकन चोरी की संभावना को कम करने के लिए टोकन समाप्ति और ताज़ा तर्क को लागू करने की आवश्यकता है।

let request = URLRequest(url: apiURL)
request.setValue("Bearer \(jwtToken)", forHTTPHeaderField: "Authorization")

6. असुरक्षित लॉगिंग और त्रुटि प्रबंधन

कैसे ठीक करें:

• <पी> संवेदनशील जानकारी को सावधानीपूर्वक लॉग करें।

• <पी> नियंत्रित त्रुटि प्रबंधन लागू करें और उपयोगकर्ता द्वारा प्रस्तुत संदेशों में न्यूनतम मात्रा में जानकारी प्रदान करें।

• <पी> सुरक्षित लॉगिंग लाइब्रेरी लागू करें जो व्यक्तिगत डेटा को छुपाएं या एन्क्रिप्ट करें।

do {
 try someRiskyOperation()
} catch {
 // Log error securely
 Logger.log("Operation failed: \(error.localizedDescription)")
}

7. कोड अस्पष्टता और रिवर्स इंजीनियरिंग को नजरअंदाज करना

• <पी> कक्षा के नाम और विधि हस्ताक्षर

• <पी> स्ट्रिंग अक्षर (यूआरएल, त्रुटि संदेश, कुंजियाँ)

• <पी> आपके कोड तर्क की संरचना

• <पी> एल्गोरिथम कार्यान्वयन

class FeatureManager {
 func isPremiumUser() -> Bool {
 // Check if user has premium access
 let hasSubscription = UserDefaults.standard.bool(forKey: "premium_unlocked")
 return hasSubscription
 }
 func unlockPremiumFeature() {
 guard isPremiumUser() else {
 showPaywall()
 return
 }
 // Show premium content
 showPremiumContent()
 }
}

// In your build settings:
// - Set "Optimization Level" to "-O" (or -Osize) for release builds
// - Enable "Strip Debug Symbols During Copy" = YES
// - Set "Strip Style" to "All Symbols"

// Before obfuscation (readable to attackers):
class FeatureManager {
 func isPremiumUser() -> Bool { ... }
}
// After obfuscation (harder to understand):
class a7f3b2 {
 func x9k2m() -> Bool { ... }
}

// ✅ Secure approach - Server validates everything
class FeatureManager {
 func unlockPremiumFeature() async {
 do {
 // Server checks if user truly has premium access
 let hasAccess = try await backend.verifyPremiumAccess(userId: currentUserId)
 if hasAccess {
 showPremiumContent()
 } else {
 showPaywall()
 }
 } catch {
 // Handle error
 showPaywall()
 }
 }
}

8. असुरक्षित तृतीय-पक्ष लाइब्रेरी

कैसे ठीक करें:

• <पी> केवल उच्च-गुणवत्ता, सुव्यवस्थित पुस्तकालयों का उपयोग करें।

• <पी> निर्भरताएँ अद्यतन करें और सीवीई (सामान्य कमजोरियाँ और एक्सपोज़र) की निगरानी करें।

• <पी> यदि लाइब्रेरी कोड संवेदनशील डेटा को संभालता है तो उसका ऑडिट करें।

9. अपर्याप्त बायोमेट्रिक और मल्टी-फैक्टर प्रमाणीकरण

कैसे ठीक करें:

• <पी> बायोमेट्रिक प्रमाणीकरण के लिए स्थानीय प्रमाणीकरण ढाँचा बाँधें।

• <पी> मल्टीफैक्टर प्रमाणीकरण (एमएफए) के लिए बायोमेट्रिक्स को सर्वर-आधारित प्रमाणीकरण के साथ संयोजित करें।

import LocalAuthentication
let context = LAContext()
var error: NSError?
if context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) {
 context.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics,
 localizedReason: "Access your account") { success, authError in
 DispatchQueue.main.async {
 if success {
 // Proceed securely
 } else {
 // Handle failure (authError may contain the reason)
 print("Authentication failed: \(authError?.localizedDescription ?? "Unknown error")")
 }
 }
}
} else {
// Biometrics not available, check error for details
 print("Biometrics unavailable: \(error?.localizedDescription ?? "Unknown error")")
}

10. आवधिक सुरक्षा परीक्षण की अवहेलना

1. <पी> स्वचालित सुरक्षा स्कैन: सामान्य समस्याओं को पकड़ने के लिए प्रत्येक बिल्ड के साथ स्वचालित रूप से चलाएँ।

2. <पी> स्व-संचालित कोड ऑडिट: स्थापित दिशानिर्देशों का उपयोग करके अपने स्वयं के कोड की नियमित सुरक्षा-केंद्रित समीक्षाएँ।

3. <पी> भेद्यता स्कैनिंग उपकरण: सुरक्षा खामियों के लिए अपने ऐप का विश्लेषण करने के लिए MobSF जैसे मुफ़्त टूल का उपयोग करें।

4. <पी> निर्भरता ऑडिट: ज्ञात सुरक्षा कमजोरियों के लिए तृतीय-पक्ष लाइब्रेरी की जाँच करना।

# Example: GitHub Actions workflow for automated security scanning
name: Security Scan
on: [push, pull_request]
jobs:
 security-scan:
 runs-on: macos-latest
 steps:
 - name: Checkout code
 uses: actions/checkout@v3
 - name: Run MobSF Security Scan
 run: |
 # Mobile Security Framework - scans for common vulnerabilities
 docker run -v $(pwd):/app opensecurity/mobile-security-framework-mobsf
 - name: Dependency Vulnerability Check
 run: |
 # Check CocoaPods/SPM dependencies for known CVEs
 brew install dependency-check
 dependency-check --scan ./Podfile.lock --format JSON
 - name: Secret Detection
 run: |
 # Detect accidentally committed secrets
 brew install truffleHog
 truffleHog filesystem . --json
 - name: Fail build on critical issues
 run: |
 if grep -q "CRITICAL" security-report.json; then
 echo "Critical security issues found!"
 exit 1
 fi

• <पी> हार्डकोडेड एपीआई कुंजी, टोकन, या पासवर्ड
• <पी> असुरक्षित नेटवर्क कॉन्फ़िगरेशन (HTTPS के बजाय HTTP की अनुमति देना)

• <पी> कमजोर क्रिप्टोग्राफ़िक एल्गोरिदम

• <पी> तृतीय-पक्ष लाइब्रेरीज़ में ज्ञात कमज़ोरियाँ

• <पी> अनुचित एसएसएल/टीएलएस प्रमाणपत्र सत्यापन
• <पी> असुरक्षित डेटा संग्रहण (UserDefaults में संवेदनशील डेटा संग्रहीत करना)

• <पी> अत्यधिक ऐप अनुमतियाँ

Security Scan Results:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[CRITICAL] Hardcoded API Key Found
 File: APIClient.swift:15
 Issue: API key "sk_live_abc123..." detected in source code
[HIGH] Insecure HTTP Connection
 File: NetworkManager.swift:42
 Issue: App allows cleartext HTTP traffic to api.example.com
 Fix: Enforce HTTPS or add exception to Info.plist if required
[MEDIUM] Weak Encryption Algorithm
 File: DataEncryption.swift:28
 Issue: Using MD5 for hashing (cryptographically broken)
 Fix: Use SHA-256 or better
[LOW] Outdated Dependency
 Library: Alamofire 4.2.0
 Issue: Known vulnerability CVE-2021-12345
 Fix: Update to version 5.6.0 or later
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Build Failed: 2 critical issues must be fixed before deployment

# Install and run MobSF locally
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf
# Upload your .ipa file through the web interface at localhost:8000
# MobSF will analyze and provide a detailed security report

• <पी> हार्डकोडेड रहस्यों के लिए बाइनरी विश्लेषण

• <पी> असुरक्षित डेटा भंडारण पैटर्न

• <पी> कमजोर क्रिप्टोग्राफ़िक कार्यान्वयन

• <पी> असुरक्षित नेटवर्क कनेक्शन

• <पी> कोड गुणवत्ता और सुरक्षा सर्वोत्तम प्रथाएँ

• <पी> सुरक्षा मानकों का अनुपालन

// Example: Following OWASP MSTG recommendations for secure storage
class SecureStorage {
 // ❌ Insecure - UserDefaults is not encrypted
 func saveTokenInsecurely(_ token: String) {
 UserDefaults.standard.set(token, forKey: "authToken")
 }
 // ✅ Secure - Using Keychain as OWASP recommends
 func saveTokenSecurely(_ token: String) throws {
 let data = token.data(using: .utf8)!
 let query: [String: Any] = [
 kSecClass as String: kSecClassGenericPassword,
 kSecAttrAccount as String: "authToken",
 kSecValueData as String: data,
 kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly
 ]
 SecItemDelete(query as CFDictionary)
 let status = SecItemAdd(query as CFDictionary, nil)
 guard status == errSecSuccess else {
 throw StorageError.saveFailed
 }
 }
}

• <पी> [ ] क्या सभी संवेदनशील डेटा बाकी एन्क्रिप्टेड हैं?

• <पी> [ ] क्या HTTPS सभी नेटवर्क कॉल के लिए लागू है?

• <पी> [ ] क्या प्रमाणपत्र उचित रूप से मान्य हैं?

• <पी> [ ] क्या संवेदनशील डेटा को लॉग से बाहर रखा गया है?

• <पी> [ ] क्या एपीआई कुंजियाँ और रहस्य हार्डकोडेड नहीं हैं?

• <पी> [ ] क्या उपयोगकर्ता इनपुट मान्य और स्वच्छ है?

• <पी> [ ] क्या प्रमाणीकरण टोकन किचेन में सुरक्षित रूप से संग्रहीत हैं?

# For CocoaPods projects
gem install cocoapods-audit
pod audit
# For Swift Package Manager
# Use GitHub Dependabot (free for public repos) or
brew install swift-outdated
swift-outdated

• <पी> गिटहब डिपेंडाबोट: असुरक्षित निर्भरता का पता चलने पर स्वचालित रूप से पीआर बनाता है (मुक्त)

• <पी> स्निक :ओपन-सोर्स प्रोजेक्ट्स के लिए निःशुल्क टियर उपलब्ध है

• <पी> OWASP निर्भरता-जाँच: निःशुल्क कमांड-लाइन टूल

निष्कर्ष