KR20140114433A

KR20140114433A - 리턴-지향형 프로그래밍을 억제하기 위한 동적 실행 방지

Info

Publication number: KR20140114433A
Application number: KR1020147022839A
Authority: KR
Inventors: 아룬 발라크리쉬난; 알렉산더 간트만; 렌웨이 게; 다니엘 코마로마이; 이니안 마오; 아난드 파라니고운더; 브라이언 엠. 로센버그
Original assignee: 퀄컴 인코포레이티드
Priority date: 2012-01-16
Filing date: 2013-01-15
Publication date: 2014-09-26
Also published as: CN105303104B; EP2805246A1; TW201342109A; WO2013109546A1; KR101480821B1; JP5769891B2; EP2805246B1; US8776223B2; CN104054061A; US20130185792A1; BR112014017156A2; CN105303104A; BR112014017156A8; TWI468980B; CN104054061B; JP2015503815A

Abstract

실행 방지를 위한 방법, 장치, 및/또는 시스템이 제공된다. 메모리 디바이스에서 실행가능 코드의 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자는 비-실행가능 상태로 설정된다. 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자는 실행가능 상태로 설정되고, 여기서 복수의 메모리 페이지들의 제 2 서브세트는 복수의 메모리 페이지들의 제 1 서브세트에서의 함수들에 대한 간접 스터브들을 포함한다. 애플리케이션의 실행시에, 복수의 메모리 페이지들의 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 수정하는, 복수의 메모리 페이지들의 제 2 서브세트에서 대응하는 간접 스터브에 대해 함수 호출이 지시된다.

Description

반환-지향형 프로그래밍을 억제하기 위한 동적 실행 방지{DYNAMIC EXECUTION PREVENTION TO INHIBIT RETURN-ORIENTED PROGRAMMING}

일 특징은, 일반적으로, 소프트웨어 시스템들에서 악의적인(malicious) 코드의 연산을 억제하는 것에 관한 것이고, 더욱 구체적으로는, 소프트웨어 시스템들에서 반환-지향형 프로그래밍 활용들(return-oriented programming exploitations)에 이용가능한 명령들의 수를 감소시키기 위해, 실행 방지(execution prevention)를 구현하고 자동으로(by default) 메모리 페이지들을 비-실행가능한 것으로 마킹하는 방법들 및 디바이스들에 관한 것이다.

소프트웨어를 실행하는 컴퓨팅 시스템들은 증가하는 어레이의 공격들 하에 (under a growing array of attacks) 있다. 이러한 공격들은 종종 악의적인 코드를 컴퓨팅 시스템으로 삽입한 후, 컴퓨팅 시스템이 그 악의적인 코드를 실행하도록 야기한다. 악의적인 코드는, 수많은 상이한 연산들을 수행할 수 있는데, 예를 들어, 컴퓨팅 시스템이 정상보다 더 느리게 구동하도록 야기하고, 컴퓨팅 시스템상에서의 액티비티를 모니터링하여, 사용자가 통신되기 원하지 않을 수도 있는 정보를 컴퓨팅 시스템이 송신 또는 수신하도록 야기하고, 지속성(persistent) 그리고 비지속성(non-persistent) 메모리에서 데이터를 변질시키고, 그리고 컴퓨팅 시스템을 고장낼 수 있다.

최근에, 반환-지향형 프로그래밍(ROP; Return-Oriented Programming) 활용으로 때때로 지칭되는 공격 메커니즘들이 제안되어 왔다. 일 클래스의 ROP 활용은, 종종 c 라이브러리로의 반환(RTL; return-to-libc) 공격(또는 return-into-libc 공격)으로 지칭된다. RTL(return-to-libc)(또는 return-into-libc) 공격은, 2개의 속성들: (a) 이 공격이 수많은 소프트웨어 시스템들에 상주하는 표준 C 라이브러리를 이용함, 및 (b) 이 공격이, 그 내부가 아닌 c 라이브러리 함수(libc function)의 진입 지점으로 직접 점핑함에 의해 식별될 수 있다. ROP 활용은, 공격자가 프로세서의 어드레스 공간으로 임의의 새로운 악의적인 코드를 주입하지 않고 소프트웨어 프로그램들에서의 유효 코드 시퀀스들을 활용하도록 허용하는 강력한 기법이다. 몇몇 버그 또는 약점을 활용함으로써, 공격은 명령을 실행할 다음 메모리 어드레스에 대한 제어를 획득할 수 있다. 일 예시에서, 이는, 스택 상에서 저장된 반환 어드레스를 겹쳐씀(overwriting)으로써 발생할 수 있다. 예를 들어, 이러한 공격은 반환 어드레스들을 스택 상의 적당한(legitimate) 코드 블록들로 특정하기 위해 버퍼 오버플로우들을 활용할 수 있으며, 이는 적당한 함수가 반환할 때 원하는 효과를 갖는다. 명령 포인터를 공격하고 그리고/또는 다음 메모리 어드레스에 대한 제어를 획득하는 다른 방법들도 또한 가능하다. 종종 가젯(gadget)들로 지칭되는 유효 코드 시퀀스들의 작은 스니펫(snippet)들은, 공격자에 의해 발견되어, 그후 새로운 악의적인 코드 시퀀스들을 형성하기 위해 함께 이어져서(strung), 이에 의해 코드 주입에 대항하는 방어들을 회피(sidestepping)할 수 있다.

통상적인 ROP 활용들에서, 작은 코드 스니펫들은, 예를 들어, 반환 또는 점프 명령을 통해 종료하는 코드의 부분들이다. 다른 명령들이 또한 명령들을 종결하는 가젯으로서 이용될 수 있다. 함수가 호출될 때, 호출 이후의 명령의 어드레스는, 호출된 함수가 완료한 이후로 반환하기 위한 어드레스로서 스택 상으로 푸시된다. 따라서, 스택은, 프로세서로 하여금 호출된 함수들이 완료하는 때로 점핑하게 하기 위한 수많은 반환 어드레스들을 포함할 수 있다. 공격이 스택에 정보를 기록할 수 있으면, 의도된 반환 어드레스에 악의적인 반환 어드레스를 겹쳐쓸 수 있다. 이러한 반환 어드레스는 공격에 의해 식별되는 가젯들 중 하나에 대응할 수 있다.

다수의 반환 어드레스들을 조작함으로써, 호출 스택을 제어하는 공격은, 프로세서들의 어드레스 공간으로 임의의 새로운 코드를 전혀 주입하지 않고 악의적인 코드 시퀀스를 생성하기 위해 다수의 가젯들을 함께 엮을(chain) 수 있다. 이러한 악의적인 코드 시퀀스들 및 그들의 어레인지먼트의 선택을 통해서, 공격은 일련의(the string of) 가젯들로 구성된 악의적인 프로그램에 대해 임의적인 거동을 유발할 수 있다. 이러한 유형의 공격은, 대부분의 시스템들에서 코드 및 데이터 어드레스들이 예측가능하기 때문에 성공적이다. 즉, 공격들은 제 1 컴퓨터에서 특정 코드를 로딩할 수 있고, 코드가 어떻게 로딩되는지 결정하기 위해 제 1 컴퓨터의 스택을 관찰할 수 있고, 그리고 이러한 코드가 제 2 (타겟) 컴퓨터에 로딩될 때 반환 스택을 활용하도록 이러한 정보를 이용할 수 있다. 이러한 공격은, 일반적으로, 상이한 컴퓨터들에 걸쳐 동일한 방식으로 로딩되는 코드에 의존할 수 있다.

이에 따라, 반환-지향형 프로그래밍 공격들을 억제할 수 있는 강건한 카운터-측정들에 대한 필요성이 존재한다.

본 개시물의 실시예들은, 스택들 및/또는 메모리에서의 취약성들의 활용을 억제하기 위한 장치들, 방법들, 및 컴퓨터 판독가능을 포함한다.

프로세싱 회로에서 동작가능한 방법은, 실행가능 코드의 실행 방지에 의해 반환 지향형 공격들을 저지(thwart)하기 위해 제공된다. 메모리 디바이스에서 실행가능 코드의 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자는 비-실행가능 상태로 설정될 수 있다. 예를 들어, 이러한 상태 표시자는 복수의 메모리 페이지들의 제 1 서브세트에 상주하는 실행가능 코드의 실행 방지를 수행하도록 기능할 수 있다. 유사하게, 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자는 실행가능 상태로 설정될 수 있고, 여기서 복수의 메모리 페이지들의 제 2 서브세트는 복수의 메모리 페이지들의 제 1 서브세트에서의 함수들에 대한 간접 스터브(indirection stub)들을 포함한다. 복수의 메모리 페이지들의 제 1 서브세트 또는 제 2 서브세트 중 적어도 하나에 대한 상태 표시자가 비-실행가능 상태로 설정되기 전 및/또는 설정된 후에, 실행가능 코드의 복수의 메모리 페이지들이 메모리 디바이스들에 로딩될 수 있다는 점에 주목한다. 실행가능 코드가 상주하는 메모리 디바이스는 가상 메모리를 구현할 수 있다. 그후, 복수의 메모리 페이지들의 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 수정하는, 복수의 메모리 페이지들의 제 2 서브세트에서 대응하는 간접 스터브에 대한 함수 호출이 지시된다. 간접 스터브는, 함수의 실행을 가능하게 하기 위해, 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 비-실행가능 상태에서 실행가능 상태로 수정할 수 있다. 함수 호출의 완료시에, 방법은, 복수의 메모리 페이지들의 제 2 서브세트에서 대응하는 간접 스터브로 반환할 수 있고, 여기서 대응하는 간접 스터브는 그후 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 수정한다. 간접 스터브는 그후, 함수의 실행을 불가능하게 하기 위해, 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 실행가능 상태에서 비-실행가능 상태로 수정할 수 있다.

일 예시에서, 실행 방지를 수행하는 단계는, 실행가능 코드가 실행을 위해 프로세싱 회로에 의해 페칭(fetch)될 때 비-실행가능 상태에 있는 메모리 페이지에 상주하는 임의의 실행가능 코드의 실행을 중단하는 단계를 포함할 수 있다.

일 예시에서, 제 1 명령은 함수 호출의 일부일 수 있고, 제 2 명령은 대응하는 함수의 초기 명령일 수 있다. 간접 스터브는, 제 1 명령 이후에 제 2 명령이 뒤따르지 않는 한 실행이 중단되도록, 제 1 명령을 제 2 명령에 바인딩함(binding)으로써 구현될 수 있다.

실행가능 코드는 단일의 애플리케이션 및/또는 프로세스에 대응할 수 있다. 몇몇 구현들에서, 방법은 또한 함수 호출의 완료시에 프로세싱 회로의 내부 캐시 메모리를 플러싱(flushing)하는 단계를 포함할 수 있다. 몇몇 구현들에서, 간접 스터브들은 실행가능 코드의 컴파일링 스테이지 또는 사전-컴파일링 스테이지에서 발생될 수 있다.

일 예시에 따르면, 함수에 대한 코드는, 복수의 메모리 페이지들의 제 1 서브세트 내에서의 제 1 메모리 페이지에 상주할 수 있다. 실행가능 상태에 있는 제 1 메모리 페이지의 사용은, 모든 진행중인 함수 호출들이 제 1 메모리 페이지 내에서의 대응하는 코드의 실행을 완료했을 시기를 확인하기 위해 추적될 수 있다. 제 1 메모리 페이지에 대한 상태 표시자는 그후, 마지막 진행중인 함수 호출의 완료시에 비-실행가능 상태로 설정된다.

메모리 디바이스 및 프로세싱 회로를 포함하는 프로세싱 디바이스가 또한 제공될 수 있다. 프로세싱 회로는: (a) 메모리 디바이스에서 실행가능 코드의 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자를 비-실행가능 상태로 설정하고; (b) 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자를 실행가능 상태로 설정하고(여기서, 복수의 메모리 페이지들의 제 2 서브세트는 복수의 메모리 페이지들의 제 1 서브세트에서의 함수들에 대한 간접 스터브들을 포함함); 그리고/또는 (c) 복수의 메모리 페이지들의 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 수정하는, 복수의 메모리 페이지들의 제 2 서브세트에서 대응하는 간접 스터브에 함수 호출을 지시하도록 구성될 수 있다.

다른 양상에 따르면, 대응하는 간접 스터브는, 프로세싱 회로에 의해 차례로(in sequence) 실행되도록 제한된 적어도 제 1 명령 및 제 2 명령을 포함할 수 있다. 제 1 명령 이후에 제 2 명령이 아닌 다른 명령이 뒤따르면, 함수 호출의 실행은 중단된다.

프로세싱 회로에서 동작가능한 또 다른 방법이 제공된다. 복수의 함수들을 포함하는 애플리케이션 소스 코드가 발생된다. 소스 코드에서의 각각의 함수에 대한 간접 코드도 또한 획득되고 그리고/또는 발생된다. 메모리로 로딩될 때 소스 코드가 비-실행가능한 것으로서 식별되도록 야기하기 위한 명령들이 부가될 수 있다. 또한, 메모리로 로딩될 때 간접 코드가 실행가능한 것으로서 식별되도록 야기하기 위한 명령들이 부가될 수 있다. 소스 코드 및 간접 코드는 실행가능 코드를 발생시키기 위해 프로세싱 회로에서 변형될 수 있다. 실행가능 코드는 단일의 애플리케이션 및/또는 프로세스에 대응할 수 있다. 간접 스터브들은 실행가능 코드의 컴파일링 스테이지 또는 사전-컴파일링 스테이지에서 발생될 수 있다. 소스 코드 및 간접 코드는, 이들이 메모리로 로딩될 때 별도의 메모리 페이지들에 상주하도록, 컴파일링될 수 있다. 일 예시에서, 제 1 간접 코드는, 제 1 함수가 실행을 위해 인보크되어(invoked) 있을 때, 대응하는 제 1 함수에 대한 메모리 상태 표시자가 비-실행가능 상태에서 실행가능 상태로 스위칭되도록 야기할 수 있다. 다른 예시에서, 제 1 간접 코드는, 제 1 함수가 실행을 종결할 때, 대응하는 제 1 함수에 대한 메모리 상태 표시자가 실행가능 상태에서 비-실행가능 상태로 스위칭되도록 야기할 수 있다. 또 다른 예시에서, 제 1 함수와 연관된 제 1 간접 코드는 제 1 함수를 지목하도록 적응될 수 있고, 여기서 실행가능 코드가 발생될 때, 제 1 간접 코드 및 제 1 함수는 상이한 메모리 페이지들에 로딩되도록 컴파일링된다.

일 양상에 따르면, 간접 코드는 프로세싱 회로에 의해 차례로 실행되도록 제한된 적어도 제 1 명령 및 제 2 명령을 포함할 수 있다. 이 방법은, 제 1 명령 이후에 제 2 명령이 아닌 다른 명령이 뒤따르면, 간접 코드의 실행을 중단하도록 야기하기 위한 명령들을 부가하는 단계를 더 포함할 수 있다.

도 1은, ROP 공격들을 억제하기 위한 하나 또는 그 초과의 특징들이 구현될 수 있는 예시적인 동작 환경, 디바이스, 및/또는 시스템을 예시하는 블록도이다.
도 2는 메모리에서 구현될 수 있는 예시적인 일반적인 호출 스택(general call stack)을 예시한다.
도 3은, 실행가능 코드가 상주하는 모든 또는 대부분의 메모리 공간을 비-실행가능한 것으로서 초기에 태깅함으로써 실행 방지를 수행하도록 적응될 수 있는 예시적인 프로세싱 회로를 예시한다.
도 4는, 데이터 실행 방지 모듈이 캐시 메모리 시스템과 메모리 디바이스 사이에 위치되는 예시적인 프로세싱 회로에 대한 대안적인 구성을 예시한다.
도 5는, 강화된 데이터 실행 방지 특징을 수행하도록 적응된 프로세싱 회로의 일례를 예시하는 블록도이다.
도 6은, ROP(Return Oriented Programming) 활용을 형성하기 위해 함께 이어진(strung) 가젯들을 포함하는 악의적인 코드 시퀀스를 발생시키기 위한 변질된(corrupted) 호출 스택의 일례를 예시한다.
도 7은, 도 5의 프로세싱 회로의 맥락에서 가젯 페치에 어떤 일이 발생하는지 예시하는 블록도이다.
도 8은, 프로세싱 회로에서 코드의 실행을 억제하기 위한 일반적인 예시적인 방법을 예시하는 흐름도이다.
도 9는, ROP 활용들로부터 메모리를 보호하기 위해, 프로세싱 회로에서 동작가능한 다른 예시적인 방법을 예시하는 흐름도이다.
도 10은, ROP 활용들로부터 메모리를 보호하기 위한 예시적인 방법을 예시하는 흐름도이다.
도 11은, 메모리 영역들이 필요로 됨에 또는 호출됨에 따라서, 메모리 영역들의 상태를 수정하는 것을 허용하는 간접 계층의 예시적인 구현을 예시하는 블록도이다.
도 12는, 메모리 영역들이 필요로 됨에 또는 호출됨에 따라서, 메모리 영역들의 상태를 수정하는 것을 허용하는 간접 계층을 구현하기 위한 방법을 예시한다.
도 13은, 이러한 메모리 영역들로의 액세스를 보호하기 위해 애플리케이션 실행가능 코드가 상주하는 메모리 영역들의 상태를 수정하는 것을 허용하는 간접 계층을 애플리케이션 내에서 구현하기 위한 방법을 예시한다.

후술하는 설명에서, 본 개시물이 실행될 수 있는 특정 실시예들이 예시에 의해 도시된 첨부 도면들에 대한 참조가 이루어진다. 실시예들은, 당업자들이 본 발명을 실행하는 것을 가능하게 하기 위해 본 개시물의 양상들을 충분히 상세하게 설명하도록 의도된다. 본 개시물의 범위에서 벗어나지 않고, 다른 실시예들이 활용될 수 있고, 개시된 실시예들에 대한 변경들이 행해질 수 있다. 이하 상세화된 설명은, 제한적인 의미로 취해지지 않고, 본 발명의 범위는 오직 첨부된 청구항들에 의해서만 정의된다.

용어 "데이터"는, 프로세서에 의해 이용될 수 있는 컴퓨팅 명령들 및 프로세서에 의해 동작될 수 있는 데이터를 지칭하도록 본원에서 상호교환가능하게 이용될 수 있다. 용어 "데이터"의 이용의 맥락은, "데이터"가 명령들을 언급할 때 명료하게 되어야만 한다. 필요한 경우, 명령들은 명령들 또는 명령 데이터로서 명료하게 지칭될 수 있다.

개관

본 개시물은, 실행가능 메모리 페이지 및 비-실행가능 메모리 페이지 둘 다를 사용중이 아닐 때 자동으로(by default) "비-실행가능"으로 마킹함으로써 메모리 스택들에서의 취약성들의 활용을 억제하기 위한 장치들, 방법들, 및 머신-판독가능을 나타낸다. 따라서, 프로세싱 회로는, "비-실행가능"으로 마킹된 메모리 페이지들에서의 함수들/명령들에 대한 실행 방지를 구현할 수 있고, 이에 따라 ROP 공격이 실행되게 하는 명령들에 대한 호출들을 억제한다.

일 특징에 따르면, 실행가능 코드에 대한 모든 함수 호출들이 (이러한 실행가능 코드가 상주하는) 메모리 상태를 변경하는 스터브 코드에 맨 처음 재지시되는, 간접 계층이 구현된다. 스터브 코드는, 이러한 실행가능 코드가 상주하는 메모리 영역의 메모리 상태를 디폴트 "비-실행가능" 상태로부터 "실행가능" 상태로 변경할 수 있다. 스터브 코드는 그후, 실제 실행가능 코드를 지목한다. 일 예시에서, 이러한 특징은, 애플리케이션의 소스 코드에서 그리고/또는 이러한 애플리케이션을 실행가능한 것으로 컴파일링할 때 구현될 수 있다. 즉, 간접 계층(예를 들어, 스터브 코드)는, 소스 코드 내에서 자생적으로(natively) 발생될 수 있고, 그리고/또는 이는 컴파일 시간에 발생될 수 있다.

일 양상에 따르면, 프로세싱 회로는, "비-실행가능" 메모리 페이지들에서 발견되는 코드/명령들의 실행 방지를 구현할 수 있다. 실행가능 명령들을 포함하는 메모리 페이지들은 초기에 메모리로 로딩되고, (간접 계층에 대한 스터브 코드가 상주하는 페이지들을 제외한) 모든 페이지들은 자동으로 "비-실행가능"으로 마킹된다. 프로세싱 회로 상에서 동작하는 적당한 애플리케이션들로부터 개시된 함수 호출들은, 이러한 메모리 페이지(들)로부터의 명령들/코드를 리트리브 그리고/또는 실행하기 전에, 또는 그와 동시에, 메모리 페이지의 상태를 "비-실행가능"에서 "실행가능"으로 변경하는 간접 계층(즉, 스터브 코드)을 통과한다. 명령/코드의 실행 이전에, 프로세싱 회로는, "실행가능"으로 마킹된 메모리 페이지에서 기원함을 체크하고 그리고/또는 확인할 수 있다. ROP 공격으로부터의 호출들은, 간접 계층(스터브 코드들)을 우회한다. 따라서, "비-실행가능"으로 마킹된 메모리 페이지들로부터의 명령들(예를 들어, 가젯들)을 이용하도록 시도하는 ROP 공격은, 프로세싱 회로가 그들의 실행을 방지 또는 중단하기 때문에, 실패할 것이다.

또 다른 양상에 따르면, 간접 코드는 프로세싱 회로에 의해 차례로 실행되도록 제한된 적어도 제 1 명령 및 제 2 명령을 포함할 수 있다. 제 1 명령 이후에 제 2 명령이 아닌 다른 명령이 뒤따르면, 함수 호출의 실행은 중단된다. 일 예시적인 구현에서, 별도의 간접 계층을 구현하기 위한 추가적인 명령들에 대한 필요성을 회피할 수 있다. 대신에, 쌍을 이룬 대응 명령들(예를 들어, 제 1 명령 및 제 2 명령)이 이용될 때, 이들은 프로세서로 하여금 실행가능 상태와 비-실행가능 상태 사이에서 메모리 페이지를 스위칭하도록 야기할 수 있고 그리고/또는 뒤따르는 코드를 실행하도록 야기할 수 있다. 몇몇 구현들에서, 제 1 명령 및 제 2 명령이 차례로 시행되도록 바인딩되기 때문에, 실행가능 상태와 비-실행가능 상태 사이에서 스위칭해야 할 어떠한 필요성도 존재하지 않을 것이며, 이는, 제 1 명령 이후에 제 2 명령이 아닌 다른 명령이 뒤따른다면 프로세서가 모든 후속 실행을 중단하기 때문이다.

예시적인 동작 환경

도 1은, ROP 공격들을 억제하기 위한 하나 또는 그 초과의 특징들이 구현될 수 있는 예시적인 동작 환경, 디바이스, 및/또는 시스템(100)을 예시하는 블록도이다. 동작 환경(100)은 하나 또는 그 초과의 메모리 및/또는 저장 디바이스들에 커플링된 프로세싱 회로(102)(예를 들어, 하나 또는 그 초과의 프로세서들)를 포함할 수 있다. 일례에서, 동작 환경(100)은 가상 메모리로 알려진 메모리 관리 기법을 구현할 수 있다. 가상 메모리는, 커널들을 멀티태스킹하기 위해 개발된 기법이다. 가상 메모리는, 다양한 형태들의 데이터 및/또는 실행가능 코드 저장소, 예를 들어, 랜덤-액세스 메모리 및 디스크 저장소를 가상현실화하여, 프로그램으로 하여금 마치 직접 어드레싱가능한 판독/기록 메모리(RAM)로서 거동하는, 오직 하나의 종류의 메모리, 예컨대, "가상" 메모리만이 존재하는 것처럼 설계되도록 허용한다. 가상 메모리를 지원하는 수많은 운영 시스템들은 또한, 자신 소유의 전용 어드레스 공간(예를 들어, 자신 소유의 가상 메모리)에서 각각의 프로세스를 구동시킬 수 있어서, 프로그램 또는 애플리케이션으로 하여금 마치 가상 메모리로의 단독 액세스를 가진 것처럼 설계되도록 허용한다. 예를 들어, 복수의 전용 어드레스 공간들(120a, 102b, 120c)이 여기에 도시되고, 여기서는 이러한 어드레스 공간들 각각이 상이한 프로세스, 프로그램, 및/또는 애플리케이션과 연관될 수 있다.

이 예시에서, 가상 메모리(104)는 하나 또는 그 초과의 물리적 메모리 디바이스들(108) 및/또는 영구 저장 디바이스(106) 내에서의 어드레싱가능한 메모리 공간을 나타낸다. 프로세싱 회로(102)는 물리적 메모리 디바이스(들)(108) 및/또는 영구 저장 디바이스(106)에 로딩된 코드 및/또는 데이터의 형태로 실행가능 명령들을 판독하기 위해 가상 메모리(104)(또는 가상 메모리에 의해 맵핑된 메모리 어드레스들)에 액세스하도록 적응될 수 있다.

일례에 따르면, 가상 메모리(104)는 힙(heap)(110), 스택(112), 일정 데이터(114), 초기화된 데이터(116), 및 실행가능 명령들(118)로 배열될 수 있다. 힙(110)은, 다양한 소프트웨어 프로그램들이 프로세싱 환경(100) 내에서 액티브일 수 있는 동안 다양한 소프트웨어 프로그램들에 대한 동적 할당에 이용될 수 있다. 다양한 데이터, 예를 들어, 일정 데이터(114) 및 초기화된 데이터(116)가 프로세싱 환경(100) 상에서 구동하는 하나 또는 그 초과의 프로그램들에 의한 액세스를 위해 메인 메모리 디바이스(104)에 저장될 수 있다. 다양한 프로그램들과 연관된 실행가능 명령들(118)이, 명령 영역(118), 힙(110), 또는 이들의 조합들에 저장될 수 있다.

달리 특정하여 언급되지 않는 한, 용어 "메모리"는, 실행가능 명령들 및/또는 데이터가 프로세싱 회로(102)에 의해 액세스되는(예를 들어, 그로부터 판독되고 그리고/또는 그에 기록되는) 가상 메모리 및/또는 임의의 다른 어드레싱가능한 메모리 공간을 지칭하도록 이하에서 이용된다. 본원에 설명된 개념들은, 다양한 유형들의 메모리 아키텍쳐들로 동작한다. 예를 들어, 가상 메모리는 프로세싱 회로(102) 외부의 메모리 디바이스(예를 들어, 메인 메모리)에서 구현될 수 있고 그리고/또는 프로세싱 회로(102) 내에서의 메모리 디바이스(예를 들어, 내부 캐시 메모리)에서 구현될 수 있다.

일 특징에 따르면, 반환-지향형 프로그래밍 공격들을 방지하도록 돕기 위해 데이터 실행 방지가 프로세싱 회로(102)에 의해 구현된다. 일 양상에 따르면, 실행 이전에, 프로세싱 회로(102)가 코드를 실행할 때 이용될 수 있는 대응하는 간접 코드(스터브들)와 함께, 실행가능 명령들이 가상 메모리(104)에 로딩될 수 있다. 프로세싱 회로(102)는 그후 가상 메모리(104)로부터 명령들/데이터를 판독할 수 있고, 그리고/또는 가상 메모리(104)에 명령들/데이터를 기록할 수 있다.

이러한 특징에서, 실행가능 코드가 상주하는 모든(또는 대부분의) 메모리 페이지들은, 이 메모리 페이지들이 가상 메모리(104)로 로딩(또는 맵핑)되기 때문에, 비-실행가능한 것으로 마킹될 수 있다. "No eXecute"를 나타내는 NX 비트가, 명령들(또는 코드)의 저장을 위해 또는 데이터의 저장을 위해 메모리의 별도의 영역들에 대해 몇몇 프로세싱 회로들에 의해 이용될 수 있다. NX 비트에 대한 지원과 함께 (프로세싱 회로(102) 상에서 구동하는) 운영 시스템은, 실행가능 코드가 상주하는 가상 메모리(104)의 전체 영역들을 비-실행가능한 것으로 마킹할 수 있다. 일례에서, 간접 코드(스터브들)가 상주하는 가상 메모리(104)의 영역들은 실행가능한 것으로 마킹될 수 있다. 이러한 간접 코드(스터브들)는 소스 코드에 삽입될 수 있거나 또는 애플리케이션의 컴파일 시간에 발생될 수 있다. 애플리케이션으로부터의 함수 호출들은, 메모리 상태를 "비-실행가능"과 "실행가능" 사이에서 변경하는 간접 코드를 호출할 수 있고(또는 그 간접 코드로 재지시될 수 있고), 그후 실행가능 코드의 대응하는 부분에 대해 실행을 지시한다.

메모리 페이지가 가상 메모리(104)로부터 프로세싱 회로(102)에 의해 로딩되고/페칭되는 매번, 프로세싱 회로(102) 내에서 동작하는 간접 계층(예를 들어, 스터브)은 로딩/페칭 이전에 (또는 이와 동시에) NX 비트를 "비-실행가능"에서 "실행가능"으로 변경한다. 즉, 메모리 페이지에서의 함수가 프로세싱 회로(102)에 의해 실행되는 애플리케이션/프로그램에 의해 인보크되어 있을 때, 메모리 페이지는 간접 계층에 의해 "비-실행가능"에서 "실행가능"으로 (간접 계층에 의해) 변경된다. 메모리 페이지가 "실행가능"한 것으로 이미 마킹되었다면(즉, 메모리 페이지가 비-실행가능에서 실행가능으로 사전에 변경되었다면), 간접 계층은 NX 비트를 비-실행가능으로 변경할 필요는 없다.

프로세싱 회로(102)는, 가상 메모리(104)에서 "비-실행가능"으로 마킹된 메모리 페이지들에 상주하는 임의의 코드의 실행을 차단하는 실행 방지 모듈을 포함할 수 있다. 원하는 함수(들)의 실행을 완료하면, 대응하는 실행가능 코드가 가상 메모리(104)에 상주하는 메모리 페이지는 "실행가능"에서 다시 "비-실행가능"으로 스위칭될 수 있다.

"비-실행가능"으로 마킹된, 가상 메모리에서의 메모리 페이지들로부터의 명령들에 액세스하기 위해 시도하는 ROP 공격은 실패할 것이다. 이러한 메모리 페이지들(예를 들어, 메모리에서의 영역들)에서 모든 실행가능 코드(예를 들어, 명령들)를 "비-실행가능"으로 초기화하고 그리고 오직 이러한 메모리 페이지들이 간접 계층을 통해서 프로세싱 회로(102)에 의해 호출되고/페칭될 때만 이러한 메모리 페이지들(예를 들어, 영역들, 또는 세그먼트들)의 상태를 "실행가능"으로 변경함으로써, ROP 공격은 현재 "실행가능"으로 마킹된 (가상 메모리(104) 내의) 이러한 메모리 영역들로부터의 명령들을 호출하는 것으로 제한된다. ROP 공격으로부터의 호출들은 간접 계층(스터브들)을 우회할 것이다. 따라서, (가상 메모리(104) 내의) 다른 메모리 페이지들로부터의 명령들(예를 들어, 가젯들)을 이용하도록 시도하는 ROP 공격은 "비-실행가능"으로 마킹된다. 따라서, 이러한 "비-실행가능" 페이지들의 리트리벌 시에, 프로세싱 회로(102)의 실행 방지 특징/모듈은 이러한 메모리 페이지들에서 명령들의 실행을 방지 또는 거절할 것이다. 모든 메모리 페이지들을 "비-실행가능"으로 마킹하는 것은, ROP 공격이 명령들을 이용할 수 있는 메모리 페이지들의 수를 크게 감소시킨다. ROP 공격에 이용가능한 "실행가능" 명령들을 추가로 감소시키기 위해, 함수가 종결되면, 대응하는 메모리 페이지는 가상 메모리(104)에서 "비-실행가능"으로 다시 설정된다.

NX 비트들을 이용함에 의한 실행 방지는 통상적으로 애플리케이션 스택 및 데이터를 포함하는 다른 메모리 범위들/영역들에 대해 행해진다. 그러나, 본 특징에 따르면, 애플리케이션의 적당한 실행가능 명령들(예를 들어, 코드, 함수들 등)을 포함하는 메모리 범위들 또는 페이지들은 비-실행가능으로 마킹된다.

도 2는 메모리에서 구현될 수 있는 예시적인 일반적인 호출 스택(200)을 예시한다. 호출 스택(200)은, 함수가 호출될 때 이용될 수 있는 다양한 정보를 저장하는데 이용될 수 있다. 스택 상에 푸시되는 각각의 함수는, 호출된 함수들(A, B, 및 C) 각각에 대해 프레임들(202A, 202B, 및 202C)로 표시된 것과 같이 프레임(202)을 점유한다.

비-제한적 예시로서, 호출 스택(200)의 각각의 프레임(202)은, 호출자 함수에서 호출된 함수로 통과되는 정보, 예를 들어, 파라미터들을 포함할 수 있다. 호출 스택(200)은 또한 호출된 프로그램에 의해 이용될 수 있는 다양한 로컬 변수들을 저장하기 위한 메모리의 영역을 포함할 수 있다. 호출하는 함수에서 호출된 함수가 실행을 완료한 이후에 실행이 계속되어야만 함을 나타내는 반환 어드레스가 또한 호출 스택(200)에 포함될 수 있다. 호출 스택(200)은, 스택 상에 푸시된 마지막 데이터가 스택으로부터 팝핑된(popped) 제 1 데이터임을 의미하는 LIFO(Last In First Out) 버퍼로서 동작할 수 있다. 호출 스택(200)은, 수많은 함수 호출들이 다른 함수들 내에 내포되어 있음을 나타내는 콰이어트 딥(quite deep)일 수 있다.

프레임 포인터(204)는 일반적으로 현재 실행되는 함수의 프레임(202)을 지목한다. 스택 포인터(206)는 팝 오프(popped off)되어 프로세서에 반환되도록 이용가능한, 스택(200) 상의 데이터의 다음 포지션을 지목한다.

ROP 활용들은 다양한 프레임들(202A, 202B, 및 202C)의 반환 어드레스 부분에 악의적인 어드레스를 기록함으로써 스택 데이터 구조의 이점을 취한다. 공격자는, 예를 들어, 표준 C 라이브러리와 같은, 메모리 또는 운영 시스템의 일부분들에 상주할 수 있는 코드를 검토할 수 있다. 공격자는 그후, ROP 명령들의 라이브러리를 생성하기 위해 수많은 이러한 가젯들(즉, 작은 코드 스니펫들)을 식별할 수 있다. 이러한 ROP 명령들은 그후, 어떤 코드도 메모리에 삽입하지 않고 유용한, 의도되지 않은, 그리고 악의적인 코드 시퀀스를 생성하기 위해 함께 이어질 수 있다. 오히려, 공격자는 원하는 가젯들의 시작을 지목하기 위해 호출 스택(200) 상에서 반환 어드레스들을 오직 변경해야만 한다. 따라서, 호출 스택에 관련된 동작들은 ROP 활용들에 의해 변질될 수 있다. 그러나, 이러한 ROP 활용들에 의해 이용되는 가젯들이 프로세싱 회로에 의해 이용되는 간접 계층을 우회시킴으로써 리트리브되기 때문에, 이러한 가젯들은 "비-실행가능"한 것으로 마킹된 메모리 페이지들에서 발견될 가능성이 높다. 따라서, 프로세싱 회로는 자신의 실행을 거절 또는 중단할 것이다.

데이터 실행 방지를 갖는 예시적인 프로세싱 회로

도 3은, 실행가능 코드가 상주하는 모든 또는 대부분의 메모리 공간을 초기에 비-실행가능으로서 태깅함으로써 실행 방지를 수행하도록 적응될 수 있는 예시적인 프로세싱 회로(302)를 예시한다. 프로세싱 회로(302)는, 하나 또는 그 초과의 프로세서들(310) 및 선택적으로는, 캐시 메모리 시스템(312)을 포함할 수 있다. 프로세싱 회로(302)는, 외부 디바이스들, 예를 들어, 메모리 디바이스(304), 다양한 통신 인터페이스들(306), 및/또는 하나 또는 그 초과의 입력/출력(I/O) 인터페이스들(308)에 커플링될 수 있다. 비-제한적인 예시들로서, 통신 인터페이스들(306)은, 버스, 셀룰러 네트워크들, 직렬 포트들, 병렬 포트들, 이더넷 접속들, USB 접속들, IEEE 1394("방화벽") 접속들, 블루투스 무선 접속들, 802.1 a/b/g/n 유형 무선 접속들을 통한 통신을 위한 인터페이스들, 및 다른 적합한 통신 프로토콜들 및 인터페이스들을 포함할 수 있다. 비-제한적인 예시들로서, I/O 인터페이스들(308)은 디바이스들, 예를 들어, 키보드들, 마우스들, 트랙볼들, 햅틱 디바이스들, 오디오 입력들 및 출력들, 및 디스플레이들로의 인터페이스들을 포함할 수 있다.

몇몇 캐시 메모리 시스템들(312)은 캐시 메모리의 2개 또는 그 초과의 레벨들(314)을 포함하는 다중-레벨 캐시를 포함한다. 이 예시에서, 제 1 레벨의 캐시는 별도의 명령 캐시(316) 및 데이터 캐시(318)를 포함할 수 있다. 데이터로부터 명령들을 분리하는 것은, 명령들 및 데이터에 대해 상이할 수 있는 시간적 및 공간적 근접성의 이점을 취하기 위한 그리고 정보를 페칭하기 위한 병렬 경로들을 생성함으로써 성능 향상들을 생성할 수 있다. 제 2 레벨의 캐시는, 명령 캐시(316)에 대한 명령들 및 데이터 캐시(318)에 대한 데이터 둘 다를 포함하는 통합된 캐시(320)로서 구성될 수 있다. 이에 더해, 캐시 메모리 시스템(312)은, 캐시 설계 업계에서의 당업자들에 의해 공지된 바와 같이, 예를 들어, 설정-연관 캐시들과 같은 캐시들에 대한 상이한 구성 및 꽉 찬 캐시들에 대한 다양한 대체 프로토콜들을 포함할 수 있다.

캐시들은, 메인 메모리(304)로부터 이러한 데이터 및/또는 명령들을 페칭하도록 진행해야만 하는 것에 관련된 명령들 및 데이터의 더 빠른 리트리벌을 허용한다. 통상적인 메모리와 비교하여 그 크기에 있어서의 트레이드오프가 존재한다. 일반적으로, 더 작은 메모리가 더 높은 대역폭, 더 낮은 레이턴시 또는 이 둘의 조합을 갖는다. 메모리 디바이스(304)는, 통상적으로 비교적 양호한 대역폭을 가질 수 있지만 비교적 긴 레이턴시들을 가질 수 있는 동적 랜덤 액세스 메모리(DRAM; Dynamic Random Access Memory)로서 구현된다. 캐시 메모리 시스템(312)에서 빈번하게 이용되는 데이터 및 명령들을 캐싱함으로써, 프로세서(312)에 의한 페치들이 훨씬 더 빠르게 그리고 더 높은 대역폭에서 수신될 수 있다. 일반적인 규칙으로서, 레벨 1 캐시들(즉, 프로세서(316 및 318)에 가장 가까운 캐시들)은 더 작고, 더 빠르며, 그리고 더 낮은 레이턴시를 갖는다. 레벨 2 캐시들(320)은 일반적으로 더 크고, 더 느릴 수 있으며, 그리고 더 긴 레이턴시들을 가질 수 있다. 그러나, 이들은, 제 2 레벨의 캐시를 포함함으로써 성능 개선들이 가능하도록, 메모리 디바이스(304)보다 여전히 더 빠르다.

캐시 메모리 시스템들의 다양한 예시들에 따르면, 하나 또는 그 초과의 레벨들이 이용될 수 있고, 각각의 레벨은 통합된 캐시 또는 별도의 명령 캐시들 및 데이터 캐시들로서 구현될 수 있다. 본원에 논의된 실시예들은 명령들과 대부분 관련된다. 결과로서, 논의들은, 명령 캐시들(316) 및/또는 통합된 캐시(320)를 특정하여 지칭할 수 있다. 그러나, 당업자는, 실시예들이 명령 캐시(316) 및 통합 캐시(320) 둘 다에서 그리고 임의의 레벨의 캐시 상에서 실행될 수 있음을 인식할 것이다.

일 특징에 따르면, 하나 또는 그 초과의 프로세서들(310)에 의해 이용되는 가상 메모리는, 캐시 메모리 시스템(312)(예를 들어, 캐시 메모리 시스템 내의 임의의 레벨) 내에 및/또는 메모리 디바이스(304) 내에 상주할 수 있다. 프로세싱 회로(302)는 또한 실행 방지 모듈(322)을 포함 또는 구현할 수 있다. 이 예시에서, 실행 방지 모듈(322)은, 프로세서들(310)과 메모리 디바이스(304)과 캐시 메모리 시스템(312) 사이에 커플링될 수 있다. 이 예시에서, 가상 메모리는 메모리 디바이스(304) 및/또는 캐시 메모리 시스템(312) 상에서 구현될 수 있다. 도 4는, 실행 방지 모듈(322)이 캐시 메모리 시스템(312)과 메모리 디바이스(304) 사이에 위치되는 예시적인 프로세싱 회로(402)에 대한 대안적인 구성을 예시한다. 이 예시에서, 가상 메모리는 메모리 디바이스(304)에서 구현될 수 있다.

일 특징에 따르면, 모든 또는 대부분의 메모리 페이지들은, 이들이 가상 메모리로 페칭 또는 맵핑되기 때문에, 비-실행가능으로 초기에 마킹된다. 프로세싱 회로(302)는 그후 메인 메모리(304)에서 "비-실행가능"으로 마킹된 이러한 영역들에 상주하는 임의의 코드를 실행하는 것을 거절한다. 대신에, 페이지가 메인 메모리(304)에서 캐시 메모리(312)로 로딩/페칭되는 매번, 실행 방지 모듈(322)은, NX 비트를 캐시 메모리(312)로 로딩하기 전에 그 NX 비트를 비-실행가능에서 실행가능으로 변경한다(또는 변경하도록 야기한다). 캐시 메모리(312)로 로딩되면, 그 페이지에서의 함수들이 실행될 수 있다.

"비-실행가능"으로 마킹된, 가상 메모리에서의 페이지들로부터의 명령들에 액세스하기 시도하는 ROP 공격은 실패할 것이다. 모든 명령 페이지들을 "비-실행가능"으로서 초기화함으로써 그리고 오직 이러한 메모리 페이지가 실행 방지 모듈(322)을 통해서 페칭될 때만 이러한 메모리 페이지 상태를 "실행가능"으로 변경함으로써, ROP 공격은 현재 "실행가능"으로 마킹된 이러한 메모리 페이지들로부터의 명령들을 호출하는 것으로 제한된다. "메모리 페이지들"이 본원에 설명된 수많은 예시들에 이용되지만, 동일한 또는 상이한 크기들의 임의의 메모리 유닛, 세그먼트, 범위는 "비-실행가능" 및/또는 "실행가능"으로 마킹될 수 있음을 주목한다. ROP 공격으로부터의 호출들이 데이터 실행 방지 모듈(322)을 우회하기 때문에, 이 호출들이 실행하도록 추구하는 명령들(예를 들어, 가젯들)은 실패할 것이며, 이는 이러한 메모리 페이지들이 "비-실행가능"으로 마킹되기 때문이다. 가상 메모리에서 모든 메모리 페이지들을 "비-실행가능"으로 자동으로 마킹하는 것은, ROP 공격이 명령들을 이용할 수 있는 메모리 페이지들의 수를 크게 감소시킨다. ROP 공격에 대해 이용가능한 "실행가능" 명령들을 추가로 감소시키기 위해, 함수가 종결하면, 자신의 대응하는 메모리 페이지는 캐시 메모리로부터 플러시될 수 있고 그리고/또는 가상 메모리에서 비-실행가능한 것으로 다시 설정된다.

도 5는, 강화된 실행 방지 특징을 수행하도록 적응된 프로세싱 회로의 일례를 예시하는 블록도이다. 프로세싱 회로(502)는, 비-실행 비트 모듈(536)과 함께, 착신 스터브(508) 및/또는 발신 스터브(510)를 포함하는 간접 계층을 구현할 수 있다. 일례에서, 착신 스터브(508) 및/또는 발신 스터브(510)는, 메모리로 로딩되는 애플리케이션의 일부일 수 있다. 그러나, 이러한 착신 스터브(508) 및/또는 발신 스터브(510)는 ("X 플래그"로 표시된) "실행가능"으로 마킹된 메모리의 상이한 영역으로 로딩될 수 있는 반면, 애플리케이션의 대응하는 실행가능 코드는 자동으로 ("NX 플래그"로 표시된) "비-실행가능"으로 마킹된 메모리 영역들로 로딩될 수 있다. 이러한 예시에서, 간접 스터브들(540)이 자동으로 실행가능한 것으로 설정된 NX 플래그를 갖는 제 1 메모리 페이지(542)로 로딩된다. 대응하는 실행가능 코드는 메모리 페이지들 k(512), 및 q(548)로 로딩된다. 여기서, 각각의 실행가능 함수가 대응하는 착신/발신 스터브를 갖는다는 것을 인식할 수 있다. 예를 들어, 메모리 페이지 k(512)에서의 함수 F는 대응하는 착신/발신 스터브 F(544)를 갖는다. 유사하게, 페이지 k(512)에서의 함수 I는 대응하는 착신/발신 스터브 I(552)를 갖고, 페이지 q(548)에서의 함수 J는 대응하는 착신/발신 스터브 J(554)를 갖는다. 이 예시에서, 착신 스터브(508) 및 발신 스터브(510)는 착신/발신 스터브 F(544)의 논리적 표현이다.

일 예시에 따르면, 스터브들(508/510)은 간접 계층으로서 기능할 수 있고, 프로세싱 회로(502)에 의해 실행되는 애플리케이션의 일부일 수 있다. 스터브들(508/510)은, 애플리케이션(514)으로부터/으로 함수 호출들을 교차하도록 기능할 수 있고, 그리고/또는 애플리케이션의 하나 또는 그 초과의 대응하는 함수들(실행가능 코드)와 특정하여 연관될 수 있다.

예시의 목적들을 위해, 착신 스터브(508) 및 발신 스터브(510)는, 프로세싱 회로(502) 내에 도시되고, 가상 메모리(504)로부터 (예를 들어, 메모리 페이지 1(542))로부터 로딩된 발신/착신 스터브들을 나타내도록 기능한다. 임의의 시간에 액티브/개방 상태에 있는 함수 호출들의 수에 따라, (예를 들어, 메모리 페이지 1(542)로부터의) 다수의 착신/발신 스터브들이 프로세싱 회로(502)에 의해 로딩될 수 있음이 주목된다. 착신 스터브(508)는, 메모리 페이지에 대한 비-실행가능(NX) 플래그(항상 일 비트)를 실행가능(X) 플래그로 변경하도록 기능하고, 그후 메모리 페이지 내에서 호출된 함수로 제어를 트랜스퍼하여, 호출된 함수가 완료되면 프로세스를 반전(예를 들어, 메모리 페이지를 실행가능(X)에서 비-실행가능(NX)로 설정)시킬 수 있다.

도 5에 예시된 예시에서, 프로세싱 회로에 의해 애플리케이션(514)을 실행할 때, 함수 F(520)에 대한 호출(여기서, 함수 F(550)는 가상 메모리(504) 내에서 메모리 페이지 k(512)에 상주함)이 행해질 수 있다. 가상 메모리(504)로부터 호출된 함수(함수 F)를 직접 페칭하는 것보다는, 함수 호출(520)이 대신에 착신 스터브(508)로 전송된다. 예를 들어, 함수 F에 대한 호출이 인보크되면, 착신 스터브 F(544)가 페칭되고 실행된다(예를 들어, 착신 스터브(508)로서 예시된다). 착신 스터브(508)(예를 들어, 착신 스터브 F(544))는, 비-실행가능(NX) 플래그/비트로 하여금, 프로세싱 회로(502)에 의한 함수 F(550)의 페칭 및/또는 로딩(524) 이전에, 함수 F(550)가 상주하는 메모리 페이지 k(512)로부터 클리어/제거되도록(522)(즉, 실행가능(X) 플래그 비트로 설정되도록) 야기한다. 비-실행 (NX) 플래그 체킹 모듈(536)은, 프로세싱 회로(502)에 의한 함수 F(550)의 로딩 및/또는 실행 이전에, 메모리 페이지가 실행가능(X)으로 마킹되는지 또는 비-실행가능(NX)으로 마킹되는지를 확인할 수 있다. 오직 가상 메모리(504)에서 "실행가능"(X)으로 마킹된 메모리 페이지들(또는 메모리 영역들/세그먼트들)에서 발견된 명령들만이, 프로세싱 회로(502)에 의해 실행되도록 허용된다.

여기서 메모리 페이지 및/또는 명령들이 가상 메모리(504)에서 "실행가능한"으로 마킹되고 프로세싱 회로(502)로 페칭되는 것으로 확인되었다면, 이러한 명령들은 보통 프로세싱 회로(502)에 의해 실행될 수 있다. 여기서, 함수 F(550)가 로딩된 메모리 페이지 k(512)로부터 실행된다. 함수 F(550)의 실행의 완료시에, 함수 F로부터의 반환(528)은 발신 스터브(510)(즉, 발신 스터브 F(544))에 전송된다. 발신 스터브(510)는 호출 애플리케이션(514)에 실행 제어를 반환할 수 있다. 추가적으로, 발신 스터브(510)는 또한, 가상 메모리(504)에서의 페이지 k(512)에 대한 비-실행가능(NX) 페이지 플래그를 설정(530)(즉, 실행가능 상태에서 비-실행가능 상태로 스위치)할 수 있을 뿐만 아니라 프로세싱 회로(502)에 의해 이용될 수 있는 임의의 선택적인 캐시 메모리로부터 페이지 k를 플러싱(534)할 수 있다. 함수 호출이 종료하면 캐시 메모리(506)로부터 페이지를 플러싱하는 것은, ROP 공격에 이용가능한 실행가능 명령들의 수를 최소화한다.

대안적인 구현에서, 착신 스터브는 실행가능으로서 이미 마킹된 메모리 페이지로 함수/명령을 이동시킬 수 있고, 그후 호출된 함수에 대한 제어를 트랜스퍼한다(예를 들어, 의도된 함수 F를 호출한다). 호출된 함수(예를 들어, 함수 F)가 실행을 완료한 후, 이전 동작들을 반전시키는(즉, 실행가능한 것으로 이미 마킹된 메모리 페이지로부터 함수/명령을 제거하고 그리고/또는 캐시로부터 메모리 페이지 k(512)의 임의의 카피를 플러시하는) 발신 스터브(530)로 반환이 우회(divert)된다.

이러한 시스템의 성능은, 동일한 또는 가까운 메모리 페이지들 상에 "호출자" 및 "피호출자" 함수들을 위치시킴으로써, 일 세트 또는 일 블록의 메모리 페이지들 상에 비-실행가능 플래그를 한 번에 설정 및 클리어링함으로써, 그리고/또는 모든 각각의 함수 진입(entry) 및 배출(exit)보다 덜 빈번하게 실행가능 상태와 비-실행가능 상태 사이를 스위칭함으로써 개선될 수 있다. 예를 들어, 함수 F가 함수 P를 호출하는 함수 M을 호출하면, 이러한 함수들은 가상 메모리(504)로부터 함께 로딩되거나 또는 페칭될 수 있는 동일한 메모리 페이지 또는 블록의 페이지들에 위치되는 것이 유리할 것이다. 따라서, 함수 F가 인보크될 때 비-실행가능(NX) 페이지 플래그를 변경하는 것은, 또한 추가적인 페이지 로딩들 및 NX 상태 변경들 없이 후속으로 호출된 함수들 M 및 P를 실행가능하게 하도록 기능할 수 있다.

ROP 활용들은 일반적으로, 필수적으로 종종 액세스되지 않는 메모리의 수많은 상이한 영역들에 위치될 수 있는 명령들(예를 들어, 가젯들)의 짧은 스니펫들의 속성으로 인해, 불량한 공간적 근접성 및 불량한 시간적 근접성을 갖는다.

도 6은 ROP(Return Oriented Programming) 활용을 형성하기 위해 함께 이어진 가젯들을 포함하는 악의적인 코드 시퀀스를 발생시키기 위한 변질된 호출 스택(600)의 일례를 예시한다. 변질된 호출 스택(600)은, 변질된 호출 스택(600) 상에서 반환 어드레스들 중 하나 또는 그 초과를 수정하는 공격자로 인해 변질된 형태에 있다. 명령들을 포함하는 메모리(602)의 일부가 또한 도 6에 예시된다.

변질된 호출 스택(600)은, 함수들(U, V, W, X, Y 및 Z)에 대한 프레임들(함수 호출들)을 포함할 수 있다. 변질된 호출 스택(600)으로부터 메모리(602)로의 실선 화살표들은, 특정 가젯의 시작시에 프로세싱 회로가 실행을 시작하도록 야기하는 스택에서 팝 오프된(popped off) 반환 어드레스들을 나타낸다. 메모리(602)로부터 변질된 호출 스택(600)으로의 점선 화살표들은, 스택으로부터 반환 어드레스를 페칭하기 위해 특정 가젯의 종료시에 실행되는 반환 명령을 나타낸다.

변질된 호출 스택(600)에서, 함수 Z(608)에 대한 반환 어드레스는 가젯 A(612)의 시작 어드레스(610)(즉, GA 반환 어드레스)를 지목하도록 수정되었다. 유사하게, 함수 Y(614)에 대한 반환 어드레스는 가젯 B(618)의 시작 어드레스(616)(즉, GB 반환 어드레스)를 지목하도록 수정되었고, 함수 W(620)에 대한 반환 어드레스는 가젯 E(624)의 시작 어드레스(622)(즉, GE 반환 어드레스)를 지목하도록 수정되었고, 함수 V(626)에 대한 반환 어드레스는 가젯 D(630)의 시작 어드레스(628)(즉, GD 반환 어드레스)를 지목하도록 수정되었으며, 함수 U(632)에 대한 반환 어드레스는 가젯 C(636)의 시작 어드레스(634)(즉, GC 반환 어드레스)를 지목하도록 수정되었다. 이 예시에서, 함수 X(640)에 대한 반환 어드레스(638)는 수정되지 않았다.

이러한 수정들로 인해, 함수 Z(608)가 자신의 동작을 완료하고 반환 명령이 적절한 위치로 반환되지 않고 수행될 때, 제어는, 어드레스가 함수 Z(608)의 반환 어드레스(610)에 위치되게 하기 위한 가젯 A(612)의 시작에서 계속한다. 모든 각각의 가젯은 반환 명령을 통해 종료한다. 따라서, 가젯 A(612)이 완료될 때, 자신의 반환 명령은 함수 Y(614)의 반환 어드레스(616)를 지목한다. 그러나, 함수 Y(614)의 반환 어드레스(616)는 가젯 B(618)의 시작을 지목하도록 수정되었다. 그 결과, 적절한 위치로의 반환 대신에, 제어는, 가젯 B(618)의 시작에서 계속한다. 가젯 실행들을 계속하면서, 가젯 B(618)가 완료한 후 함수 U(632)에 대한 적절한 위치로의 반환 대신에, 제어는, 가젯 C(636)의 시작에서 계속한다. 가젯 C(636)가 완료한 후, 함수 V(626)에 대한 적절한 위치로의 반환 대신에, 제어는, 가젯 D(630)의 시작에서 계속한다. 가젯 D(630)가 완료한 후, 함수 W(620)에 대한 적절한 위치로의 반환 대신에, 제어는, 가젯 E(624)의 시작에서 계속한다. 가젯들 A-E의 이러한 함께 이어짐(stringing)은, ROP 활용의 적어도 일부를 수행하는 중요한 함수들을 수행할 수 있다.

그러나, 본원에 논의되는 프로세싱 회로들이 데이터 실행 방지를 활용하고, 그리고 메모리에서의 모든 메모리 페이지 영역들이 자동으로 "비-실행가능"으로 마킹되기 때문에, 오직 간접 계층을 통해서 호출되었던 함수들/명령들(예를 들어, 착신 스터브(508) 및 발신 스터브(510))만이 "실행가능"으로 마킹된 메모리 페이지들 상에 상주하도록 보장된다. 결과적으로, "비-실행가능"으로 마킹된 메모리 영역에 위치된 임의의 가젯은, 이러한 가젯 호출들이 간접 계층을 우회하기 때문에, 프로세싱 회로에 의한 실행에 실패할 것이다.

도 7은, 도 5의 프로세싱 유닛의 맥락에서 가젯 페치에 어떤 일이 발생하는지 예시하는 블록도이다. 이 예시에서, 다양한 함수들이 가상 메모리(504)로 로딩되었다. 스택은, 페이지 q(548)로부터 가젯(702)을 로딩하기 위한 호출이 발생하도록, 해킹되었을 수도 있다. 그러나, 이러한 가젯 호출(702)은 착신 스터브(508)를 통해서 일어나지 않는다. 즉, 가상 메모리(504)에 대응하는 착신/발신 스터브를 갖는 함수 호출과는 다르게, 가젯 호출은 착신/발신 스터브 없이 (예를 들어, 특정 명령들의 실행을 달성하기 위해 선택된) 메모리에서의 임의적인 포인트에서 시작한다. 결과적으로, 착신 스터브가 호출되지 않기 때문에, 페이지 q(548)의 상태는 여전히 "비-실행가능"으로 마킹되어 있다. 가젯이 페이지 q(548)로부터 페칭될(704) 때, 비-실행가능(NX) 플래그 체크 모듈(536)은, "비-실행가능"으로 마킹되어 있기 때문에, 페이지 q(548)의 로딩을 거절하거나 또는 차단한다. 이는 또한, 가젯 호출 및/또는 프로세스(706)의 종결을 야기할 수 있다.

프로세싱 회로 내에서 실행을 억제하기 위한 예시적인 방법들

도 8은, 프로세싱 회로에서 코드의 실행을 억제하기 위한 일반적인 예시적인 방법을 예시하는 흐름도이다. 이 방법은, 예를 들어, 메모리(예를 들어, 가상 메모리, 내부/외부 메모리, 등)으로부터 페칭하는 프로세싱 회로에 의해 구현될 수 있다. 메모리에서의 실행가능 코드의 영역들은 비-실행가능으로서 태깅된다(예를 들어, 마킹된다)(802). 프로세싱 회로는, 메모리로부터 하나 또는 그 초과의 명령들을 실행하도록 하는 요청들에 대해 모니터링할 수 있다(804). 하나 또는 그 초과의 명령들을 실행하도록 하는 요청이 검출되면(806), 하나 또는 그 초과의 명령들이 상주하는 메모리 영역은 실행가능으로서 태깅된다(808). 그후, 프로세싱 회로가 메모리 영역으로부터의 하나 또는 그 초과의 명령들을 실행할 수 있다(810). 완료시에, 하나 또는 그 초과의 명령들이 상주하는 메모리 영역은 비-실행가능으로 다시 태깅된다(812).

도 9는, ROP 활용들로부터 메모리를 보호하기 위한, 프로세싱 회로에서 동작가능한 다른 예시적인 방법을 예시하는 흐름도이다. 이 방법은, 프로세싱 회로에 의한 애플리케이션 또는 프로세스의 실행시에 구현될 수 있다. 애플리케이션 또는 프로세스는, 자신의 실행가능 코드가 메모리로 로딩되게 하고 그리고/또는 후술하는 방식으로 보호되게 하는 명령들을 포함할 수 있다. 실행가능 코드의 복수의 메모리 페이지들이 메모리 디바이스로 로딩될 수 있다(902). 실행가능 코드는 단일의 애플리케이션 및/또는 프로세스에 대응할 수 있다. 실행가능 코드가 로딩되는 메모리 디바이스는 가상 메모리를 구현할 수 있다. 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자는 비-실행가능 상태로 설정될 수 있다(904). 유사하게, 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자는 실행가능 상태로 설정되고, 여기서 복수의 메모리 페이지들의 제 2 서브세트는 복수의 메모리 페이지들의 제 1 서브세트에서의 함수들에 대한 간접 스터브들을 포함한다(906). 실행가능 코드의 복수의 메모리 페이지들을 메모리 디바이스로 로딩하는 것은, 복수의 메모리 페이지들의 제 1 서브세트 및/또는 제 2 서브세트 중 적어도 하나에 대한 상태 표시자가 비-실행가능 상태로 설정되기 전 및/또는 후에 발생할 수 있음에 주목한다.

간접 스터브들은, 실행가능 코드의 컴파일링 스테이지 또는 사전-컴파일링 스테이지에서 발생될 수 있다. 그후, 복수의 메모리 페이지들의 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에, 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 수정하는, 복수의 메모리 페이지들의 제 2 서브세트에서 대응하는 간접 스터브에 대한 함수 호출이 지시될 수 있다(908). 프로세싱 회로는 또한 복수의 메모리 페이지들의 제 1 서브세트에 상주하는 실행가능 코드의 실행 방지를 수행할 수 있다(910). 예를 들어, 실행 방지를 수행하는 것은, 실행가능 코드가 실행을 위한 프로세싱 회로에 의해 페칭될 때 비-실행가능 상태에 있는 메모리 페이지에 상주하는 임의의 실행가능 코드의 실행을 중단하는 것을 포함할 수 있다. 프로세싱 회로는 또한 함수 호출의 완료시에 복수의 메모리 페이지들의 제 2 서브세트에서 대응하는 간접 스터브로 반환할 수 있고, 여기서 대응하는 간접 스터브는 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 수정한다(912).

일 예시에서, 간접 스터브는, 함수의 실행을 가능하게 하기 위해 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 비-실행가능 상태에서 실행가능 상태로 수정한다. 간접 스터브는 또한, 함수의 실행을 불가능하게 하기 위해, 복수의 메모리 페이지들의 제 1 서브세트에서 대응하는 함수에 대한 상태 표시자를 실행가능 상태에서 비-실행가능 상태로 수정할 수 있다.

일 양상에 따르면, 프로세싱 회로의 내부 캐시 메모리는, 함수 호출의 완료시에 함수 호출에 대해 플러싱(클리어링)될 수 있다. 함수 호출에 대한 코드가 복수의 메모리 페이지들의 제 1 서브세트 내에서의 제 1 메모리 페이지에 상주하는 다른 예시에서, 방법은: (a) 실행가능 상태에 있는 제 1 메모리 페이지의 사용을 추적하는 단계; (b) 모든 진행중인 함수 호출들이 제 1 메모리 페이지 내에서 대응하는 코드의 실행을 완료했던 시기를 확인하는 단계; 및/또는 (c) 마지막 진행중인 함수 호출의 완료시에 제 1 메모리 페이지에 대한 상태 표시자를 비-실행가능 상태로 설정하는 단계를 더 포함할 수 있다.

도 10은, ROP 활용들로부터 메모리를 보호하기 위한 예시적인 방법을 예시하는 흐름도이다. 이 방법은, 메모리(예를 들어, 가상 메모리)로부터 실행가능 코드 또는 명령들에 액세스하는 프로세싱 회로에서 동작가능할 수 있다.

선택적인 특징에 따르면, 내포된 또는 관련된 함수들의 실행가능 코드가 실행 이전에 동일한 메모리 페이지에 배열될 수 있다(1000). 예를 들어, 이러한 배열은, 실행가능 코드의 컴파일링 동안 또는 실행가능 코드를 메모리에 로딩할 때 일어날 수 있다. 이러한 방식에서의 사전-배열 코드는, 메모리에서 관련 코드를 서로 가깝게 허용할 수 있고, 이에 의해 과잉 메모리 페이지 페치들을 회피하고, 그리고 더 나아가, (예를 들어, 실행가능과 비-실행가능 사이) 페이지 상태에 있어서의 변화들을 최소화한다.

프로세싱 회로는, 실행가능 코드의 복수의 메모리 페이지들을 메모리로 로딩할 수 있고(1002), 각각의 메모리 페이지에 대한 상태 표시자를 비-실행가능 상태로 설정할 수 있다(1004). 일례에서, 이러한 메모리는, 메인 메모리 및/또는 캐시 메모리 디바이스의 물리적 메모리 어드레스들의 맵핑일 수 있는, 가상 메모리로 지칭될 수 있다. 애플리케이션 실행시에, 프로세싱 회로 및/또는 동작 시스템은, 메모리로부터 대응하는 실행가능 코드를 페칭하기 전에 애플리케이션으로부터의 함수 호출을 검출, 모니터링, 및/또는 교차시킬 수 있다(1006). 메모리에서 제 1 실행가능 코드가 상주하는 제 1 메모리 페이지에 대한 상태 표시자가 실행가능 상태로 설정되고 그리고/또는 변경된다(1008). 그후, 제 1 메모리 페이지가 메모리로부터 페칭될 수 있다(1010). 제 1 메모리 페이지로부터의 명령을 실행하기 전에, 제 1 메모리 페이지 상태 표시자를 실행가능 상태로 설정했는지 여부에 관한 결정이 행해진다(1012). 메모리 페이지 상태가 실행가능 상태가 아니면, (프로세싱 회로에 의해) 제 1 메모리 페이지의 로딩/실행이 중단된다(1014). 그렇지 않으면, 제 1 메모리 페이지 상태가 사실상 실행가능 상태이면, 제 1 실행가능 코드가 (프로세싱 회로에 의해) 실행된다(1016). 제 1 실행가능 코드의 실행 완료시에, 프로세싱 회로는 (만약 존재한다면) 임의의 내부 캐시 메모리로부터 제 1 메모리 페이지를 플러싱할 수 있다(1018).

추가적으로, 프로세싱 회로는 또한 메모리에서의 상태 표시자를 다시 비-실행가능으로 설정할 수 있다(1020). 이러한 방식으로, 애플리케이션 밖에서 발생하는 호출들은 인터셉트되지 않고, 그들의 대응하는 명령들이 "비-실행가능" 상태를 갖는 메모리 페이지들에서 발견될 가능성이 있다.

몇몇 구현들에서, 하나 또는 그 초과의 메모리 페이지들에서의 함수들에 대한 다수의 내포된 호출들이 존재할 수 있다. 일 양상에 따르면, 하나 또는 그 초과의 카운터들은 프로세싱 회로 실행 애플리케이션에 의해 유지될 수 있고, 여기서 각각의 카운터는, 특정 메모리 페이지에서의 함수 및/또는 명령들의 실행이 종료되었는지 여부를 추적하도록 기능한다. 예를 들어, 제 1 메모리 페이지에서의 함수가 제 2 페이지에서의 함수를 호출할 수 있는 내포된 함수 호출들을 통해서, 다수의 메모리 페이지들이 동시에 개방된 채로 유지할 수 있다. 하나 또는 그 초과의 카운터들은, 예를 들어, 특정 메모리 페이지로의 진입들의 수뿐만 아니라 배출들의 수를 추적하도록 기능할 수 있고, 이에 의해, 메모리 페이지의 이용이 완료되어, 플러싱되거나 또는 "비-실행가능"으로 다시 변경될 수 있는 시기를 확인할 수 있다. 몇몇 구현들에서, 컴파일러는, 컴파일러가 동일한 메모리 페이지(들)에 상주하도록, 관련 실행가능 코드를 함께 배열할 수 있다. 이는, 그 메모리 페이지의 "비-실행가능" 상태를 빈번하게 클리어하고 설정할 필요 없이, 메모리 페이지로부터의 명령들을 실행하는 것을 허용한다.

다른 양상에 따르면, 부트-업(boot-up) 코드 및/또는 특정 시동(startup) 동작 시스템 실행가능 코드는, 본원에 설명된 실행 방지 특징으로부터 제외될 수 있다. 즉, 이러한 코드를 포함하는 메모리 페이지들은 자동으로 ("비-실행가능"이 아닌) "실행가능"으로 마킹될 수 있다. 이는, 프로세싱 회로 또는 동작 시스템에서 최소한의 동작 기능이 달성될 때까지, 더 빠른 부트-업을 허용할 것이다.

예시적인 간접 계층

도 11은, 메모리 영역들이 필요로 됨에 또는 호출됨에 따라서, 메모리 영역들의 상태를 수정하는 것을 허용하는 간접 계층의 예시적인 구현을 예시하는 블록도이다. 이러한 예시에서, 프로세싱 회로(1102)는, 실행가능 명령들/코드(1108) 및/또는 대응하는 간접 코드(1104/1106)(즉, 간접 계층)를 포함하는 메모리 모듈(1110)(예를 들어, 가상 메모리, 메모리 디바이스 등)에 커플링될 수 있다. 일례에서, 간접 코드(1104/1106)는, 실행가능 코드로 (예를 들어, 사전-컴파일링시에, 컴파일링시에, 및/또는 컴파일링-후에) 특정하여 부가된 또는 삽입된 별도의 명령들일 수 있다. 다른 예시에서, 간접 코드(1104/1106)는, 메모리에 상주하는 특정 명령들로의 액세스를 확보하는 원하는 기능들을 달성하기 위해 프로세서에 의해 구성/해석된 기존의 명령들일 수 있다.

일 예시에서, 간접 코드(1104/1106)는 실행가능 명령들(1108)에 대한 메모리 상태들을 설정/클리어링하도록 기능할 수 있다. 예를 들어, 함수 A가 프로세싱 회로에 의해 실행되는 애플리케이션 내에서 호출될 때, 대응하는 간접 코드 A(1104)가 사실상 호출된다. 간접 코드 A(1104)는 실행가능 코드 A(함수 A)에 대해 대응하는 메모리 영역(1112)의 상태를 "비-실행가능"에서 "실행가능"으로 설정하여, 명령들이 프로세싱 회로(1102)에 의해 실행될 수 있다. 명령들의 완료시에, 간접 코드(1104)는 실행가능 코드 A(함수 A)에 대한 대응하는 메모리 영역(1112)의 상태를 "실행가능"에서 "비-실행가능"으로 설정하여, 명령들이 (예를 들어, ROP 공격에 의해) 실행에 이용불가할 수 있다. 동일한 프로세스가 다른 함수들에 대해서도 반복될 수 있다. 예를 들어, 제 2 함수 B는 실행가능 코드 B(함수 B)(1114)에 액세스하는데 이용되는 대응하는 간접 코드 B(1106)를 가질 수 있다.

(자동으로 "비-실행가능"으로 마킹된) 실행가능 명령들(1108)이 상주하는 메모리 공간에 비해, 간접 코드(1104 및/또는 1106)는, 프로세싱 회로(1102)가 이러한 코드를 실행할 수 있도록, "실행가능"으로 마킹된 메모리 공간에 상주할 수 있다. 간접 코드(1104 및/또는 1106)는 특정 애플리케이션의 컴파일 시간에 발생될 수 있고, 여기서는 이러한 간접 코드가 실행가능 명령들과는 별도로 조직화된다. 대안적으로, 간접 코드(1104 및/또는 1106)는 메모리로의 실행가능 명령들(1108)의 로딩시에 동적으로 발생될 수 있다.

일례에서, 각각의 실행가능 코드(1112/1114)(또는 함수)는 대응하는 간접 코드(1104/1106)를 가질 수 있다. 결과적으로, 각각의 간접 코드(스터브)(1104/1106)는, 자신의 대응하는 실행가능 코드(1112/1114)가 메모리의 어디에 상주하는지 인지할 수 있고, 이러한 메모리 어드레스를 지목하는 것이 가능할 수 있다. 이러한 메모리 어드레스는, 각각의 함수와 연관된 실행가능 코드의 크기뿐만 아니라 (애플리케이션의) 컴파일 시간을 인지가능하다. 결과적으로, 간접 코드(1104/1106)는, 대응하는 실행가능 코드(1112/1114)가 어떤 메모리 페이지들에 상주하는지 그리고 대응하는 실행가능 코드(1112/1114)가 얼마나 많은 메모리 페이지들에 상주하는지 결정할 수 있다. 임의의 함수에 대한 실행가능 코드의 크기 및 메모리 페이지의 크기에 따라, 하나 또는 그 초과의 페이지들은 주어진 함수 호출에 대해 임의의 시간에 "비-실행가능"에서 "실행가능"으로 스위칭될 수 있다(또는 "실행가능" 상태에 유지될 수 있다). 추가적으로, 몇몇 구현들에서, 오직 대부분의 현재, 중요한(outstanding), 및/또는 계류중인 함수 호출에 대응하는 실행가능 코드가 상주하는 메모리 영역/페이지(들)만이 "실행가능" 상태에 유지된다. 또 다른 구현들에서, 성능을 개선시키기 위해, 마지막 n개의 함수 호출들에 이용된 메모리 페이지(들)가 "실행가능" 메모리 상태에서 유지된다.

도 12는, 메모리 영역들이 필요함에 따라 또는 호출됨에 따라 메모리 영역들의 상태를 수정하는 것을 허용하는 간접 계층을 구현하기 위한 방법을 예시한다. 이 방법은, 동작 시스템 레벨 또는 애플리케이션 레벨에서 구현될 수 있다. 함수 호출들(예를 들어, 메모리에서 실행가능 코드에 대한 호출들)은 애플리케이션의 실행 동안 인터셉트될 수 있다(1202). 호출된 함수를 로딩/실행하기 전에, 간접 계층은 호출된 함수에 대한 실행가능 코드와 연관된 메모리 상태를 비-실행가능에서 실행가능으로 변경할 수 있다(1204). 프로세싱 회로는 그후 호출된 함수에 대한 실행가능 코드를 페칭 및/또는 실행할 수 있다(1206). 일 특징에 따르면, 프로세싱 회로는, 함수 호출이 완료되는 시기를 확인하기 위해 실행가능 코드로부터의 내포된 진입들 및/또는 배출들을 추적할 수 있다(1208). 호출된 함수의 완료시에, 간접 계층은 호출된 함수에 대한 실행가능 코드와 연관된 메모리 상태를 실행가능에서 비-실행가능으로 변경할 수 있다(1210).

도 13은, 이러한 메모리 영역들로의 액세스를 보호하기 위해 애플리케이션 실행가능 코드가 상주하는 메모리 영역들의 상태를 수정하는 것을 허용하는 간접 계층을 애플리케이션 내에서 구현하기 위한 방법을 예시한다. 복수의 함수들을 포함하는 애플리케이션 소스 코드가 발생될 수 있다(1302). 간접 코드는 또한 소스 코드에서 각각의 함수에 대해 발생될 수 있다(1304). 메모리로 로딩될 때 소스 코드가 비-실행가능으로서 식별되도록 야기하기 위해 명령들이 부가될 수 있다(1306). 또한, 메모리로 로딩될 때 간접 코드가 실행가능으로서 식별되도록 야기하기 위해 명령들이 부가될 수 있다(1308). 소스 코드 및 간접 코드는 실행가능 코드를 발생시키기 위해 프로세싱 회로에서 변환(예를 들어, 컴파일링)될 수 있다(1310). 실행가능 코드는 단일의 애플리케이션 및/또는 프로세스에 대응할 수 있다. 간접 스터브는, 실행가능 코드의 컴파일링 스테이지 또는 사전-컴파일링 스테이지에서 발생될 수 있다. 소스 코드 및 간접 코드는, 이들이 실행을 위해 메모리로 로딩될 때 별도의 메모리 페이지들에 상주하도록 컴파일링될 수 있다. 예를 들어, 제 1 함수와 연관된 제 1 간접 코드는 제 1 함수를 지목하도록 적응되고, 여기서 실행가능 코드가 발생될 때, 제 1 간접 코드 및 제 1 함수 코드는 상이한 메모리 페이지들에 로딩되도록 컴파일링된다.

일례에서, 제 1 간접 코드는, 메모리 상태 표시자로 하여금, 제 1 함수가 실행을 위해 인보크되어 있을 때, 대응하는 제 1 함수가 비-실행가능 상태에서 실행가능 상태로 스위칭되도록 야기할 수 있다.

다른 예시에서, 제 1 간접 코드는, 메모리 상태 표시자로 하여금, 제 1 함수가 실행을 종료할 때, 대응하는 제 1 함수가 실행가능 상태에서 비-실행가능 상태로 스위칭되도록 야기한다.

예시적인 구현에서, 도 8, 도 9, 도 10, 도 12, 및/또는 도 13에 개시된 하나 또는 그 초과의 특징들이, 하나 또는 그 초과의 프로세서들에서 병렬로(예를 들어, 동시에) 및/또는 직렬로(예를 들어, 순차적으로) 구현될 수 있다. 다수의 프로세서들이 하나 또는 그 초과의 단계들을 실행하는 경우, 다수의 프로세서들 각각은 상이한 단계들, 동일한 단계들, 및/또는 단계들의 서브세트를 구현할 수 있다.

본원에 언급된 예시적인 구현들 중 몇몇에서, 간접 계층의 함수들은, 애플리케이션의 컴파일링 이전, 동안, 및/또는 이후에 애플리케이션에 부가되는 별개의(distinct) 명령들/코드로서 구현될 수 있다. 그러나, 다른 구현들은 명령 세트로 기존의 명령들을 재사용할 수 있고 그리고/또는 실행가능 상태와 비-실행가능 상태 사이의 스위칭을 회피할 수 있다.

다른 예시적인 구현에서, "간접 계층"은 명령 세트에서 일 세트의 2개(또는 그 초과의) 상보형 명령들로서 구현될 수 있다. 예를 들어, 프로세서는, 제 1 명령이 실행될 때, 다음으로 프로세서는 제 2 명령이 아닌 다른 것을 페칭하기를 거절하도록, 구성될 수 있다. 이러한 구성은, 예를 들어, 프로세서로 로딩된 명령들(예를 들어, 로더 구성)에 의해 또는 내부적으로(예를 들어, 프로세서로 하드웨어화됨) 행해질 수 있다. 제 2 명령이 제 1 명령의 실행 이후에 오는 것이라면, 프로세서는 실행을 계속한다. 그렇지 않다면, 프로세서는 실행을 중단 또는 리셋할 수 있다. 이러한 접근방식에서, 실행가능 코드를 포함하는 메모리 세그먼트들에 대해 "비-실행가능" 상태로 설정하는 것은, 선택적일 수 있고 그리고/또는 불필요할 수 있다. 예를 들어, 도 5의 별도의 착신/발신 스터브들(540)을 갖는 것 대신에, 애플리케이션 내에서 함수 호출 명령(즉, 제 1 명령) 이후에는 오직 호출된 함수의 초기 명령(즉, 제 2 명령)만 뒤따르도록 제한된다. 프로세서가 초기 명령 이외의 임의의 다른 명령이 함수 호출 명령들을 뒤따르는 것으로 언급하면, 실행을 중단한다. 이러한 함수 호출 명령(제 1 명령) 및 초기 명령(제 2 명령)은 명령 세트에 부가된 새로운/특수한 명령들일 수 있다. 대안적으로, 명령 세트의 이미 일부인 보통(ordinary) 명령들이 이러한 목적으로 이용될 수 있지만, 비트 또는 마커와 함께 이용되어 제 1 명령 이후에 제 2 명령이 뒤따라야만 함을 주목할 수 있다. 이 방식으로, 프로세서는 이러한 명령 시퀀스에 대해 체크할 수 있고, 그리고(예를 들어, 반환 지향형 공격의 경우에서와 같이) 제 2 명령이 아닌 다른 명령이 제 1 명령을 뒤따른다면 실행을 중단할 수 있다.

이러한 상보형 명령 쌍들의 일례에서, 제 1 명령은 (예를 들어, 특정 함수를 호출하기 위해) "호출"로서 기능할 수 있는 한편, 제 2 명령은 함수 진입들에 위치될 수 있는 "랜딩(land)"으로서 기능할 수 있다. 일 경우에서, 이러한 명령 쌍은 상보형 명령들이 되는 것으로 명령 세트 내에서 구체적으로 정의될 수 있고, 여기서 제 2 명령은 제 1 명령 이후에 뒤따라야만 하며, 그렇지 않으면 프로세서는 실행을 중단한다. 일례에서, 함수 호출(예를 들어, 착신 스터브)을 초기화하기 위한 제 1 쌍의 명령들 및 함수 호출(예를 들어, 발신 스터브)을 나가기/종결하기 위한 제 2 쌍의 명령들인, 이러한 명령들의 2개의 세트들이 존재할 수 있다.

대안적인 예시에서, 2개의 전용 명령들(예를 들어, 상보형 제 1 및 제 2 명령들)을 이용하는 것 대신에, 보통의 명령들이 이들이 스터브 명령들인지 또는 그렇지 않은지 나타내기 위해 이용되는 전용 비트로 인코딩 또는 마킹될 수 있다. 예를 들어, 보통 제 1 명령(예를 들어, "호출" 명령)은, 이 명령이 함수를 로딩하는데 이용된다면, 비트/마커 세트를 가질 수 있다. 유사하게, 보통 제 2 명령(예를 들어, "랜딩" 명령)은, 이 명령이 함수 로딩의 일부로서 이용된다면, 유사한 비트/마커 세트를 가질 수 있다. 따라서, 프로세서는, 제 1 및/또는 제 2 명령들을 실행할 때 이들이 순차적으로 실행되는 것을 확실하게 하기 위해 이러한 비트/마커를 체크할 수 있고, 순차적으로 실행되지 않는다면 실행은 중단된다. 제 1 명령(예를 들어, "호출" 명령)이 점프(JMP) 명령들, 로딩 명령 등을 포함하는 다양한 유형들의 명령들일 수 있다. 유사하게, 반전 동작(예를 들어, 함수가 완료될 때) 에서, 제 1 명령은, 반환 명령들, 종료 명령 등을 포함하는 다양한 유형들의 명령들일 수 있다.

일례에서, "호출" 명령의 실행은, 프로세서로 하여금, 호출된 함수가 상주하는 메모리 세그먼트/페이지의 상태를 비-실행가능에서 실행가능으로 자동으로 스위칭하게 야기할 수 있다는 점에 주목한다. 호출된 함수의 실행의 완료시에, 동작은 반전되고, 메모리 세그먼트/페이지는 비-실행가능 상태로 다시 설정된다. 대안적인 실시예에서, 메모리 세그먼트/페이지가 비-실행가능으로서 전혀 마킹되지 않는다. 대신에, 반환 지향형 프로그래밍 공격들은, 함수 호출 명령(제 1 명령) 이후에 호출된 함수의 초기 명령(제 2 명령)이 뒤따라야만 한다는 제한에 의해 저지될 수 있다. 이는, 호출 명령들 이후에 랜딩 명령들이 뒤따라야만 하는 것으로 제한되기 때문에, 반환 지향형 프로그래밍 공격을 메모리 내에서 특정 명령들로 선택적으로 점핑하는 것으로부터 억제한다.

도시되고 설명된 특정 구현들은, 오직 예시들이며, 본원에 달리 특정되지 않는 한, 본 개시물을 수행하기 위한 유일한 방법으로서 해석되지 않아야 한다. 당업자에게는, 본 개시물의 다양한 예시들이 수많은 다른 분할하는 해결책들에 의해 실행될 수 있다는 것이 용이하게 명백하다.

본원에 설명되고 도면들에 예시된 컴포넌트들, 동작들, 특징들 및/또는 기능들 중 하나 또는 그 초과는, 단일의 컴포넌트, 동작, 특징, 또는 기능으로 재배열 및/또는 조합될 수 있거나 또는 몇몇 컴포넌트들, 동작들, 특징들, 또는 기능들로 구현될 수 있다. 추가적인 엘리먼트들, 컴포넌트들, 동작들, 및/또는 기능들은 또한 본 발명으로부터 벗어나지 않고 부가될 수 있다. 본원에 설명된 알고리즘들은 소프트웨어에서 효율적으로 구현될 수 있고 그리고/또는 하드웨어에서 임베딩될 수 있다.

설명에서, 엘리먼트들, 회로들, 및 기능들은, 불필요한 세부사항으로 본 개시물을 모호하게 하지 않기 위해 블록도 형태로 도시될 수 있다. 반대로, 도시되고 설명된 특정 구현들은 오직 예시적이며, 본원에 달리 특정되지 않는 한 본 개시물을 구현하기 위한 유일한 방식으로서 해석되지 않아야 한다. 추가적으로, 다양한 블록들 사이에서의 로직의 분할 및 블록 정의들은 특정 구현의 예시이다. 본 개시물이 수많은 다른 분할 해결책들에 의해 실행될 수 있다는 것이 당업자에게는 용이하게 명백할 것이다. 대부분의 경우, 타이밍 고려사항들 등을 고려하는 세부사항들은 생략되었으며, 여기서 이러한 세부사항들은 본 개시물의 완전한 이해를 획득하기 위해 필수적이지 않으며 관련 기술에서의 당업자들의 능력 내에 있다.

또한, 실시예들이 플로우차트, 흐름도, 구조도, 또는 블록도로서 도시된 프로세스로서 설명될 수 있음에 주목한다. 플로우차트는 동작들을 순차적인 프로세스로서 설명하지만, 수많은 동작들이 병렬로 또는 동시에 수행될 수 있다. 이에 더해, 동작들의 순서는 재-배열될 수 있다. 프로세스는, 자신의 동작들이 완료될 때 종결된다. 프로세스는, 방법, 함수, 절차, 서브루틴, 서브프로그램 등에 대응할 수 있다. 프로세스가 함수에 대응할 때, 자신의 종결은 호출 함수 또는 메인 함수로의 그 함수의 반환에 대응한다.

당업자들은 정보 및 신호들이 임의의 다양한 상이한 기술들 및 기법들을 이용하여 표현될 수 있다는 것을 이해할 것이다. 예를 들어, 전술한 설명 전반에 걸쳐 참조될 수 있는 데이터, 명령들, 커맨드들, 정보, 신호들, 비트들, 심볼들 및 칩들은 전압들, 전류들, 전자기파들, 자기장들 또는 자기 입자들, 광 필드들 또는 광 입자들, 또는 이들의 임의의 결합에 의해 표현될 수 있다. 몇몇 도면들은 신호들을 제시 및 설명의 명료함을 위해 단일 신호로서 예시할 수 있다. 신호는 신호들의 버스를 표현할 수 있는데, 여기서 버스는 다양한 비트 폭들을 가질 수 있고, 그리고 본 개시물은 단일 데이터 신호를 포함하는 임의의 수의 데이터 신호들에 대해 구현될 수 있다는 것이 당업자들에 의해 이해될 것이다.

"제 1", "제 2" 등과 같이 지정을 이용하는 본원의 엘리먼트에 대한 임의의 참조는, 이러한 제한이 명백하게 언급되지 않는 한, 이러한 엘리먼트들의 양 또는 순서를 제한하지 않는 것으로 이해해야 한다. 오히려, 이러한 지정들은 2개 또는 그 초과의 엘리먼트들 또는 엘리먼트의 인스턴스들 사이를 구별하는 편리한 방법으로서 본원에서 이용될 수 있다. 따라서, 제 1 및 제 2 엘리먼트들에 대한 참조는, 오직 2개의 엘리먼트들만이 거기에 채용될 수 있거나 또는 제 1 엘리먼트가 몇몇 방식으로 제 2 엘리먼트를 선행해야만 하는 것을 의미하는 것은 아니다. 또한, 달리 언급되지 않는 한, 일 세트의 엘리먼트들은 하나 또는 그 초과의 엘리먼트들을 포함할 수 있다.

더욱이, 저장 매체는, 데이터를 저장하기 위한 하나 또는 그 초과의 디바이스들(예를 들어, ROM(read-only memory), RAM(random access memory), 자기 디스크 저장 매체들, 광학 저장 매체들, 플래시 메모리 디바이스들, 및/또는 다른 머신-판독가능 매체들을 포함) 및 정보를 저장하기 위한 프로세서-판독가능 매체들, 및/또는 컴퓨터 판독가능 매체들을 나타낼 수 있다. 용어들 "머신-판독가능 매체", "컴퓨터-판독가능 매체" 및/또는 "프로세서-판독가능 매체"는, 휴대용 또는 고정형 저장 디바이스들, 광학 저장 디바이스들과 같은 비-일시적 매체들 명령(들) 및/또는 데이터를 저장, 포함 또는 운반할 수 있는 다양한 다른 매체들을 포함할 수 있다(그러나, 이에 한정되지 않는다). 따라서, 본원에 설명된 다양한 방법들은, "머신-판독가능 매체", "컴퓨터-판독가능 매체", 및/또는 "프로세서-판독가능 매체"에 저장될 수 있는 명령들 및/또는 데이터에 의해 완전하게 또는 부분적으로 구현될 수 있고, 그리고/또는 하나 또는 그 초과의 프로세서들, 머신들, 및/또는 디바이스들에 의해 실행될 수 있다.

게다가, 실시예들은 하드웨어, 소프트웨어, 펌웨어, 미들웨어, 마이크로코드, 또는 이들의 임의의 조합으로 구현될 수 있다. 소프트웨어, 펌웨어, 미들웨어 또는 마이크로코드에서 구현되는 경우, 필수적인 임무들을 수행하기 위한 프로그램 코드 또는 코드 세그먼트들은 저장 매체 또는 다른 저장(들)과 같은 머신-판독가능 매체에 저장될 수 있다. 프로세서는 필수적인 임무들을 수행할 수 있다. 코드 세그먼트는 절차, 함수, 서브프로그램, 프로그램, 무틴, 서브루틴, 모듈, 소프트웨어 패키지, 클래스, 또는 명령들, 데이터 구조들, 또는 프로그램 스테이트먼트들의 임의의 조합을 나타낼 수 있다. 코드 세그먼트는, 명령, 데이터, 아규먼트들, 파라미터들, 또는 메모리 컨텐츠들을 통과 및/또는 수신함으로써 다른 코드 세그먼트 또는 하드웨어 회로에 커플링될 수 있다. 정보, 아규먼트들, 파라미터들, 데이터 등이, 메모리 공유, 메시지 통과, 토큰 통과, 네트워크 송신 등을 포함하는 임의의 적절한 수단을 통해 통과, 포워딩, 또는 송신될 수 있다.

본원에 개시된 예시들과 관련하여 설명된 다양한 예시적인 논리 블록들, 모듈들, 회로들, 엘리먼트들, 및/또는 컴포넌트들은, 범용 프로세서, 디지털 신호 프로세서(DSP), 주문형 집적 회로(ASIC), 필드 프로그래머블 게이트 어레이(FPGA) 또는 다른 프로그래머블 로직 디바이스, 이산 게이트 또는 트랜지스터 로직, 이산 하드웨어 컴포넌트들, 전기 컴포넌트들, 광학 컴포넌트들, 기계 컴포넌트들 또는 본원에서 설명된 기능들을 수행하도록 설계된 이들의 임의의 조합으로 구현 또는 수행될 수 있다. 범용 프로세서는 마이크로프로세서일 수 있지만, 대안적으로 이 프로세서는 임의의 종래의 프로세서, 컨트롤러, 마이크로컨트롤러 또는 상태 머신일 수 있다. 프로세서는 또한 컴퓨팅 디바이스들의 조합, 예를 들어, DSP와 마이크로프로세서의 조합, 복수의 마이크로프로세서들, DSP 코어와 연결된 하나 또는 그 초과의 마이크로프로세서들 또는 임의의 다른 이러한 구성으로서 구현될 수 있다. 본원에 설명된 실시예들을 실행하기 위해 구성된 범용 프로세서는, 이러한 실시예들을 수행하기 위한 특수 목적 프로세서로서 고려된다. 유사하게, 범용 컴퓨터는 본원에 설명된 실시예들을 수행하기 위해 구성될 때 특수 목적 컴퓨터로서 고려된다.

본원에 개시된 예시들과 관련하여 설명된 방법들 또는 알고리즘들은, 프로세싱 유닛, 프로그래밍 명령들, 또는 다른 방향들의 형태로, 하드웨어에서 직접, 프로세서에 의해 실행가능한 소프트웨어 모듈에서, 또는 이들 둘의 조합으로 구현될 수 있고, 단일의 디바이스에 포함될 수 있거나 또는 다수의 디바이스들에 걸쳐 분산될 수 있다. 소프트웨어 모듈은, RAM 메모리, 플래시 메모리, ROM 메모리, EPROM 메모리, EEPROM 메모리, 레지스터들, 하드 디스크, 탈착식 디스크, CD-ROM, 또는 당업계에 공지된 저장 매체의 임의의 다른 형태로 상주할 수 있다. 저장 매체는, 프로세서가 저장 매체로부터 정보를 판독하고 저장 매체에 정보를 기록할 수 있도록, 프로세서에 커플링될 수 있다. 대안적으로, 저장 매체는 프로세서 내부에 있을 수 있다.

당업자들은 본원에 개시된 실시예들과 관련하여 설명된 다양한 예시적인 논리 블록들, 모듈들, 회로들, 방법들 및 알고리즘 단계들이 전자 하드웨어, 컴퓨터 소프트웨어 또는 이 둘의 조합들로서 구현될 수 있다는 것을 더 이해할 것이다. 하드웨어 및 소프트웨어의 이러한 상호 호환성을 명확하게 설명하기 위해, 다양한 예시적인 컴포넌트들, 블록들, 모듈들, 회로들, 단계들이 이들의 기능과 관련하여 위에서 일반적으로 설명되었다. 이러한 기능이 하드웨어로서, 소프트웨어로서, 또는 이들의 조합으로서 구현되는지 여부는, 특정한 애플리케이션 및 전체 시스템에 대하여 부과되는 설계 제약들에 따라 좌우된다.

본원에 설명된 방법의 다양한 특징들은, 본 발명을 벗어나지 않고 상이한 시스템들에서 구현될 수 있다. 전술한 실시예들이 단지 예시들이며 본 발명을 제한하는 것으로서 해석되지 않는다는 것에 주목해야 한다. 실시예들의 설명은, 청구항들의 범위를 제한하는 것이 아닌 예시적인 것으로 의도된다. 이와 같이, 본 교시들은 다른 유형들의 장치들에게 용이하게 적용될 수 있으며, 수많은 대안들, 변형들, 및 변화들이 당업자에게 명백하게 될 것이다.

Claims

프로세싱 회로에서 동작가능한 방법으로서,
메모리 디바이스에서 실행가능 코드의 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자를 비-실행가능 상태로 설정하는 단계;
상기 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자를 실행가능 상태로 설정하는 단계 ― 상기 복수의 메모리 페이지들의 상기 제 2 서브세트는, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 함수들에 대한 간접 스터브(indirection stub)들을 포함함 ―; 및
상기 복수의 메모리 페이지들의 상기 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 수정하는, 상기 복수의 메모리 페이지들의 상기 제 2 서브세트에서의 대응하는 간접 스터브에 함수 호출을 지시하는 단계를 포함하는,
방법.
제 1 항에 있어서,
상기 실행가능 코드는 단일의 애플리케이션 및/또는 프로세스에 대응하는,
방법.
제 1 항에 있어서,
상기 복수의 메모리 페이지들의 상기 제 1 서브세트 또는 상기 제 2 서브세트 중 적어도 하나에 대한 상태 표시자가 비-실행가능 상태로 설정된 후에, 상기 실행가능 코드의 상기 복수의 메모리 페이지들을 상기 메모리 디바이스로 로딩하는 단계를 더 포함하는,
방법.
제 1 항에 있어서,
상기 복수의 메모리 페이지들의 상기 제 1 서브세트 또는 상기 제 2 서브세트 중 적어도 하나에 대한 상태 표시자가 비-실행가능 상태로 설정되기 전에, 상기 실행가능 코드의 상기 복수의 메모리 페이지들을 상기 메모리 디바이스로 로딩하는 단계를 더 포함하는,
방법.
제 1 항에 있어서,
상기 실행가능 코드가 상주하는 상기 메모리 디바이스는 가상 메모리를 구현하는,
방법.
제 1 항에 있어서,
상기 복수의 메모리 페이지들의 상기 제 1 서브세트에 상주하는 실행가능 코드의 실행 방지를 수행하는 단계를 더 포함하는,
방법.
제 6 항에 있어서,
상기 실행 방지를 수행하는 단계는, 상기 실행가능 코드가 실행을 위해 상기 프로세싱 회로에 의해 페칭(fetch)될 때 상기 비-실행가능 상태에 있는 메모리 페이지에 상주하는 임의의 실행가능 코드의 실행을 중단하는(aborting) 단계를 포함하는,
방법.
제 1 항에 있어서,
상기 간접 스터브는, 상기 함수의 실행을 가능하게 하기 위해, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 비-실행가능 상태에서 실행가능 상태로 수정하는,
방법.
제 1 항에 있어서,
상기 함수 호출의 완료시에 상기 복수의 메모리 페이지들의 상기 제 2 서브세트에서의 대응하는 간접 스터브로 반환하는 단계 ― 상기 대응하는 간접 스터브는 그후, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 수정함 ― 를 더 포함하는,
방법.
제 9 항에 있어서,
상기 간접 스터브는, 상기 함수의 실행을 불가능하게 하기 위해, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 실행가능 상태에서 비-실행가능 상태로 수정하는,
방법.
제 1 항에 있어서,
상기 함수 호출의 완료시에 상기 프로세싱 회로의 내부 캐시 메모리를 플러싱하는(flushing) 단계를 더 포함하는,
방법.
제 1 항에 있어서,
상기 간접 스터브들은 상기 실행가능 코드의 컴파일링 스테이지 또는 사전-컴파일링 스테이지에서 발생되는,
방법.
제 1 항에 있어서,
상기 대응하는 간접 스터브는, 상기 프로세싱 회로에 의해 차례로(in sequence) 실행되도록 제한된 적어도 제 1 명령 및 제 2 명령을 포함하는,
방법.
제 13 항에 있어서,
상기 제 1 명령 이후에 상기 제 2 명령이 아닌 다른 명령이 뒤따르면 상기 함수 호출의 실행을 중단하는 단계를 더 포함하는,
방법.
제 13 항에 있어서,
상기 제 1 명령은 상기 함수 호출의 일부이고, 상기 제 2 명령은 대응하는 함수의 초기 명령인,
방법.
제 15 항에 있어서,
상기 간접 스터브는, 상기 제 1 명령 이후에 상기 제 2 명령이 뒤따르지 않는 한 중단되도록, 상기 제 1 명령을 상기 제 2 명령에 바인딩함(binding)으로써 구현되는,
방법.
제 1 항에 있어서,
상기 함수에 대한 코드는, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트 내에서의 제 1 메모리 페이지에 상주하고,
상기 실행가능 상태에 있는 상기 제 1 메모리 페이지의 이용을 추적하는(tracking) 단계;
모든 진행중인(ongoing) 함수 호출들이 상기 제 1 메모리 페이지 내에서의 대응하는 코드의 실행을 완료한 시기를 확인하는(ascertaining) 단계; 및
마지막 진행중인 함수 호출의 완료시에 상기 제 1 메모리 페이지에 대한 상태 표시자를 비-실행가능 상태로 설정하는 단계를 더 포함하는,
방법.
프로세싱 디바이스로서,
메모리 디바이스; 및
상기 메모리 디바이스에 커플링된 프로세싱 회로를 포함하고,
상기 프로세싱 회로는,
메모리 디바이스에서 실행가능 코드의 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자를 비-실행가능 상태로 설정하고;
상기 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자를 실행가능 상태로 설정하고 ― 상기 복수의 메모리 페이지들의 상기 제 2 서브세트는, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 함수들에 대한 간접 스터브들을 포함함 ―; 그리고
상기 복수의 메모리 페이지들의 상기 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 수정하는, 상기 복수의 메모리 페이지들의 상기 제 2 서브세트에서의 대응하는 간접 스터브에 함수 호출을 지시하도록 구성되는,
프로세싱 디바이스.
제 18 항에 있어서,
상기 프로세싱 회로는:
상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서 상주하는 실행가능 코드의 실행 방지를 수행하도록 더 구성되는,
프로세싱 디바이스.
제 19 항에 있어서,
상기 실행 방지를 수행하는 것에서,
상기 프로세싱 회로는:
상기 실행가능 코드가 실행을 위해 상기 프로세싱 회로에 의해 페칭될 때 상기 비-실행가능 상태에 있는 메모리 페이지에 상주하는 임의의 실행가능한 코드의 실행을 중단하도록 더 구성되는,
프로세싱 디바이스.
제 18 항에 있어서,
상기 간접 스터브는, 상기 함수의 실행을 가능하게 하기 위해, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 비-실행가능 상태에서 실행가능 상태로 수정하는,
프로세싱 디바이스.
제 18 항에 있어서,
상기 프로세싱 회로는:
상기 함수 호출의 완료시에 상기 복수의 메모리 페이지들의 상기 제 2 서브세트에서의 대응하는 간접 스터브로 반환하도록 더 구성되고,
상기 대응하는 간접 스터브는 그후, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 수정하는,
프로세싱 디바이스.
제 18 항에 있어서,
상기 간접 스터브는, 상기 함수의 실행을 불가능하게 하기 위해, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 실행가능 상태에서 비-실행가능 상태로 수정하는,
프로세싱 디바이스.
제 18 항에 있어서,
상기 대응하는 간접 스터브는, 상기 프로세싱 회로에 의해 차례로 실행되도록 제한된 적어도 제 1 명령 및 제 2 명령을 포함하고,
상기 프로세싱 회로는:
상기 제 1 명령 이후에 상기 제 2 명령이 아닌 다른 명령이 뒤따르면 상기 함수 호출의 실행을 중단하도록 더 구성되는,
프로세싱 디바이스.
프로세싱 디바이스로서,
실행가능 코드의 복수의 메모리 페이지들을 메모리 디바이스로 로딩하기 위한 수단;
상기 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자를 비-실행가능 상태로 설정하기 위한 수단;
상기 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자를 실행가능 상태로 설정하기 위한 수단 ― 상기 복수의 메모리 페이지들의 상기 제 2 서브세트는, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 함수들에 대한 간접 스터브들을 포함함 ―; 및
상기 복수의 메모리 페이지들의 상기 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 수정하는, 상기 복수의 메모리 페이지들의 상기 제 2 서브세트에서의 대응하는 간접 스터브에 함수 호출을 지시하기 위한 수단을 포함하는,
프로세싱 디바이스.
명령들이 저장된 프로세서-판독가능 매체로서,
상기 명령들은, 적어도 하나의 프로세서에 의해 실행될 때, 상기 적어도 하나의 프로세서로 하여금:
메모리 디바이스에서 실행가능 코드의 복수의 메모리 페이지들의 제 1 서브세트에 대한 상태 표시자를 비-실행가능 상태로 설정하고;
상기 복수의 메모리 페이지들의 제 2 서브세트에 대한 상태 표시자를 실행가능 상태로 설정하고 ― 상기 복수의 메모리 페이지들의 상기 제 2 서브세트는, 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 함수들에 대한 간접 스터브들을 포함함 ―; 그리고
상기 복수의 메모리 페이지들의 상기 제 1 서브세트로부터 호출된 함수의 실행을 지시하기 전에 상기 복수의 메모리 페이지들의 상기 제 1 서브세트에서의 대응하는 함수에 대한 상태 표시자를 수정하는, 상기 복수의 메모리 페이지들의 상기 제 2 서브세트에서의 대응하는 간접 스터브에 함수 호출을 지시하게 하는,
프로세서-판독가능 매체.
프로세싱 회로에서 동작가능한 방법으로서,
복수의 함수들을 포함하는 애플리케이션 소스 코드를 발생시키는 단계;
상기 소스 코드에서의 각각의 함수에 대한 간접 코드를 발생시키는 단계;
메모리로 로딩될 때 상기 소스 코드가 비-실행가능한 것으로서 식별되도록 하는 명령들을 부가하는 단계;
메모리로 로딩될 때 상기 간접 코드가 실행가능한 것으로서 식별되도록 하는 명령들을 부가하는 단계; 및
실행가능 코드를 발생시키기 위해 상기 프로세싱 회로에서 상기 소스 코드 및 상기 간접 코드를 변형시키는 단계를 포함하는,
방법.
제 27 항에 있어서,
상기 실행가능 코드는 단일의 애플리케이션 및/또는 프로세스에 대응하는,
방법.
제 27 항에 있어서,
상기 간접 스터브들은 상기 실행가능 코드의 컴파일링 스테이지 또는 사전-컴파일링 스테이지에서 발생되는,
방법.
제 27 항에 있어서,
상기 소스 코드 및 상기 간접 코드는, 이들이 메모리로 로딩될 때 별도의 메모리 페이지들에 상주하도록, 컴파일링되는,
방법.
제 27 항에 있어서,
제 1 간접 코드는, 상기 제 1 함수가 실행을 위해 인보크되어(invoked) 있을 때, 대응하는 제 1 함수에 대한 메모리 상태 표시자가 비-실행가능 상태에서 실행가능 상태로 스위칭되게 하는,
방법.
제 27 항에 있어서,
제 1 간접 코드는, 상기 제 1 함수가 실행을 종결할 때, 대응하는 제 1 함수에 대한 메모리 상태 표시자가 실행가능 상태에서 비-실행가능 상태로 스위칭되게 하는,
방법.
제 27 항에 있어서,
제 1 함수와 연관된 제 1 간접 코드는 상기 제 1 함수를 지목하도록 적응되고,
상기 실행가능 코드가 발생될 때, 상기 제 1 간접 코드 및 상기 제 1 함수는 상이한 메모리 페이지들에 로딩되도록 컴파일링되는,
방법.
제 27 항에 있어서,
상기 간접 코드는, 프로세싱 회로에 의해 차례로 실행되도록 제한된 적어도 제 1 명령 및 제 2 명령을 포함하는,
방법.
제 27 항에 있어서,
상기 제 1 명령 이후에 상기 제 2 명령이 아닌 다른 명령이 뒤따르면 상기 함수 호출의 실행을 중단하도록 하는 명령들을 부가하는 단계를 더 포함하는,
방법.
명령들이 저장된 프로세서-판독가능 매체로서,
상기 명령들은, 적어도 하나의 프로세서에 의해 실행될 때, 상기 적어도 하나의 프로세서로 하여금:
복수의 함수들을 포함하는 애플리케이션 소스 코드를 발생시키고;
상기 소스 코드에서의 각각의 함수에 대한 간접 코드를 발생시키고;
메모리로 로딩될 때 상기 소스 코드가 비-실행가능한 것으로서 식별되게 하는 명령들을 부가하고;
메모리로 로딩될 때 상기 간접 코드가 실행가능한 것으로서 식별되게 하는 명령들을 부가하고; 그리고
실행가능 코드를 발생시키기 위해 상기 프로세싱 회로에서 상기 소스 코드 및 상기 간접 코드를 변형하게 하는,
프로세서-판독가능 매체.
제 36 항에 있어서,
상기 실행가능 코드는 단일의 애플리케이션 및/또는 프로세스에 대응하는,
프로세서-판독가능 매체.
제 36 항에 있어서,
상기 간접 스터브들은 상기 실행가능 코드의 컴파일링 스테이지 또는 사전-컴파일링 스테이지에서 발생되는,
프로세서-판독가능 매체.
제 36 항에 있어서,
제 1 간접 코드는, 상기 제 1 함수가 실행을 위해 인보크되어 있을 때, 대응하는 제 1 함수에 대한 메모리 상태 표시자가 비-실행가능 상태에서 실행가능 상태로 스위칭되게 하는,
프로세서-판독가능 매체.
제 36 항에 있어서,
제 1 간접 코드는, 상기 제 1 함수가 실행을 종결할 때, 대응하는 제 1 함수에 대한 메모리 상태 표시자가 실행가능 상태에서 비-실행가능 상태로 스위칭되게 하는,
프로세서-판독가능 매체.