[Tech Report] 사라진 악성코드까지 추적한다

카빙(carving)의 동사 원형인 ‘carve’의 사전적 정의는 ‘조각하다, 깎아서 만들다’로, 어떠한 덩어리를 조각하여 의미 있는 형태로 만드는 행위를 뜻한다. 컴퓨터 기술 용어인 ‘카빙’ 역시 어떤 덩어리, 즉 데이터에서 불필요한 부분을 제거하거나 삭제하고 필요한 부분을 합치는 등의 작업를 통해 애플리케이션이 읽을 수 있는 형태의 데이터를 만드는 작업이라 할 수 있다. 즉, 필요에 따라 데이터를 추출하고 재구성함으로써 파일을 복구하거나 시스템을 분석할 수 있어 복잡다단한 시스템과 나날이 고도화되는 공격을 대면하고 있는 분석가들에게 필수적인 기술이다.

이에 월간 안을 통해 PE 카빙을 시작으로 다양한 파일 포맷에 따른 카빙 기술과 활용 방안을 살펴본다.

PE 포맷
PE(Portable Executable) 포맷은 마이크로소프트의 윈도 3.1부터 지원되는 실행 파일의 형식을 말한다. 유닉스 COFF(Common Object file format)를 기반으로 나왔으며, PE 포맷을 사용하는 파일의 확장자는 cpl, exe, dll, ocx, vxd, sys, scr, drv가 있다.

다양한 운영 체제에서의 이식성을 보여준다는 뜻에서 이식이 가능한 ‘실행 형식(Portable Executable)’이라는 이름이 붙었다.
*출처: 위키피디아, http://ko.wikipedia.org/wiki/PE_포맷

import optparse
import glob
import struct
import time
import binascii
import os

def Timestamp(epoch=None):
if epoch == None:
localTime = time.localtime()
else:
localTime = time.localtime(epoch)
return '%04d%02d%02d-%02d%02d%02d' % localTime[0:6]

def LogLine(line):
print('%s: %s' % (Timestamp(), line))

def File2Data(filename):
try:
f = open(filename, 'rb')
except:
return None
try:
return f.read()
except MemoryError:
return MemoryError
except:
return None
finally:
f.close()

def Data2File(data, filename):
try:
f = open(filename, 'wb')
except:
return False
try:
f.write(data)
except:
return False
finally:
f.close()
return True

def CheckPEStructure(baseAddress, data, rData, bSize, filename):
rSize = os.path.getsize(rData)
found = False
index = 0

while index != -1:
index = data.find('\x4D\x5A', index)
# MZ찾기
if index != -1:
e_lfanew = index + 60
e_lfanew_value = int(binascii.hexlify(data[e_lfanew:e_lfanew+4]), 16)
e_lfanew_value_little = struct.pack(' e_lfanew_value_little = e_lfanew_value_little.encode('hex')
e_lfanew_value_little = int(e_lfanew_value_little, 16)

NT_Header = index + e_lfanew_value_little
# NT Header 위치 확인

verifyOptional_Header = binascii.hexlify(data[NT_Header+24:NT_Header+26])

if '50450000' == binascii.hexlify(data[NT_Header:NT_Header+4]) and \
'0b01' == verifyOptional_Header or '0b02' == verifyOptional_Header:
# PE 및 Optional_Header 확인
numberOfSections = binascii.hexlify(data[NT_Header+6:NT_Header+7])
if len(numberOfSections) > 0:
numberOfSections_little = int(numberOfSections, 16)
numberOfSections_little = struct.pack(' numberOfSections_little = numberOfSections_little.encode('hex')
numberOfSections_big = int(numberOfSections_little[0:2], 16)
# Section 개수 확인

sizeOfOptional_Header = binascii.hexlify(data[NT_Header+20:NT_Header+22])
if len(sizeOfOptional_Header) > 0:
sizeOfOptional_Header_little = int(sizeOfOptional_Header, 16)
sizeOfOptional_Header_little = struct.pack(' sizeOfOptional_Header_little = sizeOfOptional_Header_little.encode('hex')
sizeOfOptional_Header_big = int(sizeOfOptional_Header_little[0:4], 16)
# Optional Header 크기 확인

sizeOfPE_Header = binascii.hexlify(data[NT_Header+84:NT_Header+88])
if len(sizeOfPE_Header) > 0:
sizeOfPE_Header_little = int(sizeOfPE_Header, 16)
sizeOfPE_Header_little = struct.pack(' sizeOfPE_Header_little = sizeOfPE_Header_little.encode('hex')
sizeOfPE_Header_big = int(sizeOfPE_Header_little, 16)
# PE Header 크기 확인

if len(sizeOfOptional_Header) > 0:
count = numberOfSections_big
defaultSize = 40
# Section Default 크기는 0x28
totalSizeOfSection = 0
startOfSection_Header = NT_Header + 24 + sizeOfOptional_Header_big
startOfSection_HeaderOffset = startOfSection_Header
# Section Header 시작 위치 찾기
sizeOfSection_header = 40 * numberOfSections_big
endOfSection_Header = startOfSection_Header + sizeOfSection_header
while count > 0:
sizeOfSection = startOfSection_Header + 16
sizeOfSection_little = int(binascii.hexlify(data[sizeOfSection:sizeOfSection+4]), 16)
sizeOfSection_little = struct.pack(' sizeOfSection_little = sizeOfSection_little.encode('hex')
sizeOfSection_big = int(sizeOfSection_little, 16)
#print "sizeOfSection is " + str(sizeOfSection_big)
startOfSection_Header = startOfSection_Header + defaultSize
totalSizeOfSection = totalSizeOfSection + sizeOfSection_big
count = count - 1

totalLength = sizeOfPE_Header_big + totalSizeOfSection

filenameExists = os.path.exists(filename)

if filenameExists == False:
os.mkdir(filename)
running = 1
elif filenameExists == True and running == 1:
running = 1
else:
print "Directory exists"
return True

resultDir = str(os.path.abspath(filename)) + "\\" + str(index)
print resultDir
f = open(resultDir, 'wb')
f.write(data[index:index+totalLength])
# 검증이 끝난 데이터를 파일로 생성

print "MZ Offset " + str(index)
print "MZ Hex Value " + binascii.hexlify(data[index:index+2])
print "NT_Header Offset " + str(NT_Header)
print "NT_Header Hex Value " + binascii.hexlify(data[NT_Header:NT_Header+4])
print "Number Of Sections " + str(numberOfSections_big)
print "Size Of Optional_Header " + str(sizeOfOptional_Header_big)
print "Verify Optional_Header " + verifyOptional_Header
print "Size Of PE_Header " + str(sizeOfPE_Header_big)
print "Size Of Section " + str(sizeOfSection_header)
print "Start of Section " + str(startOfSection_HeaderOffset)
print "End of Section " + str(endOfSection_Header)
print "Total Size Of Section " + str(totalSizeOfSection)
print "Total Length " + str(totalLength) + '\n\n'

index = index + int(bSize)
index = index + int(bSize)
return True

def ExtractPEFromFile(rawDataName, blockSize, folderName, filename):
LogLine('Start')
LogLine('Reading file %s' % rawDataName)
rawData = File2Data(rawDataName)
#print rawData
if rawData == None:
LogLine('Error reading file')
if rawData == MemoryError:
LogLine('File is too large to fit in memory')
else:
LogLine('Searching for PE Format\n')
CheckPEStructure(0, rawData, rawDataName, blockSize, filename)
LogLine('Done')

return True

def Main():
Parser = optparse.OptionParser(usage='usage: python PE_Carver.py -i input_dummy -b block_size -o output_folder')
Parser.add_option('-i', '--input', dest='input', default=False, help='input dummy')
Parser.add_option('-b', '--bsize', dest='bsize', default=False, help='Block Size')
Parser.add_option('-o', '--output', dest='output', default=False, help='The Directory included Carved Files')
(options, args) = Parser.parse_args()

if options.input == False or options.bsize == False or options.output == False:
print('')
print(' python PE_Carver.py --help\n\n')
Parser.error("incorrect number of arguments\n\n")
return
else:
a = []
rData = options.input
bSize = options.bsize
folder = options.output

#filenames = sum(map(glob.glob, filenames), [])

ExtractPEFromFile(rData, bSize, folder, options.output)

if __name__ == '__main__':
Main()

사용법 : python PE_Carver.py -i input_dummy -b block_size -o output_folder
옵션 :
-h, --help show this help message and exit
-i INPUT, --input=INPUT
Input dummy
-b BSIZE, --bsize=BSIZE
Block Size
-o OUTPUT, --output=OUTPUT
The Directory included Carved Files