1. 루팅 감지 구현하기

가장 기본적인 보안 검사는 기기가 루팅되었는지 확인하는 거에요. 루팅된 기기에서는 앱이 더 쉽게 해킹될 수 있거든요!

public boolean isDeviceRooted() {
    // 방법 1: su 바이너리 체크
    String[] paths = {"/system/app/Superuser.apk", "/system/bin/su", 
                      "/system/xbin/su", "/sbin/su", "/data/local/su"};
    for (String path : paths) {
        if (new File(path).exists()) {
            return true;
        }
    }
    
    // 방법 2: 루트 관리 앱 체크
    String[] rootApps = {"com.noshufou.android.su", "com.thirdparty.superuser",
                         "eu.chainfire.supersu", "com.topjohnwu.magisk"};
    PackageManager pm = context.getPackageManager();
    for (String appName : rootApps) {
        try {
            pm.getPackageInfo(appName, 0);
            return true;
        } catch (PackageManager.NameNotFoundException e) {
            // 앱이 설치되어 있지 않음
        }
    }
    
    // 방법 3: 명령어 실행 시도
    Process process = null;
    try {
        process = Runtime.getRuntime().exec("su");
        return true;
    } catch (Exception e) {
        return false;
    } finally {
        if (process != null) {
            process.destroy();
        }
    }
}
      

위 코드는 세 가지 방법으로 루팅을 감지해요:

1. 루트 권한 관련 파일 존재 여부 확인
2. 루트 관리 앱 설치 여부 확인
3. su 명령어 실행 가능 여부 확인

주의! 해커들은 이런 기본적인 루팅 감지를 우회하는 방법을 알고 있어요. 그래서 여러 방법을 조합해서 사용하는 것이 중요해요!

2. 앱 서명 검증하기

앱이 원본 서명과 일치하는지 확인하는 것도 중요해요. 변조된 앱은 서명이 다를 거에요!

public boolean verifyAppSignature(Context context) {
    try {
        // 앱의 서명 정보 가져오기
        PackageInfo packageInfo = context.getPackageManager()
            .getPackageInfo(context.getPackageName(), PackageManager.GET_SIGNATURES);
        
        // 서명 해시 계산
        for (Signature signature : packageInfo.signatures) {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(signature.toByteArray());
            
            String currentSignature = Base64.encodeToString(md.digest(), Base64.DEFAULT);
            
            // 원본 서명 해시와 비교 (이 값은 빌드 시 생성하여 코드에 하드코딩하거나 서버에서 가져와야 함)
            String originalSignature = "YOUR_APP_SIGNATURE_HASH_HERE";
            
            return originalSignature.equals(currentSignature);
        }
    } catch (Exception e) {
        // 예외 발생 시 보안을 위해 false 반환
        return false;
    }
    
    return false;
}
      

이 코드는 앱의 현재 서명을 확인하고 원본 서명과 비교해요. 만약 앱이 리패키징되었다면 서명이 달라질 거에요!

3. 디버거 감지하기

해커들은 종종 디버거를 사용해 앱을 분석해요. 디버거가 연결되었는지 감지하는 코드를 추가해봅시다!

public boolean isDebuggerConnected() {
    // 방법 1: Android API 사용
    boolean isDebuggerAttached = Debug.isDebuggerConnected();
    
    // 방법 2: TracerPid 확인
    try {
        BufferedReader reader = new BufferedReader(new FileReader("/proc/self/status"));
        String line;
        
        while ((line = reader.readLine()) != null) {
            if (line.startsWith("TracerPid:")) {
                int tracerPid = Integer.parseInt(line.substring(line.indexOf(":") + 1).trim());
                if (tracerPid != 0) {
                    reader.close();
                    return true;  // 디버거 연결됨
                }
                break;
            }
        }
        reader.close();
    } catch (Exception e) {
        // 파일 읽기 실패
    }
    
    return isDebuggerAttached;
}
      

이 코드는 두 가지 방법으로 디버거를 감지해요:

1. Android API의 Debug.isDebuggerConnected() 메서드 사용
2. /proc/self/status 파일에서 TracerPid 값 확인 (0이 아니면 디버거가 연결된 것)

4. 에뮬레이터 감지하기

해커들은 종종 에뮬레이터에서 앱을 분석해요. 실제 기기가 아닌 에뮬레이터에서 실행 중인지 감지해봅시다!

public boolean isEmulator() {
    // 방법 1: Build 속성 확인
    boolean isEmulator = (Build.FINGERPRINT.startsWith("generic")
            || Build.FINGERPRINT.startsWith("unknown")
            || Build.MODEL.contains("google_sdk")
            || Build.MODEL.contains("Emulator")
            || Build.MODEL.contains("Android SDK built for x86")
            || Build.MANUFACTURER.contains("Genymotion")
            || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
            || "google_sdk".equals(Build.PRODUCT));
    
    // 방법 2: 전화번호 관련 속성 확인
    if (!isEmulator) {
        try {
            TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            String networkOperator = tm.getNetworkOperatorName();
            if ("Android".equals(networkOperator)) {
                return true;
            }
            
            // 에뮬레이터에서 자주 사용되는 전화번호
            String deviceId = tm.getDeviceId();
            if ("000000000000000".equals(deviceId) || "012345678912345".equals(deviceId)) {
                return true;
            }
        } catch (Exception e) {
            // 권한 문제 등으로 실패할 수 있음
        }
    }
    
    return isEmulator;
}
      

이 코드는 여러 방법으로 에뮬레이터를 감지해요:

1. Build 클래스의 여러 속성 확인 (FINGERPRINT, MODEL, MANUFACTURER 등)
2. 전화 관련 속성 확인 (에뮬레이터는 특정 패턴의 deviceId를 가짐)

5. 코드 무결성 검사하기

앱의 중요한 코드 부분이 변조되지 않았는지 확인하는 것도 중요해요!

public boolean verifyCodeIntegrity() {
    try {
        // 중요 클래스의 바이트코드 해시 계산
        Class<?> clazz = PaymentProcessor.class;  // 검사할 중요 클래스
        String className = clazz.getName().replace('.', '/') + ".class";
        
        InputStream is = clazz.getClassLoader().getResourceAsStream(className);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int bytesRead;
        
        while ((bytesRead = is.read(buffer)) != -1) {
            baos.write(buffer, 0, bytesRead);
        }
        
        byte[] classBytes = baos.toByteArray();
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] digest = md.digest(classBytes);
        
        String currentHash = bytesToHex(digest);
        
        // 원본 해시값과 비교 (이 값은 빌드 시 생성하여 코드에 하드코딩하거나 서버에서 가져와야 함)
        String originalHash = "ORIGINAL_CLASS_HASH_HERE";
        
        return originalHash.equals(currentHash);
    } catch (Exception e) {
        // 예외 발생 시 보안을 위해 false 반환
        return false;
    }
}

private String bytesToHex(byte[] bytes) {
    StringBuilder sb = new StringBuilder();
    for (byte b : bytes) {
        sb.append(String.format("%02x", b));
    }
    return sb.toString();
}
      

이 코드는 중요한 클래스(예: 결제 처리 클래스)의 바이트코드 해시를 계산하고 원본 해시와 비교해요. 코드가 변조되면 해시가 달라질 거에요!

6. 모든 검사를 통합하기

이제 위의 모든 검사를 하나로 통합해서 앱의 무결성을 종합적으로 확인해봅시다!

public class IntegrityChecker {
    private Context context;
    
    public IntegrityChecker(Context context) {
        this.context = context;
    }
    
    public boolean isEnvironmentSafe() {
        // 여러 검사 실행
        boolean rootCheck = !isDeviceRooted();
        boolean signatureCheck = verifyAppSignature(context);
        boolean debuggerCheck = !isDebuggerConnected();
        boolean emulatorCheck = !isEmulator();
        boolean codeIntegrityCheck = verifyCodeIntegrity();
        
        // 모든 검사를 통과해야 안전하다고 판단
        return rootCheck && signatureCheck && debuggerCheck && 
               emulatorCheck && codeIntegrityCheck;
    }
    
    public void enforceIntegrity() {
        if (!isEnvironmentSafe()) {
            // 무결성 위반 시 대응
            // 1. 앱 종료
            // System.exit(0);
            
            // 2. 제한된 기능만 허용
            // ApplicationState.setRestrictedMode(true);
            
            // 3. 서버에 로그 남기기
            // reportIntegrityViolation();
            
            // 4. 사용자에게 알림
            Toast.makeText(context, "보안 위반이 감지되었습니다. 앱을 종료합니다.", 
                          Toast.LENGTH_LONG).show();
            
            // 앱 종료 (실제 구현 시 적절한 방법 선택)
            android.os.Process.killProcess(android.os.Process.myPid());
        }
    }
    
    // 여기에 앞서 구현한 모든 검사 메서드들 추가
    // isDeviceRooted(), verifyAppSignature(), isDebuggerConnected(), 
    // isEmulator(), verifyCodeIntegrity() 등
}
      

이 통합 클래스는 모든 검사를 실행하고 결과에 따라 적절히 대응해요. 실제 앱에서는 다음과 같이 사용할 수 있어요:

// 앱 시작 시 또는 중요 작업 전에 무결성 검사 실행
IntegrityChecker checker = new IntegrityChecker(context);
checker.enforceIntegrity();
      

이제 안드로이드에서 런타임 무결성 검사를 구현하는 방법을 알게 되셨네요! 다음으로 iOS에서는 어떻게 구현하는지 알아볼게요. 🍎

1. 탈옥 감지 구현하기

iOS에서 가장 기본적인 보안 검사는 기기가 탈옥(Jailbreak)되었는지 확인하는 거에요!

func isDeviceJailbroken() -> Bool {
    // 방법 1: 탈옥 앱 설치 여부 확인
    let jailbreakApps = [
        "/Applications/Cydia.app",
        "/Applications/blackra1n.app",
        "/Applications/FakeCarrier.app",
        "/Applications/Icy.app",
        "/Applications/IntelliScreen.app",
        "/Applications/MxTube.app",
        "/Applications/RockApp.app",
        "/Applications/SBSettings.app",
        "/Applications/WinterBoard.app"
    ]
    
    for path in jailbreakApps {
        if FileManager.default.fileExists(atPath: path) {
            return true
        }
    }
    
    // 방법 2: 탈옥 파일 시스템 확인
    let jailbreakPaths = [
        "/Library/MobileSubstrate/MobileSubstrate.dylib",
        "/bin/bash",
        "/usr/sbin/sshd",
        "/etc/apt",
        "/private/var/lib/apt/"
    ]
    
    for path in jailbreakPaths {
        if FileManager.default.fileExists(atPath: path) {
            return true
        }
    }
    
    // 방법 3: 샌드박스 외부 쓰기 가능 여부 확인
    let stringToWrite = "Jailbreak Test"
    do {
        try stringToWrite.write(toFile: "/private/jailbreak.txt", atomically: true, encoding: .utf8)
        // 파일 쓰기 성공 = 탈옥됨
        try FileManager.default.removeItem(atPath: "/private/jailbreak.txt")
        return true
    } catch {
        // 파일 쓰기 실패 = 정상
        return false
    }
}
      

이 코드는 세 가지 방법으로 탈옥을 감지해요:

1. Cydia 등 탈옥 관련 앱 설치 여부 확인
2. 탈옥 환경에만 존재하는 파일/디렉토리 확인
3. 샌드박스 외부에 파일 쓰기 시도 (정상 기기에서는 실패해야 함)

2. 디버거 감지하기

iOS에서도 디버거가 연결되었는지 감지하는 것이 중요해요!

func isDebuggerAttached() -> Bool {
    // 방법 1: sysctl 사용
    var info = kinfo_proc()
    var mib: [Int32] = [CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid()]
    var size = MemoryLayout<kinfo_proc>.stride
    let junk = sysctl(&mib, UInt32(mib.count), &info, &size, nil, 0)
    
    if junk != 0 {
        return false
    }
    
    return (info.kp_proc.p_flag & P_TRACED) != 0
    
    // 방법 2: ptrace 사용 (더 강력한 방법)
    /*
    var ptrace_ret: Int32 = 0
    ptrace_ret = ptrace(PT_DENY_ATTACH, 0, 0, 0)
    return ptrace_ret != 0
    */
}
      

이 코드는 두 가지 방법으로 디버거를 감지해요:

1. sysctl을 사용해 프로세스 정보를 확인하고 P_TRACED 플래그 체크
2. ptrace(PT_DENY_ATTACH)를 호출해 디버거 연결 자체를 방지 (주석 처리됨)

참고: PT_DENY_ATTACH는 디버거 연결을 방지하는 강력한 방법이지만, 앱 스토어 심사 과정에서 문제가 될 수 있어요. 신중하게 사용해야 해요!

3. 코드 서명 검증하기

iOS 앱의 코드 서명이 유효한지 확인하는 것도 중요해요!

func isCodeSignatureValid() -> Bool {
    // 앱 번들의 코드 서명 상태 확인
    let task = Process()
    task.launchPath = "/usr/bin/codesign"
    task.arguments = ["-v", Bundle.main.bundlePath]
    
    let pipe = Pipe()
    task.standardError = pipe
    task.standardOutput = pipe
    
    do {
        try task.run()
        task.waitUntilExit()
        
        // 종료 코드가 0이면 서명이 유효함
        return task.terminationStatus == 0
    } catch {
        // 프로세스 실행 실패
        return false
    }
}
      

이 코드는 codesign 명령어를 사용해 앱 번들의 코드 서명 상태를 확인해요. 서명이 유효하면 종료 코드가 0이 될 거에요!

4. 런타임 라이브러리 후킹 감지하기

iOS에서는 Substrate, Fishhook 같은 도구로 런타임 후킹이 가능해요. 이를 감지해봅시다!

func isRuntimeTampered() -> Bool {
    // 방법 1: 의심스러운 라이브러리 로드 여부 확인
    let suspiciousLibraries = [
        "SubstrateLoader.dylib",
        "libcycript.dylib",
        "libsparkapplist.dylib",
        "libsparkcolourpicker.dylib",
        "TweakInject.dylib",
        "MobileSubstrate.dylib"
    ]
    
    let count = _dyld_image_count()
    for i in 0..<count {
        if let imageName = _dyld_get_image_name(i) {
            let name = String(cString: imageName)
            for library in suspiciousLibraries {
                if name.contains(library) {
                    return true
                }
            }
        }
    }
    
    // 방법 2: 함수 무결성 검사 (예시)
    // 중요 함수의 메모리 주소를 확인하여 후킹 여부 감지
    let originalFunction: @convention(c) () -> Bool = isDeviceJailbroken
    let functionPtr = unsafeBitCast(originalFunction, to: UnsafeRawPointer.self)
    
    // 첫 몇 바이트를 읽어서 JMP 명령어(후킹의 흔적) 확인
    // 실제 구현은 더 복잡할 수 있음
    let bytes = functionPtr.assumingMemoryBound(to: UInt8.self)
    if bytes[0] == 0xE9 || bytes[0] == 0xFF {  // JMP 명령어
        return true
    }
    
    return false
}
      

이 코드는 두 가지 방법으로 런타임 후킹을 감지해요:

1. 의심스러운 동적 라이브러리 로드 여부 확인
2. 중요 함수의 메모리 내용을 확인해 후킹 여부 감지

5. 에뮬레이터 감지하기

iOS 앱이 시뮬레이터에서 실행 중인지 감지해봅시다!

func isRunningOnSimulator() -> Bool {
    #if targetEnvironment(simulator)
        return true
    #else
        // 추가 확인 (드물게 매크로가 우회될 수 있음)
        let simulatorPaths = [
            "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform",
            "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/Library/CoreSimulator"
        ]
        
        for path in simulatorPaths {
            if FileManager.default.fileExists(atPath: path) {
                return true
            }
        }
        
        return false
    #endif
}
      

이 코드는 두 가지 방법으로 시뮬레이터를 감지해요:

1. 컴파일 타임 매크로 사용 (targetEnvironment(simulator))
2. 시뮬레이터 관련 파일 경로 확인

6. 모든 검사를 통합하기

이제 위의 모든 검사를 하나로 통합해서 앱의 무결성을 종합적으로 확인해봅시다!

class IntegrityChecker {
    static let shared = IntegrityChecker()
    
    private init() {}
    
    func isEnvironmentSafe() -> Bool {
        // 여러 검사 실행
        let jailbreakCheck = !isDeviceJailbroken()
        let debuggerCheck = !isDebuggerAttached()
        let signatureCheck = isCodeSignatureValid()
        let runtimeCheck = !isRuntimeTampered()
        let simulatorCheck = !isRunningOnSimulator()
        
        // 모든 검사를 통과해야 안전하다고 판단
        return jailbreakCheck && debuggerCheck && signatureCheck && 
               runtimeCheck && simulatorCheck
    }
    
    func enforceIntegrity() {
        if !isEnvironmentSafe() {
            // 무결성 위반 시 대응
            // 1. 앱 종료
            // exit(0)
            
            // 2. 제한된 기능만 허용
            // AppState.shared.setRestrictedMode(true)
            
            // 3. 서버에 로그 남기기
            // reportIntegrityViolation()
            
            // 4. 사용자에게 알림
            DispatchQueue.main.async {
                let alert = UIAlertController(
                    title: "보안 경고",
                    message: "보안 위반이 감지되었습니다. 앱을 종료합니다.",
                    preferredStyle: .alert
                )
                
                alert.addAction(UIAlertAction(title: "확인", style: .default) { _ in
                    exit(0)
                })
                
                // 최상위 뷰 컨트롤러 찾기
                if let rootVC = UIApplication.shared.windows.first?.rootViewController {
                    var topVC = rootVC
                    while let presentedVC = topVC.presentedViewController {
                        topVC = presentedVC
                    }
                    topVC.present(alert, animated: true)
                }
            }
        }
    }
    
    // 여기에 앞서 구현한 모든 검사 메서드들 추가
    // isDeviceJailbroken(), isDebuggerAttached(), isCodeSignatureValid(), 
    // isRuntimeTampered(), isRunningOnSimulator() 등
}
      

이 통합 클래스는 모든 검사를 실행하고 결과에 따라 적절히 대응해요. 실제 앱에서는 다음과 같이 사용할 수 있어요:

// 앱 시작 시 또는 중요 작업 전에 무결성 검사 실행
IntegrityChecker.shared.enforceIntegrity()
      

이제 iOS에서도 런타임 무결성 검사를 구현하는 방법을 알게 되셨네요! 다음으로 더 고급 기법들을 알아볼게요. 🚀