'분류 전체보기'에 해당되는 글 28건

  1. 2014.03.01 Anti_APKProtect 39
  2. 2014.01.21 Extract Ip address from dex 3
  3. 2014.01.20 reversing.kr 6
  4. 2013.11.26 QQ Messenger Analysis 1
  5. 2013.10.30 Themida/WinLicense 2.2.3.0 1
  6. 2013.10.18 kkoha@msn.com
  7. 2013.09.27 공인인증서 1만건 이상 유출 1
  8. 2013.09.18 국내 "최초" Java Native Interface 사용한 악성코드 4

Anti_APKProtect

2014. 3. 1. 21:24 from 카테고리 없음

언제부터인가 스미싱 악성코드에서 APKProtect 라는 APK 보호 솔루션을 사용하고 있다.


참고자료 : http://viruslab.tistory.com/2801


APKprotect 리뷰/검토 내용 : http://chogar.blog.me/80204437121


<Fig1. http://apkprotect.com >


해당 솔루션이 적용되어 있는지 확인하는 방법은 apk안에 apkprotect.com 폴더가 생성되고 key.dat파일과 readme.txt가 생성된다.


<Fig2. apkprotect.com>


보호 된 classes.dex 파일을 dex2jar로 디컴파일을 하게 되면 에러가 발생하여 분석할 수 없다.


<Fig3. Error >



<Fig4. 잡았다 요놈! >


분석해보니 의외로 간단한 트릭이여서 Anti_APKProtect를 개발하였다. Unpacker라고 해야 하나 @.@



<Fig5. 실행>


깔끔하게 잘 열린다~


<Fig6. Java Decompiler >




여러 샘플을 제공해 주신 김남준님에게 무한한 감사를




-------------- 2014-03-31 Bugfix/Update 0.02 --------------- 



특정 조건에 의해 unpack 하지 못하는 버그가 수정되었으며, 기존 알고리즘을 개선하였습니다.







<Fig7. Registration Code >


등록 코드를  kkoha@msn.com으로  메일로 보내주셔야 사용이 가능합니다.




-------------- 2014-04-19 Bugfix/Update 0.03 --------------- 




<Fig8. ㄱ*ㄲ... >



세월호 침몰사고 사칭 스미싱앱이 디컴파일 되지 않는 문제를 수정하였습니다.


<Fig9. 실행 >




-------------- 2014-10-10 Bugfix/Update 0.04 --------------- 


드디어 APK Protect Professional 버전을 지원합니다.



<Fig10. APKProtect.so >


lite 버전보다 상위 버전으로 난독화를 적용한 앱은 lib/armeabi/libAPKProtect.so파일이 존재합니다.



<Fig11. 실행 >



<Fig12. Unpacked >


원본 apk에서 실제 동작하는 apk를 추출하여 암호화된 문자열을 복호화합니다.



<Fig9. Deobfuscation >


암호화된 문자열 : 복호화된 문자열로 구분하였습니다. 복호화된 문자열 중 마지막에 깨진 문자열은 무시하세요.


샘플을 제공해 주신 김남준님에게 무한한 감사를





<Fig9. Not Support >


다음과 같은 에러가 나오는 샘플을 저한테 보내주시면 분석해서 반영 하겠습니다.



차기 버전은 여기서 다운로드가능합니다.



http://kkoha.tistory.com/entry/AntiAPKProtecten


-------------- 2015-04-07  --------------- 


vmware에서 동작하지 않으며, java 32비트에서 동작합니다.









Posted by kkoha :


안드로이드 어플리케이션은은 DEX (Dalvik Executable) 파일로 컴파일된다. 

DEX 파일은 Java 코드로 작성돼 컴파일된 클래스 파일을 DX(Android dx tool) 도구를 사용해 변환한 파일이다. 

이 과정에 Java 바이트 코드는 달빅 바이트 코드로 변환되며 여러 클래스 파일에 들어있는 중복된 코드들을 재사용하기 때문에 JAR(Java archive) 파일에 비해 필요한 공간이 절반 정도로 크게 줄어들어 모바일 기기에 적합하다.



<Fig1. File Layout >



의외로 구조가 간단하여 DEX 파일 포맷을 따라가 하드코딩된 URL이나 IP 주소를 추출하는 툴을 개발하였다.




<Fig2. 실행 >




<Fig3. 악성앱의 URL >


dexfinder.exe




스미싱 악성코드 분석시에 유용할것 같다.


DEX 파일 구조의 자세한 내용 : http://source.android.com/devices/tech/dalvik/dex-format.html


샘플을 제공해 주신 김남준님에게 무한한 감사를





Posted by kkoha :

reversing.kr

2014. 1. 20. 15:14 from 카테고리 없음

취미 생활로 하던 reversing.kr




오늘 다 끝났다.


crc1는 정말...




Posted by kkoha :

QQ Messenger Analysis 1

2013. 11. 26. 21:50 from 카테고리 없음

QQ는 중국에서 가장 인기 있는 메신저 프로그램이다.

대박인건 QQ는 메신저 기능뿐만 아니라 게임 등 기타 부가 서비스도 개발해 놓은 대형 플렛폼이다. 

스팀이 메신저 부터 공략 했다면..ㅜ.ㅠ


QQ PC 버전 다운로드 : http://im.qq.com/download/pc.shtml





<Fig1. 전용 브라우저 까지.. >



학부생때 기숙사에서 생활했었다. 학생 복지(?)로 기숙사 로비에 컴퓨터가 있었는데...팽귄 아이콘 있는 자리에선 상당히 느렸다.
분명 대량 구매라면 같은 사양의 PC를 샀을텐데~
나~ 중에 알게 되었는데 QQ 을사조약을 맺은거였다.



<Fig2. 뭔말인지 모르겠다 그냥 다음이나 눌러야겠다 >


여튼 QQ메신저는 엄청난 사용자를 가지고 있는 만큼 안티 역공학에 신경 많이 쓰셨다.


디버깅이 불가능하였다....




<Fig3. Unable to set breakpoint >


오잉 확인해보니.......현존 최고(?)의 기술로 역공학을 막고 있었다..





<Fig4. kia >



사전조사를 통해 알아본 결과 돈되는건 다하는 중국 해커 조차 아직까지 채팅 DB Decrypt를 못한거로 파악된다.


확인 할 수 있는 상용화(?) 툴은 설치 이후 로깅되는 로거 뿐이였다.


참고자료 http://www.qqeo.com/msg3.htm    http://hackpx.cn/soft/sort016/down-577.html




<Fig5. 로거까는게 쉽데요 >




이정도만 하더라도 어느정도인지 예상이 되는가?? 이건 빙산의 일각!!




<Fig6. ASSA >


언제 분석 끝날지 모르겠지만 무력화 하였으니 이제 시작이다.


Posted by kkoha :

바이너리 패킹의 시대


IT의 눈부신 발전으로 지속되는 해킹과 크래킹 덕에 이제는 제품 릴리즈 전에 패킹하는 시대를 맞이하였다.

<Fig1. NPC 주제에 욕이라니! >


Themida 같은 Packer/Protector로 보호된 프로그램은 Code Virtualization를 사용하여 Origin Code로 복원되는 시점이 없고 다양한 난독화 기법으로 Virtualization 영역이 보호되어 있어 역공학시 많이 까다롭다. 

그런데 이러한 기술이 엉뚱하게 악성코드 보호에 악용되어 악성코드 분석 및 대응에 어려움을 겪고 있다.

특정 백신은 unpack을 성공하지 못하면 바이러스로 잡기도 한다. 


<Fig2. Packed/Themida >


그리하여 궁금해졌다. Themida 2.2.3.0은 뭐로 보호할까? 전 버전으로? 아니면 새로운 버전으로?

궁금증을 해결하기 위해 공식 홈페이지 http://www.oreans.com 에서 2.2.3.0 Demo를 다운로드를 받았다.


<Fig3. Themida Demo >


다운로드 받으면서 버전 업데이트 히스토리를 봤다.

2.2.2.0 버전에서도 기능향상 및 버그 수정 업데이트를 많이 했다.


<Fig4. Themida Update >


.net 이슈로 2.2.2.0 나오고 얼마 지나지 않아 2.2.3.0이 나온걸 확인 할 수 있다.

자 이제 확인해 볼까?


<Fig5. Themida v2.2.3.0 >


마찬가지로 Anti-debugging, Monitor blocked가 적용되어 있으며 Section 정보만 하더라도 Themida가 가지고 있는 형태이다.

좀더 알기 위해서 olly에서 살펴보니... Code Virtualization 기능, API wraping 등등이 적용 되었으며 보호 할 수 있는 모든 풀옵션을 적용한 것으로 예측 된다. 아무래도 자기들이 만든거니깐...


<Fig6. A SSA >


결론으로 Themida 2.2.3.0은 Themida 2.2.3.0로 보호되고 있으며 델파이로 만들어졌다.


<Fig7. Delphi >


데모버전은 2.2.3.0 밖에 제공되지 않는다.

10월 14일에 2.2.6.0가 릴리즈 되었다. 어떻게 바뀌었을까? 보고싶다.


<Fig10. New Released >


Posted by kkoha :

kkoha@msn.com

2013. 10. 18. 21:07 from 카테고리 없음


kkoha

Posted by kkoha :
111-1111-1111 테스트용
공인인증서 유출 여부 확인 (11492건 유출)
Phone Number :

by koha




www.667803.com 으로 유포된 악성코드는 2013-09-25 21:04:20 ~2013-09-26 12:30 까지 불과 3시간만에 11044건의 공인인증서가를 가져갔다. 악성코드 전파속도가 ㅎㄷㄷ


이후 추가적으로 다른 악성코드를 다운받아서 비밀번호랑 보안카드도 유출을 시도한다.



어떻게 짧은 시간에 많은 사람들을 감염시켰을까?


감염시 전화번호부 목록에 있는 모든 전화번호로 문자메시지를 보낸다.

<Fig1. 문자 >



<Fig2. 문자메시지 전송 및 문자메시지 내용 할당 >

기존 스미싱 같은 경우 114등 모르는번호로 오기 때문에 의심할 수 있지만 아는 사람이 보낸다면 어떨까? 내가 좋아 하는 사람이 보냈다면?

헤헤 나같아도 클릭했을것 같다.



유출되었는지 어떻게 확인이 가능하냐?


<Fig3. NPKI 폴더 압축 >

<Fig4. 유출된 공인인증서 >

감염 이후 공인인증서가 들어있는 폴더를 감염자 핸드폰 전화번호를 이름으로 압축한다.ex)01012345678.zip 그 이후 악성앱 제작자의 FTP로 접속하여 업로드한다.

그렇게 때문에 FTP에 올라간 파일 리스트를 뽑으면 확인이 가능하다.



공인인증서만 유출된다고 아무것도 못하지않느냐?


당연히 공인인증서만 가지고는 아무것도 못한다. 그러나...우리나라에서의 개인정보는.....

<Fig4. 공격자는 당신의 정보를 가지고 있다. >

얘들은 010-1234-5678 번호을 가지고 있는 사람의 이름도 알고 있으며 통신사 그리고 주민등록번호까지 알고 있다.

참고 자료 : 지난 2년간 개인정보 유출 6천만 건 이상

공인인증서 유효기간은 1년이다. 악성앱 제작자는 가져간 공인인증서의 유효기간안에 다양한 방법으로 다시 공략할것이다.



Posted by kkoha :


국내에서 발생한 안드로이드 악성코드 중 개인적으로 가장 진보된? 난독화 기술을 사용한 카카오톡 보안 플러그인 악성코드를 소개하고 싶다.

카카오톡 보안 플러그인이라는 악성코드는 국내 안드로이드 개발자 컴퓨터를 해킹하여 구글플레이에 업로드 되어 2013년 6월 30일에 유포된 것으로 알려져 있다.

허나 개발자 계정 해킹으로는 구글마켓 업로드는 불가능하며 keystore 비밀번호 등등  등록된 컴퓨터에서만 업로드가 가능하다고 한다~ 해킹일지 아니면 개발자가 큰돈 받고 올린건지...


참고 http://erteam.nprotect.com/428  

분석보고서 http://training.nshc.net/KOR/Document/isac/20130630_KakaoTalk_Plug-in_Malware_1.1.pdf


JNI를 사용하는 악성코드가 언젠간 나오겠지~ 라고 생각하다 정말 나와버렸다. 


ddd

<Fig1. AndroidManifest.xml>



정직하게 MainActivity 에서 따라가보면



<Fig2. MainActivitiy.class>

???????이게 끝????



<Fig3. MoriService.class>

Manifest의 Serivce에서 MoriService.class가 정의되어 Service로 앱 실행 시  Eglsv1.so 를 호출하여 Handle 생성 후 ReadDAT()를 호출한다. 



<Fig4. Eglsv1.so>

ReadDAT을 보면 참 아름답다.



<Fig5. Encrypted String>




음...................문자열이 암호화 되었군.............


ida가 뭐하는건데 킨 거지?


음...


내가 arm을 알았던가?


음...


아톰시피유가 뭐죠?




긴글 봐주셔서 감사합니다.

























는 훼이끄...




<Fig6. Decryption Function >


암호 루틴을 찾고 따라가보니 바로~~~~ 

rijndael192  + xor 연산으로 암호화 되어있었다~


ex) RAINEBQBQVkKiAwEs9VWPODaejQh3TFn1jpcS9ztCX

R     A      INEBQBQV            kKiAwEs9VWPODaejQh3TFn1jpcS9ztCX

XOR key     Rijndael192 key    Rijndael192 CipherText


자 이제 파이썬으로 구현해보자

# ported from the Java reference code by Bram Cohen, bram@gawth.com, April 2001
# this code is public domain, unless someone makes
# an intellectual property claim against the reference
# code, in which case it can be made public domain by
# deleting all the comments and renaming all the variables
 
import copy
import string
import base64
 
 
#-----------------------
#TREV - ADDED BECAUSE THERE'S WARNINGS ABOUT INT OVERFLOW BEHAVIOR CHANGING IN
#2.4.....
import os
if os.name != "java":
    import exceptions
    if hasattr(exceptions, "FutureWarning"):
        import warnings
        warnings.filterwarnings("ignore", category=FutureWarning, append=1)
#-----------------------
 
 
 
shifts = [[[0, 0], [1, 3], [2, 2], [3, 1]],
          [[0, 0], [1, 5], [2, 4], [3, 3]],
          [[0, 0], [1, 7], [3, 5], [4, 4]]]
 
# [keysize][block_size]
num_rounds = {16: {16: 10, 24: 12, 32: 14}, 24: {16: 12, 24: 12, 32: 14}, 32: {16: 14, 24: 14, 32: 14}}
 
A = [[1, 1, 1, 1, 1, 0, 0, 0],
     [0, 1, 1, 1, 1, 1, 0, 0],
     [0, 0, 1, 1, 1, 1, 1, 0],
     [0, 0, 0, 1, 1, 1, 1, 1],
     [1, 0, 0, 0, 1, 1, 1, 1],
     [1, 1, 0, 0, 0, 1, 1, 1],
     [1, 1, 1, 0, 0, 0, 1, 1],
     [1, 1, 1, 1, 0, 0, 0, 1]]
 
# produce log and alog tables, needed for multiplying in the
# field GF(2^m) (generator = 3)
alog = [1]
for i in xrange(255):
    j = (alog[-1] << 1) ^ alog[-1]
    if j & 0x100 != 0:
        j ^= 0x11B
    alog.append(j)
 
log = [0] * 256
for i in xrange(1, 255):
    log[alog[i]] = i
 
# multiply two elements of GF(2^m)
def mul(a, b):
    if a == 0 or b == 0:
        return 0
    return alog[(log[a & 0xFF] + log[b & 0xFF]) % 255]
 
# substitution box based on F^{-1}(x)
box = [[0] * 8 for i in xrange(256)]
box[1][7] = 1
for i in xrange(2, 256):
    j = alog[255 - log[i]]
    for t in xrange(8):
        box[i][t] = (j >> (7 - t)) & 0x01
 
B = [0, 1, 1, 0, 0, 0, 1, 1]
 
# affine transform:  box[i] <- B + A*box[i]
cox = [[0] * 8 for i in xrange(256)]
for i in xrange(256):
    for t in xrange(8):
        cox[i][t] = B[t]
        for j in xrange(8):
            cox[i][t] ^= A[t][j] * box[i][j]
 
# S-boxes and inverse S-boxes
S =  [0] * 256
Si = [0] * 256
for i in xrange(256):
    S[i] = cox[i][0] << 7
    for t in xrange(1, 8):
        S[i] ^= cox[i][t] << (7-t)
    Si[S[i] & 0xFF] = i
 
# T-boxes
G = [[2, 1, 1, 3],
    [3, 2, 1, 1],
    [1, 3, 2, 1],
    [1, 1, 3, 2]]
 
AA = [[0] * 8 for i in xrange(4)]
 
for i in xrange(4):
    for j in xrange(4):
        AA[i][j] = G[i][j]
        AA[i][i+4] = 1
 
for i in xrange(4):
    pivot = AA[i][i]
    if pivot == 0:
        t = i + 1
        while AA[t][i] == 0 and t < 4:
            t += 1
            assert t != 4, 'G matrix must be invertible'
            for j in xrange(8):
                AA[i][j], AA[t][j] = AA[t][j], AA[i][j]
            pivot = AA[i][i]
    for j in xrange(8):
        if AA[i][j] != 0:
            AA[i][j] = alog[(255 + log[AA[i][j] & 0xFF] - log[pivot & 0xFF]) % 255]
    for t in xrange(4):
        if i != t:
            for j in xrange(i+1, 8):
                AA[t][j] ^= mul(AA[i][j], AA[t][i])
            AA[t][i] = 0
 
iG = [[0] * 4 for i in xrange(4)]
 
for i in xrange(4):
    for j in xrange(4):
        iG[i][j] = AA[i][j + 4]
 
def mul4(a, bs):
    if a == 0:
        return 0
    r = 0
    for b in bs:
        r <<= 8
        if b != 0:
            r = r | mul(a, b)
    return r
 
T1 = []
T2 = []
T3 = []
T4 = []
T5 = []
T6 = []
T7 = []
T8 = []
U1 = []
U2 = []
U3 = []
U4 = []
 
for t in xrange(256):
    s = S[t]
    T1.append(mul4(s, G[0]))
    T2.append(mul4(s, G[1]))
    T3.append(mul4(s, G[2]))
    T4.append(mul4(s, G[3]))
 
    s = Si[t]
    T5.append(mul4(s, iG[0]))
    T6.append(mul4(s, iG[1]))
    T7.append(mul4(s, iG[2]))
    T8.append(mul4(s, iG[3]))
 
    U1.append(mul4(t, iG[0]))
    U2.append(mul4(t, iG[1]))
    U3.append(mul4(t, iG[2]))
    U4.append(mul4(t, iG[3]))
 
# round constants
rcon = [1]
r = 1
for t in xrange(1, 30):
    r = mul(2, r)
    rcon.append(r)
 
del A
del AA
del pivot
del B
del G
del box
del log
del alog
del i
del j
del r
del s
del t
del mul
del mul4
del cox
del iG
 
class rijndael:
    def __init__(self, key, block_size = 16):
        if block_size != 16 and block_size != 24 and block_size != 32:
            raise ValueError('Invalid block size: ' + str(block_size))
        if len(key) != 16 and len(key) != 24 and len(key) != 32:
            raise ValueError('Invalid key size: ' + str(len(key)))
        self.block_size = block_size
 
        ROUNDS = num_rounds[len(key)][block_size]
        BC = block_size / 4
        # encryption round keys
        Ke = [[0] * BC for i in xrange(ROUNDS + 1)]
        # decryption round keys
        Kd = [[0] * BC for i in xrange(ROUNDS + 1)]
        ROUND_KEY_COUNT = (ROUNDS + 1) * BC
        KC = len(key) / 4
 
        # copy user material bytes into temporary ints
        tk = []
        for i in xrange(0, KC):
            tk.append((ord(key[i * 4]) << 24) | (ord(key[i * 4 + 1]) << 16) |
                (ord(key[i * 4 + 2]) << 8) | ord(key[i * 4 + 3]))
 
        # copy values into round key arrays
        t = 0
        j = 0
        while j < KC and t < ROUND_KEY_COUNT:
            Ke[t / BC][t % BC] = tk[j]
            Kd[ROUNDS - (t / BC)][t % BC] = tk[j]
            j += 1
            t += 1
        tt = 0
        rconpointer = 0
        while t < ROUND_KEY_COUNT:
            # extrapolate using phi (the round key evolution function)
            tt = tk[KC - 1]
            tk[0] ^= (S[(tt >> 16) & 0xFF] & 0xFF) << 24 ^  \
                     (S[(tt >>  8) & 0xFF] & 0xFF) << 16 ^  \
                     (S[ tt        & 0xFF] & 0xFF) <<  8 ^  \
                     (S[(tt >> 24) & 0xFF] & 0xFF)       ^  \
                     (rcon[rconpointer]    & 0xFF) << 24
            rconpointer += 1
            if KC != 8:
                for i in xrange(1, KC):
                    tk[i] ^= tk[i-1]
            else:
                for i in xrange(1, KC / 2):
                    tk[i] ^= tk[i-1]
                tt = tk[KC / 2 - 1]
                tk[KC / 2] ^= (S[ tt        & 0xFF] & 0xFF)       ^ \
                              (S[(tt >>  8) & 0xFF] & 0xFF) <<  8 ^ \
                              (S[(tt >> 16) & 0xFF] & 0xFF) << 16 ^ \
                              (S[(tt >> 24) & 0xFF] & 0xFF) << 24
                for i in xrange(KC / 2 + 1, KC):
                    tk[i] ^= tk[i-1]
            # copy values into round key arrays
            j = 0
            while j < KC and t < ROUND_KEY_COUNT:
                Ke[t / BC][t % BC] = tk[j]
                Kd[ROUNDS - (t / BC)][t % BC] = tk[j]
                j += 1
                t += 1
        # inverse MixColumn where needed
        for r in xrange(1, ROUNDS):
            for j in xrange(BC):
                tt = Kd[r][j]
                Kd[r][j] = U1[(tt >> 24) & 0xFF] ^ \
                           U2[(tt >> 16) & 0xFF] ^ \
                           U3[(tt >>  8) & 0xFF] ^ \
                           U4[ tt        & 0xFF]
        self.Ke = Ke
        self.Kd = Kd
 
    def encrypt(self, plaintext):
        if len(plaintext) != self.block_size:
            raise ValueError('wrong block length, expected ' + str(self.block_size) + ' got ' + str(len(plaintext)))
        Ke = self.Ke
 
        BC = self.block_size / 4
        ROUNDS = len(Ke) - 1
        if BC == 4:
            SC = 0
        elif BC == 6:
            SC = 1
        else:
            SC = 2
        s1 = shifts[SC][1][0]
        s2 = shifts[SC][2][0]
        s3 = shifts[SC][3][0]
        a = [0] * BC
        # temporary work array
        t = []
        # plaintext to ints + key
        for i in xrange(BC):
            t.append((ord(plaintext[i * 4    ]) << 24 |
                      ord(plaintext[i * 4 + 1]) << 16 |
                      ord(plaintext[i * 4 + 2]) <<  8 |
                      ord(plaintext[i * 4 + 3])        ) ^ Ke[0][i])
        # apply round transforms
        for r in xrange(1, ROUNDS):
            for i in xrange(BC):
                a[i] = (T1[(t[ i           ] >> 24) & 0xFF] ^
                        T2[(t[(i + s1) % BC] >> 16) & 0xFF] ^
                        T3[(t[(i + s2) % BC] >>  8) & 0xFF] ^
                        T4[ t[(i + s3) % BC]        & 0xFF]  ) ^ Ke[r][i]
            t = copy.copy(a)
        # last round is special
        result = []
        for i in xrange(BC):
            tt = Ke[ROUNDS][i]
            result.append((S[(t[ i           ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF)
            result.append((S[(t[(i + s1) % BC] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF)
            result.append((S[(t[(i + s2) % BC] >>  8) & 0xFF] ^ (tt >>  8)) & 0xFF)
            result.append((S[ t[(i + s3) % BC]        & 0xFF] ^  tt       ) & 0xFF)
        return string.join(map(chr, result), '')
 
    def decrypt(self, ciphertext):
        if len(ciphertext) != self.block_size:
            raise ValueError('wrong block length, expected ' + str(self.block_size) + ' got ' + str(len(plaintext)))
        Kd = self.Kd
 
        BC = self.block_size / 4
        ROUNDS = len(Kd) - 1
        if BC == 4:
            SC = 0
        elif BC == 6:
            SC = 1
        else:
            SC = 2
        s1 = shifts[SC][1][1]
        s2 = shifts[SC][2][1]
        s3 = shifts[SC][3][1]
        a = [0] * BC
        # temporary work array
        t = [0] * BC
        # ciphertext to ints + key
        for i in xrange(BC):
            t[i] = (ord(ciphertext[i * 4    ]) << 24 |
                    ord(ciphertext[i * 4 + 1]) << 16 |
                    ord(ciphertext[i * 4 + 2]) <<  8 |
                    ord(ciphertext[i * 4 + 3])        ) ^ Kd[0][i]
        # apply round transforms
        for r in xrange(1, ROUNDS):
            for i in xrange(BC):
                a[i] = (T5[(t[ i           ] >> 24) & 0xFF] ^
                        T6[(t[(i + s1) % BC] >> 16) & 0xFF] ^
                        T7[(t[(i + s2) % BC] >>  8) & 0xFF] ^
                        T8[ t[(i + s3) % BC]        & 0xFF]  ) ^ Kd[r][i]
            t = copy.copy(a)
        # last round is special
        result = []
        for i in xrange(BC):
            tt = Kd[ROUNDS][i]
            result.append((Si[(t[ i           ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF)
            result.append((Si[(t[(i + s1) % BC] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF)
            result.append((Si[(t[(i + s2) % BC] >>  8) & 0xFF] ^ (tt >>  8)) & 0xFF)
            result.append((Si[ t[(i + s3) % BC]        & 0xFF] ^  tt       ) & 0xFF)
        return string.join(map(chr, result), '')
 
def decrypt(key, encoded):
    padded_key = key.ljust(16, "\0")
    ciphertext = base64.b64decode(encoded)
    r = rijndael(padded_key, 24)
    padded_text = ""
    for start in range(0, len(ciphertext), 24):
        padded_text += r.decrypt(ciphertext[start:start+24])
    plaintext = padded_text.split("\x00", 1)[0]
    return plaintext
 
#antivirus
listcipher =["RAINEBQBQVkKiAwEs9VWPODaejQh3TFn1jpcS9ztCX","EOAZSDCFEJPfxIxidWIbTZZhRr2S93AV7Yp3QNsb6z",
            "LREZSDYTKJV25RUXuaGaYxFh2KEkKK56QrHZmY5e2q","OAIPAHUDEJ0vxHNfSV8c2JRz4eVzhlYAQlbnq8JXw9",
            "HXIPORYFQRQuAesYG1S6EEFrYdn6aNiRBA1IHGg4IT","NSYPQDUDSDTSmgLN1wAzssSl67lhAbT5DimAHhHCqC",
            "OPEBMDUPSXAspKQCk9szNWNQfNMTbM1mzWTvvp7WaF","TAOVSLSXSVGnsP8nXvrxfh5v0UHS07LtkaP1KV0AFz",
            "BSMTQHCRQPxanYLQfvfuvGVNDv4FAtWsOx5WAL12Kr","ASKLELIJGFH2hVPH4Z3Og4bxxFNoSQeNDvaGZagz0n",
            "MBHGFABMTGozpXfPpWzm1gdQBjuGoDCve5MSFH96juSwt6Q1Dg8XX9yTTHVnC4hDcJBoazVL7a","GOZAZMNOLSQnxZiJ5NLQmQ46mGbJZjwIORoKy62gDA",
            "HLHADWZKBMZLiXM1RvbljIGPwhH8MugKzVxE1UehWV","XMLSLGZMLSjQ6rUtct4zB2L2pduxajx64YgU0ZHWUATPUYCVT6kKC4VnB3KmKRpokvWb6oxnzT",
            "YRRADOXOLOrPn117W4R7xlTzgZeP54RNQd5qvRUMGyaX4duLH1Bxa2miWSaAeaeODR7RDTytqd","CDTGVSXUDSZRhuNHOo9JH1HIMm2dhOd89mxMM1nk6A",
            "VBFMVQZMLEDBWNKvBDPv8NEbarx0mryt7oq7JTX7Kn","BAPYNONKHKE7Co6zfGHY8vOxtJM9iga6KQtrMDjskj",
            "RVFCVAXWXEwQAc0Va4Mt5pC1v6E4I4AHIGkR08eW7n0JcxbQwEDTFtyqdYJhmLJf4qG0dRiBxP","QVPGHGLOPE9HUz2cdW0iAu6ZcMP9DiKfKiss2EvdGF"]


for i in range (len(listcipher)):
        chipertxt=listcipher[i]
        oneround = decrypt(chipertxt[2:10], chipertxt[10:])
        xorkey= chr(ord(chipertxt[0]) ^ 0x0a)
        plaintext=''
        for c in oneround:
            plaintext += chr(ord(c) ^ ord(xorkey))
        print plaintext
        

<Fig7. String Decryption >

Decryption하니 백신사 패키지 명이 보인다~


이젠 안드로이드 악성코드도 백신 공격 시대 ㅎㄷㄷ


<Fig8. Http Authorization>


이 녀석... 통신도 한다. 

  if(authstatus->picked == CURLAUTH_BASIC) {
    /* Basic */
    if((proxy && conn->bits.proxy_user_passwd &&
       !Curl_checkheaders(data, "Proxy-authorization:")) ||
       (!proxy && conn->bits.user_passwd &&
       !Curl_checkheaders(data, "Authorization:"))) {
      auth="Basic";
      result = http_output_basic(conn, proxy);
      if(result)
        return result;
    }



또 하나 재미있는 부분

<Fig9. Apk>


쟤 뱃속에 APK가 들어있어요!!!!

<Fig10. WriteFile>

/system/app/FOTAKill.apk로 저장된다


<Fig11. dump.apk>

긁은 파일 정보

https://www.virustotal.com/en/file/141652d4d44143d232a35180f704d1c1c9b0b33049ebbe19026d6b1d978790ab/analysis/ 



JNI를 사용하여 스트링 난독화로 안티 역공학에...백신 확인, 드롭퍼 역할까지.... 


아무튼 JNI를 활용하면 기존 바이너리에 쓰이던 코드 난독화 기법을 사용할 수 있게된다. (ex api 리다이렉션, 더미 코드 삽입  등등) 

참 무궁무진하므로  안드로이드 분석도 이젠 ㅠㅠ




Posted by kkoha :