def save_signature(fname, _id):
# 현재 날짜와 시간을 구한다.
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)
# 크기 파일 저장 : ex) script.s01
sname = '%s.s%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(set(size_sig))) # 중복된 데이터 삭제 후 저장
t = 'KAVS' + struct.pack('<L', len(size_sig)) + val_date + val_time + t
save_file(sname, t)
# 패턴 p1 파일 저장 : ex) script.i01
sname = '%s.i%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(p1_sig))
t = 'KAVS' + struct.pack('<L', len(p1_sig)) + val_date + val_time + t
save_file(sname, t)
# 패턴 p2 파일 저장 : ex) script.c01
sname = '%s.c%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(p2_sig))
t = 'KAVS' + struct.pack('<L', len(p2_sig)) + val_date + val_time + t
save_file(sname, t)
# 악성코드 이름 파일 저장 : ex) script.n01
sname = '%s.n%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(name_sig))
t = 'KAVS' + struct.pack('<L', len(name_sig)) + val_date + val_time + t
save_file(sname, t)
def save_signature(fname, _id):
# 현재 날짜와 시간을 구한다.
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)
# 크기 파일 저장 : ex) script.s01
sname = '%s.s%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(size_sig))
t = 'KAVS' + struct.pack('<L', len(size_sig)) + val_date + val_time + t
save_file(sname, t)
# 패턴 p1 파일 저장 : ex) script.i01
sname = '%s.i%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(p1_sig))
t = 'KAVS' + struct.pack('<L', len(p1_sig)) + val_date + val_time + t
save_file(sname, t)
# 패턴 p2 파일 저장 : ex) script.c01
sname = '%s.c%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(p2_sig))
t = 'KAVS' + struct.pack('<L', len(p2_sig)) + val_date + val_time + t
save_file(sname, t)
# 악성코드 이름 파일 저장 : ex) script.n01
sname = '%s.n%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(name_sig))
t = 'KAVS' + struct.pack('<L', len(name_sig)) + val_date + val_time + t
save_file(sname, t)
def make_signature(fname):
p_rule = re.compile(re_rule)
buf = open(fname, 'rb').read()
sig_num = len(p_rule.findall(buf))
c = yara.compile(fname)
c.save(fname + '.yc')
buf = open(fname + '.yc', 'rb').read()
os.remove(fname + '.yc')
# 현재 날짜와 시간을 구한다.
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)
# 크기 파일 저장 : ex) script.a01
name = os.path.splitext(fname)[0]
sname = '%s.y01' % name
t = zlib.compress(buf)
t = 'KAVS' + struct.pack('<L', sig_num) + val_date + val_time + t
save_file(sname, t)
def save_signature(fname, _id):
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)
sname = '%s.s%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(set(size_sig)))
t = 'KAVS' + struct.pack('<L', len(size_sig)) + val_date + val_time + t
save_file(sname, t)
sname = '%s.i%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(p1_sig))
t = 'KAVS' + struct.pack('<L', len(p1_sig)) + val_date + val_time + t
save_file(sname, t)
sname = '%s.c%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(p2_sig))
t = 'KAVS' + struct.pack('<L', len(p2_sig)) + val_date + val_time + t
save_file(sname, t)
sname = '%s.n%02d' % (fname, _id)
t = zlib.compress(marshal.dumps(name_sig))
t = 'KAVS' + struct.pack('<L', len(name_sig)) + val_date + val_time + t
save_file(sname, t)
def make_signature(fname):
p_rule = re.compile(re_rule)
buf = open(fname, 'rb').read()
sig_num = len(p_rule.findall(buf))
c = yara.compile(fname)
c.save(fname + '.yc')
buf = open(fname + '.yc', 'rb').read()
os.remove(fname + '.yc')
# 현재 날짜와 시간을 구한다.
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)
# 크기 파일 저장 : ex) script.a01
name = os.path.splitext(fname)[0]
sname = '%s.y01' % name
t = zlib.compress(buf)
t = 'KAVS' + struct.pack('<L', sig_num) + val_date + val_time + t
save_file(sname, t)
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 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