コード例 #1
0
ファイル: sigtool_md5.py プロジェクト: hanul93/kicomav
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)
コード例 #2
0
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)
コード例 #3
0
ファイル: sigtool_yar.py プロジェクト: hanul93/kicomav
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)
コード例 #4
0
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)
コード例 #5
0
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)
コード例 #6
0
ファイル: k2kmdfile.py プロジェクト: hanul93/kicomav
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
コード例 #7
0
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
コード例 #8
0
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
コード例 #9
0
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
コード例 #10
0
ファイル: k2kmdfile.py プロジェクト: kth93/antivirusproject
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
コード例 #11
0
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