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 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