def set_plugins(self, plugins_path):
self.plugins_path = plugins_path
pu = k2rsa.read_key(plugins_path + os.sep + 'key.pkr')
if not pu:
return False
ret = self.__get_kmd_list(plugins_path + os.sep + 'kicom.kmd', pu)
if not ret:
return False
if self.debug:
print('[*] kicom.kmd :')
print(' ', self.kmdfiles)
for kmd_name in self.kmdfiles:
kmd_path = plugins_path + os.sep + kmd_name
k = k2kmdfile.KMD(kmd_path, pu)
module = k2kmdfile.load(kmd_name.split('.')[0], k.body)
if module:
self.kmd_modules.append(module)
self.__get_last_kmd_build_time(k)
else:
print(kmd_name, "is failed to load on memory")
if self.debug:
print('[*] kmd_moudles :')
print(' ', self.kmd_modules)
print('[*] Last updated %s UTC' % (self.max_datetime.ctime()))
return True
def set_plugins(self, plugins_path):
# 플러그인 경로를 저장한다.
self.plugins_path = plugins_path
# 공개키를 로딩한다.
pu = k2rsa.read_key(plugins_path + os.sep + 'key.pkr')
if not pu:
return False
# 우선순위를 알아낸다.
ret = self.__get_kmd_list(plugins_path + os.sep + 'kicom.kmd', pu)
if not ret: # 로딩할 KMD 파일이 없다.
return False
if self.debug:
print '[*] kicom.kmd :'
print ' ', self.kmdfiles
# 우선순위대로 KMD 파일을 로딩한다.
for kmd_name in self.kmdfiles:
kmd_path = plugins_path + os.sep + kmd_name
try:
k = k2kmdfile.KMD(kmd_path, pu) # 모든 KMD 파일을 복호화한다.
module = k2kmdfile.load(kmd_name.split('.')[0], k.body)
if module: # 메모리 로딩 성공
self.kmd_modules.append(module)
# 메모리 로딩에 성공한 KMD에서 플러그 엔진의 시간 값 읽기
# 최신 업데이트 날짜가 된다.
self.__get_last_kmd_build_time(k)
except IOError:
pass
except k2kmdfile.KMDFormatError: # 다른키로 암호호화 한 엔진은 무시
pass
# 악성코드 패턴에서 최신 시간 값을 얻는다.
fl = glob.glob(plugins_path + os.sep + '*.n??')
for fname in fl:
try:
buf = open(fname, 'rb').read(12)
if buf[0:4] == 'KAVS':
sdate = k2timelib.convert_date(
struct.unpack('<H', buf[8:10])[0])
stime = k2timelib.convert_time(
struct.unpack('<H', buf[10:12])[0])
t_datetime = datetime.datetime(sdate[0], sdate[1],
sdate[2], stime[0],
stime[1], stime[2])
if self.max_datetime < t_datetime:
self.max_datetime = t_datetime
except IOError:
pass
if self.debug:
print '[*] kmd_modules :'
print ' ', self.kmd_modules
print '[*] Last updated %s UTC' % self.max_datetime.ctime()
return True
def set_plugins(self, plugins_path):
# 플러그인 경로를 저장한다.
self.plugins_path = plugins_path
# 공개키를 로딩한다.
pu = k2rsa.read_key(plugins_path + os.sep + 'key.pkr')
if not pu:
return False
# 우선순위를 알아낸다.
ret = self.__get_kmd_list(plugins_path + os.sep + 'kicom.kmd', pu)
if not ret: # 로딩할 KMD 파일이 없다.
return False
if self.debug:
print '[*] kicom.kmd :'
print ' ', self.kmdfiles
# 우선순위대로 KMD 파일을 로딩한다.
for kmd_name in self.kmdfiles:
kmd_path = plugins_path + os.sep + kmd_name
try:
k = k2kmdfile.KMD(kmd_path, pu) # 모든 KMD 파일을 복호화한다.
module = k2kmdfile.load(kmd_name.split('.')[0], k.body)
if module: # 메모리 로딩 성공
self.kmd_modules.append(module)
# 메모리 로딩에 성공한 KMD에서 플러그 엔진의 시간 값 읽기
# 최신 업데이트 날짜가 된다.
self.__get_last_kmd_build_time(k)
except IOError:
pass
except k2kmdfile.KMDFormatError: # 다른키로 암호호화 한 엔진은 무시
pass
# 악성코드 패턴에서 최신 시간 값을 얻는다.
fl = glob.glob(plugins_path + os.sep + '*.n??')
for fname in fl:
try:
buf = open(fname, 'rb').read(12)
if buf[0:4] == 'KAVS':
sdate = k2timelib.convert_date(struct.unpack('<H', buf[8:10])[0])
stime = k2timelib.convert_time(struct.unpack('<H', buf[10:12])[0])
t_datetime = datetime.datetime(sdate[0], sdate[1], sdate[2], stime[0], stime[1], stime[2])
if self.max_datetime < t_datetime:
self.max_datetime = t_datetime
except IOError:
pass
if self.debug:
print '[*] kmd_modules :'
print ' ', self.kmd_modules
print '[*] Last updated %s UTC' % self.max_datetime.ctime()
return True
def set_plugins(self, plugins_path):
self.plugins_path = plugins_path
#pu = k2rsa.read_key(plugins_path +os.sep+'key.pkr')
pu = k2rsa.read_key('key.pkr')
if not pu:
print('not load pkr')
return False
#ret = self.__get_kmd_list(plugins_path + os.sep +'kicom.kmd', pu)
ret = self.__get_kmd_list('kicom.kmd', pu)
if not ret:
print('not exist KDM file')
return False
if self.debug:
print('[*] kicom.kmd:')
print(' ', self.kmdfiles)
return True
def set_plugins(self, plugins_path):
# 플러그인 경로 저장
self.plugins_path = plugins_path
#print 'plugins_path: ' + plugins_path
# 공개키 로딩
pu = k2rsa.read_key(plugins_path + os.sep + 'key.pkr')
#print pu
if not pu:
return False
# 우선순위 체크
ret = self.__get_kmd_list(plugins_path + os.sep + 'kicom.kmd', pu)
if not ret:
return False
if self.debug:
print '[*] load kicom.kmd:'
print ' ', self.kmdfiles
# 우선순위 대로 KMD파일 로딩
for kmd_name in self.kmdfiles:
kmd_path = plugins_path + os.sep + kmd_name
k = k2kmdfile.KMD(kmd_path, pu) # 모든 KMD 파일 복호화
module = k2kmdfile.load(kmd_name.split('.')[0], k.body)
if module: # 메모리 로딩 성공
self.kmd_modules.append(module)
# 메모리 로딩에 성공한 KMD에서 플러그인 엔진의 시간 값 읽기
# 최신 업데이트 날짜가 된다
self.__get_last_kmd_build_time(k)
if self.debug:
print '[*] kmd_modules:'
print ' ', self.kmd_modules
print '[*] Last updated %s UTC' % self.max_datetime.ctime()
return True
import k2rsa
import k2kmdfile
k2rsa.create_key('key.pkr', 'key.skr')
ret = k2kmdfile.make('kicom.lst')
if ret:
pu = k2rsa.read_key('key.pkr')
k = k2kmdfile.KMD('kicom.kmd', pu)
print k.body
def set_plugins(self, plugins_path, callback_fn=None):
self.plugins_path = plugins_path
if k2const.K2DEBUG:
pu = None
ret = self.__get_kmd_list(os.path.join(plugins_path, 'kicom.lst'),
pu)
else:
pu = k2rsa.read_key(os.path.join(plugins_path, 'key.pkr'))
if not pu:
return False
ret = self.__get_kmd_list(os.path.join(plugins_path, 'kicom.kmd'),
pu)
if not ret:
return False
if self.verbose:
print '[*] kicom.%s :' % ('lst' if k2const.K2DEBUG else 'kmd')
print ' ', self.kmdfiles
for kmd_name in self.kmdfiles:
kmd_path = os.path.join(plugins_path, kmd_name)
try:
name = kmd_name.split('.')[0]
if k2const.K2DEBUG:
k = None
module = imp.load_source(
name,
os.path.splitext(kmd_path)[0] + '.py')
try:
os.remove(os.path.splitext(kmd_path)[0] + '.pyc')
except OSError:
pass
else:
k = k2kmdfile.KMD(kmd_path, pu)
data = k.body
module = k2kmdfile.load(name, data)
if module:
self.kmd_modules.append(module)
self.__get_last_kmd_build_time(k)
else:
if isinstance(callback_fn, types.FunctionType):
callback_fn(name)
except IOError:
pass
except k2kmdfile.KMDFormatError:
pass
fl = glob.glob1(plugins_path, '*.n??')
for fname in fl:
try:
fname = os.path.join(plugins_path, fname)
buf = open(fname, 'rb').read(12)
if buf[0:4] == 'KAVS':
sdate = k2timelib.convert_date(
struct.unpack('<H', buf[8:10])[0])
stime = k2timelib.convert_time(
struct.unpack('<H', buf[10:12])[0])
t_datetime = datetime.datetime(sdate[0], sdate[1],
sdate[2], stime[0],
stime[1], stime[2])
if self.max_datetime < t_datetime:
self.max_datetime = t_datetime
except IOError:
pass
if self.verbose:
print '[*] kmd_modules :'
print ' ', self.kmd_modules
print '[*] Last updated %s UTC' % self.max_datetime.ctime()
return True
def make(src_fname, debug=False):
# -----------------------------------------------------------------
# 암호화 대상 파일을 컴파일 또는 복사해서 준비한다.
# -----------------------------------------------------------------
fname = src_fname # 암호화 대상 파일
if fname.split('.')[1] == 'py': # 파이썬 파일을 컴파일 한다.
py_compile.compile(fname) # 컴파일
pyc_name = fname+'c' # 컴파일 이후 파일명
else: # 파이썬 파일이 아닐 경우 확장자를 pyc로 하여 복사한다.
pyc_name = fname.split('.')[0]+'.pyc'
shutil.copy(fname, pyc_name)
# -----------------------------------------------------------------
# Simple RSA를 사용하기 위해 공개키와 개인키를 로딩한다.
# -----------------------------------------------------------------
# 공개키를 로딩한다.
rsa_pu = k2rsa.read_key('key.pkr')
# print 'pkr : ', rsa_pu
# 개인키를 로딩한다.
rsa_pr = k2rsa.read_key('key.skr')
# print 'skr : ', rsa_pr
if not (rsa_pr and rsa_pu): # 키 파일을 찾을 수 없다
if debug:
print 'ERROR : Canot find the Key files!'
return False
# -----------------------------------------------------------------
# KMD 파일을 생성한다.
# -----------------------------------------------------------------
# 헤더 : 시그너처(KAVM)+예약영역 : [[KAVM][[날짜][시간]...]
# -----------------------------------------------------------------
# 시그너처(KAVM)을 추가한다.
kmd_data = 'KAVM'
# 현재 날짜와 시간을 구한다.
ret_date = k2timelib.get_now_date()
ret_time = k2timelib.get_now_time()
# 날짜와 시간 값을 2Byte로 변경한다.
val_date = struct.pack('<H', ret_date)
val_time = struct.pack('<H', ret_time)
reserved_buf = val_date + val_time + (chr(0) * 28) # 예약 영역
# 날짜/시간 값이 포함된 예약 영역을 만들어 추가한다.
kmd_data += reserved_buf
# -----------------------------------------------------------------
# 본문 : [[개인키로 암호화한 RC4 키][RC4로 암호화한 파일]]
# -----------------------------------------------------------------
random.seed()
while 1:
tmp_kmd_data = '' # 임시 본문 데이터
# RC4 알고리즘에 사용할 128bit 랜덤키 생성
key = ''
for i in range(16):
key += chr(random.randint(0, 0xff))
# 생성된 RC4 키를 암호화한다.
e_key = k2rsa.crypt(key, rsa_pr) # 개인키로 암호화
if len(e_key) != 32: # 암호화에 오류가 존재하면 다시 생성
continue
# 암호화된 RC4 키를 복호화한다.
d_key = k2rsa.crypt(e_key, rsa_pu) # 공개키로 복호화
# 생성된 RC4 키에 문제 없음을 확인한다.
if key == d_key and len(key) == len(d_key):
# 개인키로 암호화 된 RC4 키를 임시 버퍼에 추가한다.
tmp_kmd_data += e_key
# 생성된 pyc 파일 압축하기
buf1 = open(pyc_name, 'rb').read()
buf2 = zlib.compress(buf1)
e_rc4 = k2rc4.RC4() # RC4 알고리즘 사용
e_rc4.set_key(key) # RC4 알고리즘에 key를 적용한다.
# 압축된 pyc 파일 이미지를 RC4로 암호화한다.
buf3 = e_rc4.crypt(buf2)
e_rc4 = k2rc4.RC4() # RC4 알고리즘 사용
e_rc4.set_key(key) # RC4 알고리즘에 key를 적용한다.
# 암호화한 압축된 pyc 파일 이미지 복호화하여 결과가 같은지를 확인한다.
if e_rc4.crypt(buf3) != buf2:
continue
# 개인키로 암호화 한 압축 된 파일 이미지를 임시 버퍼에 추가한다.
tmp_kmd_data += buf3
# ---------------------------------------------------------
# 꼬리 : [개인키로 암호화한 MD5x3]
# ---------------------------------------------------------
# 헤더와 본문에 대해 MD5를 3번 연속 구한다.
md5 = hashlib.md5()
md5hash = kmd_data + tmp_kmd_data # 헤더와 본문을 합쳐서 MD5 계산
for i in range(3):
md5.update(md5hash)
md5hash = md5.hexdigest()
m = md5hash.decode('hex')
e_md5 = k2rsa.crypt(m, rsa_pr) # MD5 결과를 개인키로 암호화
if len(e_md5) != 32: # 암호화에 오류가 존재하면 다시 생성
continue
d_md5 = k2rsa.crypt(e_md5, rsa_pu) # 암호화횓 MD5를 공개키로 복호화
if m == d_md5: # 원문과 복호화 결과가 같은가?
# 헤더, 본문, 꼬리를 모두 합친다.
kmd_data += tmp_kmd_data + e_md5
break # 무한 루프를 종료한다.
# -----------------------------------------------------------------
# KMD 파일을 생성한다.
# -----------------------------------------------------------------
# KMD 파일 이름을 만든다.
ext = fname.find('.')
kmd_name = fname[0:ext] + '.kmd'
try:
if kmd_data:
# KMD 파일을 생성한다.
open(kmd_name, 'wb').write(kmd_data)
# pyc 파일은 삭제한다.
os.remove(pyc_name)
if debug:
print ' Success : %-13s -> %s' % (fname, kmd_name)
return True
else:
raise IOError
except IOError:
if debug:
print ' Fail : %s' % fname
return False
def make(src_fname, debug=False):
# -----------------------------------------------------------------
# 암호화 대상 파일을 컴파일 또는 복사해서 준비한다.
# -----------------------------------------------------------------
fname = src_fname # 암호화 대상 파일
if fname.split('.')[1] == 'py': # 파이썬 파일을 컴파일 한다.
py_compile.compile(fname) # 컴파일
pyc_name = fname + 'c' # 컴파일 이후 파일명
else: # 파이썬 파일이 아닐 경우 확장자를 pyc로 하여 복사한다.
pyc_name = fname.split('.')[0] + '.pyc'
shutil.copy(fname, pyc_name)
# -----------------------------------------------------------------
# Simple RSA를 사용하기 위해 공개키와 개인키를 로딩한다.
# -----------------------------------------------------------------
# 공개키를 로딩한다.
rsa_pu = k2rsa.read_key('key.pkr')
# print 'pkr : ', rsa_pu
# 개인키를 로딩한다.
rsa_pr = k2rsa.read_key('key.skr')
# print 'skr : ', rsa_pr
if not (rsa_pr and rsa_pu): # 키 파일을 찾을 수 없다
if debug:
print 'ERROR : Canot find the Key files!'
return False
# -----------------------------------------------------------------
# KMD 파일을 생성한다.
# -----------------------------------------------------------------
# 헤더 : 시그너처(KAVM)+예약영역 : [[KAVM][[날짜][시간]...]
# -----------------------------------------------------------------
# 시그너처(KAVM)을 추가한다.
kmd_data = 'KAVM'
# 현재 날짜와 시간을 구한다.
ret_date = k2timelib.get_now_date()
ret_time = k2timelib.get_now_time()
# 날짜와 시간 값을 2Byte로 변경한다.
val_date = struct.pack('<H', ret_date)
val_time = struct.pack('<H', ret_time)
reserved_buf = val_date + val_time + (chr(0) * 28) # 예약 영역
# 날짜/시간 값이 포함된 예약 영역을 만들어 추가한다.
kmd_data += reserved_buf
# -----------------------------------------------------------------
# 본문 : [[개인키로 암호화한 RC4 키][RC4로 암호화한 파일]]
# -----------------------------------------------------------------
random.seed()
while 1:
tmp_kmd_data = '' # 임시 본문 데이터
# RC4 알고리즘에 사용할 128bit 랜덤키 생성
key = ''
for i in range(16):
key += chr(random.randint(0, 0xff))
# 생성된 RC4 키를 암호화한다.
e_key = k2rsa.crypt(key, rsa_pr) # 개인키로 암호화
if len(e_key) != 32: # 암호화에 오류가 존재하면 다시 생성
continue
# 암호화된 RC4 키를 복호화한다.
d_key = k2rsa.crypt(e_key, rsa_pu) # 공개키로 복호화
# 생성된 RC4 키에 문제 없음을 확인한다.
if key == d_key and len(key) == len(d_key):
# 개인키로 암호화 된 RC4 키를 임시 버퍼에 추가한다.
tmp_kmd_data += e_key
# 생성된 pyc 파일 압축하기
buf1 = open(pyc_name, 'rb').read()
buf2 = zlib.compress(buf1)
e_rc4 = k2rc4.RC4() # RC4 알고리즘 사용
e_rc4.set_key(key) # RC4 알고리즘에 key를 적용한다.
# 압축된 pyc 파일 이미지를 RC4로 암호화한다.
buf3 = e_rc4.crypt(buf2)
e_rc4 = k2rc4.RC4() # RC4 알고리즘 사용
e_rc4.set_key(key) # RC4 알고리즘에 key를 적용한다.
# 암호화한 압축된 pyc 파일 이미지 복호화하여 결과가 같은지를 확인한다.
if e_rc4.crypt(buf3) != buf2:
continue
# 개인키로 암호화 한 압축 된 파일 이미지를 임시 버퍼에 추가한다.
tmp_kmd_data += buf3
# ---------------------------------------------------------
# 꼬리 : [개인키로 암호화한 MD5x3]
# ---------------------------------------------------------
# 헤더와 본문에 대해 MD5를 3번 연속 구한다.
md5 = hashlib.md5()
md5hash = kmd_data + tmp_kmd_data # 헤더와 본문을 합쳐서 MD5 계산
for i in range(3):
md5.update(md5hash)
md5hash = md5.hexdigest()
m = md5hash.decode('hex')
e_md5 = k2rsa.crypt(m, rsa_pr) # MD5 결과를 개인키로 암호화
if len(e_md5) != 32: # 암호화에 오류가 존재하면 다시 생성
continue
d_md5 = k2rsa.crypt(e_md5, rsa_pu) # 암호화횓 MD5를 공개키로 복호화
if m == d_md5: # 원문과 복호화 결과가 같은가?
# 헤더, 본문, 꼬리를 모두 합친다.
kmd_data += tmp_kmd_data + e_md5
break # 무한 루프를 종료한다.
# -----------------------------------------------------------------
# KMD 파일을 생성한다.
# -----------------------------------------------------------------
# KMD 파일 이름을 만든다.
ext = fname.find('.')
kmd_name = fname[0:ext] + '.kmd'
try:
if kmd_data:
# KMD 파일을 생성한다.
open(kmd_name, 'wb').write(kmd_data)
# pyc 파일은 삭제한다.
os.remove(pyc_name)
if debug:
print ' Success : %-13s -> %s' % (fname, kmd_name)
return True
else:
raise IOError
except IOError:
if debug:
print ' Fail : %s' % fname
return False
def make(src_fname, debug=False):
# 암호화 대상 파일을 컴파일 또는 복사하여 준비
fname = src_fname
if fname.split('.')[1] == 'py':
py_compile.compile(fname)
pyc_name = fname+'c'
else:
pyc_name = fname.split('.')[0]+'.pyc'
shutil.copy(fname, pyc_name)
#RSA 사용
#에러남.
rsa_pu = k2rsa.read_key('key.pkr')
print("pkr : ", rsa_pu)
rsa_pr = k2rsa.read_key('key.skr')
print("skr : ", rsa_pr)
if not (rsa_pr and rsa_pu):
if debug :
print("ERROR : no Key files")
return False
# KMD 파일 생성 (암호화 파일)
### 헤더 부분
#원래는 KSAIV 로 하려고했으나 에러때문에 KSIV 로 대체함.
kmd_data= 'KSIV' # 우리팀 확장자 ㅎㅎ. 시그니처 원래 KSAIV
# 현재 날짜와 시간 구함
ret_date = k2timelib.get_now_date()
ret_time = k2timelib.get_now_time()
#에러..체크
print(ret_date)
print(ret_time)
# 날짜와 시간 값을 2Byte로 변경.
val_date = struct.pack('<H', ret_date)
val_time = struct.pack('<H', ret_time)
print(val_date)
print(val_time)
#에러난다.
#reserved_buf = val_date + val_time + (chr(0) * 28) 에러코
reserved_buf = str(val_date) + str(val_time) + (chr(0) * 28) ## 예약 버퍼 잡기
kmd_data += reserved_buf
### 바디 부분
random.seed()
while 1:
tmp_kmd_data = ''
# RC4 알고리즘에 사용할 128bit 랜덤 키 생성
key = ''
for i in range(16):
key += chr(random.randint(0, 0xff))
print(key)
#개인키로 암호화
e_key = k2rsa.crypt(key, rsa_pr)
#e_key = k2rc4.RC4.crypt(key, rsa_pr)
if len(e_key) != 32:
continue
#복호화
d_key = k2rsa.crypt(e_key, rsa_pu)
#d_key = k2rc4.RC4.crypt(e_key, rsa_pu)
if key == d_key and len(key) == len(d_key):
tmp_kmd_data += e_key
buf1 = open(pyc_name, 'rb').read()
buf2 = zlib.compress(buf1)
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
buf3 = e_rc4.crypt(buf2)
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
if e_rc4.crypt(buf3) != buf2:
continue
tmp_kmd_data += buf3
### 꼬리 부분 : 개인키로 암호화한 MD5x3
md5 = hashlib.md5()
md5hash = kmd_data + tmp_kmd_data
for i in range(3):
md5.update(md5hash)
md5hash = md5.hexdigest()
m = md5hash.decode('hex')
e_md5 = k2rsa.crypt(m, rsa_pr)
if len(e_md5) != 32:
continue
d_md5 = k2rsa.crypt(e_md5, rsa_pu)
if m == d_md5:
kmd_data += tmp_kmd_data + e_md5
break
# kmd 파일 생성
ext = fname.find(',')
kmd_name = fname[0:ext] + '.kmd'
try:
if kmd_data:
open(kmd_name, 'wb').write(kmd_data)
os.remove(pyc_name)
if debug:
print(" Success : %-13s -> %s " % (fname, kmd_name))
return True
else:
raise IOError
except IOError:
if debug:
print(" Fail : %s" % fname)
return False
def set_plugins(self, plugins_path, callback_fn=None):
# 플러그인 경로를 저장한다.
self.plugins_path = plugins_path
# 우선순위를 알아낸다.
if k2const.K2DEBUG:
pu = None
ret = self.__get_kmd_list(os.path.join(plugins_path, 'kicom.lst'), pu)
else:
# 공개키를 로딩한다.
pu = k2rsa.read_key(os.path.join(plugins_path, 'key.pkr'))
if not pu:
return False
ret = self.__get_kmd_list(os.path.join(plugins_path, 'kicom.kmd'), pu)
if not ret: # 로딩할 KMD 파일이 없다.
return False
if self.verbose:
print '[*] kicom.%s :' % ('lst' if k2const.K2DEBUG else 'kmd')
print ' ', self.kmdfiles
# 우선순위대로 KMD 파일을 로딩한다.
for kmd_name in self.kmdfiles:
kmd_path = os.path.join(plugins_path, kmd_name)
try:
name = kmd_name.split('.')[0]
if k2const.K2DEBUG:
k = None
module = imp.load_source(name, os.path.splitext(kmd_path)[0] + '.py')
try:
os.remove(os.path.splitext(kmd_path)[0] + '.pyc')
except OSError:
pass
else:
k = k2kmdfile.KMD(kmd_path, pu) # 모든 KMD 파일을 복호화한다.
data = k.body
module = k2kmdfile.load(name, data)
if module: # 메모리 로딩 성공
self.kmd_modules.append(module)
# 메모리 로딩에 성공한 KMD에서 플러그 엔진의 시간 값 읽기
# 최신 업데이트 날짜가 된다.
self.__get_last_kmd_build_time(k)
else: # 메모리 로딩 실패
if isinstance(callback_fn, types.FunctionType):
callback_fn(name)
except IOError:
pass
except k2kmdfile.KMDFormatError: # 다른키로 암호호화 한 엔진은 무시
pass
# 악성코드 패턴에서 최신 시간 값을 얻는다.
fl = glob.glob(os.path.join(plugins_path, '*.n??'))
for fname in fl:
try:
buf = open(fname, 'rb').read(12)
if buf[0:4] == 'KAVS':
sdate = k2timelib.convert_date(struct.unpack('<H', buf[8:10])[0])
stime = k2timelib.convert_time(struct.unpack('<H', buf[10:12])[0])
t_datetime = datetime.datetime(sdate[0], sdate[1], sdate[2], stime[0], stime[1], stime[2])
if self.max_datetime < t_datetime:
self.max_datetime = t_datetime
except IOError:
pass
if self.verbose:
print '[*] kmd_modules :'
print ' ', self.kmd_modules
print '[*] Last updated %s UTC' % self.max_datetime.ctime()
return True
# -*- coding:utf-8 -*-
# Author: ColorLion
import k2rsa
import k2kmdfile
pu = k2rsa.read_key('key.pkr') # 복호화 할 공개키를 로딩
k = k2kmdfile.KMD('dummy.kmd', pu) # dummy.kmd 파일 읽기
# k.body에 dummy.kmd의 파이썬 코드가 복호화
module = k2kmdfile.load('dummy', k.body)
print dir(module)
def set_plugins(self, plugins_path, callback_fn=None):
# 플러그인 경로를 저장한다.
self.plugins_path = plugins_path
# 우선순위를 알아낸다.
if k2const.K2DEBUG:
pu = None
ret = self.__get_kmd_list(os.path.join(plugins_path, 'kicom.lst'), pu)
else:
# 공개키를 로딩한다.
pu = k2rsa.read_key(os.path.join(plugins_path, 'key.pkr'))
if not pu:
return False
ret = self.__get_kmd_list(os.path.join(plugins_path, 'kicom.kmd'), pu)
if not ret: # 로딩할 KMD 파일이 없다.
return False
if self.verbose:
print '[*] kicom.%s :' % ('lst' if k2const.K2DEBUG else 'kmd')
print ' ', self.kmdfiles
# 우선순위대로 KMD 파일을 로딩한다.
for kmd_name in self.kmdfiles:
kmd_path = os.path.join(plugins_path, kmd_name)
try:
name = kmd_name.split('.')[0]
if k2const.K2DEBUG:
k = None
module = imp.load_source(name, os.path.splitext(kmd_path)[0] + '.py')
try:
os.remove(os.path.splitext(kmd_path)[0] + '.pyc')
except OSError:
pass
else:
k = k2kmdfile.KMD(kmd_path, pu) # 모든 KMD 파일을 복호화한다.
data = k.body
module = k2kmdfile.load(name, data)
if module: # 메모리 로딩 성공
self.kmd_modules.append(module)
# 메모리 로딩에 성공한 KMD에서 플러그 엔진의 시간 값 읽기
# 최신 업데이트 날짜가 된다.
self.__get_last_kmd_build_time(k)
else: # 메모리 로딩 실패
if isinstance(callback_fn, types.FunctionType):
callback_fn(name)
except IOError:
pass
except k2kmdfile.KMDFormatError: # 다른키로 암호호화 한 엔진은 무시
pass
# 악성코드 패턴에서 최신 시간 값을 얻는다.
fl = glob.glob(os.path.join(plugins_path, '*.n??'))
for fname in fl:
try:
buf = open(fname, 'rb').read(12)
if buf[0:4] == 'KAVS':
sdate = k2timelib.convert_date(struct.unpack('<H', buf[8:10])[0])
stime = k2timelib.convert_time(struct.unpack('<H', buf[10:12])[0])
t_datetime = datetime.datetime(sdate[0], sdate[1], sdate[2], stime[0], stime[1], stime[2])
if self.max_datetime < t_datetime:
self.max_datetime = t_datetime
except IOError:
pass
if self.verbose:
print '[*] kmd_modules :'
print ' ', self.kmd_modules
print '[*] Last updated %s UTC' % self.max_datetime.ctime()
return True
def make(src_fname, debug=False):
#
# 암호화 대상 파일 컴파일/준비
#
fname = src_fname
if fname.split('.')[1] == 'py':
py_compile.compile(fname)
pyc_name = fname+'c'
else:
pyc_name = fname.split('.')[0]+'.pyc'
shutil.copy(fname, pyc_name)
# -----
# simple rsa를 사용하기 위해 공개키/개인키 로드.
# -----
# 공개키 로드
rsa_pu = k2rsa.read_key('key.pkr')
# print 'pkr: ', rsa_pu
rsa_pr = k2rsa.read_key('key.skr')
# print 'skr: ', rsa_pr
if not (rsa_pr and rsa_pu):
if debug:
print 'ERROR: cannot find key files'
return False
# -----
# kmd 파일 생성.
# -----
kmd_data = 'KAVM'
# 현재 날짜와 시간을 구함
ret_date = k2timelib.get_now_date()
ret_time = k2timelib.get_now_time()
# 날짜와 시간 값을 2bytes로 변경
val_date = struct.pack('<H', ret_date)
val_time = struct.pack('<H', ret_time)
reserved_buf = val_date + val_time + (chr(0) * 28) # 예약 영역 설정.
kmd_data += reserved_buf
# -----
# 본문 내용...
# [[개인키로 암호화한 RC4 키][RC4로 암호화한 파일]]
# -----
random.seed()
while 1:
tmp_kmd_data = '' # 임시 본문 데이터
# 랜덤키 생성
key = ''
for i in range(16):
key += chr(random.randint(0, 0xFF))
e_key = k2rsa.crypt(key, rsa_pr) # 개인키로 암호화
if len(e_key) != 32:
continue
d_key = k2rsa.crypt(e_key, rsa_pu) # 공개키로 복호화
# RC4키에 문제없는지 확인.
if key == d_key and len(key) == len(d_key):
tmp_kmd_data += e_key
buf1 = open(pyc_name, 'rb').read()
buf2 = zlib.compress(buf1)
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
buf3 = e_rc4.crypt(buf2)
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
if e_rc4.crypt(buf3) != buf2:
continue
tmp_kmd_data += buf3
# -----
# 꼬리 내용...
# [개인키로 암호화한 md5 * 3]
# -----
md5 = hashlib.md5()
md5hash = kmd_data + tmp_kmd_data # 헤더+본문으로 md5 계산
for i in range(3):
md5.update(md5hash)
md5hash = md5.hexdigest()
m = md5hash.decode('hex')
e_md5 = k2rsa.crypt(m, rsa_pr) # md5 결과를 개인키로 암호화
if len(e_md5) != 32:
continue
d_md5 = k2rsa.crypt(e_md5, rsa_pu)
if m == d_md5:
kmd_data += tmp_kmd_data + e_md5
break
# -----
# kmd 파일 생성.
# -----
ext = fname.find('.')
kmd_name = fname[0:ext] + '.kmd'
try:
if kmd_data:
open(kmd_name, 'wb').write(kmd_data)
os.remove(pyc_name)
if debug:
print '[o] success: %-13s -> %s' % (fname, kmd_name)
return True
else:
raise IOError
except IOError:
if debug:
print '[x] fail: %s' % fname
return False
def make(src_fname, debug=False):
fname = src_fname
fname = fname.replace('.\\', '')
if fname.split('.')[-1] == 'py':
pyc_name = fname + 'c'
py_compile.compile(fname, pyc_name)
else:
pyc_name = fname.split('.')[0] + '.pyc'
shutil.copy(fname, pyc_name)
rsa_pu = k2rsa.read_key('key.pkr') # public key
rsa_pr = k2rsa.read_key('key.skr') # private key
if not (rsa_pr and rsa_pu):
if debug:
print('Error: Cannot find the key files.')
return False
# Header
kmd_data = b'KAVM'
ret_date = k2timelib.get_now_date()
ret_time = k2timelib.get_now_time()
val_date = struct.pack('<H', ret_date)
val_time = struct.pack('<H', ret_time)
reserved_buf = val_date + val_time + bytes(28)
kmd_data += reserved_buf
random.seed()
# Body
while 1:
tmp_kmd_data = b''
key = b'' # RC4 algorithm
for i in range(16):
key += bytes([random.randint(0, 0xff)])
e_key = k2rsa.crypt(key, rsa_pr) # RC4 key encrypt using prviate key
if len(e_key) != 32:
print('key encrypt error')
continue
d_key = k2rsa.crypt(e_key, rsa_pu)
# validate key
if key == d_key and len(key) == len(d_key):
tmp_kmd_data += e_key
buf1 = open(pyc_name, 'rb').read()
buf2 = zlib.compress(buf1)
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
buf3 = e_rc4.crypt(buf2) # encrypt image using RC4 algorithm
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
if e_rc4.crypt(buf3) != buf2:
print('image encrypt error')
continue
tmp_kmd_data += buf3
# trailer
md5 = hashlib.md5()
md5hash = kmd_data + tmp_kmd_data
for i in range(3):
md5.update(md5hash)
md5hash = md5.hexdigest().encode('utf-8')
m = md5hash
e_md5 = k2rsa.crypt(m, rsa_pr) # encrypt md5 using private key
if len(e_md5) != 32:
print('e_md5 encrypt error')
continue
d_md5 = k2rsa.crypt(
e_md5, rsa_pu) # decrypt encrypted md5 using public key
if m == d_md5:
kmd_data += tmp_kmd_data + e_md5
break
# make KMD file
ext = fname.find('.')
kmd_name = fname[0:ext] + '.kmd'
try:
if kmd_data:
open(kmd_name, 'wb').write(kmd_data)
os.remove(pyc_name)
if debug:
print('Success: {0:>13s} -> {1:<s}'.format(fname, kmd_name))
return True
else:
raise IOError
except IOError:
if debug:
print('Fail: {}'.format(fname))
return False
def make(src_fname, debug=False):
fname = src_fname
if fname.split('.')[1] == 'py':
py_compile.compile(fname)
pyc_name = fname+'c'
else:
pyc_name = fname.split('.')[0]+'.pyc'
shutil.copy(fname, pyc_name)
rsa_pu = k2rsa.read_key('key.pkr')
rsa_pr = k2rsa.read_key('key.skr')
if not (rsa_pr and rsa_pu):
if debug:
print 'ERROR : Canot find the Key files!'
return False
kmd_data = 'KAVM'
ret_date = k2timelib.get_now_date()
ret_time = k2timelib.get_now_time()
val_date = struct.pack('<H', ret_date)
val_time = struct.pack('<H', ret_time)
reserved_buf = val_date + val_time + (chr(0) * 28)
kmd_data += reserved_buf
random.seed()
while 1:
tmp_kmd_data = ''
key = ''
for i in range(16):
key += chr(random.randint(0, 0xff))
e_key = k2rsa.crypt(key, rsa_pr)
if len(e_key) != 32:
continue
d_key = k2rsa.crypt(e_key, rsa_pu)
if key == d_key and len(key) == len(d_key):
tmp_kmd_data += e_key
buf1 = open(pyc_name, 'rb').read()
buf2 = zlib.compress(buf1)
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
buf3 = e_rc4.crypt(buf2)
e_rc4 = k2rc4.RC4()
e_rc4.set_key(key)
if e_rc4.crypt(buf3) != buf2:
continue
tmp_kmd_data += buf3
md5 = hashlib.md5()
md5hash = kmd_data + tmp_kmd_data
for i in range(3):
md5.update(md5hash)
md5hash = md5.hexdigest()
m = md5hash.decode('hex')
e_md5 = k2rsa.crypt(m, rsa_pr)
if len(e_md5) != 32: #
continue
d_md5 = k2rsa.crypt(e_md5, rsa_pu)
if m == d_md5:
kmd_data += tmp_kmd_data + e_md5
break
ext = fname.find('.')
kmd_name = fname[0:ext] + '.kmd'
try:
if kmd_data:
open(kmd_name, 'wb').write(kmd_data)
os.remove(pyc_name)
if debug:
print ' Success : %-13s -> %s' % (fname, kmd_name)
return True
else:
raise IOError
except IOError:
if debug:
print ' Fail : %s' % fname
return False
