KR102117209B1 - 바이너리 취약점 패치 방법 및 장치 - Google Patents

Abstract

바이너리의 취약점을 패치하는 방법 및 장치가 제공된다. 본 발명의 일 실시예에 따른 취약점 패치 방법은, 대상 바이너리 내에 패치 코드 블록을 삽입하는 단계와, 상기 대상 바이너리의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 코드 블록으로 점프하는 인스트럭션으로 치환하는 단계를 포함하되, 상기 패치 코드 블록은 상기 취약점을 해소하는 인스트럭션을 포함한다.

Description

바이너리 취약점 패치 방법 및 장치{METHOD AND DEVICE FOR PATCHING SECURITY VULNERABLE EXECUTABLE BINARIES}

본 발명은 취약점이 존재하는 바이너리에 대한 패치 방법 및 장치에 관한것이다. 보다 자세하게는, 바이너리의 취약점을 보완하는 패치 코드를 바이너리에 직접 삽입하는 방법 및 장치에 관한 것이다.

프로그램 바이너리에는 다양한 취약점들이 존재할 수 있다. 예를 들어, 초기화되지 않은 변수의 사용, 버퍼 오버플로우(buffer overflow), 정수 오버플로우(integer overflow), 메모리 익셉션(memory exception), 기형 입력(malformed-input), 레이스 컨디션(race condition), 기호 링크(symbolic link) 및 널 포인터(null pointer) 참조 등 다양한 유형이 알려져 있다. 상기 취약점으로 인하여 상기 바이너리의 일부 기능이 부적절한 목적으로 무단 수정될 수도 있고, 상기 바이너리가 실행되는 시스템이 보안상 문제를 일으킬 수 있으므로, 보안상 중요한 시스템에서 실행되는 바이너리는 신속하고 정확하게 취약점이 해결되어야 할 것 이다. 또한, 바이너리에 이러한 취약점이 존재하는 경우 바이너리의 실행 시점에 예상치 못한 오류가 발생된다. 예를 들어, 초기화하지 않은 변수를 사용함으로써 예상치 못한 결과 값이 발생하거나, 프로그램의 제어 흐름이 잘못된 경로로 진행될 수 있으며, 버퍼 오버플로우에 관한 예외 처리(Exception)를 누락하는 등의 이유로 세그멘테이션 오류(segmentation fault) 등이 빈번하게 발생한다.

프로그램의 개발 과정에서는 일반적으로 프로그램의 소스 코드의 내용을논리적으로 분석 및 검증하거나, 디버깅 프로그램을 이용하여 프로그램의 소스 코드에서 취약점이 발생할 가능성이 있는 곳에 브레이크 포인트를 설정하고, 프로그램의 실행 중에 브레이크 포인트에 따라 실행이 일시 중단되면 프로그램의 실행 환경을 관찰함으로써 프로그램의 취약점을 파악한다. 그리고 파악된 취약점이 제거되도록 소스 코드를 수정하여 프로그램을 다시 빌드함으로써, 프로그램의 취약점을 제거할 수 있다.

그런데 프로그램이 개발된 후에 특히 프로그램의 개발자가 아닌 제3자가 프로그램의 취약점을 분석 및 패치하는 경우에는, 대부분 소스 코드를 확보할 수 없는 환경에서 프로그램 바이너리를 대상으로 취약점 분석과 패치가 수행되므로, 소스 코드를 수정하여 취약점을 제거하는 방법이 활용될 수 없다. 따라서, 취약점이 존재하는 바이너리를 직접 수정하여 패치하는 기술의 제공이 요구된다.

한국 공개특허공보 제10-2016-0024583호

본 발명의 몇몇 실시예들이 해결하고자 하는 기술적 과제는, 취약점이 존재하는 바이너리에 대한 패치 방법 및 장치를 제공하는 것이다.

본 발명의 몇몇 실시예들이 해결하고자 하는 다른 기술적 과제는, 바이너리의 취약점을 보완하는 패치 코드를 바이너리에 직접 삽입하는 방법 및 장치를 제공하는 것이다.

본 발명의 몇몇 실시예들이 해결하고자 하는 또 다른 기술적 과제는, 초기화되지 않은 변수의 사용으로 인한 바이너리의 취약점을 효과적으로 패치하는 방법 및 장치를 제공하는 것이다.

본 발명의 몇몇 실시예들이 해결하고자 하는 또 다른 기술적 과제는, 널포인터 참조로 인한 바이너리의 취약점을 효과적으로 패치하는 방법 및 장치를 제공하는 것이다.

본 발명의 기술적 과제들은 이상에서 언급한 기술적 과제로 제한되지 않으며, 언급되지 않은 또 다른 기술적 과제들은 아래의 기재로부터 본 발명의 기술분야에서의 통상의 기술자에게 명확하게 이해될 수 있을 것이다.

상기 기술적 과제를 해결하기 위한, 본 발명의 일 실시예에 따른 바이너리 취약점 패치 방법은, 대상 바이너리 내에 패치 코드 블록을 삽입하는 단계와, 상기 대상 바이너리의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 코드 블록으로 점프하는 인스트럭션으로 치환하는 단계를 포함하되, 상기 패치 코드 블록은, 상기 취약점을 해소하는 인스트럭션을 포함한다.

일 실시예에서, 상기 패치 코드 블록은, 상기 취약점 발생 영역에서 치환된 인스트럭션의 다음 인스트럭션으로 점프하는 인스트럭션을 더 포함한다. 몇몇 실시예에서, 상기 치환되는 적어도 일부 인스트럭션은, 상기 취약점 발생 영역을 포함하는 함수의 프로롤그부 인스트럭션이고, 상기 패치 코드 블록은, 상기 함수의 프롤로그부 인스트럭션과, 상기 함수의 스택 프레임을 초기화하는 인스트럭션을 더 포함한다. 몇몇 실시예에서, 상기 스택 프레임을 초기화하는 인스트럭션은,스택 포인터 레지스터 및 베이스 포인터 레지스터 값을 이용하여, 상기 스택 프레임의 데이터를 초기화하는 인스트럭션을 포함한다.

일 실시예에서, 상기 대상 바이너리의 사이즈는 상기 패치 코드 블록의 삽입 전후에 그대로 유지된다. 몇몇 실시예에서, 상기 패치 코드 블록을 삽입하는 단계는, 상기 대상 바이너리의 텍스트 영역 중 유휴 영역을 탐색하는 단계와, 상기 유휴 영역에 상기 패치 코드 블록을 기록하는 단계를 포함한다.

일 실시예에서, 상기 패치 코드 블록을 삽입하는 단계는, 상기 대상 바이너리에 상기 패치 코드 블록을 위한 영역을 추가하고, 상기 추가된 영역에 상기 패치 코드 블록을 기록하는 단계를 포함한다. 몇몇 실시예에서, 상기 패치 코드 블록을 삽입하는 단계는, 상기 상기 대상 바이너리의 텍스트 영역 중 유휴 영역을 탐색하는 단계와, 상기 유휴 영역의 크기와 상기 패치 코드 블록의 크기를 비교하는 단계와, 상기 유휴 영역의 크기가 상기 패치 코드 블록의 크기 미만이라는 판정에 응답하여, 상기 대상 바이너리에 상기 패치 코드 블록을 위한 영역을 추가하고, 상기 추가된 영역에 상기 패치 코드 블록을 기록하는 단계를 포함한다.

상기 기술적 과제를 해결하기 위한, 본 발명의 다른 실시예에 따른 바이너리 취약점 패치 방법은, 대상 바이너리 내에 패치 코드 블록을 삽입하는 단계와, 상기 대상 바이너리의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 코드 블록으로 점프하는 인스트럭션으로 치환하는 단계를 포함하되, 상기 패치 코드 블록은, 상기 대상 바이너리의 실행시 크래시가 발생되는지 판정하는 인스트럭션을 포함한다.

일 실시예에서, 상기 패치 코드 블록은, 상기 대상 바이너리의 실행시 크래시가 발생된다는 판정에 응답하여, 상기 대상 바이너리의 실행을 중단하는 인스트럭션과, 상기 대상 바이너리의 실행시 크래시가 발생되지 않는다는 판정에 응답하여, 상기 취약점 발생 영역에서 치환된 인스트럭션의 다음 인스트럭션으로 점프하는 인스트럭션을 더 포함한다. 몇몇 실시예에서, 상기 크래시는, 비정상적 메모리 접근으로 인한 크래시를 포함하며, 상기 판정하는 인스트럭션은, 상기 취약점 발생 영역의 적어도 일부 인스트럭션 중 메모리에 접근하는 인스트럭션의 오퍼랜드로 사용된 레지스터의 값에 기초하여, 상기 바이너리의 실행 흐름을 결정하는 인스트럭션을 포함한다. 몇몇 실시예에서, 상기 비정상적 메모리 접근은, 널 포인터 사용, 버퍼 오버 라이트, 및 버퍼 언더 라이트 중 적어도 하나를 포함한다.

일 실시예에서, 상기 패치 코드 블록을 삽입하는 단계는, 상기 대상 바이너리의 텍스트 영역 중 유휴 영역을 탐색하는 단계와, 상기 유휴 영역에 상기 패치 코드 블록을 기록하는 단계를 포함한다.

일 실시예에서, 상기 패치 코드 블록을 삽입하는 단계는, 상기 대상 바이너리에 상기 패치 코드 블록을 위한 영역을 추가하고, 상기 추가된 영역에 상기 패치 코드 블록을 기록하는 단계를 포함한다.

상기 기술적 과제를 해결하기 위한, 본 발명의 또 다른 실시예에 따른 바이너리 취약점 패치 장치는, 패치 영역 생성부 및 패치 실행부를 포함한다. 상기 패치 영역 생성부는, 상기 대상 바이너리의 텍스트 영역 중 유휴 영역을 탐색하고, 상기 유휴 영역의 크기가 패치 코드의 크기 미만일 경우, 상기 대상 바이너리에 상기 패치 코드를 위한 영역을 추가하며, 상기 대상 바이너리 내에 상기 패치 코드가 삽입될 패치 영역을 결정한다. 또한 상기 패치 실행부는, 상기 패치 영역에 상기 패치 코드를 삽입하고, 상기 대상 바이너리의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 영역으로 점프하는 인스트럭션으로 치환한다. 또한 상기 패치 코드는, 상기 취약점을 해소하는 인스트럭션과, 상기 취약점 발생 영역에서 치환된 인스트럭션의 다음 인스트럭션으로 점프하는 인스트럭션을 포함한다.

도 1은 본 발명의 실시예들이 적용될 수 있는 예시적인 환경을 설명하기 위한 도면이다.
도 2는, 본 발명의 일 실시예에 따른 바이너리 취약점 패치 방법을 설명하기 위한 도면이다.
도 3은, 도 2를 참조하여 설명된 실시예에서, 대상 바이너리 내에 패치 영역을 확보하는 예시적인 방법을 설명하기 위한 도면이다.
도 4a 및 도 4b는, 초기화되지 않은 변수를 사용하는 취약점을 가지는 예시적인 바이너리를 설명하기 위한 도면이다.
도 5는, 본 발명의 몇몇 실시예에 따른 방법에 의해, 초기화되지 않은 변수를 사용하는 취약점을 가지는 바이너리를 대상으로 패치를 수행하기 전과 후의 바이너리의 변화를 설명하기 위한 도면이다.
도 6은, 본 발명의 몇몇 실시예에 따른 방법에 의해, 초기화되지 않은 변수를 사용하는 취약점을 패치하는 프로그램의 동작을 설명하기 위한 의사 코드(pseudo-code)이다.
도 7은, 널 포인터 참조 취약점을 가지는 예시적인 바이너리를 설명하기 위한 도면이다.
도 8은, 본 발명의 다른 몇몇 실시예에 따른 방법에 의해, 널 포인터 참조 취약점을 가지는 바이너리를 대상으로 패치를 수행하기 전과 후의 바이너리의 변화를 설명하기 위한 도면이다.
도 9는, 본 발명의 다른 실시예에 따른 바이너리 취약점 패치 장치를 설명하기 위한 도면이다.

이하, 첨부된 도면을 참조하여 본 발명의 실시예들을 상세히 설명한다. 본 발명의 이점 및 특징, 그리고 그것들을 달성하는 방법은 첨부되는 도면과 함께 상세하게 후술되어 있는 실시예들을 참조하면 명확해질 것이다. 그러나 본 발명의 기술적 사상은 이하의 실시예들에 한정되는 것이 아니라 서로 다른 다양한 형태로 구현될 수 있으며, 단지 이하의 실시예들은 본 발명의 기술적 사상을 완전하도록 하고, 본 발명이 속하는 기술분야에서 통상의 지식을 가진 자에게 본 발명의 범주를 완전하게 알려주기 위해 제공되는 것이며, 본 발명의 기술적 사상은 청구항의 범주에 의해 정의될 뿐이다.

각 도면의 구성요소들에 참조부호를 부가함에 있어서, 동일한 구성요소들에 대해서는 비록 다른 도면상에 표시되더라도 가능한 한 동일한 부호를 가지도록 하고 있음에 유의해야 한다. 또한, 본 발명을 설명함에 있어, 관련된 공지 구성 또는 기능에 대한 구체적인 설명이 본 발명의 요지를 흐릴 수 있다고 판단되는 경우에는 그 상세한 설명은 생략한다.

다른 정의가 없다면, 본 명세서에서 사용되는 모든 용어(기술 및 과학적 용어를 포함)는 본 발명이 속하는 기술분야에서 통상의 지식을 가진 자에게 공통적으로 이해될 수 있는 의미로 사용될 수 있다. 또 일반적으로 사용되는 사전에 정의되어 있는 용어들은 명백하게 특별히 정의되어 있지 않는 한 이상적으로 또는 과도하게 해석되지 않는다. 본 명세서에서 사용된 용어는 실시예들을 설명하기 위한 것이며 본 발명을 제한하고자 하는 것은 아니다. 본 명세서에서, 단수형은 문구에서 특별히 언급하지 않는 한 복수형도 포함한다.

또한, 본 발명의 구성 요소를 설명하는 데 있어서, 제1, 제2, A, B, (a), (b) 등의 용어를 사용할 수 있다. 이러한 용어는 그 구성 요소를 다른 구성 요소와 구별하기 위한 것일 뿐, 그 용어에 의해 해당 구성 요소의 본질이나 차례 또는 순서 등이 한정되지 않는다. 어떤 구성 요소가 다른 구성요소에 "연결", "결합" 또는 "접속"된다고 기재된 경우, 그 구성 요소는 그 다른 구성요소에 직접적으로 연결되거나 또는 접속될 수 있지만, 각 구성 요소 사이에 또 다른 구성 요소가 "연결", "결합" 또는 "접속"될 수도 있다고 이해되어야 할 것이다.

이하, 본 발명의 몇몇 실시예들에 대하여 첨부된 도면에 따라 상세하게 설명한다.

먼저 도 1을 참조하여, 바이너리의 취약점을 패치하는 일련의 과정을 설명한다.

먼저, 취약점 식별 및 패치 대상 바이너리(10)가 주어지고, 상기 대상 바이너리(10)에 대한 취약 영역 탐색 또는 취약점 탐색 과정(110)이 수행된다. 취약점 탐색(110)은 퍼징, 기호 실행, 및 이들을 결합한 하이브리드 퍼징 등 종래의 다양한 기술을 이용하여 수행될 수 있다.

퍼징은 임의의 값(테스트 케이스)들을 반복적으로 생성하여 대상 프로그램에 입력함으로써, 프로그램에 충돌(크래시)이 발생하는 상황을 만들어내는 방법이다. 기호 실행은 대상 프로그램의 입력 값을 기호로 지정하고, 프로그램의 취약점이 있는 경로에 도달할 수 있는 값을 찾아내는 방법이다. 한편, 하이브리드 퍼징은 퍼징과 기호 실행을 혼합한 기술로서, 얕은 경로에서는 퍼징을 활용해 취약점을 빠르게 탐색하고, 더 이상 경로 탐색이 어려운 경우 기호 실행을 활용하여 취약점을 탐색하는 방식이다.

취약점 탐색 과정(110)에 의해서, 대상 바이너리에서 취약점이 발견된 영역의 주소, 취약점을 유발하는 인스트럭션의 주소, 또는 취약점이 발견된 함수의 명칭이 식별될 수 있고, 취약점에 의해 발생한 크래시에 관한 정보가 기록될 수 있다.

이어서 도 1의 취약점 원인 분석(120) 과정에 관해 설명한다. 상기 대상 바이너리(10)에 대한 취약점 탐색(110)의 수행 결과 산출된 취약점 발견 영역에 관한 정보 및 크래시 정보에 기초하여, 취약점이 발생한 원인을 분석하는 과정(120)이 수행된다. 바이너리에 존재하는 취약점의 원인과 유형은 매우 다양하다. 2010년부터 2015년까지 취약점 데이터베이스인 NVD(National Vulnerability Database)에 약 8만건의 보안 취약점(CVE)들이 등록되었으며, 최근에도 지속적으로 증가하고 있다. 이처럼 다양한 보안 취약점들 중에 대표적인 몇몇 유형들은, 할당된 저장 공간을 초과하는 데이터를 저장하는 버퍼 오버플로우 또는 인티저 오버플로우 유형, 변수 형식 오류 유형, 변수를 초기화하지 않고 사용하는 취약점 유형, 널 포인터를 참조하는 취약점 등이다. 취약점이 발생된 원인은 다양한 기술에 의해 분석될 수 있다.

이어서 도 1의 취약점 제거 패치(130) 과정에 관해 설명한다. 전술한 바와 같이 다양한 취약점들의 유형과 발생 원인에 따라, 취약점을 제거하기 위한 다양한 패치 유형과 패치 적용 방법이 선택될 수 있다. 예컨대, 취약점 발생 원인에 따라, 변수 초기화 패치, 함수의 매개 변수 검증 또는 변경 패치, 제어 흐름 변경 패치 등의 여러가지 목적의 패치가 선택될 수 있다. 또한, 예컨대 대상 바이너리의 어셈블리 인스트럭션을 변경하는 패치, 대상 바이너리에서 안전하지 않은 라이브러리 함수를 호출하는 인스트럭션을 변경하는 패치, 대상 바이너리의 실행 시점에 보안 라이브러리가 로드되도록 하는 런타임 메모리 패치 등의 여러 가지 패치 수행 방법이 선택될 수 있다. 본 발명의 실시예들은, 상기 취약점 제거 패치(130) 과정에 적용될 수 있다.

지금까지는 도 1을 참조하여 바이너리의 취약점을 패치하는 일련의 과정에 본 발명의 실시예들이 적용될 수 있음을 설명하였다. 이하에서는, 도 2 내지 도 9를 참조하여, 본 발명의 여러 실시예들에 따른 바이너리 취약점 패치 방법 및 장치에 대하여 상세히 설명하기로 한다.

도 2는, 본 발명의 일 실시예에 따른 바이너리 취약점 패치 방법을 설명하기 위한 도면이다. 본 실시예에 따른 바이너리 취약점 패치 방법은 컴퓨팅 장치에서 수행될 수 있다. 이하, 본 실시예에 따른 바이너리 취약점 패치 방법에 포함된 각각의 동작에 대한 주체가 생략된 경우, 그 주체는 컴퓨팅 장치인 것으로 해석될 수 있을 것이다.

먼저 단계 S210에서, 대상 바이너리(10)가 로드되고, 발견된 취약점에 관한 정보가 식별된다. 상기 취약점에 관한 정보는, 취약점의 유형 및 취약점이 발생한 영역의 주소를 포함할 수 있다. 상기 취약점에 관한 정보는, 예컨대 도 1에 도시된 취약점 탐색(110) 과정 및 취약점 원인 분석(120) 과정의 수행 결과로서 제공된 것일 수 있다.

단계 S220에서는, 대상 바이너리(10) 내에 패치 코드가 삽입될 영역이 확보되고, 상기 영역의 주소가 식별된다. 본 발명의 몇몇 실시예들에 따르면, 취약점을 제거하기 위한 패치 코드 전체가 대상 바이너리(10) 파일에 통합될 수 있다. 또한, 본 발명의 몇몇 실시예들에 따르면, 대상 바이너리(10) 내에 존재하는 유휴 공간이 식별되어, 패치 코드 삽입을 위해 이용될 수 있다. 또한, 본 발명의 다른 몇몇 실시예들에 따르면, 대상 바이너리(10) 내에 패치 코드를 위한 추가적인 영역이 생성될 수 있다. 대상 바이너리(10) 내에 패치 코드가 삽입될 영역이 확보되는 방법에 관하여 도 3을 참조하여 보다 자세히 설명한다.

먼저 단계 S222에서는, 대상 바이너리(10) 내의 코드 섹션(.text)이 탐색된다. 보다 구체적으로, 대상 바이너리(10)의 코드 섹션(.text) 내의 유휴 공간이 탐색된다. 여기서 유휴 공간은, 예컨대 NOP 명령어로 채워진 공간들을 포함한다. 상기 NOP 명령은, CPU 아키텍처에 따라, 0x90, 0x00, 0x00000000 등의 opcode에 대응될 수 있다.

단계 S224에서는, 상기 탐색의 결과 발견된 유휴 공간의 크기와, 패치 코드 블록의 크기가 서로 비교된다. 만약 패치 코드 블록이 삽입되기에 충분한 크기의 유휴 공간이 발견되었다면, 상기 발견된 유휴 공간이 상기 패치 코드 블록이 삽입될 영역으로서 결정된다(단계 S226). 또한, 상기 유휴 공간이 시작되는 주소가 식별되고, 후술할 도 2의 단계 S230에서 이용될 수 있다.

만약 대상 바이너리(10) 내의 코드 섹션(.text)이 탐색된 결과, 유휴 공간이 발견되지 않았거나, 또는 발견된 유휴 공간의 크기가 상기 패치 코드 블록의 크기보다 작은 경우, 단계 S228로 진행된다.

단계 S228에서는, 상기 대상 바이너리(10) 내에 상기 패치 코드 블록을 위한 추가 영역이 생성된다. 몇몇 실시예에서, 상기 대상 바이너리(10) 내에 상기 추가 영역을 위한 새로운 섹션이 생성될 수 있다. 다른 몇몇 실시예에서, 상기 추가 영역은, 상기 대상 바이너리(10) 내의 기존 섹션들 중에 적절한 공간에 생성될 수 있다. 또한, 상기 추가 영역의 생성을 반영하기 위하여, 상기 대상 바이너리(10) 파일 내에 새로운 헤더가 추가되거나, 상기 대상 바이너리(10) 파일 내의 기존 헤더들 중 일부가 수정될 수 있다. 상기 헤더는, 섹션 헤더, 프로그램 헤더 또는 PHDR 등을 포함한다. 단계 S228에서 생성된 추가 영역은 상기 패치 코드 블록이 삽입될 영역으로서 결정된다(단계 S226). 또한, 상기 추가 영역이 시작되는 주소가 식별되고, 후술할 도 2의 단계 S230에서 이용될 수 있다.

다시 도 2를 참조하여, 대상 바이너리(10) 내에 패치 코드가 삽입될 영역이 확보된 이후의 동작에 관하여 설명한다.

단계 S230에서는, 상기 취약점을 제거하기 위한 패치 코드를 포함하는 패치 코드 블록이 상기 대상 바이너리(10) 내에 삽입된다. 이때, 전술한 단계 S220에서 확보된, 대상 바이너리(10) 내의 영역이 이용될 수 있다. 예컨대, 대상 바이너리(10) 내의 코드 섹션의 유휴 공간, 또는 대상 바이너리(10) 내에서 패치 코드 블록의 삽입을 위해 추가로 생성된 공간에, 상기 패치 코드 블록이 삽입될 수 있다. 몇몇 실시예에서, 상기 패치 코드는 기계어로 작성된 머신코드며, 상기 패치 코드가 상기 대상 바이너리(10) 파일 내의 상기 영역에 기록될 수 있다.

몇몇 실시예에서, 상기 제거 대상 취약점이 초기화되지 않은 변수의 사용으로 인한 취약점이라면, 상기 패치 코드는 초기화되지 않은 변수들에게 할당된 메모리 공간에 저장된 값들을 초기화하는 인스트럭션들을 포함할 수 있다. 다른 몇몇 실시예에서, 상기 제거 대상 취약점이 널 포인터 참조로 인한 취약점이라면, 상기 패치 코드는 널 값을 저장하고 있을 가능성이 있는 레지스터 또는 오퍼랜드의 값이 널 값 또는 0인지 판정하여, 그 결과에 따라 적절한 에러 메시지를 출력하면서 대상 바이너리(10)의 실행을 중단시키거나, 또는 대상 바이너리(10)의 실행을 계속하도록 하는 인스트럭션들을 포함할 수 있다.

또한, 상기 패치 코드는 전술한 바와 같은 동작들을 수행하는 인스트럭션들 다음에, 상기 바이너리(10)의 제어 흐름이 상기 취약점이 발생한 지점으로 돌아가도록 하는 인스트럭션을 포함한다. 상기 상기 취약점이 발생한 지점으로 돌아가도록 하는 인스트럭션은, 점프 명령을 나타내는 opcode 및 상기 취약점 발생 지점의 주소를 포함한다. 상기 취약점 발생 지점의 주소는, 전술한 단계 S210에서 식별된 정보가 이용될 수 있다.

단계 S240에서는, 대상 바이너리(10) 내에서 취약점이 발견된 영역의 적어도 일부 인스트럭션이 새로운 인스트럭션으로 치환된다. 상기 새로운 인스트럭션은, 상기 패치 코드 블록으로 점프하는 인스트럭션을 포함한다. 상기 패치 코드 블록으로 점프하는 인스트럭션은, 점프 명령을 나타내는 opcode 및 상기 패치 코드 블록의 주소를 포함한다. 대상 바이너리(10) 파일 내에서, 상기 취약점이 발견된 영역의 치환 대상 인스트럭션이 기록된 위치에, 상기 패치 코드 블록으로 점프하는 인스트럭션에 대응되는 머신코드가 기록될 수 있다.

비록 도 2에서는, 단계 S230이 수행된 이후에 단계 S240이 수행되는 것으로 도시되었지만, 본 발명의 여러 실시예에 따른 방법들이 그러한 순서로 한정되는 것은 아니다. 다시 말해, 몇몇 실시예들에서는, 대상 바이너리(10) 내의 취약 영역 인스트럭션을 패치 코드 블록으로 점프하는 인스트럭션으로 치환하는 동작이 수행된 이후에, 대상 바이너리(10) 내에 패치 코드 블록을 삽입하는 동작이 수행될 수도 있다.

단계 S250에서는, 전술한 단계 S210 내지 S240을 통해 대상 바이너리(10)에 패치가 적용된 바이너리가 저장 또는 전송된다. 몇몇 실시예에서, 상기 패치가 적용된 바이너리는 대상 바이너리(10) 파일과 별개의 파일로 저장될 수 있으며, 다른 몇몇 실시예에서, 상기 패치가 적용된 바이너리는 대상 바이너리(10) 파일을 대체할 수 있다. 또 다른 몇몇 실시예에서, 상기 패치가 적용된 바이너리는, 네트워크를 통하여 다른 컴퓨팅 장치로 전송될 수 있다.

지금까지는 도 2 및 도 3을 참조하여 본 발명의 일 실시예에 따른 바이너리 취약점 패치 방법을 설명하였다. 본 실시예에 따르면, 대상 바이너리(10)의 취약점을 제거하기 위한 패치 코드가 대상 바이너리(10) 파일 내에 삽입된다. 따라서, 실행시 상기 대상 바이너리(10)와 링크되는 다른 바이너리 또는 대상 바이너리(10)가 호출하는 라이브러리 함수 등에 의존하지 않고도, 상기 대상 바이너리(10)에 존재하는 취약점의 제거가 완료될 수 있다. 또한, 본 실시예에 따르면, 가급적 상기 대상 바이너리(10) 파일 내의 유휴 공간을 활용하여 패치 코드가 삽입된다. 이로써, 대상 바이너리(10) 파일 사이즈의 불필요한 증가를 초래하지 않고, 대상 바이너리의 취약점을 제거할 수 있게 된다. 뿐만 아니라, 대상 바이너리(10) 파일의 구조가 그대로 유지되므로, 패치된 바이너리 파일의 높은 호환성을 보장할 수 있게 된다. 또한, 상기 대상 바이너리(10) 파일의 코드 섹션(.text) 내의 공간을 패치 코드 삽입에 활용함으로써, 대상 바이너리(10)의 실행시 제어 흐름이 패치 코드 블록으로의 빠르게 이동하고 복귀할 수 있는 성능상의 이점 또한 가질 수 있다.

이하에서는, 도 4 내지 도 6을 참조하여, 본 발명의 몇몇 실시예에 따라, 초기화되지 않은 변수를 사용하는 취약점을 가지는 바이너리를 대상으로 패치를 수행하는 방법을 설명한다. 또한, 도 7 내지 도 9를 참조하여, 비정상적인 메모리 접근에 의한 취약점, 특히 널 포인터 참조 취약점을 가지는 바이너리를 대상으로 패치를 수행하는 방법을 설명하기로 한다.

도 4a는, 초기화되지 않은 변수를 사용하는 취약점을 가지는 예시적인 프로그램 바이너리를 설명하기 위한 예제 코드이다. 도 4a의 프로그램에서 호출되는 함수 'foo'는 총 7개의 인티저형 지역 변수들(a, b, c, d, e, f, g)를 선언하였지만, 상기 지역 변수들에 아무런 값을 할당하지 않는다. 그리고 상기 함수는 상기 지역 변수들에 저장된 값을 출력하는 명령(printf)을 수행한다.

도 4b는 도 4a에 도시된 예제 코드를 컴파일하고 실행한 예시적인 결과를 보여주는 도면이다. 도 4b에 도시된 바와 같이, 도 4a의 프로그램을 실행하면, 상기 'foo' 함수의 지역 변수들의 값으로서 예상할 수 없는 값들이 출력된다. 이처럼 초기화되지 않은 변수들을 사용하는 것은, 잠재적인 보안 위협을 초래할 수 있으므로, 상기 프로그램에서 초기화되지 않은 변수를 사용하는 취약점을 제거하는 것이 바람직하다.

도 5는, 본 발명의 몇몇 실시예에 따른 방법에 의해, 도 4a에 도시된 프로그램의 바이너리를 대상으로, 초기화되지 않은 변수의 사용으로 인한 취약점을 제거하는 패치를 수행하기 전과 후의 바이너리의 변화를 설명하기 위한 도면이다. 이해의 편의를 위하여, 도 5에서 취약점 패치 전 바이너리(500) 및 취약점 패치 후 바이너리(520)의 내용은 어셈블리 코드의 형태로 표기되어 있지만, 실제로는 기계어(머신코드)의 형태로 기록되어 있음에 유의한다.

도 5의 취약점 패치 전 바이너리(500)은, 취약점을 포함하는 함수(상기 'foo' 함수)에 대응되는 취약 함수 블록(510)을 포함한다. 상기 취약 함수 블록(510)은, 프롤로그부(511) 및 바디부(512)를 포함한다.

상기 프롤로그부(511)는, 상기 'foo' 함수의 스택 프레임을 설정하고 상기 'foo' 함수에서 선언된 지역 변수들을 위한 메모리 공간을 확보하는 인스트럭션들을 포함하는 영역이다. 보다 구체적으로, 상기 프롤로그부(511)는, 베이스 포인터 레지스터의 값을 스택에 저장하는 인스트럭션(push %ebp), 스택 포인터 레지스터에 저장된 값을 베이스 포인터 레지스터에 저장하는 인스트럭션(mov %esp, %ebp), 및 스택 포인터 레지스터가 가리키는 메모리 주소를 예컨대 0x28만큼 감산하여, 상기 'foo' 함수에 선언된 지역 변수들을 위한 메모리 공간(스택)을 확보하는 인스트럭션(sub $0x28, %esp)을 포함한다.

상기 바디부(512)는 상기 'foo' 함수가 수행하는 동작들(예컨대, 도 4a에 도시된 예제 코드에서 printf 명령문)에 대응되는 인스트럭션들을 포함한다.

도 5의 취약점 패치 후 바이너리(520)는, 취약점 패치 전 바이너리(510)에 패치 코드 블록(540)이 삽입되고, 취약점 패치 전 바이너리(510)의 취약 함수 블록(510)의 내용이 수정된 블록(530)이 포함된 바이너리이다.

보다 자세히 설명하면, 우선 취약점 패치 후 바이너리(520)에는 패치 코드 블록(540)이 삽입된다. 패치 코드 블록(540)이 삽입되는 영역은, 도 3을 참조하여 설명한 방법에 의해 결정된, 취약점 패치 전 바이너리(510)의 코드 섹션(.text) 내에 존재하는 유휴 공간 또는, 취약점 패치 전 바이너리(510) 내에 추가로 생성된 영역일 수 있다.

상기 패치 코드 블록(540)은, 상기 취약 함수 블록(510)의 프롤로그부(511)의 인스트럭션들이 그대로 복사되어 기록된 블록(541)을 포함한다. 또한 상기 패치 코드 블록(540)은, 상기 'foo' 함수의 취약점을 제거하기 위한 인스트럭션들이 기록된 블록(542)을 포함한다.

보다 구체적으로, 상기 블록(542)은 상기 'foo' 함수의 지역 변수들을 초기화하는 인스트럭션들을 포함한다. 몇몇 실시예에서, 상기 'foo' 함수의 취약점을 제거하기 위한 인스트럭션들은, 베이스 포인터 레지스터가 가리키는 메모리 주소로부터 스택 포인터 레지스터가 가리키는 메모리 주소까지의 메모리 공간에 예컨대 0의 값을 저장하는 인스트럭션들을 포함한다. 다시 말해, 상기 'foo' 함수의 지역 변수에 초기 값(예컨대 0)이 저장된다. 이로써, 상기 'foo' 함수에 존재하는 취약점이 제거될 수 있다. 또한 상기 블록(542)은 블록(532)으로 점프하기 위한 인스트럭션이 기록된다. 블록(532)에 관해서는 후술한다.

전술한 바와 같이, 취약점 패치 후 바이너리(520)는 상기 취약점 패치 전 바이너리(510)의 취약 함수 블록(510)의 내용이 수정된 블록(530)을 포함한다. 상기 블록(530)은, 상기 취약 함수 블록(510)의 프롤로그부(511)의 인스트럭션들을 새로운 인스트럭션으로 치환한 블록(531) 및 상기 취약 함수 블록(510)의 바디부(512)의 인스트럭션들을 그대로 포함하는 블록(532)을 포함한다.

상기 블록(531)은, 상기 프롤로그부(511)의 인스트럭션들 대신에, 상기 패치 코드 블록(540)으로 점프하는 인스트럭션을 포함한다. 몇몇 실시예에서, 상기 블록(531)이 상기 프롤로그부(511)의 크기와 동일한 크기를 가지도록 하기 위하여, 상기 블록(531)에는 적절한 수의 NOP 인스트럭션이 기록될 수 있다.

한편, 상기 블록(532)에는 상기 취약 함수 블록(510)의 바디부(512)의 인스트럭션들이 그대로 기록된다. 예를 들어, 상기 블록(532)에는, 상기 'foo' 함수가 수행하는 동작들(예컨대, 도 4a에 도시된 예제 코드에서 printf 명령문)에 대응되는 인스트럭션들이 기록된다.

지금까지, 본 발명의 몇몇 실시예에 따른 방법에 의해, 도 4a에 도시된 프로그램의 바이너리를 대상으로, 초기화되지 않은 변수의 사용으로 인한 취약점을 제거하는 패치를 수행하기 전과 후의 바이너리에 기록된 인스트럭션들을 설명하였다. 이하에서는 취약점 패치 후 바이너리(520)의 실행 흐름을 설명한다.

먼저 도 4a에 도시된 프로그램의 main() 함수에서 'foo' 함수가 호출되면, 제어 흐름은 블록(530)으로 이동된다. 그리고 블록(531)에 기록된 점프 인스트럭션에 의해, 제어 흐름이 패치 코드 블록(540)으로 이동된다. 블록(541)에 기록된 인스트럭션들은, 전술한 바와 같이 함수 'foo'의 프롤로그에 대응되는 인스트럭션들이다. 블록(541)에 기록된 인스트럭션들에 의해, 상기 'foo' 함수의 스택 프레임이 설정되고, 상기 'foo' 함수에서 선언된 지역 변수들을 위한 메모리 공간이 확보된다. 이어서, 블록(542)에 기록된 인스트럭션들에 의해 상기 'foo' 함수의 지역 변수들이 초기화된다. 다시 말해, 상기 'foo' 함수의 지역 변수에 초기 값(예컨대 0)이 저장됨으로써, 상기 'foo' 함수에 존재하는 취약점이 제거된다. 또한, 블록(542)에 기록된 점프 인스트럭션에 의해, 제어 흐름이 블록(532)으로 이동된다. 블록(532)에 기록된 인스트럭션들에 의해, 상기 'foo' 함수가 수행하는 동작들(예컨대, 도 4a에 도시된 예제 코드에서 printf 명령문)이 수행된다.

도 6은, 본 발명의 몇몇 실시예에 따른 방법에 의해, 도 4a에 도시된 예제 코드와 같이 초기화되지 않은 변수를 사용하는 취약점을 가지는 프로그램의 바이너리를 패치하기 위한 패치 프로그램을 설명하는 예시적인 의사 코드(pseudo-code)이다. 예를 들어, 도 5의 취약점 패치 전 바이너리(500)를 수정하여 도 5의 취약점 패치 후 바이너리(520)를 생성하는 패치 프로그램의 의사 코드가 도 6에 도시되어 있다.

도 6을 참조하면, 먼저 패치 대상 바이너리 파일이 오픈된다. 이어서, 파일 디스크립터가, 상기 패치 대상 바이너리 내의 취약 함수의 프롤로그부로 이동된다. 상기 취약 함수의 주소는, 예컨대 도 1에 도시된 취약점 탐색(110) 과정 및 취약점 원인 분석(120) 과정의 수행 결과로서 제공되어, 상기 패치 프로그램에 입력 값으로 제공된 것일 수 있다.

이어서, 취약 함수의 프롤로그부에 머신 코드로 기록된 인스트럭션들이 판독되어 변수'b_prologue'에 저장되고, 파일 디스크립터는 다시 상기 프롤로그부의 위치로 이동된다.

이어서, 상기 프롤로그부의 위치에, 제1 점프 인스트럭션이 머신 코드로 기록된다. 여기서, 상기 제1 점프 인스트럭션은 패치 코드 블록이 삽입되는 주소로 점프하는 인스트럭션이다. 상기 패치 코드 블록이 삽입되는 주소는, 예컨대 도 3을 참조하여 설명한 방법에 의해 결정된, 취약점 패치 전 바이너리(510)의 코드 섹션(.text) 내에 존재하는 유휴 공간 또는, 취약점 패치 전 바이너리(510) 내에 추가로 생성된 영역의 주소일 수 있으며, 상기 주소는 도 6에 도시된 의사 코드들에 선행하는 코드에 의해 사전에 식별될 수 있다.

이어서, 파일 디스크립터가 상기 패치 코드 블록이 삽입되는 주소로 이동되고, 변수 'b_prologue'에 저장된 상기 취약 함수의 프롤로그부의 머신 코드들이 상기 주소에 기록된다.

이어서, 상기 취약 함수의 지역 변수들을 초기화하기 위한 인스트럭션들이 머신 코드로 기록된다. 예를 들어, 상기 인스트럭션들은, 베이스 포인터 레지스터가 가리키는 메모리 주소로부터 스택 포인터 레지스터가 가리키는 메모리 주소까지의 메모리 공간에 예컨대 0의 값을 저장하는 인스트럭션들일 수 있다. 즉, 상기 인스트럭션들은 상기 대상 바이너리의 취약점을 제거하는 인스트럭션들이다.

이어서, 제2 점프 인스트럭션이 머신 코드로 기록된다. 여기서, 상기 제2 점프 인스트럭션의 목적지의 주소는, 상기 대상 바이너리에서 상기 취약 함수의 프롤로그부의 인스트럭션들이 기록되어 있던 주소에 기초하여 결정될 수 있다. 예를 들어, 상기 취약 함수의 프롤로그부의 인스트럭션들이 기록되어 있던 주소의 바로 다음 주소가, 상기 제2 점프 인스트럭션의 목적지를 가리키는 오퍼랜드로 사용될 수 있다.

전술한 바와 같은 패치 프로그램을 통하여, 초기화되지 않은 변수를 사용하는 취약점을 가지는 바이너리로부터 취약점이 제거될 수 있다.

지금까지 도 4 내지 도 6을 참조하여, 본 발명의 몇몇 실시예에 따라, 초기화되지 않은 변수를 사용하는 취약점을 가지는 바이너리를 대상으로 패치를 수행하는 방법을 설명하였다. 이하에서는, 도 7 내지 도 9를 참조하여, 본 발명의 다른 몇몇 실시예에 따라, 비정상적인 메모리 접근에 의한 취약점, 특히 널 포인터 참조 취약점을 가지는 바이너리를 대상으로 패치를 수행하는 방법을 설명하기로 한다.

도 7은, 널 포인터 참조 취약점을 가지는 예시적인 프로그램 바이너리를 설명하기 위한 예제 코드이다. 도 7의 프로그램에서 호출되는 함수 'foo2'는 'double' 형의 데이터를 저장하기 위한 메모리의 주소를 저장하는 'data'라는 포인터 변수를 선언하였지만, 상기 포인터 변수가 가리키는 메모리 공간을 할당하지 않고, 상기 메모리 공간의 주소를 상기 포인터 변수에 저장하지 않는다. 즉, 상기 포인터 변수 'data'는 초기화되지 않은채로 사용된다.

만약 도 7에 도시된 예제 코드를 컴파일한 바이너리가 실행되면, 예상할 수 없는 문자열이 출력될 수 있다. 한편, 상기 바이너리를 대상으로, 도 4 내지 도 6을 참조하여 설명한 패치 방법에 의해, 초기화되지 않은 지역 변수를 초기화하는 패치를 적용할 경우, 상기 포인터 변수 'data'가 초기화되어 포인터 변수 'data'에 0 또는 NULL 값이 저장될 것이다. 따라서, 상기 패치가 적용된 바이너리가 실행되면, NULL 값이 저장된 포인터 변수 'data'가 가리키는 메모리 주소를 참조하게 되므로, Segmentation Fault가 발생되어 상기 바이너리의 실행이 비정상적으로 중단될 수 있다.

이하에서는, 본 발명의 다른 몇몇 실시예에 따라, 비정상적 메모리 접근에 의한 취약점을 가지는 바이너리를 패치하는 방법을 설명한다. 이하의 설명에서는, 비정상적 메모리 접근에 의한 취약점들 중 주로 널 포인터 참조에 의한 취약점을 패치하는 방법에 관하여 설명할 것이다. 그러나 후술할 방법은 비정상적 메모리 접근에 의한 취약점들 중 다른 유형들(예컨대, 버퍼 오버 라이트, 버퍼 언더 라이트, 버퍼 오버 리드, 버퍼 언더 리드 등)을 패치하기 위하여 적용될 수도 있음에 유의한다.

도 8은, 본 발명의 몇몇 실시예에 따른 방법에 의해, 널 포인터 참조에 의한 취약점을 제거하는 패치를 수행하기 전과 후의 바이너리의 변화를 설명하기 위한 도면이다. 이해의 편의를 위하여, 도 8에서 취약점 패치 전 바이너리(800) 및 취약점 패치 후 바이너리(820)의 내용은 어셈블리 코드의 형태로 표기되어 있지만, 실제로는 기계어(머신코드)의 형태로 기록되어 있음에 유의한다. 한편, 도 8에 도시된 어셈블리 코드들은, 도 7에 도시된 예제 코드에 대응되는 것이 아님에 유의한다.

도 8의 취약점 패치 전 바이너리(800)는, 레지스터 'eax'에 저장된 값에 해당하는 메모리 주소로부터 데이터를 판독하여 레지스터 'eax'에 저장하는 인스트럭션(mov (%eax), %eax)(811)을 포함한다. 상기 인스트럭션은, 상기 취약점 패치 전 바이너리(800)에서 0x0804895a의 주소에 기록되어 있음에 주목한다. 설명을 위한 목적으로, 상기 인스트럭션(811)은, 취약점 탐색 및 원인 분석 과정에서 널 포인터 참조로 인한 크래시를 유발할 가능성이 있는 것으로 식별되었다고 가정하기로 한다.

도 8의 취약점 패치 후 바이너리(820)에서는, 상기 크래시를 유발할 가능성이 있는 인스트럭션(mov (%eax), %eax)(811)이 제1 점프 인스트럭션(831)으로 치환되었다. 다시 말해, 취약점 패치 후 바이너리(820)의 0x0804895a의 주소에는, 패치 코드 블록(840)으로 점프하는 제1 점프 인스트럭션(831)이 기록되었다.

패치 코드 블록(840)은, 메모리에 접근하는 인스트럭션의 오퍼랜드로 사용된 상기 레지스터 'eax'의 값을 검증하는 인스트럭션을 포함한다. 예를 들어, 패치 코드 블록(840)은, 상기 레지스터 'eax'의 값이 NULL 값인지 판정하는 인스트럭션(841)을 포함한다. 상기 패치 코드 블록(840)은, 상기 레지스터 'eax'의 값이 NULL 값이 아닐 경우에 제어 흐름을 인스트럭션(844)으로 이동시키는 제2 인스트럭션(842)을 포함한다. 또한, 상기 패치 코드 블록(840)은, 상기 레지스터 'eax'의 값이 NULL 값이라면, 에러 메시지("[ERROR] null ptr")를 출력하고 상기 취약점 패치 후 바이너리(820)의 실행을 중단하는 인스트럭션들(843)을 포함한다.

또한 상기 패치 코드 블록(840)은, 상기 크래시를 유발할 가능성이 있는 인스트럭션(mov (%eax), %eax)(811)을 그대로 복사한 인스트럭션(844)을 포함하며, 이어서 상기 인스트럭션(811)에 후속하는 인스트럭션이 기록된 주소로 점프하는 제3 점프 인스트럭션(845)을 포함한다.

지금까지, 본 발명의 다른 몇몇 실시예에 따른 방법에 의해, 널 포인터 참조에 의한 취약점을 제거하는 패치를 수행하기 전과 후의 바이너리에 기록된 인스트럭션들을 설명하였다. 이하에서는 취약점 패치 후 바이너리(820)의 실행 흐름을 설명한다.

먼저 취약점 패치 후 바이너리(820)에서 'foo2' 함수가 호출되면, 제어 흐름은 블록(830)으로 이동된다. 널 포인터 참조로 인한 크래시를 유발할 가능성을 가진 인스트럭션(mov (%eax), %eax)(811)을 대신하여 기록된 제1 점프 인스트럭션(831)이 실행된다. 상기 제1 점프 인스트럭션(831)에 의해, 제어 흐름이 패치 코드 블록(840)으로 이동된다.

인스트럭션(841)은, 전술한 바와 같이, 메모리에 접근하는 인스트럭션의 오퍼랜드로 사용된 상기 레지스터 'eax'의 값이 NULL 값인지 판정하는 인스트럭션이다. 만약, 상기 레지스터 'eax'의 값이 NULL 값이 아니라면, 제2 점프 인스트럭션(842)에 의하여, 제어 흐름이 인스트럭션(844)로 이동된다.

상기 인스트럭션(844)은, 널 포인터 참조로 인한 크래시를 유발할 가능성을 가진 인스트럭션(mov (%eax), %eax)(811)을 그대로 복사한 인스트럭션이다. 그런데 이미 상기 레지스터 'eax'의 값이 NULL 값이 아니라고 판정되었으므로, 상기 인스트럭션(844)이 실행되더라도 널 포인터 참조로 인한 크래시는 발생되지 않을 것이다. 상기 인스트럭션(844)이 실행된 후, 제3 점프 인스트럭션(845)에 의해, 제어 흐름이 다시 블록(830)의 인스트럭션(831)의 다음 주소로 이동된다.

한편, 상기 레지스터 'eax'의 값이 NULL 값인지 판정하는 인스트럭션(841)을 실행한 결과, 상기 레지스터 'eax'의 값이 NULL 값이라고 판정된 경우, 상기 인스트럭션(mov (%eax), %eax)은 크래시를 유발할 것이다. 따라서, 에러 메시지("[ERROR] null ptr")를 출력하고 상기 취약점 패치 후 바이너리(820)의 실행을 중단하는 인스트럭션들(843)이 실행되게 된다.

지금까지 도 8을 참조하여, 본 발명의 다른 몇몇 실시예에 따른 방법에 의해, 널 포인터 참조에 의한 취약점을 제거하는 패치를 수행하는 예시적인 방법을 설명하였다. 지금까지 설명한 예시적인 방법은, 널 포인터 참조에 의한 취약점 외에, 비정상적 메모리 접근에 의한 다른 취약점(예컨대, 버퍼 오버 라이트, 버퍼 언더 라이트, 버퍼 오버 리드, 버퍼 언더 리드 등)을 패치하기 위하여 적용될 수 있음을 이해할 것이다. 예를 들어, 도 8에 도시된 취약점 패치 후 바이너리(820)에서 비정상적 메모리 접근이 발생할지 검증하기 위해 기록되는 인스트럭션(841)을, 취약점의 유형에 따라 적절히 선택함으로써, 다른 취약점들(예컨대, 버퍼 오버 라이트, 버퍼 언더 라이트, 버퍼 오버 리드, 버퍼 언더 리드 등)의 제거에도 활용될 수 있다.

이하에서는, 도 9를 참조하여 본 발명의 다른 실시예에 따른 바이너리 취약점 패치 장치를 설명한다. 본 실시예에 따른 바이너리 취약점 패치 장치의 구성 및 동작을 해석함에 있어서, 도 2 내지 8을 참조하여 설명한 본 발명의 몇몇 실시예에 따른 바이너리 취약점 패치 방법에 관한 설명이 반영될 수 있다.

본 실시예에 따른 바이너리 취약점 패치 장치(900)는, 바이너리 분석부(910), 패치 영역 생성부(920), 및 패치 실행부(930)로 구성될 수 있다. 상기 바이너리 취약점 패치 장치(900)는, 취약점을 가지는 대상 바이너리(10)를 입력받아서, 취약점을 제거하고, 취약점을 제거하는 패치가 적용된 바이너리(20)를 출력한다. 도시되지는 않았지만, 몇몇 실시예에서는, 상기 대상 바이너리(10)에서 발견된 취약점에 관한 정보 또한 상기 패치 장치(900)의 입력으로 제공될 수 있다. 상기 취약점에 관한 정보는, 취약점의 유형 및 취약점이 발생한 영역의 주소를 포함할 수 있다. 상기 취약점에 관한 정보는, 예컨대 도 1에 도시된 취약점 탐색(110) 과정 및 취약점 원인 분석(120) 과정의 수행 결과로서 제공된 것일 수 있다.

바이너리 분석부(910)는, 대상 바이너리(10)를 디스어셈블링하여 어셈블리 코드를 산출할 수 있다. 또한 바이너리 분석부(910)는, 대상 바이너리(10)에서 발견된 취약점에 관한 정보를 입력받아서, 취약점이 발생한 영역의 주소 또는 취약점이 발생한 함수를 식별할 수 있다. 또한 바이너리 분석부(910)는, 대상 바이너리(10)에 대한 상기 어셈블리 코드로부터, 취약점이 발생한 함수의 프롤로그부를 탐색하여, 상기 프로로그부가 기록된 주소를 식별할 수 있다. 바이너리 분석부(910)는, 상기 어셈블리 코드 및 상기 취약점에 관한 정보 등을, 패치 영역 생성부(920) 및 패치 실행부(930)에 제공할 수 있다.

패치 영역 생성부(920)는, 상기 대상 바이너리(10) 내에 패치 코드가 삽입될 영역을 확보할 수 있다. 패치 영역 생성부(920)는, 대상 바이너리(10) 내에서 패치 코드가 삽입될 수 있는 충분한 크기를 가지는 유휴 공간을 탐색하여 패치 코드가 삽입될 영역으로서 결정할 수 있다. 이때, 패치 영역 생성부(920)는 대상 바이너리(10) 내의 코드 섹션(.text) 내에 NOP 명령어로 채워진 공간을 유휴 공간으로 식별할 수 있다. 한편, 대상 바이너리(10) 내에서 패치 코드가 삽입될 수 있는 충분한 크기를 가지는 유휴 공간이 발견되지 않을 경우, 패치 영역 생성부(920)는 대상 바이너리(10) 내에 추가 영역을 생성하고, 상기 추가 영역 생성을 반영하기 위하여, 상기 대상 바이너리(10) 파일에서, 상기 추가 영역이 생성된 세그먼트 또는 섹션에 대응되는 프로그램 헤더 또는 섹션 헤더를 수정할 수 있다. 패치 영역 생성부(920)는, 대상 바이너리(10) 내에 패치 코드가 삽입될 영역에 관한 정보(예컨대, 상기 영역의 주소 및 크기)를 패치 실행부(930)에 제공할 수 있다.

패치 실행부는(930)는, 상기 취약점에 관한 정보에 기초하여, 패치 코드를 자동으로 생성할 수 있다. 이때 상기 패치 코드는 머신 코드의 형태로 자동으로 생성되거나, 어셈블리 코드의 형태로 자동으로 생성된 후 머신 코드로 변환될 수 있다.

상기 패치 코드는, 대상 바이너리(10)에서 발견된 취약점을 제거 또는 해소하는 인스트럭션들을 포함한다. 예를 들어, 상기 대상 바이너리(10)에서 발견된 취약점이 초기화되지 않은 변수의 사용으로 인한 취약점이라면, 상기 인스트럭션들은, 초기화되지 않은 변수를 사용하는 함수의 스택 프레임을 초기화하는 인스트럭션들을 포함할 수 있다. 또 다른 예로, 상기 대상 바이너리(10)에서 발견된 취약점이 널 포인터 참조로 인한 취약점이라면, 상기 인스트럭션들은 메모리에 접근하는 인스트럭션의 오퍼랜드로 사용된 레지스터에 저장된 값을 판정하는 인스트럭션, 및 상기 레지스터에 저장된 값이 널 값일 경우 적절한 에러 메시지를 출력하도록 하는 인스트럭션을 포함할 수 있다. 또 다른 예로, 상기 대상 바이너리(10)에서 발견된 취약점이 버퍼 오버 라이트로 인한 취약점이라면, 상기 인스트럭션들은, 버퍼에 할당된 메모리 범위를 넘어서는 영역을 접근하는데 사용될 가능성이 있는 레지스터에 저장된 값을 판정하는 인스트럭션을 포함할 수 있다.

또한, 상기 패치 코드는, 상기 취약점을 제거 또는 해소하는 인스트럭션들 이후에 점프 인스트럭션을 포함할 수 있다. 상기 점프 인스트럭션은, 상기 대상 바이너리(10)에서 취약점이 발견된 영역으로 제어 흐름을 이동시키는 인스트럭션이다. 보다 구체적으로, 상기 점프 인스트럭션은, 상기 취약점이 발견된 영역의 마지막 인스트럭션의 다음 주소로 점프하는 인스트럭션을 포함한다.

패치 실행부는(930)는, 상기 패치 코드를, 패치 영역 생성부(920)에 의해 식별된 상기 대상 바이너리(10) 내의 영역에 삽입할 수 있다. 예를 들어, 패치 실행부는(930)는, 대상 바이너리(10)에서 상기 패치 코드가 삽입될 영역의 주소에 머신 코드 형태의 상기 패치 코드를 기록할 수 있다.

또한, 패치 실행부는(930)는, 상기 대상 바이너리(10)의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 코드 블록으로 점프하는 인스트럭션으로 치환할 수 있다. 보다 구체적으로, 패치 실행부는(930)는, 대상 바이너리(10)에서 상기 취약점 발생 영역의 상기 적어도 일부 인스트럭션이 기록된 주소에, 상기 패치 코드 블록으로 점프하는 인스트럭션을 기록할 수 있다. 이때, 상기 점프 인스트럭션의 기록에 사용되는 공간의 크기가 상기 치환되는 일부 인스트럭션이 기록된 공간의 크기보다 작을 경우, 적절한 수의 NOP 인스트럭션이 추가로 기록될 수 있다. 상기 NOP 인스트럭션의 기록으로 인하여, 대상 바이너리(10)의 수정 또는 재기록을 최소화하면서도, 패치된 바이너리의 실행시 오동작을 방지할 수 있다.

또한, 패치 실행부는(930)는, 대상 바이너리(10)에 패치를 적용한 바이너리(20)를 저장하거나, 네트워크를 통하여 다른 컴퓨팅 장치로 전송할 수 있다.

지금까지 도 1 내지 도 9를 참조하여 설명된 본 발명의 실시예들은 컴퓨터가 읽을 수 있는 매체 상에 컴퓨터가 읽을 수 있는 코드로 구현될 수 있다. 상기 컴퓨터로 읽을 수 있는 기록 매체는, 예를 들어 이동형 기록 매체(CD, DVD, 블루레이 디스크, USB 저장 장치, 이동식 하드 디스크)이거나, 고정식 기록 매체(ROM, RAM, 컴퓨터 구비 형 하드 디스크)일 수 있다. 상기 컴퓨터로 읽을 수 있는 기록 매체에 기록된 상기 컴퓨터 프로그램은 인터넷 등의 네트워크를 통하여 다른 컴퓨팅 장치에 전송되어 상기 다른 컴퓨팅 장치에 설치될 수 있고, 이로써 상기 다른 컴퓨팅 장치에서 사용될 수 있다.

이상에서, 본 발명의 실시예를 구성하는 모든 구성 요소들이 하나로 결합되거나 결합되어 동작하는 것으로 설명되었다고 해서, 본 발명의 기술적 사상이 반드시 이러한 실시예에 한정되는 것은 아니다. 즉, 본 발명의 목적 범위 안에서라면, 그 모든 구성요소들이 하나 이상으로 선택적으로 결합하여 동작할 수도 있다.

도면에서 동작들이 특정한 순서로 도시되어 있지만, 반드시 동작들이 도시된 특정한 순서로 또는 순차적 순서로 실행되어야만 하거나 또는 모든 도시 된 동작들이 실행되어야만 원하는 결과를 얻을 수 있는 것으로 이해되어서는 안 된다. 특정 상황에서는, 멀티태스킹 및 병렬 처리가 유리할 수도 있다. 더욱이, 위에 설명한 실시예들에서 다양한 구성들의 분리는 그러한 분리가 반드시 필요한 것으로 이해되어서는 안 되고, 설명된 프로그램 컴포넌트들 및 시스템들은 일반적으로 단일 소프트웨어 제품으로 함께 통합되거나 다수의 소프트웨어 제품으로 패키지 될 수 있음을 이해하여야 한다.

이상 첨부된 도면을 참조하여 본 발명의 실시예들을 설명하였지만, 본 발명이가 속하는 기술분야에서 통상의 지식을 가진 자는 그 기술적 사상이나 필수적인 특징을 변경하지 않고서 본 발명이가 다른 구체적인 형태로도 실시될 수 있다는 것을 이해할 수 있다. 그러므로 이상에서 기술한 실시예들은 모든 면에서 예시적인 것이며 한정적인 것이 아닌 것으로 이해해야만 한다. 본 발명의 보호 범위는 아래의 청구범위에 의하여 해석되어야 하며, 그와 동등한 범위 내에 있는 모든 기술 사상은 본 발명에 의해 정의되는 기술적 사상의 권리범위에 포함되는 것으로 해석되어야 할 것이다.

Claims (14)

1. 컴퓨팅 장치에서 수행되는 방법으로서,
   대상 바이너리 내에 패치 코드 블록을 삽입하는 단계; 및
   상기 대상 바이너리의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 코드 블록으로 점프하는 인스트럭션으로 치환하는 단계
   를 포함하되,
   상기 패치 코드 블록은,
   상기 취약점 발생 영역을 포함하는 함수의 프롤로그부 인스트럭션;
   상기 함수의 스택 프레임을 벗어나지 않은 채로, 스택 포인터 레지스터가 가리키는 메모리 주소와 베이스 포인터 레지스터가 가리키는 메모리 주소 사이의 메모리 값들을 초기화하여, 상기 함수의 스택 프레임의 데이터를 초기화하는 인스트럭션; 및
   상기 취약점 발생 영역에서 치환된 인스트럭션의 다음 인스트럭션으로 점프하는 인스트럭션
   을 포함하며,
   상기 패치 코드 블록의 스택 프레임은 상기 함수의 스택 프레임과 동일하고,
   상기 패치 코드 블록을 삽입하는 단계는,
   상기 대상 바이너리의 유휴 영역을 탐색하는 단계; 및
   상기 유휴 영역의 크기가 상기 패치 코드 블록의 크기 이상일 경우, 상기 유휴 영역에 상기 패치 코드를 기록하는 단계
   를 포함하고,
   상기 유휴 영역은 상기 대상 바이너리의 텍스트 영역 중 연속된 NOP 명령어로 채워진 영역이며,
   상기 패치 코드 블록의 삽입 전후에 상기 대상 바이너리 내에 포함된 인스트럭션들의 주소는 그대로 유지되는,
   바이너리 취약점 패치 방법.
2. 삭제
3. 삭제
4. 제1항에 있어서,
   상기 대상 바이너리의 사이즈는 상기 패치 코드 블록의 삽입 전후에 그대로 유지되는,
   바이너리 취약점 패치 방법.
5. 삭제
6. 제1항에 있어서,
   상기 패치 코드 블록을 삽입하는 단계는,
   상기 대상 바이너리에 상기 패치 코드 블록을 위한 영역을 추가하고, 상기 추가된 영역에 상기 패치 코드 블록을 기록하는 단계
   를 포함하는,
   바이너리 취약점 패치 방법.
7. 제6항에 있어서,
   상기 패치 코드 블록을 삽입하는 단계는,
   상기 유휴 영역의 크기가 상기 패치 코드 블록의 크기 미만이라는 판정에 응답하여, 상기 대상 바이너리에 상기 패치 코드 블록을 위한 영역을 추가하고, 상기 추가된 영역에 상기 패치 코드 블록을 기록하는 단계
   를 더 포함하는,
   바이너리 취약점 패치 방법.
8. 컴퓨팅 장치에서 수행되는 방법으로서,
   대상 바이너리 내에 패치 코드 블록을 삽입하는 단계; 및
   상기 대상 바이너리의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 코드 블록으로 점프하는 인스트럭션으로 치환하는 단계
   를 포함하되,
   상기 패치 코드 블록은,
   상기 대상 바이너리의 실행시 상기 취약점 발생 영역에서 크래시가 발생되는지 판정하는 인스트럭션;
   상기 대상 바이너리의 실행시 크래시가 발생된다는 판정에 응답하여, 상기 대상 바이너리의 실행을 중단하는 인스트럭션; 및
   상기 대상 바이너리의 실행시 크래시가 발생되지 않는다는 판정에 응답하여, 상기 취약점 발생 영역에서 치환된 인스트럭션의 다음 인스트럭션으로 점프하는 인스트럭션
   을 포함하며,
   상기 패치 코드 블록에 포함된 인스트럭션들은 상기 취약점 발생 영역을 포함하는 함수의 스택 프레임을 벗어나지 않은 채로 실행되고,
   상기 패치 코드 블록을 삽입하는 단계는,
   상기 대상 바이너리의 유휴 영역을 탐색하는 단계; 및
   상기 유휴 영역의 크기가 상기 패치 코드 블록의 크기 이상일 경우, 상기 유휴 영역에 상기 패치 코드를 기록하는 단계
   를 포함하고,
   상기 유휴 영역은 상기 대상 바이너리의 텍스트 영역 중 연속된 NOP 명령어로 채워진 영역이며,
   상기 패치 코드 블록의 삽입 전후에 상기 대상 바이너리 내에 포함된 인스트럭션들의 주소는 그대로 유지되는,
   바이너리 취약점 패치 방법.
9. 삭제
10. 제8항에 있어서,
    상기 크래시는, 비정상적 메모리 접근으로 인한 크래시를 포함하며,
    상기 판정하는 인스트럭션은,
    상기 취약점 발생 영역의 적어도 일부 인스트럭션 중 메모리에 접근하는 인스트럭션의 오퍼랜드로 사용된 레지스터의 값에 기초하여, 상기 바이너리의 실행 흐름을 결정하는 인스트럭션
    을 포함하는,
    바이너리 취약점 패치 방법.
11. 제10항에 있어서,
    상기 비정상적 메모리 접근은, 널 포인터 사용, 버퍼 오버 라이트, 및 버퍼 언더 라이트 중 적어도 하나를 포함하는,
    바이너리 취약점 패치 방법.
12. 삭제
13. 제8항에 있어서,
    상기 패치 코드 블록을 삽입하는 단계는,
    상기 유휴 영역의 크기가 상기 패치 코드 블록의 크기 미만이라는 판정에 응답하여, 상기 대상 바이너리에 상기 패치 코드 블록을 위한 영역을 추가하고, 상기 추가된 영역에 상기 패치 코드 블록을 기록하는 단계
    를 더 포함하는,
    바이너리 취약점 패치 방법.
14. 패치 영역 생성부; 및
    패치 실행부
    를 포함하되,
    상기 패치 영역 생성부는,
    대상 바이너리의 텍스트 영역 중 유휴 영역을 탐색하고,
    상기 유휴 영역의 크기가 패치 코드의 크기 미만일 경우, 상기 대상 바이너리에 상기 패치 코드를 위한 영역을 추가하며,
    상기 대상 바이너리 내에 상기 패치 코드가 삽입될 패치 영역을 결정하고,
    상기 패치 실행부는,
    상기 패치 영역에 상기 패치 코드를 삽입하고,
    상기 대상 바이너리의 취약점 발생 영역의 적어도 일부 인스트럭션을, 상기 패치 영역으로 점프하는 인스트럭션으로 치환하며,
    상기 패치 코드는,
    상기 취약점 발생 영역을 포함하는 함수의 프롤로그부 인스트럭션;
    상기 함수의 스택 프레임을 벗어나지 않은 채로, 스택 포인터 레지스터가 가리키는 메모리 주소와 베이스 포인터 레지스터가 가리키는 메모리 주소 사이의 메모리 값들을 초기화하여, 상기 함수의 스택 프레임의 데이터를 초기화하는 인스트럭션; 및
    상기 취약점 발생 영역에서 치환된 인스트럭션의 다음 인스트럭션으로 점프하는 인스트럭션
    을 포함하고,
    상기 유휴 영역은 상기 대상 바이너리의 텍스트 영역 중 연속된 NOP 명령어로 채워진 영역이며,
    상기 패치 코드의 삽입 전후에 상기 대상 바이너리 내에 포함된 인스트럭션들의 주소는 그대로 유지되는,
    바이너리 취약점 패치 장치.

Images