werty2 님의 블로그

7주차_Jadx(2)

werty2 — Mon, 25 May 2026 17:06:29 +0900

아래 코드를 이어서 분석

public final int onStartCommand(Intent intent, int i2, int i3) {
    String str;
    String str2;
    String str3;
    String str4;
    Thread thread;
    String str5;
    int iM2535 = C1032.m2535("۠ۨۨ");
    Thread thread2 = null;
    String str6 = null;
    while (true) {
        switch (iM2535) {
            case 56293:
            case 1746818:
            case 1752670:
                iM2535 = C1025.f + (C1023.f4365 / 6412) < 0 ? C1058.m2711("ۨ۟۟") : (C1050.f4392 - C1022.f4364) + 1753444;
                break;
            case 56356:
                String strM2476 = C1023.m2476(intent);
                if (C1058.f4402 * (C1075.f4419 | (-2499)) >= 0) {
                    iM2535 = C1032.m2535("ۢ۟۠");
                    str6 = strM2476;
                } else {
                    iM2535 = (C1073.f4417 / C1055.f4399) + 1751653;
                    str6 = strM2476;
                }
                break;
            case 56414:
                thread = new Thread(new RunnableC0019q(C1067.f4411 ^ (-625), this), C1051.m2668(m2663(), 492, C1020.f4362 ^ (-960), 1703));
                if ((C1050.f4392 ^ (C1040.f4382 / (-3268))) < 0) {
                    str5 = "ۣۨۨ";
                    iM2535 = C1068.m2771(str5);
                    thread2 = thread;
                } else {
                    iM2535 = C1067.m2764("ۣ۟ۧ");
                    thread2 = thread;
                }
                break;
            case 1746819:
                if (C1031.f4373 >= 0) {
                    str = "ۡۥ";
                    iM2535 = C1059.m2718(str);
                } else {
                    C1020.m2452();
                    str4 = "۟ۧ۠";
                    iM2535 = C1029.m2519(str4);
                }
                break;
            case 1747748:
                C1047.m2635(thread2);
                iM2535 = C1046.f4388 + (C1036.f4378 ^ 7498) >= 0 ? C1049.m2649("ۨۨۦ") : (C1060.f4404 | C1041.f4383) + 1750631;
                break;
            case 1747868:
                if (C1032.f4374 * (C1064.f4408 - 3537) <= 0) {
                    iM2535 = C1064.m2747("ۣۡ");
                } else {
                    C1043.f4385 = 4;
                    str3 = "ۨ۠ۨ";
                    iM2535 = C1045.m2622(str3);
                }
                break;
            case 1747936:
                if (intent == null) {
                    if (C1041.f4383 - (C1050.f4392 + 6568) < 0) {
                        iM2535 = C1067.f4411 + C1065.f4409 + 1753428;
                    } else {
                        C1041.m2594();
                        str2 = "ۣۦۤ";
                        iM2535 = C1023.m2469(str2);
                    }
                    break;
                } else if (C1031.f4373 >= 0) {
                }
                break;
            case 1749571:
                C1067.m2768(this, true);
                str3 = "ۤ۟ۡ";
                iM2535 = C1045.m2622(str3);
                break;
            case 1749573:
                if (C1048.m2641(C1051.m2668(m2663(), 504, C1047.f4389 ^ (-862), 566), str6)) {
                    iM2535 = (C1056.f4400 - C1023.f4365) ^ (-1751895);
                } else if (C1025.f + (C1023.f4365 / 6412) < 0) {
                }
                break;
            case 1750753:
                if (C1043.m2606(this)) {
                    if (C1053.m2682() > 0) {
                        str2 = "ۨۦۨ";
                        iM2535 = C1023.m2469(str2);
                    } else {
                        C1068.m2774();
                        iM2535 = C1068.m2771("ۣ۟ۦ");
                    }
                    break;
                } else if (C1032.f4374 * (C1064.f4408 - 3537) <= 0) {
                }
                break;
            case 1751494:
                if (C1021.f4363 > 0) {
                    str4 = "ۥۦ۟";
                    iM2535 = C1029.m2519(str4);
                } else {
                    C1041.m2594();
                    iM2535 = C1031.m2528("۠ۢۦ");
                }
                break;
            case 1751625:
                C1038.m2576(this);
                if (C1027.f4369 < 0) {
                    str2 = "ۦ۟ۢ";
                    iM2535 = C1023.m2469(str2);
                } else {
                    C1065.f4409 = 26;
                    iM2535 = C1049.m2649("ۢ۟ۢ");
                }
                break;
            case 1751649:
                if (C1054.m2683() < 0) {
                    str3 = "۟ۤ";
                    iM2535 = C1045.m2622(str3);
                } else {
                    iM2535 = C1040.m2588("ۦ۟ۢ");
                }
                break;
            case 1751653:
                if (C1048.m2641(C1055.m2694(m2663(), 434, C1024.f4366 ^ 384, 1670), str6)) {
                    str2 = "ۣۦۤ";
                    iM2535 = C1023.m2469(str2);
                } else if (C1055.m2692() <= 0) {
                    iM2535 = (C1033.f4375 * C1040.f4382) + 1678999;
                } else {
                    str5 = "ۣۧۡ";
                    thread = thread2;
                    iM2535 = C1068.m2771(str5);
                    thread2 = thread;
                }
                break;
            case 1751774:
                if (C1055.m2692() <= 0) {
                }
                break;
            case 1753417:
                return 1;
            case 1753538:
                return C1069.f4413 ^ 346;
            case 1755562:
                C1043.m2607(C1062.m2737(m2663(), 466, C1056.f4400 ^ 61, 3093), C1058.m2714(m2663(), 473, C1048.f4390 ^ (-163), 2338));
                if ((C1051.f4395 ^ (C1059.f4403 ^ (-5623))) < 0) {
                    str3 = "ۢ۟۠";
                    iM2535 = C1045.m2622(str3);
                } else {
                    C1068.m2774();
                    iM2535 = C1074.m2810("ۡۥ");
                }
                break;
            case 1755619:
                this.f1818b = thread2;
                if (C1042.f4384 <= 0) {
                    C1047.m2631();
                    iM2535 = C1065.m2753("ۨۦۨ");
                } else {
                    iM2535 = (C1056.f4400 / C1052.f4396) + 1747748;
                }
                break;
            case 1755622:
                if (C1039.f4381 < 0) {
                    iM2535 = C1040.m2588("۠ۨۨ");
                } else {
                    str = "ۢ۠ۤ";
                    iM2535 = C1059.m2718(str);
                }
                break;
        }
    }
}

case 1750753: if의 조건인 m2606 함수 안으로 들어가보면 아래와 같다.
```
public static boolean m2606(Object obj) {
    if (C1020.m2452() <= 0) {
        return ((ServiceHandler) obj).f1817a;
    }
    return false;
}
```
안드로이드에서 Service는 화면이 꺼져 있거나 앱을 닫아도 백그라운드에서 계속 실행되는 컴포넌트를 말한다. 그리고 Handler는 특정 작업이나 메시지를 순차적으로 처리하는 역할을 한다. 즉, 이 함수에 들어오는 obj는 백그라운드 작업을 관리하는 객체이다. C1020.m2452() <= 0 라는 조건문이 참이어야만 정상값을 반환하는 데, 특정 환경(분석 환경)이 감지되면 정상 작동을 멈추도록 설계한 것 같다.

case 1751625: m2576으로 들어가면, 아래와 같은 함수가 나온다.
```
public static void m2576(Object obj) {
    if (C1048.m2644() <= 0) {
        ((ServiceHandler) obj).m1476e();
    }
}
```
m1476 함수로 들어가면, 아래와 같다.

public final void m1476e() {
    String str;
    String str2;
    String str3;
    String str4;
    String str5;
    Thread threadM2557;
    String str6;
    ParcelFileDescriptor parcelFileDescriptor = null;
    Thread thread = null;
    String strM2778 = null;
    int iM2676 = C1052.m2676("ۣۡۢ");
    while (true) {
        switch (iM2676) {
            case 56482:
                threadM2557 = C1035.m2557(this);
                str5 = "ۣ۟ۥ";
                iM2676 = C1027.m2500(str5);
                thread = threadM2557;
                break;
            case 1746753:
                strM2778 = C1069.m2778(m2663(), 390, C1056.f4400 ^ 61, 1195);
                if (C1026.m2495() < 0) {
                    str = "ۧۦۨ";
                    iM2676 = C1054.m2688(str);
                } else {
                    C1075.m2811();
                    str = "ۨۢۤ";
                    iM2676 = C1054.m2688(str);
                }
                break;
            case 1746817:
                if (thread == null) {
                    iM2676 = (C1074.f4418 % C1040.f4382) ^ (-1754454);
                } else if ((C1049.f4391 | (C1071.f4415 ^ 2207)) < 0) {
                    iM2676 = (C1028.f4370 | C1054.f4398) + 1751723;
                } else {
                    str2 = "ۨۧ۠";
                    iM2676 = C1060.m2724(str2);
                }
                break;
            case 1746843:
                C1023.m2475(this);
                if (C1070.m2783() >= 0) {
                    C1040.m2591();
                    iM2676 = C1058.m2711("ۦۡۢ");
                } else {
                    iM2676 = C1053.f4397 + C1067.f4411 + 1750206;
                }
                break;
            case 1747653:
                C1067.m2768(this, false);
                iM2676 = (C1048.f4390 % C1027.f4369) + 1747021;
                break;
            case 1747772:
                iM2676 = C1066.f4410 > 0 ? C1069.m2781("۟۟") : C1072.m2797("ۣ۟ۡ");
                break;
            case 1747775:
            case 1755585:
                str3 = C1041.f4383 % (C1075.f4419 ^ 5134) <= 0 ? "ۡ۟ۦ" : "ۣۨ۠";
                iM2676 = C1075.m2812(str3);
                break;
            case 1748706:
                if (!C1043.m2606(this)) {
                    if (C1062.f4406 <= 0) {
                        C1028.m2503();
                        iM2676 = C1052.m2676("ۣۡۢ");
                    } else {
                        iM2676 = (C1073.f4417 / C1057.f4401) + 1748804;
                    }
                } else if (C1066.f4410 > 0) {
                }
                break;
            case 1748804:
            case 1749572:
                break;
            case 1749574:
                try {
                    C1033.m2539(parcelFileDescriptor);
                    str = "ۨۢۤ";
                    iM2676 = C1054.m2688(str);
                } catch (IOException e2) {
                    C1043.m2603(strM2778, C1054.m2689(m2663(), 412, C1030.f4372 ^ (-176), 1728), e2);
                    if (C1051.m2665() <= 0) {
                        C1074.f4418 = 93;
                        str6 = "ۣ۟ۥ";
                    } else {
                        str6 = "ۨۧ۠";
                    }
                    iM2676 = C1022.m2467(str6);
                }
                break;
            case 1750539:
                this.f1817a = false;
                if (C1030.m2526() >= 0) {
                    C1035.m2554();
                    iM2676 = C1031.m2528("۟ۤ۠");
                } else {
                    iM2676 = (C1067.f4411 % C1052.f4396) + 57118;
                }
                break;
            case 1750600:
                this.f1818b = null;
                str = "ۧۥۥ";
                iM2676 = C1054.m2688(str);
                break;
            case 1750811:
                this.f1819c = null;
                str2 = "۠۟ۤ";
                iM2676 = C1060.m2724(str2);
                break;
            case 1751530:
                C1025.m2489(thread);
                if (C1048.f4390 < 0) {
                    str3 = "ۣۡۦ";
                    iM2676 = C1075.m2812(str3);
                } else {
                    iM2676 = C1048.m2642("ۦۥۤ");
                }
                break;
            case 1751740:
                break;
            case 1753479:
                if (C1020.f4362 / (C1023.f4365 | (-9728)) != 0) {
                    C1063.f4407 = 61;
                    iM2676 = C1049.m2649("ۣۡ۠");
                } else {
                    iM2676 = C1049.m2649("ۨۢۤ");
                }
                break;
            case 1753605:
                iM2676 = parcelFileDescriptor == null ? (C1025.f ^ C1058.f4402) + 1747711 : C1023.f4365 - (C1044.f4386 ^ 5756) >= 0 ? C1074.m2810("ۥۧ") : C1030.f4372 + C1050.f4392 + 1750499;
                break;
            case 1754537:
                if (C1040.f4382 <= 0) {
                    C1061.m2726();
                    str5 = "ۥۧۥ";
                    threadM2557 = thread;
                } else {
                    str5 = "ۣۡۢ";
                    threadM2557 = thread;
                }
                iM2676 = C1027.m2500(str5);
                thread = threadM2557;
                break;
            case 1754539:
                iM2676 = (C1074.f4418 % C1040.f4382) ^ (-1754454);
                break;
            case 1754567:
                ParcelFileDescriptor parcelFileDescriptorM2734 = C1062.m2734(this);
                if (C1026.f4368 / (C1053.f4397 - 9053) != 0) {
                    iM2676 = C1053.m2677("ۣۨ۠");
                    parcelFileDescriptor = parcelFileDescriptorM2734;
                } else {
                    iM2676 = (C1047.f4389 * C1075.f4419) ^ 1574155;
                    parcelFileDescriptor = parcelFileDescriptorM2734;
                }
                break;
            case 1754601:
                C1043.m2607(strM2778, C1026.m2491(m2663(), 397, C1046.f4388 ^ 428, 2197));
                if (C1073.f4417 % (C1073.f4417 * (-5181)) >= 0) {
                    C1052.f4396 = 52;
                    str4 = "ۤ۠ۦ";
                } else {
                    str4 = "ۣ۟ۧ";
                }
                iM2676 = C1047.m2629(str4);
                break;
            case 1754661:
                iM2676 = (C1070.f4414 - C1026.f4368) ^ 1749746;
                break;
            case 1755434:
                if (C1042.f4384 / (C1020.f4362 | (-2882)) < 0) {
                    str4 = "ۣ۠ۢ";
                    iM2676 = C1047.m2629(str4);
                } else {
                    C1020.f4362 = 12;
                    iM2676 = C1029.m2519("ۧۤۨ");
                }
                break;
        }
        return;
    }
}

switch-case로 난독화가 되어있어서 보기가 어렵다. 중요한 부분만 보자면, ParcelFileDescriptor parcelFileDescriptorM2734 = C1062.m2734(this); 이 부분에서는 이 앱이 기기 내부의 특정 파일, 데이터베이스, 혹은 외부 서버와 연결된 통신 통로를 연다는 것을 알 수 있고, threadM2557 = C1035.m2557(this); 이 코드를 통해 스드를 생성하고 뒤에서 실행한다는 것을 알 수 있다. 마지막에 열었던 파일을 닫으려면 this.f1817a = false;을 통해 흔적을 지우며 서비스를 종료한다는 것을 알 수 있다. 간단하게 보면, 이 함수는 조용히특정 파일을 열어서 백그라운드 스레드를 띄워 가동한 뒤, 목적을 달성하면 흔적을 지우고 꺼지는 일련의 백그라운드 동작 프로세스를 실행한다.

case 1751653: m2641함수로 들어와보면 아래와 같다.

public static boolean m2641(Object obj, Object obj2) {
    if (C1035.m2554() <= 0) {
        return ((String) obj).equals(obj2);
    }
    return false;
}

인자로 들어온 두 값이 같으면 true, 다르면 false를 반환한다. 그러면 인자는 어떤 코드일까. 인자 안의 m2694 함수로 들어가보면 아래와 같다.

public static String m2694(short[] sArr, int i2, int i3, int i4) {
    char[] cArr = new char[i3];
    for (int i5 = 0; i5 < i3; i5++) {
        cArr[i5] = (char) (sArr[i2 + i5] ^ i4);
    }
    return new String(cArr);
}

암호화되어 있던 short형 정수 배열을 우리가 읽을 수 있는 String으로 변환해 주는 아주 전형적인 XOR 복호화 함수가 나온다. i3 크기만큼의 새로운 char 배열을 만들고 암호화된 배열의 특정 시작 위치(i2)부터 값을 하나씩 가져와서 복호화 키 값(i4)과 XOR 연산을 한다. 계산된 숫자를 다시 char로 변환 후, cArr 이라는 새로운 문자열을 반환한다.

위의 함수들과 연관지어서 해석하면,

m2663() 메서드로 암호화된 전체 데이터 배열을 가져옴
434번째 위치부터 시작
C1024.f4366 ^ 384 글자 수만큼 1670이라는 키를 이용해 XOR 복호화를 수행
복호화되어 나온 진짜 텍스트가 다른 값(str6)과 일치하는지(equals) 비교

위와 같다. 만약 일치한다면 다른 곳으로 분기하도록 한다. else if일 때는 C1055.m2692() <= 0를 만족하면 실행되는데, 들어가면 764^881의 값을 반환하는 것을 알 수 있다. 그래서 일치하지 않는다면, else까지는 가지않고 else if에서 다른 분기 위치가 정해지는 것을 알 수 있다.

case 1755562:m2607 함수로 들어가보면 아래와 같다.
```
public static int m2607(Object obj, Object obj2) {
    if (C1051.m2665() >= 0) {
        return Log.i((String) obj, (String) obj2);
    }
    return 0;
}
```
obj를 태그로 하고, obj2가 그 내용으로 로그를 만든다. 공격자가 원하는 행동을 시작할 때 로그를 남기는 것 같다. 그러고 다른 곳으로 분기하도록 한다.

case 1755619: 현재 떠 있는 스레드(thread2) 정보를 클래스 내부 변수(this.f1818b)에 백업 후 C1042.f4384 <= 0이면, m2631 실행. f4384는 882로 실행되지 않음. 무조건 else의 코드가 실행됨. else에서는 (58)/(-759)+1747748으로 case 1747748로 분기된다. 1747748은 아래 코드이다.

case 1747748:
    C1047.m2635(thread2);
    _go = C1046.f4388 + (C1036.f4378 ^ 7498) >= 0 ? C1049.m2649("ۨۨۦ") : (C1060.f4404 | C1041.f4383) + 1750631;
    break;

m2635 함수의 내용이 m2480 변수가 0보다 크면 ((Thread) obj).start(); 로 인자로 받은 스레드(thread2)를 실제로 구동하는 것인데, m2480이 ( -835)^(-739)으로 0보다 큰 값이 나와 백그라운드 작업(thread2)을 시작시키고, 삼항 연산자로 다음 case에 분기하도록 한다.

와이파이 공유기 분해

werty2 — Mon, 18 May 2026 21:20:25 +0900

윗판을 제거한 모습

PCB를 꺼낸 모습

PCB 근접샷

기판 부품 구성

1. 외부 연결 포트 (상단)
- 오렌지색 포트 (LAN): 컴퓨터, TV, 게임기 등을 유선으로 연결하는 곳.
- 노란색 포트 (WAN/Internet): 통신사 모뎀에서 오는 메인 인터넷 선을 꽂는 곳.
- 전원 잭 (좌측 상단 검은색): AC 어댑터를 연결하여 보드에 전기를 공급.
2. 전원 공급 및 필터부 (좌측 상단)
- 원통형 부품 (전해 커패시터): 전기를 일시적으로 저장했다가 안정적으로 내보냄. 회로를 보호함.
- 작은 사각형 부품들 (인덕터 및 레귤레이터): 외부에서 들어온 높은 전압을 칩셋들이 사용할 수 있는 낮은 전압으로 변환.
3. 핵심 연산 장치 (중앙 및 우측)
- 검은색 방열판 (Heatsink): 아래에는 공유기의 두뇌인 CPU가 있음. 인터넷 트래픽을 처리하면서 열이 많이 나기 때문에 금속판을 붙여 열을 식힘.
- 우측 사각형 칩 (무선 칩셋): Wi-Fi 신호를 생성하고 관리하는 역할.
4. 무선 신호 및 안테나 (중앙 하단)
- 회색 및 검은색 선 (안테나 케이블): 기판의 무선 칩셋에서 만들어진 신호를 외부 안테나로 전달.
- 납땜 패드 (ANT): 케이블이 보드에 고정된 부분으로, 무선 신호가 증폭되어 밖으로 나감.
5. 상태 표시등 (하단)
- 투명한 전구 모양 (LED): 현재 공유기의 상태(전원, Wi-Fi 작동, LAN 연결 등)를 사용자에게 빛으로 알려줌. 보드 하단에 'CPU', 'WIFI', 'LAN1~4'라고 이름이 써져 있음.

구조가 생각보다 단순했다. 필요한 기능들을 하는 부품들만 넣어 최대한 단순화를 한 것 같다고 느꼈다.

6주차_Jadx(1)

werty2 — Mon, 18 May 2026 20:47:03 +0900

이번 주에 한 일

Jadx로 Anubis 정적분석(ServiceHandler.onStartCommand 함수 일부)

Anubis 샘플 apk파일을 Jadx에 넣어주었다. 폴더 이름이 a, b, c, d 등으로 난독화가 되어있다.

난독화 해제를 위해 설정 -> 난독화 해제 -> 난독 해제 활성화를 체크해준다.

그 후, 폴더 이름이 아래와 같이 모든 폴더를 완벽히 알아볼 수는 없지만, 중요 폴더들은 식별이 가능하게 된다.

1. AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    android:versionCode="1"
    versionName="3.1.5"
    compileSdkVersion="35"
    compileSdkVersionCodename="15"
    package="com.eksctm.android"
    platformBuildVersionCode="35"
    platformBuildVersionName="15"
    android:tag="⟨STRING_DECODE_ERROR⟩">
    <uses-sdk
        minSdkVersion="26"
        targetSdkVersion="35"
        android:tag="⟨STRING_DECODE_ERROR⟩"/>
    <uses-permission
        name="android.permission.INTERNET"
        android:tag="⟨STRING_DECODE_ERROR⟩"/>
    <uses-permission
        name="android.permission.REQUEST_INSTALL_PACKAGES"
        android:tag="⟨STRING_DECODE_ERROR⟩"/>
    <uses-permission
        name="android.permission.ACCESS_NETWORK_STATE"
        android:tag="⟨STRING_DECODE_ERROR⟩"/>
    <permission
        android:name="com.eksctm.android.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION"
        android:protectionLevel="signature"
        android:tag="⟨STRING_DECODE_ERROR⟩"/>
    <uses-permission
        name="com.eksctm.android.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION"
        android:tag="⟨STRING_DECODE_ERROR⟩"/>
    <application
        theme="@kbfcb17/kbfcb_res_0x7f110222"
        android:label="@kbfcb16/kbfcb_res_0x7f10001c"
        android:icon="@kbfcb13/kbfcb_res_0x7f0d0000"
        allowBackup="true"
        supportsRtl="true"
        android:fullBackupContent="@kbfcb19/kbfcb_res_0x7f130000"
        android:roundIcon="@kbfcb13/kbfcb_res_0x7f0d0002"
        appComponentFactory="androidx.core.app.CoreComponentFactory"
        android:dataExtractionRules="@kbfcb19/kbfcb_res_0x7f130001"
        android:tag="⟨STRING_DECODE_ERROR⟩">
        <activity
            name="com.eksctm.android.MainActivity"
            exported="true"
            android:tag="⟨STRING_DECODE_ERROR⟩">
            <intent-filter android:tag="⟨STRING_DECODE_ERROR⟩">
                <action
                    android:name="android.intent.action.MAIN"
                    android:tag="⟨STRING_DECODE_ERROR⟩"/>
                <category
                    android:name="android.intent.category.LAUNCHER"
                    android:tag="⟨STRING_DECODE_ERROR⟩"/>
            </intent-filter>
        </activity>
        <service
            name="com.eksctm.android.ServiceHandler"
            permission="android.permission.BIND_VPN_SERVICE"
            exported="true"
            android:tag="⟨STRING_DECODE_ERROR⟩">
            <intent-filter android:tag="⟨STRING_DECODE_ERROR⟩">
                <action
                    android:name="android.net.VpnService"
                    android:tag="⟨STRING_DECODE_ERROR⟩"/>
            </intent-filter>
        </service>
        <receiver
            android:name="com.eksctm.android.Receiver"
            exported="true"
            android:tag="⟨STRING_DECODE_ERROR⟩"/>
        <provider
            name="androidx.startup.InitializationProvider"
            exported="false"
            authorities="com.eksctm.android.androidx-startup"
            android:tag="⟨STRING_DECODE_ERROR⟩">
            <meta-data
                android:name="androidx.emoji2.text.EmojiCompatInitializer"
                android:value="androidx.startup"
                android:tag="⟨STRING_DECODE_ERROR⟩"/>
            <meta-data
                android:name="androidx.lifecycle.ProcessLifecycleInitializer"
                android:value="androidx.startup"
                android:tag="⟨STRING_DECODE_ERROR⟩"/>
            <meta-data
                android:name="androidx.profileinstaller.ProfileInstallerInitializer"
                android:value="androidx.startup"
                android:tag="⟨STRING_DECODE_ERROR⟩"/>
        </provider>
        <receiver
            android:name="androidx.profileinstaller.ProfileInstallReceiver"
            permission="android.permission.DUMP"
            enabled="true"
            exported="true"
            directBootAware="false"
            android:tag="⟨STRING_DECODE_ERROR⟩">
            <intent-filter android:tag="⟨STRING_DECODE_ERROR⟩">
                <action
                    android:name="androidx.profileinstaller.action.INSTALL_PROFILE"
                    android:tag="⟨STRING_DECODE_ERROR⟩"/>
            </intent-filter>
            <intent-filter android:tag="⟨STRING_DECODE_ERROR⟩">
                <action
                    android:name="androidx.profileinstaller.action.SKIP_FILE"
                    android:tag="⟨STRING_DECODE_ERROR⟩"/>
            </intent-filter>
            <intent-filter android:tag="⟨STRING_DECODE_ERROR⟩">
                <action
                    android:name="androidx.profileinstaller.action.SAVE_PROFILE"
                    android:tag="⟨STRING_DECODE_ERROR⟩"/>
            </intent-filter>
            <intent-filter android:tag="⟨STRING_DECODE_ERROR⟩">
                <action
                    android:name="androidx.profileinstaller.action.BENCHMARK_OPERATION"
                    android:tag="⟨STRING_DECODE_ERROR⟩"/>
            </intent-filter>
        </receiver>
    </application>
</manifest>

name="com.eksctm.android.ServiceHandler"

permission="android.permission.BIND_VPN_SERVICE"

기기의 모든 네트워크 트래픽을 가로채기 위해 VpnService 권한을 요구한다고 의심이 된다. 사용자가 입력하는 데이터를 탈취하는 목적일 수 있다.

<uses-permission name="android.permission.INTERNET"/>

<uses-permission name="android.permission.REQUEST_INSTALL_PACKAGES"/>

INTERNET 권한(앱이 네트워크를 쓸 수 있게 허용)으로 추가 악성 페이로드를 다운로드한 뒤, REQUEST_INSTALL_PACKAGES를 이용해 가짜 업데이트나 다른 악성 앱을 사용자 몰래설치할 수 있다.

exported="false"

다른 조종용 시스템이 이 앱의 기능을 원격으로 사용할 수 있도록 true로 설정했다.

2. com.eksctm.android.ServiceHandler

onStartCommand 함수 부분을 먼저 보면

public final int onStartCommand(android.content.Intent r9, int r10, int r11) {
        /*
            Method dump skipped, instruction units count: 632
            To view this dump change 'Code comments level' option to 'DEBUG'
        */
        throw new UnsupportedOperationException("Method not decompiled: com.eksctm.android.ServiceHandler.onStartCommand(android.content.Intent, int, int):int");
    }
}

JADX가 코드를 제대로 해석하지 못하고 "Method dump skipped"라는 메시지를 띄웠다. 코드가 너무 길거나(632 units), 분석을 방해하기 위해 바이트코드를 비정상적으로 꼬아놓아서 그런 것 같다. 632 유닛이라는 건, 이 서비스가 켜지자마자 하는 일이 매우 방대하고 복잡하다는 뜻이다. 일반적인 서비스와는 확실히 다른 점이 있다.

파일 > 설정 > 디컴파일에서 디컴파일 안된 코드 표시에 체크를 해주고, 코드 주석 수준을 DEBUG로 바꿔준다.

그 후, 다시 com.eksctm.android.ServiceHandler를 보면

public final int onStartCommand(Intent intent, int i2, int i3) {
    String str;
    String str2;
    String str3;
    String str4;
    Thread thread;
    String str5;
    int iM2535 = C1032.m2535("۠ۨۨ");
    Thread thread2 = null;
    String str6 = null;
    while (true) {
        switch (iM2535) {
            case 56293:
            case 1746818:
            case 1752670:
                iM2535 = C1025.f4367 + (C1023.f4365 / 6412) < 0 ? C1058.m2711("ۨ۟۟") : (C1050.f4392 - C1022.f4364) + 1753444;
                break;
            case 56356:
                String strM2476 = C1023.m2476(intent);
                if (C1058.f4402 * (C1075.f4419 | (-2499)) >= 0) {
                    iM2535 = C1032.m2535("ۢ۟۠");
                    str6 = strM2476;
                } else {
                    iM2535 = (C1073.f4417 / C1055.f4399) + 1751653;
                    str6 = strM2476;
                }
                break;
            case 56414:
                thread = new Thread(new RunnableC0019q(C1067.f4411 ^ (-625), this), C1051.m2668(m2663(), 492, C1020.f4362 ^ (-960), 1703));
                if ((C1050.f4392 ^ (C1040.f4382 / (-3268))) < 0) {
                    str5 = "ۣۨۨ";
                    iM2535 = C1068.m2771(str5);
                    thread2 = thread;
                } else {
                    iM2535 = C1067.m2764("ۣ۟ۧ");
                    thread2 = thread;
                }
                break;
            case 1746819:
                if (C1031.f4373 >= 0) {
                    str = "ۡۥ";
                    iM2535 = C1059.m2718(str);
                } else {
                    C1020.m2452();
                    str4 = "۟ۧ۠";
                    iM2535 = C1029.m2519(str4);
                }
                break;
            case 1747748:
                C1047.m2635(thread2);
                iM2535 = C1046.f4388 + (C1036.f4378 ^ 7498) >= 0 ? C1049.m2649("ۨۨۦ") : (C1060.f4404 | C1041.f4383) + 1750631;
                break;
            case 1747868:
                if (C1032.f4374 * (C1064.f4408 - 3537) <= 0) {
                    iM2535 = C1064.m2747("ۣۡ");
                } else {
                    C1043.f4385 = 4;
                    str3 = "ۨ۠ۨ";
                    iM2535 = C1045.m2622(str3);
                }
                break;
            case 1747936:
                if (intent == null) {
                    if (C1041.f4383 - (C1050.f4392 + 6568) < 0) {
                        iM2535 = C1067.f4411 + C1065.f4409 + 1753428;
                    } else {
                        C1041.m2594();
                        str2 = "ۣۦۤ";
                        iM2535 = C1023.m2469(str2);
                    }
                    break;
                } else if (C1031.f4373 >= 0) {
                }
                break;
            case 1749571:
                C1067.m2768(this, true);
                str3 = "ۤ۟ۡ";
                iM2535 = C1045.m2622(str3);
                break;
            case 1749573:
                if (C1048.m2641(C1051.m2668(m2663(), 504, C1047.f4389 ^ (-862), 566), str6)) {
                    iM2535 = (C1056.f4400 - C1023.f4365) ^ (-1751895);
                } else if (C1025.f4367 + (C1023.f4365 / 6412) < 0) {
                }
                break;
            case 1750753:
                if (C1043.m2606(this)) {
                    if (C1053.m2682() > 0) {
                        str2 = "ۨۦۨ";
                        iM2535 = C1023.m2469(str2);
                    } else {
                        C1068.m2774();
                        iM2535 = C1068.m2771("ۣ۟ۦ");
                    }
                    break;
                } else if (C1032.f4374 * (C1064.f4408 - 3537) <= 0) {
                }
                break;
            case 1751494:
                if (C1021.f4363 > 0) {
                    str4 = "ۥۦ۟";
                    iM2535 = C1029.m2519(str4);
                } else {
                    C1041.m2594();
                    iM2535 = C1031.m2528("۠ۢۦ");
                }
                break;
            case 1751625:
                C1038.m2576(this);
                if (C1027.f4369 < 0) {
                    str2 = "ۦ۟ۢ";
                    iM2535 = C1023.m2469(str2);
                } else {
                    C1065.f4409 = 26;
                    iM2535 = C1049.m2649("ۢ۟ۢ");
                }
                break;
            case 1751649:
                if (C1054.m2683() < 0) {
                    str3 = "۟ۤ";
                    iM2535 = C1045.m2622(str3);
                } else {
                    iM2535 = C1040.m2588("ۦ۟ۢ");
                }
                break;
            case 1751653:
                if (C1048.m2641(C1055.m2694(m2663(), 434, C1024.f4366 ^ 384, 1670), str6)) {
                    str2 = "ۣۦۤ";
                    iM2535 = C1023.m2469(str2);
                } else if (C1055.m2692() <= 0) {
                    iM2535 = (C1033.f4375 * C1040.f4382) + 1678999;
                } else {
                    str5 = "ۣۧۡ";
                    thread = thread2;
                    iM2535 = C1068.m2771(str5);
                    thread2 = thread;
                }
                break;
            case 1751774:
                if (C1055.m2692() <= 0) {
                }
                break;
            case 1753417:
                return 1;
            case 1753538:
                return C1069.f4413 ^ 346;
            case 1755562:
                C1043.m2607(C1062.m2737(m2663(), 466, C1056.f4400 ^ 61, 3093), C1058.m2714(m2663(), 473, C1048.f4390 ^ (-163), 2338));
                if ((C1051.f4395 ^ (C1059.f4403 ^ (-5623))) < 0) {
                    str3 = "ۢ۟۠";
                    iM2535 = C1045.m2622(str3);
                } else {
                    C1068.m2774();
                    iM2535 = C1074.m2810("ۡۥ");
                }
                break;
            case 1755619:
                this.f1818b = thread2;
                if (C1042.f4384 <= 0) {
                    C1047.m2631();
                    iM2535 = C1065.m2753("ۨۦۨ");
                } else {
                    iM2535 = (C1056.f4400 / C1052.f4396) + 1747748;
                }
                break;
            case 1755622:
                if (C1039.f4381 < 0) {
                    iM2535 = C1040.m2588("۠ۨۨ");
                } else {
                    str = "ۢ۠ۤ";
                    iM2535 = C1059.m2718(str);
                }
                break;
        }
    }
}

제어 흐름 난독화가 되어 있어 분석하기가 어렵다. ㅠ.ㅠ

함수 안의 모든 코드가 switch-case 제어문 안에 있다. case에 맞는 코드로 바로 이동해 실행하는 조건이 여러 개인 제어문이다. break로 끊어주어야지 다음 코드까지 실행하지 않는다.

case 56293, 1746818, 1752670:iM2535 = C1025.f4367 + (C1023.f4365 / 6412) < 0 ? C1058.m2711("ۨ۟۟") : (C1050.f4392 - C1022.f4364) + 1753444; 의 삼항연산자가 있다. 분석가가 이해하는데에 오래 걸리도록 꼬아놓은 것 같다. 웬만하면 조건이 거짓이 되도록 해 (C1050.f4392 - C1022.f4364) + 1753444라는 값을 iM2535라는 변수에 넣는 코드를 어렵게 만들어놓은 것 같다.
case 56356: String strM2476 = C1023.m2476(intent); 이 서비스가 시작될 때 받은 intent에서 중요한 문자열(명령어, 서버 주소 등)을 뽑아내서 strM2476에 저장한다. 그 뒤로 if-else 문이 있는데, 조건이 맞든 안맞든 iM2535에 새로운 값을 넣어 다시 분기하도록 한다. 두 iM2535의 값이 다른지 다르지 않은지는 여기서는 알 수 없다.
case 56414: 이 부분이 가장 위험한 부분이다. thread = new Thread(new RunnableC0019q(C1067.f4411 ^ (-625), this), C1051.m2668(m2663(), 492, C1020.f4362 ^ (-960), 1703)); 여기서 새로운 작업 스래드를 만든다. RunnableC0019q가 실제 악성 짓을 수행하는 스래드일 확률이 높다. 스래드를 실행할 때 넘겨주는 인자값을 비트연산(^) 등으로 알아보기 어렵게 해놨다. 인자는 어떤 값인지 여기서는 알 수가 없지만 이 코드의 전반적인 의도는 메인 서비스 흐름과는 별개로 백그라운드에서 계속 동작하는 악성 루프를 돌리겠다는 의미로 보인다. 그 후 iM2535에 특정 값을 넣어 분기하도록 하고, thread2 = thread를 통해 만든 스래드에 thread2라는 다른 이름을 붙인다. thread라는 이름을 나중에 또 사용하기 위해서이거나, 분석을 어렵게 만들기 위해서인 것 같다.
case 1746819: C1031.f4373이라는 변수값이 0보다 큰지 확인한다. case 1747748(스레드 시작) 바로 전 부분에서 이 체크가 일어나므로 실행환경이 안전한지 확인하는 코드로 보인다. 예를 들어 실행환경이 실제 환경인지, 에뮬레이터인지와 같은 것을 확인하는 것으로 보인다. 그 후 if-else를 통해 iM2535가 서로 다른 곳으로 분기할 수 있도록 한다.
case 1747748: C1047.m2635(thread2); 를 통해 위에서 만든 thread2 이름표의 스레드에게 실행을 시작하라고 신호를 보내는 곳으로 보인다. m2635는 아마도 Thread.start()를 호출하는 함수일 가능성이 높다. 그 후, 삼항연산자로 iM2535에 새 값을 넣어줘 다른 곳으로 분기하도록 한다.
case 1747868: if (intent == null)에서 intent는 컴포넌트 간에 데이터를 주고받는 핵심 객체인데 이게 null이라는 것은 정상적인 실행이 아니라는 뜻이다. intent에 아무것도 없다면 다음 케이스로 분기하도록 한다. 중간중간에 보이는 ۦ 이렇게 생긴 이상한 문자는 다른 함수에 넣으면 의도한대로 값이 나오도록 설계한 것 같다. 분석하기 어렵게 이상한 문자를 넣은 것 같다. intent가 null이 아니라면 실행하는 값은 중괄호 안에 아무것도 넣어놓지 않아서 겉보기에는 그냥 스위치문을 탈출하는 것처럼 보인다. 코드 제작자가 다른 곳에 참일시 실행하는 코드를 숨겨놓은 것 같다.
case 1749571: this 인자를 넘겨줌으로써 현재 이 코드의 화면이나 권한 등의 것을 m2768 함수로 넘겨준다. 그리고 true를 통해 어떤 기능을 활성화한다는 것 같다. m2768 함수를 보면 아래와 같다.

    /* JADX INFO: renamed from: ۥۣۣۢ, reason: contains not printable characters */
    public static void m2768(Object obj, boolean z2) {
        if (C1023.m2471() >= 0) {
            ((ServiceHandler) obj).m1474c(z2);
        }
    }

Object obj로 들어온 객체를 진짜 타입인 (ServiceHandler)로 강제 형변환을 하고 있다. m1474 함수를 보면

    public final void m1474c(boolean z2) {
        String strM2703;
        boolean z3;
        ArrayList arrayList;
        String strM2668;
        int i2 = 1616;
        while (true) {
            i2 ^= 1633;
            switch (i2) {
                case 14:
                    break;
                case 49:
                    i2 = !z2 ? 1678 : 1709;
                    break;
                case 204:
                    strM2703 = C1052.m2673(m2663(), 25, 13, 1513);
                    int i3 = 1740;
                    while (true) {
                        i3 ^= 1757;
                        switch (i3) {
                            case 17:
                                i3 = 1771;
                                continue;
                            case 54:
                                break;
                        }
                    }
                    break;
                case 239:
                    strM2703 = C1056.m2703(m2663(), 38, 16, 452);
                    break;
            }
        }

case 49 -> case 204 순으로 실행이 된다. case 204는 난독화해 둔 중요한 문자열(C2 서버 주소, 탈취할 데이터 항목 등)을 드디어 복호화해서 strM2703이라는 변수에 담고 있는 것 같다. 더 자세히 알아보기 위해 m2673 함수를 보면

    public static String m2673(short[] sArr, int i2, int i3, int i4) {
        char[] cArr = new char[i3];
        for (int i5 = 0; i5 < i3; i5++) {
            cArr[i5] = (char) (sArr[i2 + i5] ^ i4);
        }
        return new String(cArr);
    }

XOR 연산을 이용해 암호화된 데이터를 글자로 복원하는 함수이다. 이 함수는 난독화가 되어있지 않다. 위의 case 204 코드와 연결지어 보면, m2663()이 가진 배열의 25번째 인덱스부터 시작해서 13개의 숫자를 각각 1513과 XOR 연산하면 숨겨진 진짜 문자열이 나오는 구조이다. m2663()으로 들어가면

    public static short[] m2663() {
        short[] sArr;
        String str;
        short[] sArr2 = null;
        short[] sArr3 = null;
        int iM2747 = C1064.m2747("۟ۡ");
        while (true) {
            switch (iM2747) {
                case 56289:
                    str = "ۥۥۢ";
                    sArr3 = null;
                    iM2747 = C1055.m2695(str);
                    break;
                case 56290:
                    if (C1056.m2696() < 0) {
                        iM2747 = C1066.m2758("ۨۡۤ");
                    } else if (C1068.f4412 <= 0) {
                        C1048.f4390 = 57;
                        iM2747 = C1061.m2729("۟۠");
                    } else {
                        iM2747 = (C1058.f4402 % C1025.f) + 1749697;
                    }
                    break;
                case 56538:
                case 1746942:
                    if (C1061.f4405 >= 0) {
                        C1044.m2616();
                        iM2747 = C1060.m2724("ۣۢۢ");
                    } else {
                        iM2747 = C1022.m2467("ۧۥ۟");
                    }
                    break;
                case 56567:
                    iM2747 = C1066.m2758("ۨۡۤ");
                    break;
                case 1746812:
                    if (C1048.f4390 < 0) {
                        iM2747 = C1058.m2711("۟ۡ");
                    } else {
                        C1072.m2798();
                        str = "ۣۣۡ";
                        iM2747 = C1055.m2695(str);
                    }
                    break;
                case 1749703:
                    sArr = f4394short;
                    if (C1048.f4390 < 0) {
                        iM2747 = 1748521 + C1066.f4410 + C1045.f4387;
                        sArr2 = sArr;
                    } else {
                        C1045.f4387 = 18;
                        iM2747 = C1067.m2764("ۧۥ۟");
                        sArr2 = sArr;
                    }
                    break;
                case 1749794:
                    if (C1038.f4380 + C1033.f4375 + 4148 > 0) {
                        sArr = sArr2;
                        sArr3 = sArr2;
                        iM2747 = C1067.m2764("ۧۥ۟");
                        sArr2 = sArr;
                    } else {
                        sArr3 = sArr2;
                        iM2747 = C1064.m2747("ۢۦۦ");
                    }
                    break;
                case 1752642:
                    iM2747 = C1063.f4407 / (C1039.f4381 + (-9919)) != 0 ? C1060.m2724("ۣ۟۠") : C1042.m2600("ۧۡ");
                    break;
                case 1754561:
                    break;
                case 1755403:
                    iM2747 = C1059.f4403 / (C1068.f4412 + (-4286)) != 0 ? C1068.m2771("۟ۧۦ") : (C1044.f4386 - C1044.f4386) + 56289;
                    break;
            }
            return sArr3;
        }
    }

위와 같은데, case 1749703과 1749794를 보면 sArr3에 담겨 리턴되는 원본 배열은 이 클래스(혹은 상위 클래스)의 멤버 변수로 선언되어 있는 f4394short라는 변수를 sArr3 으로 반환한다는 것을 알 수 있다. f4394short 변수로들어가면

    private static final short[] f4394short = {933, 899, 925, 944, 924, 897, 918, 2982, 2967, 2965, 2973, 2963, 2946, 3030, 2950, 2967, 2948, 2949, 2963, 3030, 2963, 2948, 2948, 2969, 2948, 1471, 1465, 1447, 1462, 1450, 1446, 1447, 1447, 1452, 1450, 1469, 1452, 1453, 402, 404, 394, 411, 384, 397, 407, 391, 395, 394, 394, 385, 391, 400, 385, 384, 2357, 2327, 2304, 2333, 2331, 2330, 2388, 2328, 2333, 2311, 2304, 2382, 2388, 905, 958, 936, 948, 951, 941, 946, 949, 956, 1019, 943, 930, 939, 958, 1019, 3188, 3159, 3163, 3161, 3156, 3194, 3146, 3159, 3161, 3164, 3163, 3161, 3147, 3148, 3189, 3161, 3158, 3161, 3167, 3165, 3146, 1355, 1304, 1288, 1283, 1294, 1286, 1294, 1355, 2803, 2748, 2741, 2803, 2746, 2749, 2727, 2742, 2749, 2727, 2803, 2590, 2621, 2609, 2611, 2622, 2576, 2592, 2621, 2611, 2614, 2609, 2611, 2593, 2598, 2591, 2611, 2620, 2611, 2613, 2615, 2592, 3321, 3290, 3286, 3284, 3289, 3319, 3271, 3290, 3284, 3281, 3286, 3284, 3270, 3265, 3320, 3284, 3291, 3284, 3282, 3280, 3271, 731, 759, 738, 757, 766, 767, 760, 753, 694, 759, 753, 759, 767, 760, 741, 738, 694, 752, 767, 762, 738, 755, 740, 694, 262, 293, 297, 299, 294, 264, 312, 293, 299, 302, 297, 299, 313, 318, 263, 299, 292, 299, 301, 303, 312, 1192, 1192, 1230, 1249, 1252, 1276, 1261, 1274, 1199, 1275, 1192, 1276, 1257, 1274, 1263, 1261, 1276, 1192, 1257, 1252, 1274, 1261, 1257, 1260, 1265, 1192, 1257, 1260, 1260, 1261, 1260, 1733, 1766, 1770, 1768, 1765, 1739, 1787, 1766, 1768, 1773, 1770, 1768, 1786, 1789, 1732, 1768, 1767, 1768, 1774, 1772, 1787, 2381, 2414, 2402, 2400, 2413, 2371, 2419, 2414, 2400, 2405, 2402, 2400, 2418, 2421, 2380, 2400, 2415, 2400, 2406, 2404, 2419, 3083, 3083, 3181, 3138, 3143, 3167, 3150, 3161, 3083, 3142, 3146, 3167, 3144, 3139, 3150, 3151, 3082, 3083, 3083, 3142, 3146, 3167, 3144, 3139, 3094, 3099, 3155, 2323, 2312, 2317, 2312, 2313, 2321, 2312, 2374, 2324, 2307, 2311, 2325, 2313, 2312, 2576, 2589, 2580, 2561, 1866, 1871, 1882, 1871, 1730, 1728, 1751, 1738, 1740, 1741, 1305, 1307, 1294, 1311, 1309, 1301, 1288, 1283, 1845, 1814, 1818, 1816, 1813, 1851, 1803, 1814, 1816, 1821, 1818, 1816, 1802, 1805, 1844, 1816, 1815, 1816, 1822, 1820, 1803, 2362, 2362, 2396, 2419, 2422, 2414, 2431, 2408, 2362, 2430, 2419, 2430, 2362, 2420, 2421, 2414, 2362, 2423, 2427, 2414, 2425, 2418, 2336, 2362, 1277, 1243, 1221, 1256, 1220, 1241, 1230, 2246, 2273, 2298, 2277, 2277, 2300, 2299, 2290, 2229, 2243, 2245, 2267, 2235, 2235, 2235, 1668, 1701, 1715, 1699, 1714, 1705, 1712, 1716, 1711, 1714, 1760, 1699, 1708, 1711, 1715, 1701, 1760, 1701, 1714, 1714, 1711, 1714, 1765, 1769, 1771, 1704, 1744, 1782, 1768, 1749, 1763, 1780, 1776, 1775, 1765, 1763, 1704, 1767, 1768, 1762, 1780, 1769, 1775, 1762, 1704, 1749, 1746, 1735, 1748, 1746, 1753, 1744, 1750, 1736, 3139, 3173, 3195, 3158, 3194, 3175, 3184, 2420, 2418, 2412, 2306, 2371, 2382, 2384, 2375, 2371, 2374, 2395, 2306, 2371, 2369, 2390, 2379, 2388, 2375, 2316, 1779, 1746, 1737, 1737, 1730, 1739, 1776, 1736, 1749, 1740, 1730, 1749, 597, 601, 603, 536, 608, 582, 600, 613, 595, 580, 576, 607, 597, 595, 536, 599, 600, 594, 580, 601, 607, 594, 536, 613, 610, 633, 614, 617, 608, 614, 632};

위와 같이 숫자들의 배열이 있다. 이 배열이 바로 m2663()이 반환하는 배열이다. 이 배열을 통해 위의 코드와 같이 25번째 인덱스부터 시작해서 13개의 숫자를 각각 1513과 XOR 연산을 하면, VPN_CONNECTED 라는 글자가 나온다. 안드로이드 시스템은 기기에 VPN이 연결되거나 해제될 때 전체 앱에 브로드캐스트 인텐트를 보낸다. 이 코드는 이를 수신한 뒤, 방금 들어온 시스템 신호가 VPN이 연결되었다는 신호인지 문자열을 비교하며 체크하는 부분이라는 것을 알게되었다. 악성코드가 외부 서버와 통신하는 패킷을 가로채기 위해 분석 환경에 VPN 형태의 네트워크 프록시 도구를 켜두는 경우가 많기 때문에 기기에 VPN이 켜진 것을 감지하면 악성 행위를 일시 중단하여 정체를 숨기기 위함인 것 같다. 따라서 분석 환경일 때를 감지하기 위한 부분이라고 보면 될 것 같다.

이런 식으로 파고 들어가면서 분석을 해야할 것 같다. 이제 한 부분 분석을 완료했다. 전체적으로 제어 흐름 평탄화(모든 구조를 평평하게 늘어뜨리는 대표적인 난독화 기법)가 되어있어서 나머지 부분도 분석이 쉽지 않을 것 같다.

5주차_Frida(1)

werty2 — Mon, 11 May 2026 00:09:23 +0900

이번 주에 한 일

Anubis 다운로드
Frida를 통해 에뮬레이터 내용 가로채기(동적분석)

우분투 내에서 MalwareBazaar에서 tag:anubis로 검색한 후, 위 사진의 두 번째로 보이는 샘플을 다운받았다.

zip 폴더의 패스워트는 infected 라는 설명이 나온다.

버추얼박스 설정에서 포트포워딩 규칙을 추가해주었다. 규칙은 다음과 같다.

이름: adb
프로토콜: TCP
호스트 IP: 127.0.0.1
호스트 포트: 5555
게스트 포트: 5555

그 후 우분투로 들어와 adb connect 명령어를 통해 호스트(10.0.2.2)의 에뮬레이터와 연결해주었다.

successfully 메시지가 아래에 뜨면 성공한 것이다.

그 후, 우분투에서 아까 다운받은 zip 파일의 압축을 푼다.

압축을 푼 apk 파일이 있는 곳으로 이동해서 에뮬레이터에 push 명령어를 이용해 전송한다.

그 후, install 명령어를 통해 apk 파일을 에뮬레이터 안에서 설치하도록 한다.

adb root 명령어를 이용해 root 권한을 얻어준다.

adb shell 명령어를 통해 내부의 셸에 접속한 다음, frida-server 실행 파일을 실행시킨다. &는 백그라운드에서 실행되도록 한다. 백그라운드에서 실행되므로 셸은 바로 반환된다.

시스템에 설치된 외부 앱 목록을 확인한다. 아마 첫 번째는 저번에 다른 악성코드 분석할 때 설치한 앱이므로 두 번째 앱인 것 같다.

frida -U -f com.eksctm.android 명령어를 이용해 com.eksctm.android 앱을 Frida로 실행한다. 위 사진과 같이 설치할 것인지 알림이 뜨고, install을 눌러 설치한다.

앱을 실행하면 위와 같이 권한 허용에 관해 물어본다. 모든 권한 허용을 해준다.

앱 내부는 위와 같이 생겼다.

실행 후, 지금 에뮬레이터 화면의 가장 맨 위에 떠 있는 앱이 무엇인지 확인하는 명령어를 입력하니 현재 실행 중인 앱의 이름이 바껴 있었다. 처음 리스트에서 com.eksctm.android는 이 본체를 안전하게 설치하기 위해 사용된 설치용 앱인 것 같고, com.racmeo.android가 이 악성코드의 본체인 것 같다.

adb shell dumpsys window: 안드로이드 기기 내부에 접속하여 윈도우 매니저라는 서비스가 관리하는 모든 화면 구성 정보를 텍스트 형태로 길게 출력
grep -E 'mCurrentFocus|mFocusedApp': 넘겨받은 수많은 텍스트 중에서 현재 사용자가 보고 있는 창(mCurrentFocus)과 시스템이 실행 중인 앱 정보(mFocusedApp)가 포함된 줄만 골라내어 보여줌

이미 실행 중인 앱(com.racmeo.android) 내부에 Frida라는 감시 장치를 심어서, 해당 앱이 StringBuilder라는 도구를 사용하여 문자열을 합치는 순간마다 그 내용을 가로채 화면에 출력한다.

(악성코드는 평소에는 단어를 쪼개서 저장하다가 프로그램이 실제로 돌아가는 순간에만 StringBuilder.append()를 사용해 조각들을 합쳐서 완성한다.)

에뮬레이터로 들어가 실행된 앱 입력칸에 아무값이나 입력을 하면 위와 같이 터미널에내부에서 문자열을 어떻게 조립하고 있는지 실시간으로 가로챈 결과를 보여준다. 로그는 아래와 같은 의미를 가진다.

컴포넌트 확인: 상단에 com.racmeo.android.MainActivity를 합치는 로그는 현재 어떤 화면이 활성화되어 있는지 기록하고 있는 것이다.
기기 정보 수집: 중간에 숫자 1080, 1380 같은 값들은 에뮬레이터나 스마트폰의 화면 해상도(가로/세로 크기) 정보를 가져와서 문자열로 만들고 있는 과정이다.
웹뷰(WebView) 탐색: 로그 하단에 webview, app:id/webview 같은 단어들이 조립되는 것을 볼 수 있다. 이는 이 악성코드가 앱 내부의 웹 브라우저 화면을 통해 무언가 조작하거나, 사용자에게 가짜 페이지를 보여주려고 준비 중임을 의미한다.
식별값 생성: c78c38c, 7f0800c6 같은 알 수 없는 코드값들도 보입니다. 이는 감염된 기기를 식별하기 위해 고유한 ID 값을 생성하거나 특정 리소스를 지칭하는 번호를 조립하는 과정이다.

FTK Imager 사용

werty2 — Sun, 10 May 2026 02:33:21 +0900

디스크/드라이브 불러 탐색

1. File > Add Evidence Item
2. 넷 중 하나 선택, 여기서는 D 드라이브만 볼거라서 logical 선택

Physical Drive (피지컬 드라이브)
- 하드디스크/SSD 전체를 통째로 이미지
- 파티션, 삭제된 파일, 여유 공간 포함
- 포렌식 목적이면 대부분 이걸 선택
Logical Drive (로지컬 드라이브)
- 운영체제에서 보여주는 C:, D: 같은 드라이브 단위만 이미지
- 삭제된 파일이나 빈 공간은 포함 안 됨
Image File (이미지 파일)
- 기존 디스크 이미지를 다시 불러오거나 분석할 때 선택
- 새로 이미지를 만들 때는 다른 옵션(Physical/Logical)을 먼저 선택
Contents of a Folder (폴더의 컨텐츠)
- 특정 폴더 안의 파일만 이미지
- 백업용이나 간단한 증거 수집용

3. 해당하는 디스크 선택 후 Finish
4. 화면 오른쪽 아래는 파일의 내용을 보여주는 Hex 값, 그 오른쪽에는 Hex 값을 해석한 ASCII 문자로 해석한 값(해석 불가능한 값은 . 으로 표시)
5. 폴더는 메타데이터, 안에 어떤 파일/폴더가 있는지 기록한 값(디렉터리 엔트리)이 나옴

이미지 파일 생성

1. File > Create Disk Image
2. Physical Drive, Logical Drive, Image File, Contents of a Folder 넷 중 하나 선택 (Fernico Device는 특별한 포렌식 하드웨어가 있는 경우에만 선택)
3. 해당하는 디스크 선택 후 Finish

cf) 삭제 파일 확인하려면 Physical Drive를 선택해야 함.

4. 셋 중에 필요한 것 선택, 첫 번째꺼만 선택해도 됨. 여기서는 파일이 만들어지는게 궁금해서 1,3번 체크

Verify images after they are created
- 이미지가 제대로 만들어졌는지 무결성 검증
- 디스크 데이터와 이미지 파일을 비교해 오류나 손상 여부 확인
Precalculate Progress statistics
- 이미지 생성 중에 진행률과 통계(몇 % 완료, 속도 등)를 미리 계산
Create directory listings of all files in the image after they are created
- 이미지 생성 후 디스크 안의 파일 목록을 텍스트/보고서 형태로 생성

5. Add 클릭 후, 넷 중에 선택, 여기서는 가장 많이 사용되는 방식인 E01 선택

Raw (DD):
- 디스크를 있는 그대로 1:1 복제
- 메타데이터나 압축 없이 순수 데이터만 저장
SMART:
- FTK Imager에서 지원하는 자동화된 검사/추적 기능 포함 포맷
- 보통 전문 포렌식 장비에서 사용
E01:
- 복사하면서 압축/무결성 체크 가능 → 안전하게 관리
- 포렌식에서 가장 많이 사용
- E01 파일을 분석, 관리, 고급 기능 사용하려면 EnCase가 필요(유료)
AFF:
- 오픈소스 포렌식 이미지 포맷
- 압축, 무결성 체크, 메타데이터 저장 가능
- 이미지 만들고 분석까지 무료로 가능

6. 사건 설명 적는 부분

7. 이미지를 저장할 폴더와 이미지 파일 이름 작성(확장자 제외)

(이미지 저장할 폴더는 덤프할 디스크와 같은 곳에 존재 X)

8. Image Fragment Size: 하나의 이미지 파일을 쪼개는 크기, 0으로 설정하면 디스크 전체를 하나의 이미지 파일로 생성
9. Compression: 압축 정도, 9에 가까울수록 용량 ↓ but 만드는 시간 ↑
(여기서는 기본으로 설정된 1500, 6으로 설정)

10. Start 클릭하면 이미지 덤프 시작
11. 끝나면 증거의 무결성에 사용되는 해시값들을 보여줌

PII 위험도 기준

werty2 — Thu, 7 May 2026 22:28:09 +0900

개인정보별 점수화

10점: 고유 식별 정보 및 민감 정보 → 권장 조치: 업로드 차단 / 암호화 저장 / 일정 기간 내 삭제 권고 등.
- 주민등록번호, 여권번호, 운전면허번호 등
8점: 금융 정보 및 생체 정보 → 권장 조치: 업로드 차단 / 암호화 저장 / 일정 기간 내 삭제 권고 등.
- 신용카드 번호, 계좌번호, 지문, 얼굴 인식 데이터 등
5점: 직접 식별 가능 정보 → 권장 조치: 불필요한 항목 삭제, 마스킹, 최소한의 공유 범위 설정 등.
- 전체 이름, 상세 주소, 휴대폰 번호
3점: 간접 식별 정보 (다른 정보와 결합 시 식별 가능한 정보) → 권장 조치: 보관 기간 축소, 접근 권한 최소화 등.
- IP 주소, MAC 주소, 접속 기록(로그), 쿠키

파일을 스캔할 수 없을 때 → 가이드라인에 따로 경고 메시지 추가

암호화/비밀번호가 걸려있어서 내용을 볼 수 없는 경우
- 경고 메시지 예시) 이 파일은 암호화되어 있어 자동 검사에 실패했습니다. 민감한 개인정보가 포함되었을 수 있으므로, 꼭 필요한 경우에만 제한된 범위에서 공유하고, 불필요하다면 삭제를 권장합니다.
단순 미지원/손상된 파일이어서 내용을 볼 수 없는 경우
- 경고 메시지 예시) 현재 지원하지 않는 형식이거나 손상된 파일이라 자동 검사에 실패했습니다. 신뢰할 수 있는 출처인지 확인하고, 필요하지 않다면 삭제를 권장합니다.

각 식별자 정규식 개요

※지문과 얼굴 인식은 정규식이 없음

{
  "KR_RRN": {
    "label": "주민등록번호",
    "regex": "(?:[0-9]{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12][0-9]|3[01]))-[1-4][0-9]{6}",
    "score": 10
  },
  "PASSPORT": {
    "label": "여권번호",
    "regex": "[MS][A-Z0-9]{8,9}",
    "score": 10
  },
  "DRIVER_LICENSE": {
    "label": "운전면허번호",
    "regex": "[0-9]{2}-[0-9]{2}-[0-9]{6}-[0-9]{2}",
    "score": 10
  },

  "CREDIT_CARD": {
    "label": "신용카드번호",
    "regex": "(?:4\\\\d{3}|5[1-5]\\\\d{2}|3[47]\\\\d{2}|6(?:011|5\\\\d{2}))-?\\\\d{4}-?\\\\d{4}-?\\\\d{4}",
    "score": 8
  },
  "BANK_ACCOUNT": {
    "label": "계좌번호",
    "regex": "\\\\d{2,4}-?\\\\d{3,6}-?\\\\d{3,6}",
    "score": 8
  },

  "NAME": {
    "label": "이름(한글)",
    "regex": "(?<![가-힣])[가-힣]{2,4}(?![가-힣])",
    "score": 5
  },
  "PHONE_NUMBER": {
    "label": "전화번호",
    "regex": "(?:01[016789]-\\\\d{3,4}-\\\\d{4})|(?:0[2-8]\\\\d?-\\\\d{3,4}-\\\\d{4})",
    "score": 5
  },
  "ADDRESS": {
    "label": "주소(상세)",
    "regex": "(?:[가-힣0-9]+(시|도)\\\\s*[가-힣0-9]+(구|군)|[가-힣0-9]+(동|읍|면)\\\\s*\\\\d+-?\\\\d*)",
    "score": 5
  },

  "IP_ADDRESS": {
    "label": "IP 주소",
    "regex": "\\\\b(?:\\\\d{1,3}\\\\.){3}\\\\d{1,3}\\\\b",
    "score": 3
  },
  "MAC_ADDRESS": {
    "label": "MAC 주소",
    "regex": "\\\\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\\\\b",
    "score": 3
  },

  "COOKIE": {
    "label": "쿠키 / 세션 ID",
    "regex": "(?i)\\\\b(?:JSESSIONID|SESSIONID|SID|SESSION_TOKEN)=([A-Za-z0-9\\\\-_]{16,})",
    "score": 3
  },
  "LOG_ENTRY": {
    "label": "접속 기록(로그)",
    "regex": "\\\\b(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\\\\s+\\\\/[^\\\\s]*\\\\s+HTTP\\\\/1\\\\.[01]\\\\b",
    "score": 3
  }
}

데이터 형식 정의

{
  // 사용자가 업로드한 파일 이름
  "filename": "string",

  // 파일의 MIME 타입 (예: text/plain, application/pdf 등)
  "mime_type": "string",

  // 스캔 상태: "ok" | "failed" | "not_supported"
  "scan_status": "ok",

  // 스캔 실패 사유 (scan_status가 "failed"일 때만 사용)
  // 예: "encrypted" | "corrupted" | "unsupported" | "too_large" | "timeout"
  "fail_reason": null,

  // 전체 파일의 위험 점수 (발견된 항목들의 최대값 또는 합산값)
  // 스캔 불가 파일이면 null 또는 0으로 둘 수 있음
  "overall_score": 0,

  // 점수 기반 위험 등급
  // 예: low | medium | high
  "risk_level": "low",

  // 발견된 개인정보 목록
  "findings": [
    {
      // 개인정보 유형 코드 (엔진 내부용)
      // 예: KR_RRN(주민등록번호), CREDIT_CARD(카드 번호), PHONE_NUMBER(전화번호) 등
      "type_code": "KR_RRN",

      // 사람이 읽기 쉽게 표시할 라벨
      "type_label": "주민등록번호",

      // 민감도 점수 (10점/8점/5점/3점)
      "score": 10,

      // 어떤 부분에서 발견되었는지
      // 예: "content" | "filename" | "metadata" | "url_query" 등
      "location": "content",

      // 마스킹 처리된 개인정보 (실제 원본을 그대로 노출하면 안 됨)
      "value_preview": "990101-1******",
    }
  ],

  // 점수 기반 요약 정보
  "summary": {
    // 점수별 발견된 항목 개수
    "score_breakdown": {
      "10": 1,
      "8": 0,
      "5": 0,
      "3": 0
    },

    // 개인정보 유형별 개수
    "by_type": {
      "KR_RRN": 1
    }
  }
}

개인정보가 발견되는 위치

파일명 (업로드된 파일 이름 전체 문자열에서 개인정보 패턴을 1차로 탐지)
파일 내용 (의심스러운 파일명, 확장자일 때 파일 내용 탐색)
- .csv (고객 정보, 전화번호·이메일 목록이 가장 자주 들어감)
- .xlsx / .xls (엑셀 파일: 이름·전화번호·주소 같은 개인정보를 표로 관리하는 대표 포맷)
- .pdf (신분증 스캔, 계약서, 민원 서류 등 민감한 자료가 매우 자주 포함됨)
- .txt / .doc / .docx / .hwp (자유 형식 텍스트 문서로, 메모·보고서·양식 등에서 개인정보가 섞여 있을 수 있음)
압축 파일
- .zip / .7z / .rar / .tar / .gz (내부에 민감한 문서·이미지·엑셀 등이 통째로 들어 있어 위험도 최상위 → 가능하면 압축 내부 파일까지 스캔 )
바이오 정보 파일
- .min (지문 정보 전용 표준 확장자)
- .face (얼굴 정보 전용 표준 확장자)
메타데이터 (문서 작성자, 제목, 코멘트, 태그, EXIF GPS 좌표 등 파일 메타데이터에 포함된 이름, 이메일, 전화번호, 위치 정보 등을 스캔)
클라우드가 자동 생성하는 로그 (IP 주소, 계정 ID, 쿠키/세션 ID, URL 파라미터에 포함된 개인정보를 탐지)
URL 또는 쿼리 파라미터에 포함되는 개인정보 (URL 경로와 쿼리 파라미터에 포함된 전화번호, 이메일, 계정 ID, 토큰 등이 있는지 검사)

PII(개인 식별 정보) 탐지 오픈소스

Microsoft Presidio
- 텍스트·이미지·구조화 데이터에서 이름, 전화번호, 이메일, 카드번호 같은 PII를 탐지·마스킹·익명화까지 해주는 프레임워크.
- Python 라이브러리로 쓸 수도 있고, Docker로 서비스 띄워서 다른 백엔드에서 API로 호출할 수도 있음.
깃허브 주소: https://github.com/microsoft/presidio
Presidio 공식 웹사이트(기능 설명, 설치 방법 등): https://microsoft.github.io/presidio/

ARP Spoofing을 이용한 네트워크 내 MITM 공격 실습

werty2 — Thu, 7 May 2026 22:16:37 +0900

https://github.com/ndb796/JavaFX-ARP-Spoofing

위 깃허브 주소에 있는 JavaFX 코드를 가져와서 프로그램 구축

기본 설정

위의 코드는 인텔리제이가 아닌 이클립스로 작성되었고 오래된 코드이기 때문에 기존 내 인텔리제이의 설정과 달라 설정 조정이 필요함

위의 사진과 같이 이전에는 OpenJDK 24를 사용하고 있었는데, JavaFX는 JDK에서 분리가 되어서 호환되지 않음

위와 같이 liberica full 버전(FX 지원 포함)을 다운로드해 프로젝트에 적용

※깃허브 코드가 9년 전 코드이기 때문에 버전도 그만큼 낮은 버전으로 다운로드, 여기에서는 버전 11을 적용

프로젝트 설정의 modules에서 jnetpcap 항목 체크

jnetpcap은 C/C++에서 쓰는 패킷 캡처 표준 라이브러리인 ****libpcap을 Java에서 쓰게 해주는 다리 역할을 함
- jnetpcap 사용을 위해 C로 작성된 libpcap 소스 코드를 window용으로 컴파일한 .dll 라이브러리가 필요, 깃허브 폴더에 포함되어 있음
- .dll 라이브러리 실행을 위해서는 Npcap 설치 필요, Npcap은 Windows 운영체제에서 libpcap API와 호환되는 네트워크 캡처 드라이버로, 커널 레벨에서 네트워크 인터페이스 카드(NIC)의 패킷을 캡처 (libpcap 구현체)

Npcap 드라이버 설치

프로그램 실행

실행시 보이는 화면

안전한 실습을 위해서 개인 휴대폰으로 핫스팟을 켜 연결함.

찾은 네트워크 장치 중 가상환경 등에서 사용하는 네트워크 장치가 아닌 실제 사용 중인 장치 선택(Intel(R), Wi-Fi 등의 단어 포함)

My IP: 공격자(이 노트북)의 IP
Sender IP: 피해자(AP와 통신하는 또 다른 기기)의 IP
Target IP: AP(핫스팟을 켠 폰)의 IP

위 세 IP를 arp -a 등의 명령어(같은 네트워크에 연결된 실제로 통신한 기기들의 ip, mac주소, 정보를 알려줌)를 통해 알아낸 뒤 입력

모두 입력 후 GET MAC 버튼을 눌러 실행

실행 결과

실행 후 콘솔에 찍히는 ARP 프로토콜

주기적으로 프로토콜을 보내 공격자의 MAC주소를 Sender에게는 Target의 맥주소로, Target에게는 Sender의 맥주소로 속임

실행 중 와이어샤크를 이용해 Sender가 보낸 패킷(내가 보낸 패킷이 아님)이 잡히는지 확인

ip.src ==172.20.10.7 (ip 주소가 172.20.10.7인 컴퓨터에서 전송되는 패킷만을 확인)을 입력하면, sender의 모든 인터넷 접속 패킷이 잡히는 것을 볼 수 있음

※원래는 잡히지 않아야 할 source ip 주소의 패킷이 공격자 노트북 랜카드로 들어와 와이어샤크에 캡처됨

프로그램 종료시 다시 패킷이 잡히지 않음

WebGoat A1_IDOR

werty2 — Tue, 28 Apr 2026 19:43:40 +0900

실행 후 가장 첫 화면은 IDOR에 관해 설명하는 화면이 나온다. IDOR은 Insecure Direct Object References의 약자로, 웹사이트가 클라이언트의 데이터에 접근할 때 발생한다.

위의 예시들과 같이 url에 사용자 정보를 그대로 받아들이고, 그 사용자에 대한 검증을 하지 않는 경우 등에 발생한다.

이는 데이터를 단순히 보는 것을 넘어, 타인의 데이터를 수정하거나 삭제하는 행위로까지 확장될 수 있는 심각한 문제로 이어질 수 있기에 항상 검증을 해야한다.

문제로 넘어가면 위와 같은 화면이 나온다. 위 페이지는 그냥 취약한 앱에 로그인하는 과정이다. 알려준대로 user에 tom을 적고 pass에 cat을 적으면 된다.

다음 페이지에는 가공되지 않은 응답 데이터와 화면에 실제로 보이는 것 사이의 차이를 살펴보는 단계이다. 화면이나 페이지에는 나타나지 않지만 서버가 보낸 원본 응답 데이터 안에는 포함되어 있는 정보를 확인한다.

버프스위트 프록시 인터셉트를 킨 후 프로필 버튼을 누르면 요청이 잡힌다. 이 요청을 repeater로 보내 응답을 보면 response에는 role과 userId가 추가로 보이는 것을 확인할 수 있다. 입력창에 role, userId를 입력하면 성공하게 된다.

다음 페이지는 관리자가 각 사용자마다의 정보를 보기위해서는 /profile이라는 주소만으로는 충분하지 않고, 추가적인 정보가 필요하다고 한다. 추가될 파라미터를 찾는 문제이다.

위의 버프스위트에서 프로필 정보를 불러오는 주소가 WebGoat/IDOR/profile 이었다. 그렇다면 뒤에 각 유저의 id를 붙인다면 유저마다의 정보가 나오지 않을까 싶다. 그래서 아까 찾은 tom의 userId인 2342384를 경로 제일 뒤에 붙였다. 제출을 하니 tom의 정보가 화면에 보였다.

첫 번째 문제는 다른 사람의 프로필을 확인하는 문제이다.

repeater에서 Tom cat의 userId에서 하나씩 바꿔가며 요청을 보내보았다. Tom cat의 userId를 2342388로 올리니까 Buffalo Bill 이라는 사람의 정보가 보이면서 성공하게 되었다.

다음 문제는 다른 사람의 프로필을 바꾸는 것이다. 문제 설명은 오래된 애플리케이션은 각기 다른 패턴을 따를 수도 있지만, RESTful 애플리케이션(현재 다루는 앱)은 대부분 메소드만 바꾸거나하는 방식으로 서로 다른 기능을 수행하기 때문에 메소드, 경로, 본문을 변경해 다른 사용자인 Buffalo Bill의 프로필을 수정할 수 있다고 한다. 수정 사항은 권한(role)을 더 낮은 숫자로 변경하거나, 색상(color)을 red로 변경하는 것이다.

버프스위트의 프록시를 킨 다음 View profile 버튼을 누른 후, 받은 GET 메소드의 요청을 repeater로 보낸다. repeater에서 아까 보았던 tom의 데이터 형식인 JSON과 똑같이 JSON 형식의 Buffalo의 데이터를 뒤에 적고, color를 "red", role을 1로 바꿔주었다.

그리고 데이터 수정을 요청하기 위해 GET을 PUT로 바꿔주고, 데이터의 종류가 JSON 형식의 데이터라는 것을 전하기 위해 Content-Type을 application/json으로 수정해주었다.

그 후 Send를 눌러보니 Buffalo의 role과 color가 바뀐 것을 확인할 수 있었다.

프록시 창으로 넘어와 아까와 같이 데이터를 수정한 다음, Forward 버튼을 눌러 보내주었다.

정보가 성공적으로 바뀐 것을 확인할 수 있다.

VirtualBox에 FreeDOS 설치

werty2 — Thu, 23 Apr 2026 17:25:18 +0900

예전(80년대 후반~90년대 초반) 악성코드를 분석하기 위해서는 그 시기에 자주 사용되던 운영체제인 MS-DOS를 깔아 분석을 하면 동작 흐름을 알기가 더 쉬울 것이다. FreeDOS는 MS-DOS와 호환되는 오픈소스 무료 배포 운영체제이다.

https://www.freedos.org/download/

위의 링크로 들어가 LiveCD를 다운받아준 후, 압축을 푼 뒤 그 안에 있는 iso 파일을 버추얼박스에 넣어주었다.

버추얼박스에서 설정은 크게 건드린 부분은 없다.

위 사진에서처럼 부팅 순서를 정해주었다. DOS 운영체제에서는 플로피디스크를 이용한 바이러스가 많았기 때문에 플로피도 마지막 순서에 넣어주었다.

그리고 iso 파일 설치가 모두 끝난 후, CD-ROM 드라이브에서 iso 파일을 뺀다.

설치를 모두 하고 reboot 해주면 위와 같은 화면이 나온다.

설치 후 dir 명령어로 하드디스크(C:)에 있는 파일들을 볼 수 있다.

debug 기능을 통해 어셈블리 코드를 메모리에 바로 입력해서 실행할 수 있다. 위 사진에서는 int 21을 통해 dl에 있는 값을 읽어서 출력하는 간단한 프로그램을 만들어 본 화면이다. 명령어 g를 통해 프로그램을 실행해보니 A(아스키코드 41)가 화면에 잘 출력되는 것을 확인할 수 있다.

또한 현재 메모리의 특정 주소에 어떤 데이터가 있는지 16진수로 확인할 수 있다.

debug를 쓰면 바이러스 분석 시, 메모리의 어느 주소에 바이러스가 숨어있는지, 인터럽트 주소가 정말로 바뀌었는지를 눈으로 직접 확인할 수 있기 때문에 자주 사용될 거 같다.

debug에서 나와서(q -> 엔터)

edit을 입력해 새 파일을 만들면 위와 같이 텍스트 에디터도 잘 나온다. 이 곳에서 원하는 코드를 짜고, 컴파일어나 어셈블러를 이용해 실행 파일로 바꿔줄 수 있다.

4주차_학습용 악성코드 동적분석

werty2 — Thu, 2 Apr 2026 22:53:25 +0900

이번 주에 한 일

syssecApp.apk 동적 분석_Frida이용(아래 보고서 링크에서 확인할 수 있다.)
- https://www.exploit-db.com/docs/english/33093-introduction-to-android-malware-analysis.pdf

Android studio

기존에 설치한 안드로이드 스튜디오에서 frida와 adb 설정을 해 준다.

일단 먼저 frida-tools를 깔아준다.

그 다음 frida-server가 설치된 폴더로 들어가 안드로이드 에뮬레이터 안에 윈도우의 frida-server 실행파일을 복사하기 위해 adb push 명령어를 이용한다.

복사하여 안에 들어간 파일이 실행 가능한 권한을 가질 수 있도록 chmod 명령어로 권한을 준다.

그 후, adb root 명령어를 이용해 관리자 권한을 얻어야 한다. 왜냐하면 안드로이드 에뮬레이터는 기본적으로 일반 사용자 모드이기 때문에 분석을 하려면 관리자 권한이 필요하다. 처음에 관리가 권한 없이 에뮬레이터 안에서 frida 서버를 실행하려고 하니 거부된 것이 아래 사진의 첫 번째 명령어 부분이다.

adb shell "/data/local/tmp/frida-server" 이 코드는 frida-server를 에뮬레이터 안에서 실행된다.

frida-server는 안드로이드 안에서의 정보를 윈도우로 보내주어 실시간 흐름을 감시할 수 있다.

실행 후, frida-ps -U 명령어를 통해 에뮬레이터 안에서 실행 중인 프로세스들을 아래 사진과 같이 윈도우에서 볼 수 있게 된다.

그 다음 보고서 안에 있는 링크를 타고 들어가 아래 사진의 악성코드를 다운로드 받아준다. 아래 사진에서 밑쪽을 향하는 화살표 모양을 누르면 설치가 된다.

설치를 하고 앱을 바로 열어보면 일반적인 게임 앱이 필요한 권한이라기에는 많아보이는 권한 접근 허용을 요구한다. 사진에서 보면 문자, 연락처, 위치, 캘린터, 전화, 통화기록으로의 접근 허용을 요구한다.

기본적으로 모두 허용이 된 상태에서 사용자에게 허용/거부 여부를 물어보기 때문에 일반 사용자들이 게임인줄 알고 큰 생각없이 continue 버튼을 쉽게 누를 수도 있겠다는 생각이 들었다.

게임 화면 안으로 들어가면 아래 사진과 같이 알림창이 나온다. 이 앱이 지금 안드로이트 에뮬레이터 버전보다 더 낮은 버전에서 만들어져서 적절하게 돌아가지 않을 것이라고 한다. 이거까지 감안을 해서 일부러 안드로이드 12.0 버전의 에뮬레이터를 설치했는데 더 낮은 버전으로 설치했어야 했나보다.. 다음 실습에서는 더 낮은 버전의 에뮬레이터를 다시 설치해 이 앱을 실행해 봐야할 것 같다. (참고로 현재(2026-04-02 기준) 안드로이드의 가장 최신 버전은 16이다.)

OK를 누르고 앱 안으로 들어가면 아래 사진과 같이 화면 비율이 이상한 미로찾기 게임이 나온다. 버전이 안맞아서 그런지 누르면 하얀 점이 움직이기는 하는데 딱히 컨트롤을 할 수는 없었다. 아무래도 버전 차이 때문에 화면이나 컨트롤이나 잘 맞지 않은 것 같다. 하지만 중요한건 게임화면이 아니다!!!!!!!!!!!!!!!!!!!!

게임을 실행한 후, 호스트 윈도우 cmd창에서 adb logcat을 입력해주면 adb를 통해 에뮬레이터에서 발생하는 모든 로그를 확인할 수 있다.

아래 사진과 같이 단말기 식별 정보를 가져오는 것은 거부되었지만, 문자나 통화기록(clog), 브라우저 북마크(bbookmarks), 브라우저 검색기록(bsearches), 위치정보(geocoord)등을 수집하고 서버로 보내는 것에 대한 로그가 보인다.

에뮬레이터 환경에는 연락처나 일정과 같은 것이 아무것도 없어서 이런 정보들은 모드 SKIPPING하였고, 위치 정보를 수집해 서버로 보내고 있다. 아래 사진의 마지막에 반복되는 timestamp에 따른 위도와 경도를 통해 사용자의 실시간 위치를 수집할 수 있다. (아래 사진에 있는 위치 정보는 내 위치 정보다........... 개인정보 무료공개 합니다^^7)

다음에는 본격적으로 악성코드가 악성 내용을 보내는 주소인 127.0.0.1:53471 서버를 만들고 열어서 이곳으로 보내지는 사용자의 개인정보들을 직접 확인해볼 것 이다.