KR20120094481A

KR20120094481A - 동적 함수 호출 시스템들에서 공격적인 자기-수정을 위한 시스템 및 방법

Info

Publication number: KR20120094481A
Application number: KR1020127011874A
Authority: KR
Inventors: 클리포드 리엠
Original assignee: 어데토 캐나다 코포레이션
Priority date: 2009-10-08
Filing date: 2009-10-08
Publication date: 2012-08-24
Also published as: JP2013507670A; CA2776913A1; EP2486482A4; US20120284792A1; CA2776913C; CN102713839A; WO2011041871A1; KR101719635B1; EP2486482A1; US9195476B2; JP5458184B2; EP2486482B1; CN102713839B

Abstract

본 발명의 실시예들은 제1 형태에서 정적 및 동적 공격들에 저항력이 있는 보다 안전한 형태로 프로그램을 변형하는 소프트웨어 모호화(software obfuscation)를 위한 시스템 및 방법을 제공한다. 일 실시예에 따른 방법은, 프로그램을 변경하기 위하여 프로그램 내의 전략적 포인트들을 결정하도록, 프로그램의 함수-호출 구조, 함수-호출 레이아웃, 및 전체적인 함수 호출 그래프를 이해하는 정교한 전-분석(pre-analysis) 단계를 활용한다. 일 실시예에 따른 방법은 원본 함수-호출 레이아웃을 새로운 레이아웃으로 변형함으로써 정적 공격들에 대한 저항력을 제공한다. 일 실시예에서, 레이아웃을 변경하는 것은 함수 경계들을 변경하는 것을 포함할 수 있다. 일 실시예에 따른 방법은 일 실시예에 따른 방법은 또한 원본 함수-호출 구조를 변형된 프로그램이 메모리에서 실행될 때 자기 보정이 가능한 새로운 구조로 변형함으로써 정적 공격들에 대한 저항력을 제공한다. 일 실시예에서, 함수-호출 구조를 변경하는 것은 언제 및 어떻게 함수들이 호출되는 지를 수정하는 것, 및/또는 동일한 결과를 가져오는 랜덤 실행 경로를 선택하는 것을 포함할 수 있다. 변형된 프로그램은 원본 프로그램과 의미론적으로(semantically) 동등하나, 정적 및 동적 공격들에 보다 저항력이 있다.

Description

동적 함수 호출 시스템들에서 공격적인 자기-수정을 위한 시스템 및 방법{A SYSTEM AND METHOD FOR AGGRESSIVE SELF-MODIFICATION IN DYNAMIC FUNCTION CALL SYSTEMS}

본 발명은 일반적으로 컴퓨터 보안 분야에 관한 것이다. 특히, 본 발명은 함수 호출 시스템들의 제어-흐름 모호화(control-flow obfuscation)를 위한 방법 및 시스템에 관한 것이다.

모호화(obfuscation)는 소프트웨어 코드의 역-엔지니어링(reverse engineering), 복제 또는 부정조작(tampering)(이하, 부정조작)을 방지 또는 지연시키는 변형(transformation)을 의미한다. 많은 경우들에서, 특히 완료되는 데에 보통 수 초만이 소요되는 금융 거래를 보호하는 소프트웨어에서는, 소프트웨어 코드의 상기 부정조작을 지연시키는 것으로 충분하다. 저작권(copyright)으로 보호되는 자료들의 경우에는, 상기 부정조작 처리를 수행하는 것이 소프트웨어의 정식 사본의 비용보다 높은 비용이 들도록 상기 부정조작 처리에 긴 시간이 소요되도록 하는 모호화가 수행될 수 있다.

소프트웨어 부정조작은 정적 공격들 및 동적 공격들의 크게 두 종류의 공격들을 포함한다. 정적 공격들은 소프트웨어를 구동시키지 않고, 예를 들어 부분 평가기(partial evaluator)를 이용하여 상기 소프트웨어를 정적으로 분석하는 것을 수반한다. 동적 공격들은 코드가 메모리에서 실행될 때 상기 코드를 모니터링 및 리프팅(lifting)(또는 복사)하여 리프팅된 부분들을 획득하고 상기 코드를 재구성할 수 있다.

동적 공격들에서, 함수 호출들(function calls), 호출부들(call sites), 및 진입(entry) 및 종료(exit) 포인트들은 프로그램의 제어-흐름을 분석하여 그것의 호출 그래프(call graph)를 검색하는 공격자(attacker)들의 전략적인 목표들이다.

현존하는 제어-흐름 모호화 방법들은 가지들(branches) 및 점프들(jumps)을 포함하는 로컬 제어-흐름에 우선적으로 적용된다. 이는 함수 범위(function scope)에 제한된다. 보다 큰 침투의 위험은 코드가 리프팅되거나(lifted) 재구현(re-implemented) 되도록 호출-구조(call-structure)를 알아내는 공격자의 능력에 있다. 종래의 호출 규약들(calling conventions)은 잘 알려져 있으므로, 함수 호출 경계들은 공격에 취약한 포인트가 될 수 있다.

현존하는 자기-수정 코드(self-modifying code) 기술들은 데이터 동작들을 수행하는 직선 명령어 블록들(straight-line instruction blocks)에 우선적으로 적용된다. 이는 동작들을 감추는 데에 도움이 될 수 있으나, 어플리케이션의 매크로 제어 레벨(macro control level)을 거의 숨기지 못한다.

C++와 같은 보다 높은 레벨의 추상 언어들이 널리 사용됨에 따라, 어플리케이션들은, 낮은 레벨 언어의 등가 어플리케이션들에 비하여, 보다 많은 함수들을 가지고, 보다 깊은 호출-트리들(call-trees)을 일반적으로 가진다. 이는 어플리케이션들의 함수 경계들이 현재 보다 큰 위험을 가짐을 의미한다.

예를 들어, 그 전체로서 참조로 여기에 포함되는 Eker 등의 국제 특허 공개 번호 제2008/074483호는 컴퓨터 프로그램을 모호화하는 방법을 개시하나, 코드 리프팅 공격들, 및 예를 들어 디버거(debugger)를 이용한 동적 및 단계 공격들을 해결하지 못한다.

국제 특허 공개 번호 제2008/074483호는 주소(address)가 계산되는 방식을 변경함으로써 함수 호출 시스템을 수정하는 방법을 개시한다. 수정된 함수 호출은 런-타임(run-time)에서 대수식(algebraic expression)에 의해 계산된다. 결과적으로, 함수의 주소가 런-타임에서 결정되는 포인터에 의한 호출(call-by-pointer) 방식의 함수 호출이 수행된다.

이러한 방법은 호출-그래프를 코드 리프팅 공격으로부터 보호할 수 없다. 예를 들어, 함수 정의 바디(function definition body)가 절대로 수정되지 않는다. 이는 용이하게 정적으로 리프트되어 다른 프로그램에 사용될 수 있다. 게다가, 디버거 또는 모니터링 프로그램이 사용되는 동적 공격에 의해, 함수 호출 시퀀스(function call sequence)가 코드 리프팅 및/또는 부정조작이 가능하도록 호출된 관심이 있는 함수를 찾기 위하여 단계적인 방식으로 모방될 수 있다.

게다가, 국제 특허 공개 번호 제2008/074483호는 정적 호출부들이 포인터에 의한 호출로 대체된다. 그럼에도 불구하고, 이들은 여전히 호출부들이다. 어떠한 호출부도 그것의 고유한 명령어 특징에 의해 확인됨으로써 공격자에게 유용한 정지 지점(break point)이 될 수 있다. 상기 공격자가 모든 호출부들에서 실행을 정지(break)하고, 그 후 프로그램을 구동하는 경우, 상기 공격자는 동적 수단들을 통하여 호출-그래프 정보를 획득할 수 있다.

그 전체로서 참조로 여기에 포함되는, 2007년 공개된 “프로그램 모호화를 통한 어플리케이션 보안(Application Security through Program Obfuscation)”이란 제목을 가지는, Matias Madou의 간행물은, 그것의 5 장에서, 데이터 동작들을 변경함으로써 명령어 레벨에서 발생하는 다수의 기술들을 조합하는 흔적 모호화(Trace Obfuscation) 방법을 개시한다. 이러한 기술들은 다양한 코드의 삽입, 코드 팩토링(code factoring) 및 모호화 서술어들(obfuscating predicates)의 삽입을 포함한다.

다양한 코드의 삽입은 명령어에 상기 명령어가 존재하는 기본 블록을 향하는 경로에 기초하여 다수의 동등한 명령어들 중 하나를 중복 기입(overwriting)하도록 사용된다.

코드 팩토링은 하나의 명령어만이 다른 두 개의 조건 코드 블록들을 병합하는 기술이다. 상기 병합된 코드 블록으로 진행하는 조건 경로들에서, 상기 단일한 명령어는 그것이 실행되기 직전에 정확한 동작을 제공하도록 중복 기입된다.

세 번째 기술은 다양성을 제공하도록 모호화 서술어들을 생성하는 것 및 이들을 코드에 삽입하는 것을 포함한다. 상기 서술어는 때로는 거짓으로 평가되고 때로는 진실로 평가되는 조건을 가진다. 상기 서술어에 의해 동등하나 다양한 코드가 제공될 수 있다.

Madou의 간행물은 상기 프로그램의 흔적 모호화를 수행하도록 상술한 세 개의 기술들을 모두 조합한다. 그러나, Madou에 의해 제안된 다양성 기술들은 데이터 명령어들의 수정에 제한된다. 상기 모호화 서술어들의 삽입은 그것의 동작들이 미리 결정된 가지들의 삽입만을 포함한다.

게다가, Madou의 시스템에서는, 함수들이 호출되고 실행되는 시퀀스(sequence), 순서(order), 시간(time) 및 방식(manner)이 동일하게 남아있다. 그러므로, Madou의 상기 방법에 의해 보호되는 소프트웨어에 대하여 동적 공격들이 여전히 성공적일 것이다.

또한, Madou의 방법은 정적 공격들에 대하여 상기 프로그램을 보호하지 않는다. 고립된(isolated) 함수들은 여전히 그것들 전체로서 리프팅될 수 있고, 리프팅된 후에 그것들의 본래의 방식으로 동작을 계속할 수 있다.

그러므로, 프로그램의 호출 그래프의 포괄적인 변형을 수행하여 정적 및 동적 공격들을 대비하여 제어 흐름 모호화를 수행하는 방법 및 시스템을 제공하는 것이 바람직하다.

본 발명의 목적은 정적 및 동적 공격들로부터 프로그램을 보호하도록 포괄적인 변형을 수반하는 보호 방법을 제공하는 것이다.

본 발명의 일 실시예에 따른 방법은 프로그램을 변형하기 위하여 원본 프로그램의 함수-호출 구조(function-call structure), 전체적인 함수 호출 그래프(function call graph) 및 함수-호출 레이아웃(function-call layout)의 세 개의 프로그램 특징들을 이해하기 위한 정교한 전-분석(pre-analysis) 단계를 포함한다. 일 실시예에서, 상기 프로그램의 변형은 빌드 타임(build time)에서 함수에 관련된 명령어들의 동적 삽입, 대체 및 수정의 통합(orchestration)을 포함하고, 이것에 의하여 상기 변형된 프로그램의 정적 분석(정적 공격)은 정확한(appropriate) 함수-호출 레이아웃을 나타내지 못하고, 따라서 메모리에서 실행될 때의 상기 프로그램의 동작을 나타내지 못한다. 빌드 타임에서 계획된 이러한 동적 변경들은 런-타임에서 실행된다. 이것에 의하여 상기 변형된 프로그램의 실행을 모니터링하는 동적 공격은 메모리에서 구동할 때 상기 변형된 프로그램의 정확한 함수 호출 그래프 또는 함수 호출 레이아웃을 결정하는 데에 성공할 수 없다.

일 측면에서, 본 발명은 프로그램을 정적 및 동적 공격들로부터 보호하도록 상기 프로그램의 제어 흐름 구조(control flow structure)를 변경함으로써 원본 형태에서 보다 안전한 형태로 소프트웨어 프로그램을 변형하는 방법을 제공한다. 상기 방법은 상기 프로그램의 원본 함수-호출 구조(function-call structure) 및 원본 함수-호출 레이아웃(function-call layout)을 분석하는 단계, 상기 원본 함수-호출 레이아웃을 새로운 함수-호출 레이아웃으로 변형하는 단계, 상기 원본 함수-호출 구조를 동적 자기 수정들(dynamic self modifications)을 수행할 수 있는 새로운 함수-호출 구조로 변형하는 단계, 및 변형된 제어 흐름 구조를 가지나 상기 프로그램의 원본과 의미론적으로(semantically) 동등하고, 실행 시 원본 함수-호출 그래프(function-call graph)를 새로운 함수-호출 그래프로 변형하는 변형된 프로그램을 생성하는 단계를 포함한다.

본문에서, 상기 용어 “의미론적으로 동등”하다는 것은 “동일한 결과들 또는 출력들을 생성하는 것”으로 해석되어야 한다.

일 실시예에서, 상기 동적 자기 수정들은 함수들이 호출되는 시간 및 방식을 변경할 수 있다. 상기 프로그램의 원본을 분석하고 변형하며, 상기 변형된 프로그램을 생성하는 단계들은 빌드 타임에 수행될 수 있고, 상기 원본 함수-호출 그래프를 상기 새로운 함수-호출 그래프로 변형하는 단계는 런-타임에 수행될 수 있다. 상기 원본 레이아웃 및 구조 또는 상기 프로그램을 변경하는 것은 상기 함수-호출 레이아웃을 위장하도록 함수 경계들을 변경하는 단계를 포함할 수 있다. 일 실시예에서, 상기 함수 경계들을 변경하는 단계는 상기 함수 경계들을 제거하는 단계 및 적어도 두 개의 함수들을 하나로 조합하는 단계를 포함할 수 있다. 다른 실시예에서, 상기 함수 경계들을 변경하는 단계는 하나의 함수를 적어도 두 개의 함수들로 분리하도록 새로운 함수 경계들을 삽입하는 단계를 포함할 수 있다.

상기 방법은 상기 프로그램에 대한 손상들을 수행하는 단계를 더 포함하고, 상기 손상들은, 상기 함수-호출 구조를 더욱 위장하고 상기 프로그램의 원본에 대한 기능적 동일성을 유지하기 위한 적어도 하나의 복구 손상(fix-up damage)이 뒤따르는 적어도 하나의 오류 손상(corruptive damage)을 포함할 수 있다.

일 실시예에서, 상기 원본 프로그램을 분석하는 것은 상기 프로그램의 수정 및/또는 상기 프로그램의 상기 함수-호출 구조, 상기 함수-호출 레이아웃 및 상기 전체적인 함수 호출 그래프의 이해를 위한 정교한 전-분석(pre-analysis) 단계의 수행을 위한 상기 프로그램 내의 전략적 포인트들을 결정하는 것을 포함한다. 수정 포인트들은 상응하는 실행 포인트들로부터 물리적 및 시간적으로 이격된 포인트에 배치될 수 있다. 일 실시예에서, 단일한 실행 포인트에 대하여 다중 수정 포인트들이 제공된다.

다른 측면에서, 본 발명은 프로그램을 정적 및 동적 공격들로부터 보호하도록 상기 프로그램의 제어 흐름 구조(control flow structure)를 변경함으로써 원본 형태에서 보다 안전한 형태로 소프트웨어 프로그램을 변형하는 방법을 제공한다. 상기 프로그램을 변형하는 방법은 빌드 타임 단계(build time phase)와 런-타임 단계(run-time phase)를 포함한다. 상기 빌드 타임 단계는, 상기 프로그램의 원본 함수-호출 구조(function-call structure) 및 원본 함수-호출 레이아웃(function-call layout)을 분석하는 단계, 상기 프로그램의 상기 원본 함수-호출 레이아웃을 새로운 함수-호출 레이아웃으로 변형하는 단계, 상기 원본 함수-호출 구조를 동적 수정들(dynamic modifications)을 수행할 수 있는 새로운 함수-호출 구조로 변형하는 단계, 및 변형된 제어 흐름 구조를 가지나 상기 프로그램의 원본과 의미론적으로(semantically)으로 동등한 변형된 프로그램을 생성하는 단계를 포함한다. 상기 런-타임 단계는 상기 프로그램의 실행 시 상기 프로그램의 상기 원본 함수-호출 그래프(function-call graph)를 새로운 함수-호출 그래프로 변형하는 단계를 포함하고, 런-타임에서 수행되는 상기 동적 수정들은, 상기 프로그램의 원본과 의미적으로 동등한 상기 변형된 프로그램을 생성하도록 빌드 타임에서 수행된 변경들에 상보적이다.

또 다른 측면에서, 본 발명은 프로그램을 정적 및 동적 공격들로부터 보호하도록 상기 프로그램의 제어 흐름 구조(control flow structure)를 변경함으로써 원본 형태에서 보다 안전한 형태로 소프트웨어 프로그램을 변형하기 위한 문장들(statements) 및 명령어들(instructions)이 기록된 컴퓨터로 판독 가능한 메모리를 제공한다. 상기 문장들 및 상기 명령어들은, 프로세서에 의해 수행될 때, 상기 프로세서가, 상기 프로그램의 원본 함수-호출 구조(function-call structure) 및 원본 함수-호출 레이아웃(function-call layout)를 분석하는 단계, 상기 원본 함수-호출 레이아웃을 새로운 레이아웃으로 변형하는 단계, 상기 원본 함수-호출 구조를 동적 자기 수정들을 수행할 수 있는 새로운 구조로 변형하는 단계, 및 변형된 제어 흐름 구조를 가지나 상기 프로그램의 원본과 의미론적으로(semantically) 동등하고, 실행 시 원본 함수-호출 그래프(function-call graph)를 새로운 함수-호출 그래프로 변형하는 변형된 프로그램을 생성하는 단계를 수행하도록 한다.

본 발명의 실시예들에 따른 프로그램 변형 방법 및 컴퓨터로 판독 가능한 메모리는 정적 및 동적 공격들로부터 프로그램을 보호할 수 있다.

본 발명 및 본 발명의 전술한 특징들은 첨부된 도면들을 참조하여 기재되는 다음의 상세한 설명을 통하여 가장 명확하게 이해될 것이다. 첨부된 도면들은 다음과 같다.
도 1은 원본 형태의 프로그램의 종래의 함수 레이아웃, 호출-그래프 및 함수 호출 시퀀스를 나타낸다.
도 2는 본 발명의 일 실시예에 따른 도 1에 도시된 상기 프로그램의 변형된 버전을 나타낸다.
도 3a는 도 2의 상기 변형된 프로그램의 런-타임 처리 및 동적 수정들을 나타낸다.
도 3b는 본 발명의 일 실시예에 따른 이미 실행된 명령어들에 대하여 상기 프로그램에 대한 손상들이 어떻게 생성되는지의 일 예를 나타낸다.
도 4는 도 1에 도시된 원본 프로그램의 호출 시퀀스에 대하여 도 2, 도 3a 및 도 3b에 도시된 변형된 프로그램의 동적 호출 시퀀스를 나타내는 흐름도이다.
도 5a 내지 도 5c는 본 발명의 일 실시예에 따른 메인 진입 함수 외에 다른 함수들을 가지지 않는 프로그램에 대한 동적 호출 시스템을 구현할 때의 런-타임 처리를 나타낸다.
도 6은 본 발명의 일 실시예에 따른 프로그램을 변형하는 단계들을 나타내는 순서도이다.
도 7은 종래의 시스템에서 실행되는 어프리케이션 프로그램을 빌드하도록 사용되는 종래의 툴들을 나타낸다.
도 8은 본 발명의 일 실시예에 따른 동적 함수 호출 시스템에서 사용되는 빌드 툴들의 일 예를 나타낸다.
도 9는 본 발명의 일 실시예에 따른 원본 프로그램을 정적 및 동적 공격들로부터 안전한 보호된 프로그램으로 변형하는 시스템의 예시적인 실시예를 나타낸다.
도 10a 내지 도 10c는 동적 함수 호출 시스템들에 대한 대안적인 동작 설정들을 나타낸다.

하기의 설명에서, 용어들, 함수-호출 그래프(function-call graph), 함수-호출 구조(function-call structure), 함수-호출 레이아웃(function-call layout) 및 제어 흐름 구조(control flow structure)는 다음과 같이 해석되어야 한다.

- 함수-호출 그래프(function-call graph)는 함수 아이디들(identifications)과 상기 프로그램이 메모리에서 구동할 때 실행을 위해 함수들이 호출된 방식(manner), 순서(order), 시간(time) 및 기간(duration)의 관계(relationship)를 나타낸다. 일반적으로, 함수-호출 그래프들은 해커들이 동적 공격들을 수행하도록 모니터링된다.

- 함수-호출 구조(function-call structure)는 실행 시 프로그램의 동작(behavior)을 결정하는 구조이다. 그것은 함수들의 구조, 및 어떻게 및 언제 상기 함수들이 호출되고 실행되는지를 구성하는 프로그램 코드(program code), 경계들(boundaries), 입출력 규약들(input/output conventions) 및 호출 규약들(calling conventions)을 포함한다.

- 함수-호출 레이아웃(function-call layout)은 상기 프로그램이 저장되고 실행되지 않을 때 정적인 관점에서 보이는 상기 함수-호출 구조로서, 함수의 개수들, 순서, 경계들 등을 포함한다. 함수-호출 레이아웃들은 공격자들이 코드 리프팅(lifting) 및 부정조작과 같은 정적 공격들을 수행하도록 조사된다.

- 제어 흐름 구조(control flow structure)는 프로그램에서 제어의 변경을 허용하는 일련의 동작들을 나타낸다. 로컬 레벨에서, 이는 가지들(branches) 및 점프들(jumps)을 포함한다. 프로그램 레벨에서, 상기 흐름 제어 구조는 함수 호출 구조, 함수 호출 레이아웃, 점프들, 가지들, 반환들(returns), 스레딩(threading) 및 예외 처리들(exception handing)을 포함한다.

본 발명의 일 실시예에 따른 방법은 원본 프로그램의 함수-호출 구조, 전체적인 함수 호출 그래프 및 함수-호출 레이아웃의 세 개의 프로그램 특징들을 이해하기 위한 정교한 전-분석(pre-analysis) 단계를 포함한다. 일 실시예에서, 상기 방법은, 상술한 Matias Madou의 “프로그램 모호화를 통한 어플리케이션 보안”에서의 가지 레벨(branch level)에서의 데이터 명령어들만의 변경과는 달리, 전체 프로그램 레벨에서의 제어-흐름을 고려한다. 상기 프로그램이 원본이고 모호화되거나 감춰지지 않은 경우, 상기 전-분석 단계는 상응하는 함수-호출 그래프 및 함수 경계들에 대한 적당한 함수-호출 구조를 검출할 수 있다. 그러므로, 이러한 세 개의 프로그램 특징들은 상기 프로그램이 원본 형태일 때 서로 일치(match)한다.

본 발명의 일 실시예에 따라, 상기 프로그램의 변형은 빌드 타임(build time)에서 함수에 관련된 명령어들의 동적 삽입, 대체 및 수정의 통합(orchestration)을 포함한다. 그러므로, 상기 프로그램이 빌드 타임에서 변형된 후, 상기 변형된 프로그램에서 상기 세 개의 프로그램 특징들이 서로 일치하지 않는다. 상기 변형된 프로그램은 새로운 함수 호출 구조 및 새로운 함수 호출 레이아웃을 가진다. 다시 말해서, 상기 프로그램의 정확한 함수 호출 구조가 더 이상 정적 또는 동적 공격들을 수행하는 것에 의해 결정될 수 없다. 특히, 상기 변형된 프로그램의 정적 분석(정적 공격)은 정확한(appropriate) 함수-호출 레이아웃을 나타내지 못하고, 따라서 메모리에서 실행될 때의 상기 프로그램의 동작을 나타내지 못한다. 또한, 정적 공격들은 상기 변형된 프로그램의 정확한 함수 호출 구조를 나타내지 못한다. 게다가, 메모리에서의 상기 변형된 프로그램의 실행을 모니터링하는 동적 공격은, 상기 변형된 프로그램이 메모리에서 구동될 때 자기 수정들(self modifications)을 수행하므로, 모니터링된 함수 호출 그래프로부터 상기 변형된 프로그램의 정확한 함수 호출 구조 또는 함수 호출 레이아웃을 결정하는 데에 성공할 수 없다. 어떤 수정들은 함수들을 서로 다른 순서로 서로 다른 시간에 실행하는 것, 및 동일한 결과를 가져오는 랜덤 실행 경로를 선택하는 것을 포함할 수 있다. 이에 따라, 상기 변형된 프로그램은 정적 및 동적 공격들에 더욱 안전하고, 정확한 함수 호출 구조가 더욱 잘 보호된다.

바람직한 실시예에서, 상기 변형된 제어 흐름 구조는 새로운 함수 호출 레이아웃 및 새로운 함수 호출 구조를 포함한다. 다른 실시예에서, 상기 변형된 함수 호출 구조는 점프들(jumps), 가지들(branches), 예외들(exceptions) 및 반환들(returns) 중 하나 이상을 포함할 수 있다.

상기 변형된 프로그램이 메모리에서 구동될 때, 프로그램 레벨에서, 상기 프로그램의 실행을 모니터링하는 공격자는 정확한 함수-호출 그래프를 검출하지 못할 뿐만 아니라, 상기 원본 프로그램의 정확한 함수-호출 레이아웃 또는 구조를 결정하지 못한다. 이에 따라, 공격자는 로컬 레벨에서의 상기 프로그램의 실행, 즉 코드의 현재 실행 포인트에서의 모니터링에 제한된다. 그러나, 프로그램 레벨에서, 상기 변형된 프로그램의 흐름 제어 및 함수 호출 그래프가 원본 프로그램의 그것들과 상이하므로, 공격자는 프로그램 코드의 모든 실행 포인트들에 대한 정보를 수집하더라도 상기 프로그램을 재구성할 수 없다.

상기 변형된 프로그램이 메모리에서 구동될 때, 원본 어플리케이션의 함수-호출들, 반환문들(return statements), 함수 진입 포인트들(function entry points) 및 함수 레이아웃 경계들(function layout boundaries)은 정적 및/또는 동적 공격들로부터 프로그램 저작자에 의해 의도된 원본 함수 호출 시스템을 숨기도록 동적으로 변경된다. 따라서, 정적 분석 또는 동적 분석을 통한 상기 프로그램의 부정조작이 어렵게 될 수 있다.

상기 함수-호출 레이아웃은 함수들 사이의 경계들을 제거하거나 변경함으로써 새로운 함수 호출 레이아웃으로 변형될 수 있다. 결과적으로, 공격자들은 런-타임에서 동적 공격들을 이용하여 함수의 진입(entry) 및 종료(exit)를 결정할 수 없고, 또한, 상기 프로그램의 함수-호출 레이아웃이 위장되었으므로, 상기 프로그램이 저장될 때 정적 공격을 이용하여 상기 변형된 프로그램의 함수 호출 구조 또는 함수 호출 레이아웃을 결정할 수 없다. 이러한 함수 바디에 대한 수정들은 공격자가 완전히 손상을 입지 않은 함수 바디를 리프팅하는 위험을 감소시킨다.

상기 함수 바디 내의 호출부들 또한 수정(제거 또는 삽입을 포함)될 수 있다. 새로운 함수들이 생성될 수 있고, 새로운 호출부들을 이용하여 호출될 수 있다. 호출부들은 정적으로 두드러지게 보이지 않는다. 이들은 런-타임에서 동적으로 삽입될 수 있다. 게다가, 상기 호출부가 상기 프로그램 내에 삽입되는 포인트는 호출이 수행되는 시점과 무관하다. 예를 들어, 런-타임에서, 상기 프로그램은 호출이 수행되기 전에 100개 이상의 서로 다른 호출부들을 삽입 또는 제거할 수 있다. 일 실시예에서, 호출부들이 삽입되거나 제거되고 함수가 호출되는 시간 및 방식을 변경하는 것이 가능하다. 예를 들어, 함수들에 대한 호출들을 지연시키거나, 호출부들을 다른 코드로 대체하거나, 다른 것들에 앞서 함수들을 호출하거나, 어떠한 호출들이 수행되었는지 또는 곧 수행될지에 대한 증거를 감추거나, 그것들의 실행 순서를 변경하거나, 이러한 기술들의 임의의 조합을 수행하는 것이 가능하다.

종래의 함수 호출-반환 어플리케이션-이진 인터페이스(Application-Binary Interface; ABI)는 상기 어플리케이션이 메모리에서 구동할 때(런-타임 처리로) 수정될 수 있는 새로운 ABI로 변형된다. 게다가, 런-타임에서 다중 코드 경로들이 가능하도록 함수 복제들(function duplicates)이 빌드 타임에서 (보안 요소들 및 부정조작-방지(anti-tampering) 기술들이 보호될 상기 프로그램에 적용될 때) 생성된다.

빌드 타임에서, 프로그램은 함수-호출 규약들의 경계들이 동적으로 수정되도록 설정된다. 이러한 함수 경계들은 호출부들(call-sites), 반환 포인트들(return points), 진입 명령어들(entry instructions), 함수들의 시작(start) 및 끝(end), 및 이와 유사한 것들을 포함한다. 본 발명의 일 실시예에서, 원본 프로그램에 대한 의미적 동일성을 보장하면서 함수-그래프를 통하여 실행 경로를 랜덤하게 선택하는 비결정 방식(non-determinism)이 이용된다. 비결정 방식은 유효한 결과를 가져오는 복수의 경로들 중 하나를 랜덤하게 선택하는 알고리즘이다.

일 실시예에서, 상기 변형된 프로그램은 그것이 실행될 때마다 서로 다른 함수-호출 그래프들을 가지도록 설정된다. 따라서, 메모리에서의 상기 변형된 프로그램의 실행을 모니터링하는 공격자는 서로 다른 실행 시점에서 서로 다른 결과를 획득할 것이다. 그러나, 어떠한 경우에도 상기 공격자는 상기 원본 프로그램의 정확한 함수 호출 구조 또는 레이아웃을 획득할 수 없을 것이다.

상기 변형된 프로그램이 실행될 때, 호출부들 및 함수 경계들이 실행 전후로 변경되도록 명령어들이 동적으로 수정된다. 본 발명의 일 실시예에서, 명령어들이 수정(삽입, 제거 또는 변경)되는 포인트들은 상기 수정된 명령어가 실행되기 전 또는 후의 적절한 포인트에 존재한다. 상기 수정된 명령어가 실행되기 전에 존재하는 수정 포인트에 대하여, 그것은 상기 수정이 상기 명령어의 실행 전에 발생하기만 하면 상기 수정이 얼마나 빨리 또는 늦게 발생하는지가 중요하지 않다.

본 발명의 다른 실시예에서, 상기 수정 포인트는, 공격자들이 상기 명령어가 어떻게 수정될지를 확인하는 것을 방지하고 상기 수정과 상기 수정된 명령어의 관계를 결정하는 것을 방지하도록, 적어도 하나의 명령어에 의해 상응하는 명령어들로부터 이격된다. 그러므로, 상기 수정 포인트를 상응하는 실행 포인트로부터 물리적으로 이격되게, 예를 들어 다른 실행 포인트들 또는 서로 다른 코드를 가지도록, 배치하는 것이 바람직하다.

일 실시예에서, 상기 상응하는 실행 포인트로부터 상기 수정 포인트를 분리하는 것은, 분석기(analyzer)/컴파일러(compiler)가 상기 상응하는 실행 포인트 전에 실행할 것을 알고 있는 함수에 상기 수정 포인트를 배치함으로써 달성될 수 있다. 이러한 분석은 도미네이터 분석(dominator analysis)라 불린다. 상기 수정 포인트들은 실행 포인트들과 일대일로 상응할 필요가 없다. 이들은 다대일 또는 일대다의 관계일 수 있다. 예를 들어, 어떠한 하나의 실행 포인트에 도달하기 전에 다수의 수정 포인트들이 발생할 수 있다.

상기 방법은 정적-기반 침투(예를 들어, 디스어셈블리(disassembly), 디컴파일러(decompiler))로부터 함수 레이아웃 및 호출 시퀀스를 숨기고, 동적-기반 침투(예를 들어, 디버거(debuffer), 에뮬레이터(emulator))로부터 상기 함수 레이아웃 및 호출 시퀀스를 숨기며, 코드 리프팅 및 부정조작 공격들을 보다 어렵게 함으로써, 승인되지 않은 공격에 대한 저항력을 제공한다. 결과적으로, 변형된 프로그램은 새로운 함수 호출 레이아웃 및 새로운 함수 호출 구조를 포함하는 새로운 제어 흐름 구조를 가진다. 상기 변형된 프로그램은 상기 원본 프로그램과 의미론적으로(semantically) 동등하나, 동시에 부정조작, 코드 리프팅과 정적 및 동적 공격들에 더욱 저항력이 있다.

도 1은 원본의 수정되지 않은 형태를 가지는 프로그램 또는 어플리케이션의 종래의 함수 레이아웃(function layout), 호출-그래프(call-graph) 및 함수 호출 시퀀스(function call sequence)의 예를 나타낸다. 각 함수는 복잡하지 않은 종래의 시퀀스로 호출되고, 실행되며, 반환된다. 도 1에 도시된 바와 같이, 종래의 호출 시퀀스는 다음과 같다. 시스템은 메인 함수(Main)을 호출하고, 메인 함수(Main)가 수행되기 시작하면 제1 함수(Function_1)가 호출하며, 제1 함수(Function_1)는 제2 함수(Function_2)를 호출하고, 제2 함수(Function_2)는 제1 함수(Function_1)로 반환되며, 그 후 제1 함수(Function_1)는 제4 함수(Function_4)를 호출하고, 제4 함수(Function_4)는 제1 함수(Function_1)로 반환되며, 그 후 제1 함수(Function_1)는 메인 함수(Main)로 반환되고, 메인 함수(Main)는 시스템으로 반환된다.

도 2는 본 발명의 일 실시예에 따른 도 1에 도시된 상기 프로그램의 변형된 버전을 나타낸다. 도시된 프로그램은 빌드 타임(build time) 후 변형된 '미리 로드된(pre-loaded)' 프로그램이다. 도 2에 예시된 상기 변형된 프로그램은 어떠한 함수 호출 시퀀스를 가진 것처럼 보이나, 실제로는 런-타임(run-time)에서 코드가 동적으로 수정됨으로써 다른 함수 호출 시퀀스를 실행할 수 있다. 빌드 타임에서, 다수의 코드 조작 준비 단계들이 수행될 수 있고, 예를 들어, 종래의 함수 호출 규약들이 런-타임에서 코드 수정을 용이하게 하는 새로운 ABI로 대체되거나, 상기 레이아웃을 위장하도록 함수 경계들이 수정되거나, 호출부(call-site) 포인트들이 위장용 호출들, 위장용 명령어들 등으로 대체되거나, 순차적인 명령어들이 호출부들로 대체되거나, 복제된 함수들이 삽입되거나, 추가적인 함수들이 삽입될 수 있다.

도 2에 도시된 바와 같이, 새로운 제5 함수(Function_5)에 대한 호출(Call Function_5)이 생성되고 삽입되었고, 이전의 제2 함수(Function_2)에 대한 호출(도 1의 Call Function_2)이 제거되었다. 제1 함수(Function_1)의 경계 또한, 본래의 제1 함수(Function_1)를 수정된 제1 함수(Function_1)와 새로운 제3 함수(Function_3)로 분할하고, 제4 함수(Function_4)에 대한 호출부를 제3 함수(Function_3)에 대한 호출부로 변경하며, 제3 함수(Function_3) 내에 제4 함수(Function_4)에 대한 호출부를 삽입함으로써, 변경되었다. 상술한 조치들은 빌드 타임에서 수행되어 공격자(attacker)가 진정한 함수 호출 레이아웃 및 호출 구조를 알 수 없도록 할 수 있다.

도 3a는 도 2의 상기 변형된 프로그램의 런-타임 처리 및 동적 수정의 예를 나타낸다. 상기 변형된 프로그램이 실행될 때, 수정 포인트들은 함수-호출 특징들을 변경한다. 상기 수정 포인트들은 상기 프로그램의 정확한 실행을 보장하도록 코드 부분들을 복원하고, 공격자에 정보를 숨기기 위하여 코드 부분들을 손상시킨다. 이러한 빌드 타임과 런-타임 사이의 상보적인 변경들을 적용함으로써, 원본 프로그램과 의미론적으로(semantically) 동일하나, 공격자가 알 수 없도록 서로 다른 함수-호출 특징들을 가지는 변형된 프로그램이 획득될 수 있다.

도 3의 예에서, 메인 함수(Main)가 실행되면, 제1 함수(Function_1) 및 제5 함수(Function_5)가 차례로 호출된다. 제5 함수(Function_5)는 상기 원본 프로그램에는 존재하지 않으나, 빌드 타임에서 컴파일러가 상기 프로그램을 분석할 때 삽입된 것이다. 제5 함수(Function_5)는, 도 2에 도시된 바와 같이 빌드 타임에서 도 1에 도시된 상기 원본 프로그램으로부터 제거된 제2 함수(Function_2)에 대한 호출부를 삽입함으로써, 제1 함수(Function_1)에 대한 복원을 수행한다. 제어가 제1 함수(Function_1)로 반환될 때, 제1 함수(Function_1)는 제2 함수(Function_2)를 호출한다. 제2 함수(Function_2)는, 다음 호출부를 제3 함수(Function_3)에 대한 호출에서 제4 함수(Function_4)에 대한 호출로 수정함으로써, 제1 함수(Function_1)에 대한 복원을 수행한다. 제4 함수(Function_4)가 호출되면, 제4 함수(Function_4)는, 반환(Return)을 무 동작(no operation; NOP)으로 대체하고, 제4 함수(Function_4)에 대한 호출(Call Function_4)을 NOP로 대체함으로써, 제1 함수(Function_1)와 제3 함수(Function_3) 사이의 경계를 제거한다. 이에 따라, 제1 함수(Function_1)는 도 1에 도시된 상기 원본 프로그램에서와 같이 다시 하나의 큰 함수가 된다. 제어는 제1 함수(Function_1)로 반환되고, 다시 메인 함수(Main)로 반환된다.

정적 및 동적 공격들에 대하여 더욱 안전한 제어 시스템을 조직(orchestrate)하기 위하여 유사한 접근 방식이 손상들(damages)을 동적으로 발생시킬 수 있다. 상기 프로그램에 대한 손상(damage)은 상기 프로그램에 오류를 발생시키고 상기 프로그램이 부정확하게 기능하도록 상기 프로그램을 수정하는 것이다. 도 2 및 도 3a에 예시된 동적 변경들과 상기 손상들의 차이를 살펴보면, 상기 동적 변경들은 상기 변형된 프로그램이 실행 중 임의의 시점에서 정적으로 완전히 정확하나 기대되지 않은 방식으로 수행되는 것이고, 반면에, 도 3b에서와 같이 오류 손상들(corruptive damages)을 포함하여 보호되는 프로그램은, 이후에 실행 도중 상기 오류 손상을 수정하는 복구 수정(fix-up modification)이 발생할 때까지, 상기 오류 손상 후 부정확하게 (예를 들어, 상기 프로그램의 저작자가 의도했던 것과 달리) 동작할 것이다.

상기 복구 수정은 상기 원본 프로그램과 의미상 동일상을 보장하도록 상기 상응하는 오류 손상으로부터 상기 변형된 프로그램을 정정할 수 있다. 도 2 및 도 3a에 예시된 수정들과 유사하게, 손상들 또한 빌드 타임에서 계획되고 런-타임에서 실행된다. 본 발명의 일 실시예에서, 단일한 오류 손상에 대하여 둘 이상의 복구 수정들을 가지는 것이 가능하다. 손상들 및 이에 상응하는 복구 수정들은, 이에 한정되지 않으나, 다음의 다중 목적들을 제공한다.

1. 이미 실행된 명령어(instruction)를 숨기는 것.

2. 후속 실행을 위한 명령어의 상태를 준비하는 것.

3. 추가적인 손상들 및/또는 수정들에 대한 프로그램을 준비하는 것.

도 3b는 이미 실행된 명령어들에 대하여 상기 프로그램에 대한 손상들이 어떻게 생성되는지의 예를 나타낸다. 상기 프로그램이 상기 분석 시스템이 계획한대로 코드의 부분들을 이미 실행하면, 그 후 상기 프로그램의 실제 호출 구조를 혼란스럽게 만드는 데에 이용되는 손상들이 발생할 수 있다. 도 3b를 참조하면, 제1 함수(Function_1)의 실행 중의 포인트(300)에서, 제2 함수(Function_2)는 실행을 완료하였고, 제4 함수(Function_2)는 실행을 시작하였다. 제4 함수(Function_4)는 다음의 두 손상들을 수행한다.

1. 제4 함수(Function_4) 내의 명령어(또는 명령들의 집합)는 이미 발생한 함수에 대한 호출들(예를 들어, 제2 함수에 대한 호출(Call Function_2))을 제거한다.

2. 제4 함수(Function_4)는 또한 상기 원본 프로그램에 존재하지 않는 제6 함수(Function_6)에 대한 호출을 삽입한다.

상술한 첫 번째 손상은 제4 함수(Function_4)가 호출된 것에 대한 증거를 제거하고, 두 번째 손상은 추가적인 손상을 야기하는 제6 함수(Function_6)에 대한 호출을 삽입하는 것이다.

상기 제6 함수(Function_6)에 대한 호출에 도달하면, 제6 함수(Function_6)는 다음의 네 개의 복구 수정들을 수행한다.

1. 제6 함수(Function_6)는 상기 원본 프로그램에 존재하지 않는 제5 함수(Function_5)(제5 함수(Function_5)는 첫 번째 단계에서 자기 수정을 위해 사용됨)에 대한 호출을 삽입한다.

2. 제6 함수(Function_6)는 제4 함수(Function_4)에 대한 호출을 제3 함수(Function_3)에 대한 호출이 되도록 수정한다.

3. 제6 함수(Function_6)는 이미 실행되었으므로 그 자신에 대한 호출을 제거한다.

4. 제6 함수(Function_6)는, 제1 함수(Function_1)에 대한 반환문(return statement) 및 제4 함수(Function_4)에 대한 호출을 삽입하고, 제1 함수(Function_1)의 레이아웃의 끝(end)을 효율적으로 생성하며, 제3 함수(Function_3)의 레이아웃을 시작(beginning)함으로써, 제3 함수(Function_3)의 경계를 삽입한다.

모든 손상들 및 이들에 상응하는 복구 수정들이 발생된 후 실행되면, 상기 변형된 프로그램은 도 2에 도시된 빌드 타임에서 미리 계획된 수정들과 조화를 이루게 된다. 다시 말해서, 모든 손상들 및 복구 수정들이 발생된 후 상기 원본 프로그램에 대한 의미상 동일성이 유지된다. 도 3b는 상기 프로그램의 호출 구조에 대하여 어떻게 손상들 및 복구 수정들이 빌드 타임에서 수행된 전-수정들과 조화를 이루도록 생성되는지를 나타내는 하나의 예를 도시할 뿐이다.

상기 동적 변경들 및/또는 손상들을 구현하는 코드는 상기 변형된 프로그램에 삽입된다. 상기 코드는 함수의 형태를 가지거나, 또는 상기 프로그램 내에 코드의 조각들로서 적절히 삽입될 수 있다. 상기 코드 자체는 화이트박스 암호화(whitebox cryptography), 데이터 변형(data transforms), 무결성 검증(integrity verifications) 또는 유사한 기술을 이용하여 보호된다. 동일한 출원인의 미국특허 등록번호 제7,397,916호, 미국특허 출원번호 제11/020,313호 및 미국특허 출원번호 제61/175,945호는 그 전체로서 참조로 여기에 포함되고, 본 발명에서 상기 프로그램 내의 상기 코드를 보호하는 것에 이용될 수 있다.

도 4는 도 1에 도시된 원본 프로그램의 호출 시퀀스에 대하여 도 2 및 도 3a에 도시된 변형된 프로그램의 동적 호출 시퀀스를 나타내는 흐름도이다. 도 4에 도시된 바와 같이, 메인 함수(Main)가 제1 함수(Function_1)를 호출한 후 메모리에서 실행될 때 상기 변형된 프로그램의 동작(behavior)은 동적으로 변경된다. 예를 들어, 상기 동적 호출 시퀀스에서, 제5 함수(Function_5)는 상기 원본 호출 시퀀스에 존재하지 않으나, 제5 함수(Function_5)는 제1 함수(Function_1) 이후 및 제2 함수(Function_2) 이전에 호출된다. 상술한 바와 같이, 제5 함수(Function_5)는 빌드 타임에서 삽입된다. 게다가, 제2 함수(Function_2)는, 제4 함수(Function_4)에 대한 호출을 제3 함수(Function_3)에 대한 호출로 대체함으로써, 제1 함수(Function_1)를 수정한다. 제3 함수(Function_3)는 도 1 및 도 2에 도시된 바와 같이 원본의 제1 함수(Function_1)의 한 부분이다. 제1 함수(Function_1)를 도 1에 도시된 것과 같은 그것의 원본 크기로 돌리기 위해, 제4 함수(Function_4)는 런-타임에서 제1 함수(Function_1)와 제3 함수(Function_3) 사이의 경계들을 제거하고, 이에 따라 빌드 타임에서 생성된 변경들을 복구할 수 있다.

도 4에 도시된 실시예에서, 함수들은 수정되고, 서로 다른 시점에 서로 다른 방식으로 호출되며, 함수 경계들이 변경되고, 새로운 함수들이 추가 및 제거된다.

공격자가 상기 보호된 프로그램의 실행을 모니터링 하더라도,

- 함수 경계들이, 예를 들어 함수들의 진입(entry) 및 종료(exit)를 변경함으로써, 변경되고, 일부 함수들이 복제될 수 있으며, 상기 원본 프로그램에 포함되지 않았던 일부 함수들이 상기 시스템에 의해 생성될 수 있으므로, 기만적인(decepcive) 함수들 및 기만적인 함수-호출 레이아웃;

- 함수들이 지연되거나 미리 호출될 수 있으므로, 각 함수의 기만적인 실행 시점;

- 일부 함수들이 상기 원본 프로그램과 비교할 때 다른 것들 전에 실행될 수 있으므로, 기만적인 실행 순서; 및

- 함수들이 분리 또는 통합되고, 예를 들어 비결정 방식(non-determinism)을 이용하여 상기 원본 프로그램에 대한 함수의 동일성은 유지하면서 메모리에서 실행될 때 다르게 보이는 랜덤 실행 경로들(random paths of execution)이 선택될 수 있으므로, 기만적인 함수-호출 그래프;

만을 획득할 수 있다.

도 5a는, 도 5a에 도시된 바와 같이 메인 진입 함수(Main) 외에 다른 함수들을 가지지 않는 프로그램에 대한 동적 호출 시스템을 구현할 때의 런-타임 처리를 나타낸다. 상기 프로그램을 구동 시 동적으로 변경되는 프로그램으로 변형하기 위한 전력적 포인트들(strategic points)을 결정하도록 상기 프로그램이 분석된다. 메인 함수(Main)의 경계는, 실행될 때, 진입(entry), 종료(exit) 및 호출부(call site)뿐만 아니라 도 5a에 표시된 바와 같이 메인 함수(Main) 내에 제A 함수(Function_A)에 대한 경계를 생성함으로써, 변경된다. 제A 함수(Function_A)가 실행된 후, 도 5b에 도시된 바와 같이, 제A 함수(Function_A)의 경계들, 호출부들, 진입 및 종료가 제거된다.

실행 후 제A 함수(Function_A)의 경계들, 호출부들, 진입 및 종료가 제거되면, 도 5c에 도시된 바와 같이, 메인 함수(Main)는 변형된 적이 없는 것처럼 보일 수 있다. 그러나, 공격자의 관점에서는, 기만적인 호출-그래프 정보가 제공되었으므로, 부정조작이 성공적이지 않을 것이다.

다른 극단적인 경우는 프로그램이 정적으로 과도한 수의 함수들을 가지도록 상기 프로그램을 설정하는 것이다. 런-타임에서, 상기 함수 경계들은, 상기 원본 프로그램과 의미론적으로 동등한 변형된 프로그램을 제공하면서, 보다 큰 함수들로 결합된다.

도 6은 본 발명의 일 실시예에 따른 프로그램을 변형하는 단계들을 나타내는 순서도이다. 도 6에 도시된 바와 같이, 단계 600에서 보호될 상기 원본 프로그램이 분석되어 상기 함수 호출 구조 및 상기 함수 호출 레이아웃이 이해될 수 있다. 단계 602에서, 상기 원본 함수-호출 레이아웃이 새로운 레이아웃으로 변형됨으로써, 메모리에 저장될 때 공격자에 의해 상기 변형된 프로그램이 정적으로 분석되더라도 상기 변형된 프로그램이 다르게 보일 수 있다. 단계 604에서, 상기 함수 호출 구조가 상기 변형된 프로그램의 실행 시 동적 자기-수정을 수행할 수 있는 새로운 함수 호출 구조로 변형된다. 단계 606에서, 단계들 604 및 606에서 미리 계획된 변경들에 의해 메모리에서의 상기 프로그램의 실행 도중 상기 원본 함수 호출-그래프가 새로운 그래프로 변형된다.

상기 프로그램이 변형됨으로써, 보다 크거나 작은 함수들을 생성하도록 호출부들(call-sites), 반환 포인트들(return points), 진입 명령어들(entry instructions), 함수의 시작(start) 및 끝(end) 등과 같은 함수 경계들이 동적으로 수정된다. 상기 함수 경계 내의 호출부들 또한 수정(제거 또는 삽입을 포함)될 수 있다. 함수 경계들은 정적 또는 동적 공격들을 방어하도록 실행 전에 또는 실행 후에 변경될 수 있다. 또한, 정적 및 동적 공격을 더욱 어렵게 만들도록 함수 복제들(function duplicates), 유인들(decoys) 및 추가적인 명령어들(additional instructions)이 삽입된다.

단계 608에서, 상기 원본 프로그램과 의미론적으로 동등한 변형된 프로그램이 생성된다. 상기 보호되는 프로그램은 정적으로 분석할 때 상기 원본 프로그램과 다르고, 동적 공격들 및 코드 리프팅을 방어하도록 메모리에서 실행 시 자기-수정이 가능하다.

일 실시예에서, 상기 프로그램의 변형 전에 각 함수에 대한 중요도를 결정하도록 상기 원본 프로그램이 분석됨으로써 보안 목적들(security objectives)에서 또는 성능 목적들(performance objectives)에서 중요한 함수들이 강조될 수 있다.

보안 목적들에서, 함수가 보안 자산들(secure assets)을 포함하거나, 트러스트 키(trust key)의 루트(root)와 같이 보안 시스템의 중요한 부분을 계산함에 따라 사용자에 의해 중요한 것으로 확인될 수 있다. 이는 언어 확장들(language extensions)을 통하여, 또는 상기 함수가 보안 관점에서 중요하다는 것을 나타내는 커맨드 라인 인터페이스(command-line interface)와 같은 외부 수단을 통하여 수행될 수 있다. 이 경우, 상기 변형 시스템은 이러한 특정한 함수에 모호화(obfuscation)가 발생하도록 집중할 수 있다.

성능 목적들에서, 컴파일러는 정적 프로파일링(profiling) 또는 실제 프로파일링 수단을 통하여 자주 실행되는 함수들을 확인할 수 있다. 성능 고려가 중요한 실시예들에서, 자주 실행되는 함수에 대하여 빠르게 수행되는 것으로 알려진 변형들이 선택될 수 있다.

도 7은 종래의 시스템에서 실행되는 어프리케이션 프로그램을 빌드하도록 사용되는 종래의 툴들을 나타낸다. 여기서 사용되는 주요한 툴들은 컴파일러(compiler)와 링커(linker)이다. 이들은 전형적으로 두 개의 서로 다른 툴들이나, 경우에 따라 동일한 톨로 결합될 수 있다. 또한, 다른 경우들에서, 이들은 세 개 이상의 툴들로 분리될 수 있다. 상기 컴파일러의 주요 기능은 어플리케이션 프로그램 파일들의 구문적 및 의미적 분석을 수행하고, 최적화를 수행하며, 상기 링커를 위한 코드를 생성하는 것이다. 상기 링커는 결합되어 실행에 필요한 이진 파일 또는 이진 파일들의 집합을 형성하는 레이아웃들로 프로그램 및 데이터 조각들을 재배치한다. 실행은 실제로 수행되거나 가상 머신에 가상화될 수 있다.

도 8은 본 발명의 일 실시예에 따른 동적 함수 호출 시스템에서 사용되는 빌드 툴들의 일 예를 나타낸다. 도 8에는 도 7에 도시된 종래의 툴들에 비하여 새로운 두 개의 툴들, 즉 컴파일러-레벨 분석 툴 및 링크-레벨 분석 툴이 도시되어 있다. 상기 컴파일러-레벨 분석 툴은 종래의 컴파일러-레벨 처리와 연관되고, 본래의 컴파일러 전 또는 후에 독립적으로 구동할 수 있다. 이는 또한 본래의 링커 전 또는 후에 독립적으로 구동하거나, 본래의 링커를 대신하여 구동할 수 있다. 도 8에 도시된 예에서, 상기 컴파일러-레벨 분석 툴은 상기 본래의 컴파일러 전에 구동한다. 이와 유사하게, 상기 링크-레벨 분석 툴은 링크-레벨 처리와 연관된다. 이는 본래의 링커 전 또는 후에 독립적으로 구동하거나, 본래의 링커를 대신하여 구동할 수 있다.

컴파일러-레벨에서, 어플리케이션의 전체 함수-호출 그래프가 분석되고, 이는 "선택적 호출(may-call)" 및 "필수적 호출(must-call)"로 표현될 수 있다. 이러한 호출 표현들은 명령어들의 삽입들, 제거들 및 수정들을 할당을 위하여 글로벌하게(globally) 분석될 수 있다. 상기 원본 프로그램은 동적 수정을 위하여 컴파일러-레벨에서 전략적으로 수정된다.

함수 경계들이 분석될 수 있고, 링크-레벨에서 사용되기 위한 정보가 준비될 수 있다. 링크-레벨에서, 컴파일러 레벨로부터 전송되고 어떠한 함수들이 어떠한 순서로 서로 인접할 필요가 있는지를 포함하는 레이아웃 정보에 따라 프로그램 조각들이 배치된다. 이는 함수 경계 동적 수정을 가능하게 한다. 게다가, 임의의 추가적인 정적 라이브러리들(static libraries) 및/또는 목적 코드(object code)가 명령어 수정과 같은 보조 동작들을 수행하도록 상기 프로그램에 링크된다. 링크-레벨에서, 상기 동적 수정 시스템에 필요한 컴포넌트들이 실행 가능한 바이너리 또는 바이너리들의 집합에 배치된다.

도 9는 프로그램의 함수-호출 레이아웃을 변경함으로써 원본 형태에서 정적 및 동적 공격들로부터 보다 안전한 형태로 상기 프로그램을 변형하고, 메모리에서의 상기 변형된 프로그램의 실행을 모니터링하는 공격자에 기만적인 함수-호출 그래프를 제공하도록 상기 프로그램의 함수-호출 구조를 상기 프로그램이 구동할 때 동적으로 자기-수정을 할 수 있는 새로운 구조로 변하는 시스템(900)의 일 실시예를 나타낸다.

도 9에 도시된 실시예에서, 시스템(900)은 적어도 두 개의 컴퓨터들(902, 904)을 포함한다. 컴퓨터(902)는 CPU(906), 메모리(908), 도 8에 도시된 빌드 툴 세트(910), 및 입출력 모듈(I/O, 912)을 포함한다. 컴퓨터(904)는 CPU(914), 메모리(916) 및 I/O(918)를 포함한다. 컴퓨터(902)는 변형될 원본 프로그램을 수신하고, 상기 프로그램의 상기 함수-호출 레이아웃 및 상기 함수-호출 구조를 변경하는 빌드 타임 처리를 수행한다. 상기 변형된 프로그램은 저장 및/또는 실행을 위하여 컴퓨터(904)에 전송된다. 상기 변형된 프로그램은 통신 링크를 통하여 또는 CD, DVD, USB 드라이브 또는 다른 수단들과 같은 컴퓨터로 판독 가능한 메모리를 통하여 컴퓨터(904)에 전송될 수 있다.

상기 변형된 프로그램은 의미론적으로 원본 프로그램과 동등하나, 정적 및 동적 공격들에 보다 안전하다. 상기 변형된 프로그램이 컴퓨터(904)에 저장될 때, 이는 상기 함수-호출 레이아웃이 상기 원본 프로그램의 실제 레이아웃을 반영하지 않으므로 정적 공격들로부터 안전하다. 따라서, 상기 보호된 프로그램에서 함수 경계들, 호출부들 및 함수들의 실행 순서가 상기 컴파일러/링커에 의해 변경되었으므로, 상기 변형된 프로그램의 상기 함수-호출 레이아웃을 분석하는 것을 시도하는 공격자는 기만적인 레이아웃만을 획득할 수 있을 것이다. 컴퓨터(904)에서 상기 변형된 프로그램이 실행될 때, 함수들이 언제 및 어떻게 호출되는지를 변경하여 상기 원본 함수-호출 그래프를 변경하도록 상기 함수-호출 구조가 자기-수정을 수행할 수 있다.

일 실시예에서, 함수 경계 수정을 수행하는 코드는 상기 프로그램과 동일한 수행 스레드(thread)에 있을 필요가 없다. 이는 선택적으로 동일한 스레드 또는 상기 프로그램과 운영 체제(즉, OS) 사이에서 구동하는 가상 머신 계층에 위치할 수 있다. 이에 따라, 상기 수정 코드는 상기 프로그램으로부터 독립적이고, 프로그램 기능과 밀접하게 관련되어 구동하거나 분리되어 구동할 수 있다. 이와 달리, 밀접한 관련 방식 및 분리 방식이 조합되어 사용될 수 있다.

도 10a 내지 도 10c는 본 발명의 실시예들에 따른 동적 함수 호출 시스템들에 대한 대안적인 동작 설정들을 나타낸다.

도 10a는 어플리케이션 프로그램과 운영 체제(즉, OS) 사이에 위치한 어플리케이션 가상 머신을 나타낸다. 상기 가상 머신은 명령어들의 실행을 관리한다. 명령어가 실행되려 할 때, 상기 가상 머신은 상기 명령어를 해석하거나 본래대로 실행되도록 상기 명령어를 그대로 상기 OS에 전송에 전송한다. 본 실시예에서, 상기 가상 머신은 구동 중인 상기 어플리케이션 프로그램에 대한 명령어 수정을 수행한다. 명령어 수정들이 어플리케이션 자체에 존재하는 경우에서와 같이 유사한 빌드 타임 분석 툴들이 이러한 설정에 필요하다.

도 10b는 상기 어플리케이션 프로그램과 나란히 구동하도록 공존하는 프로세스 또는 스레드를 나타낸다. 이러한 분리된 스레드 또는 프로세스는 상기 어플리케이션과 반-독립적으로(semi-independently) 구동한다. 이 경우, 상기 분리된 프로세스 또는 스레드는 다양한 동기식 또는 비동기식 실행 방식들 중 하나를 통하여 상기 어플리케이션 프로그램과 동시에 실행된다. 상기 어플리케이션 프로그램에 대한 명령어 수정은 상기 공존하는 프로세스 또는 스레드에 의해 수행될 수 있다. 명령어 수정들이 어플리케이션 자체에 존재하는 경우에서와 같이 유사한 빌드 타임 분석 툴들이 이러한 설정에 필요하다.

도 10c는 도 10a 및 도 10b에 도시된 설정들의 조합을 나타낸다. 두 개의 공존하는 스레드들 또는 프로세스들이 구동하고 있다. 추가적으로, 가상 머신이 어플리케이션 레벨과 OS 레벨 사이에서 구동한다. 각 공존 어플리케이션 스레드 또는 프로세스는 다른 어플리케이션 스레드 또는 프로세스의 명령어들을 수정할 수 있다. 이와 달리, 어플리케이션 스레드 또는 프로세스가 상기 가상 머신의 명령어들을 수정할 수 있다. 이와 유사하게, 상기 가상 머신은 상기 어플리케이션 프로세스들/스레드들의 명령어들을 수정할 수 있다. 게다가, 이러한 설정은 상기 어플리케이션 프로세스들/스레드들이 독립된 경우와 같이 자신을 수정하는 것이 가능하다. 상기 가상 머신 또한 자신을 수정할 수 있다.

이상에서, 설명의 목적으로, 본 발명의 실시예들에 대한 철저한 이해를 제공하기 위하여 다양한 세부적인 내용이 개시되었다. 그러나, 당업자들은 본 발명을 실시하는데 이러한 구체적인 내용들이 요구되지 않는다는 것을 이해할 수 있을 것이다. 다른 경우에서, 본 발명이 불명확하게 되지 않도록 잘 알려진 전기적인 구조들 및 회로들이 블록도의 형태로 도시되었다. 예를 들어, 여기에 기재된 본 발명의 실시예들이 소프트웨어 루틴, 하드웨어 회로, 펌웨어, 또는 이들의 조합으로 구현되었는지에 대한 세부 사항들이 제공되지 않았다.

본 발명의 실시예들은 기계로 판독 가능한 매체(machine-readable medium)에 저장되는 소프트웨어 제품으로 구현될 수 있다. 상기 기계로 판독 가능한 매체는 컴퓨터로 판독 가능한 매체, 프로세서로 판독 가능한 매체, 또는 컴퓨터로 판독 가능한 프로그램 코드를 내부에 포함한 컴퓨터로 사용한 가능 매체로도 불린다. 상기 기계로 판독 가능한 매체는 자성(magnetic), 광학적(optical), 또는 전기적 저장 매체를 포함하는 모든 적합한 유형 매체일 수 있다. 상기 매체로는 디스켓, 씨디-롬(CD-ROM), 휘발성(volatile) 또는 비휘발성의(non-volatile) 메모리 장치, 또는 기타 저장 메커니즘이 포함된다. 상기 기계로 판독 가능한 매체는 명령, 코드 시퀀스, 구성(configuration) 정보, 또는 다른 데이터를 포함하고, 이들은 실행될 때, 프로세서가 본 발명의 실시예들에 따른 방법의 단계들을 수행할 수 있도록 한다. 해당 기술 분야에서 통상의 지식을 가진 자들은 상술한 발명을 실시하는데 필수적인 다른 명령들 및 연산들도 상기 기계로 판독 가능한 매체 상에 저장될 수 있다는 것을 이해할 수 있을 것이다. 상기 기계로 판독 가능한 매체로부터 실행되는 소프트웨어는 상술한 태스크들(tasks)을 수행하는 회로와 인터페이스(interface)할 수 있다.

발명의 바람직한 실시예들에 대해 설명하였지만, 그것들의 사상을 포함하는 다른 실시예들이 사용될 수 있음은 해당 기술 분야에서 통상의 지식을 가진 자에게 자명하다. 따라서 이러한 실시예들은 개시된 실시예들에 한정되지 않으며, 특허 청구 범위의 사상과 범위에 의해서만 한정되어야 할 것이다.

Claims

프로그램을 정적 및 동적 공격들로부터 보호하도록 상기 프로그램의 제어 흐름 구조(control flow structure)를 변경함으로써 원본 형태에서 보다 안전한 형태로 소프트웨어 프로그램을 변형하는 방법에 있어서,
(a) 상기 프로그램의 원본 함수-호출 구조(function-call structure) 및 원본 함수-호출 레이아웃(function-call layout)을 분석하는 단계;
(b) 상기 원본 함수-호출 레이아웃을 새로운 함수-호출 레이아웃으로 변형하는 단계;
(c) 상기 원본 함수-호출 구조를 동적 자기 수정들(dynamic self modifications)을 수행할 수 있는 새로운 함수-호출 구조로 변형하는 단계; 및
(d) 변형된 제어 흐름 구조를 가지나 상기 프로그램의 원본과 의미론적으로(semantically) 동등하고, 실행 시 원본 함수-호출 그래프(function-call graph)를 새로운 함수-호출 그래프로 변형하는 변형된 프로그램을 생성하는 단계를 포함하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 동적 자기 수정들은 함수들이 호출되는 시간 및 방식을 변경하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 (a) 내지 (c) 단계들은 빌드 타임에 수행되는 전-수정들(pre-modifications)이고, 상기 원본 함수-호출 그래프를 상기 새로운 함수-호출 그래프로 변형하는 것은 상기 (a) 내지 (c) 단계들에서 계획된 동적 변경들을 실행하도록 런-타임에 수행되는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 (a) 단계는,
상기 프로그램을 변형할 때 중요한 함수들을 강조하도록 상기 프로그램 내의 각 함수에 대한 중요도를 결정하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 (b) 및 (c) 단계들은 상기 함수-호출 레이아웃을 위장하도록 함수 경계들을 변경하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 5 항에 있어서, 상기 함수 경계들을 변경하는 단계는 상기 함수 경계들을 제거하는 단계 및 적어도 두 개의 함수들을 하나로 조합하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 5 항에 있어서, 상기 함수 경계들을 변경하는 단계는 하나의 함수를 적어도 두 개의 함수들로 분리하도록 새로운 함수 경계들을 삽입하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 (b) 및 (c) 단계들은 상기 변형된 프로그램의 실행 도중 다중 코드 경로들이 가능하도록 함수 복제본들(function duplicates)을 삽입하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 8 항에 있어서, 상기 함수 호출 그래프를 통하여 실행 경로들을 랜덤하게 선택하는 비결정 방식(non-determinism)을 이용하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 호출 그래프에서 함수들의 실행 순서를 변경하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 새로운 함수들을 생성하고 새로운 함수 호출들을 삽입하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 전략적 포인트들에 유인 코드들(decoys)을 삽입하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 동작을 변경하도록 명령어들을 수정하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 명령어들을 제거하여 상기 명령어들을 무 동작(no operation; NOP) 명령어들로 대체하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 프로그램에 대한 손상들을 수행하는 단계를 더 포함하고,
상기 손상들은, 상기 함수-호출 구조를 더욱 위장하고 상기 프로그램의 원본에 대한 기능적 동일성을 유지하기 위한 적어도 하나의 복구 손상(fix-up damage)이 뒤따르는 적어도 하나의 오류 손상(corruptive damage)을 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 15 항에 있어서, 함수들이 호출된 증거를 제거하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 15 항에 있어서, 각 오류 손상은 하나 이상의 복구 손상을 가지는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 변형된 프로그램이 실행될 때마다 서로 다른 함수-호출 그래프들을 가지도록 상기 변형된 프로그램을 설정하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 (a) 단계는 상기 프로그램을 수정하기 위한 상기 프로그램 내의 전력적 포인트들을 결정하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 19 항에 있어서, 상기 (a) 단계는 상기 프로그램의 상기 함수-호출 구조, 상기 함수-호출 레이아웃 및 상기 전체적인 함수 호출 그래프를 이해하기 위한 정교한 전-분석(pre-analysis) 처리를 수행하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 19 항에 있어서, 상기 (b) 및 (c) 단계들은 상기 프로그램 내의 상응하는 실행 포인트들로부터 물리적 및 시간적으로 이격된 포인트에 수정 포인트들을 배치하는 단계를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 21 항에 있어서, 하나의 실행 포인트에 대하여 다수의 수정 포인트들을 제공하는 단계를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 1 항에 있어서, 상기 변형된 제어-흐름 구조는 상기 새로운 함수 호출 레이아웃 및 상기 새로운 함수 호출 구조를 포함하는 것을 특징으로 하는 프로그램 변형 방법.
제 23 항에 있어서, 상기 변형된 제어-흐름 구조는 점프들(jumps), 가지들(branches), 반환들(returns) 또는 예외들(exceptions) 중 적어도 하나를 더 포함하는 것을 특징으로 하는 프로그램 변형 방법.
프로그램을 정적 및 동적 공격들로부터 보호하도록 상기 프로그램의 제어 흐름 구조(control flow structure)를 변경함으로써 원본 형태에서 보다 안전한 형태로 소프트웨어 프로그램을 변형하는 방법에 있어서, 상기 프로그램을 변형하는 방법은 빌드 타임 단계(build time phase)와 런-타임 단계(run-time phase)를 포함하고, 상기 빌드 타임 단계는,
(a) 상기 프로그램의 원본 함수-호출 구조(function-call structure) 및 원본 함수-호출 레이아웃(function-call layout)을 분석하는 단계;
(b) 상기 프로그램의 상기 원본 함수-호출 레이아웃을 새로운 함수-호출 레이아웃으로 변형하는 단계;
(c) 상기 원본 함수-호출 구조를 동적 수정들(dynamic modifications)을 수행할 수 있는 새로운 함수-호출 구조로 변형하는 단계; 및
(d) 변형된 제어 흐름 구조를 가지나 상기 프로그램의 원본과 의미론적으로(semantically)으로 동등한 변형된 프로그램을 생성하는 단계를 포함하고,
상기 런-타임 단계는,
(e) 상기 프로그램의 실행 시 상기 프로그램의 상기 원본 함수-호출 그래프(function-call graph)를 새로운 함수-호출 그래프로 변형하는 단계를 포함하고,
런-타임에서 수행되는 상기 동적 수정들은, 상기 프로그램의 원본과 의미적으로 동등한 상기 변형된 프로그램을 생성하도록 빌드 타임에서 수행된 변경들에 상보적인 것을 특징으로 하는 프로그램 변형 방법.
프로그램을 정적 및 동적 공격들로부터 보호하도록 상기 프로그램의 제어 흐름 구조(control flow structure)를 변경함으로써 원본 형태에서 보다 안전한 형태로 소프트웨어 프로그램을 변형하기 위한 문장들(statements) 및 명령어들(instructions)이 기록된 컴퓨터로 판독 가능한 메모리에 있어서, 상기 문장들 및 상기 명령어들은, 프로세서에 의해 수행될 때, 상기 프로세서가,
(a) 상기 프로그램의 원본 함수-호출 구조(function-call structure) 및 원본 함수-호출 레이아웃(function-call layout)를 분석하는 단계;
(b) 상기 원본 함수-호출 레이아웃을 새로운 레이아웃으로 변형하는 단계;
(c) 상기 원본 함수-호출 구조를 동적 자기 수정들을 수행할 수 있는 새로운 구조로 변형하는 단계; 및
(d) 변형된 제어 흐름 구조를 가지나 상기 프로그램의 원본과 의미론적으로(semantically) 동등하고, 실행 시 원본 함수-호출 그래프(function-call graph)를 새로운 함수-호출 그래프로 변형하는 변형된 프로그램을 생성하는 단계를 수행하도록 하는 것을 특징으로 하는 컴퓨터로 판독 가능한 메모리.