KR20160108427A - 암호화 알고리즘에 사용될 때 비밀 데이터를 보호하는 방법 - Google Patents

Abstract

본 발명은 알고리즘의 보호된 적용을 생성하는 방법에 관한 것으로, 상기 방법은, 알고리즘을 구현하는 원래의 소스 코드를 리얼 동작의 단일 세트로 확장하는 단계; 원래의 형태와는 상이한 형태로 실제 리얼 데이터 조각을 사용하는 방식으로 표현된 조합을 획득하기 위하여, 리얼 데이터를 사용하는 각 리얼 동작을 리얼 데이터와 결합하는 단계; 유인 데이터에 적용되는, 상기 알고리즘의 대안적인 구현을 나타내는 복제 및 변이된 유인 동작의 세트를 생성하는 단계; 유인 동작은 리얼 동작 및 리얼 동작에 의해 처리된 리얼 데이터와 상호 작용하여, 구현에서의 리얼 데이터 흐름을 분석하기 곤란하게 하는데 상기 구현을 획득하도록, 유인 동작 세트를 결합을 포함하는 리얼 동작 세트와 결합하는 단계; 및 상기 구현을 실행될 수 있는 결과적인 코드로 변환하는 단계를 포함하는 것을 특징으로 하는 방법에 관한 것이다.

Description

암호화 알고리즘에 사용될 때 비밀 데이터를 보호하는 방법{METHOD OF PROTECTING SECRET DATA WHEN USED IN A CRYPTOGRAPHIC ALGORITHM}

본 발명은 암호화 알고리즘에 사용될 때 비밀 데이터(secret data)를 보호하는 방법에 관한 것이다.

컴퓨터 소프트웨어에서 암호화의 역할은 최근 수년간 점점 더 중요해지고 있다. 과거에, 암호화를 사용하는 것은 특정 유형의 애플리케이션 분야로 제한되었으나 최근에 프라이버시와 보안에 관한 관심이 더 높아져서 애플리케이션 개발자에 의한 암호화의 사용이 넓은 범위의 애플리케이션에 걸쳐 상당히 증가하였다.

불행하게도, 암호화의 사용이 이렇게 증가하는 것(뿐만 아니라 보안의 다른 영역에서 증가하는 것)이 실제로 프라이버시 또는 보안 영역에서 상당한 증가를 가져오지는 못했다. 그 이유 중 하나는 표준 암호화 알고리즘이 실제 세계에 항상 존재하는 것은 아닌 전제에 기초하기 때문이다.

모든 표준 암호화의 기초가 되는 기본 전제는 암호화 동작(cryptographic operation)을 수행하는데 사용되는 비밀(secret)(예를 들어, 키)이 비밀로 유지된다는 것이다. 이 비밀이 노출되면, 이 비밀을 사용하여 보호된 임의의 정보도 또한 노출된다. 암호화 문헌에서, 정보 교환에 수반되는 개체는 불투명한 종단점으로 모델링되어서, 개체가 비밀을 사용하는 경우, 이 개체가, 다른 개체에서 이 비밀을 유도할 수 있는 정보를 다른 개체에 전달하지 않는 한, 이 개체에 전속되게 유지되는 것으로 가정된다.

그러나, 실제 세계에서는, 이 개체는 일반적으로 멀웨어 공격 또는 심지어 악의적인 개인에 의한 직접 액세스를 받을 수 있는 디바이스에서 실행되는 애플리케이션이다. 공격자가 디바이스에서 실행되고 있는 소프트웨어에 직접 액세스하는 경우, 공격자가 이 애플리케이션 내에서 암호화 동작에 의해 사용되고 있는 임의의 비밀을 훔치는 것은 통상 쉬운 일이다. 이것이 발생하면, 전술된 전제는 더 이상 유효하지 않고, 침범받은 애플리케이션은 더 이상 암호화의 사용으로부터 이익을 얻을 수가 없다.

이러한 문제는 최근 수년간 비밀이 애플리케이션으로부터 직접 추출되지 못하게 하는 형태로 암호화 동작을 재-구현(re-implementing)하는 것에 의해 문제를 해결하려고 하는 화이트 박스 암호화(White Box Cryptography)라고 언급되는 새로운 분야를 야기하였다. 최소한, 암호화 동작의 화이트박스 버전은 심지어 매우 짧은 시간 기간 동안 비밀 데이터가 메모리에 노출되지 못하게 하여야 한다. 그러나, 실제로, 이것은 또한 이 구현의 내부를 검사하는 것에 의해 비밀 데이터를 유도하려고 하는 공격에 저항할 필요가 있다.

화이트박스 구현을 생성할 때 초기 시도는 매우 알고리즘에-특정되었고 - 각 알고리즘에 사용되는 방법론은 이 알고리즘에 친숙한 지식을 갖고 있는 전문가에 의해 주의 깊게 설계되어야 한다. 이 화이트박스 구현은 비밀 데이터가 메모리에 노출되지 못하게 하는데에는 매우 효과적이었으나 구현의 내부를 검사하는 것을 통해 비밀을 유도하는 것을 방지하는데에는 덜 효과적이었다. 그 기본적인 이유는, 대부분의 암호화 알고리즘이 전체적으로 동작의 복잡성에 의존하는데, - 보다 높은 입도 레벨(granular level)에서 볼 때, 이 복잡성은 더 이상 존재하지 않고, 비밀은 전체 알고리즘 중 상대적으로 작은 부분을 통해 데이터의 흐름을 관찰하는 것에 의해 종종 유도될 수 있기 때문이다.

예를 들어, AES(Advanced Encryption Standard) 알고리즘은 다수회(매회는 라운드(round)라고 언급된다) 동일한 단계 시퀀스를 수행하고, 그 강도는 (키 사이즈에 따라) 10개, 12개 또는 14개의 라운드를 사용하는 것에 의존한다. 공격자가 개별 라운드에 대해 입력과 출력을 관찰할 수 있다면, 이 공격자가 단일의 불투명한 유닛으로 모든 라운드를 관찰하는 경우보다 훨씬 더 용이하게 키를 복원할 수 있을 것이다.

보다 최근의 솔루션은 프로그램과 데이터 흐름을 사람 또는 자동화 공정이 추적하고 이해하기 극히 곤란한 심히-난독화된 형태(heavily-obfuscated form)를 사용하여 알고리즘의 화이트박스 버전을 구현하는 것에 의해 이 문제를 해결하려고 시도하였다. 이 솔루션 중 일부는 적어도 키 도난을 방지하는 면에서 실제 매우 효과적인 것으로 입증되었다.

그러나, 상당히 감소되지 않은 하나의 문제는 새로운 알고리즘을 지원하는데 요구되는 노력이다. 이것은 상당한 전문가를 요구하는 상대적으로 수동 공정이 남아 있다. 이것은 일반적인 사용에 제한된 개수의 알고리즘이 주어진 경우 심각한 문제가 있는 것으로 보이지 않을 수 있는데, 사실, 이 알고리즘은 정적인 키(static key)만을 요구하는 사용 경우에는 문제가 되지 않으나, 이 알고리즘은 동적인 키(dynamic key)를 요구하는 사용 경우에 문제가 제기된다.

정적인 키는 화이트박스 구현이 생성될 때 알려진 키이고, 화이트박스 솔루션의 기본 요소이고 - 화이트박스를 생성하는 공정은 본질적으로 정적인 키를, 키 값을 유도하는 것을 곤란하게 하는 형태로 암호화 알고리즘의 버전에 매립하는 것을 수반한다. 동적인 키는 실행시간에만 알려진 키이어서, 이는 이 키가 화이트박스 내에 이미 매립된 것이 아니라 화이트박스로 전달되는 것을 암시하고, 이는 화이트박스의 고유한 정적 특성에 반하는 것이다.

동적인 키들을 수용하기 위해, 간단한 솔루션은 다른 키(및 가능하게는 상이한 알고리즘)를 사용하여 키를 암호화하는 것이고, 여기서 이 다른 키는 화이트박스에 매립된 정적인 키가 된다. 화이트박스는 이후 표준 알고리즘에 사용되어 원래-의도된 동작을 수행하는 리얼 키(real key)를 복호화하는데 사용된다.

이 간단한 솔루션에 따른 문제는 리얼 키가 복호화될 때 이 리얼 키가 메모리에 노출되어, 제1 장소에서 화이트박스를 사용하는 목적을 부분적으로 좌절시킨다는 것이다. 기존의 솔루션은, 동작 시퀀스를 결합시키고, 그 결과를 일반-목적의 난독화 메커니즘으로 난독화시키는 것을 통해 리얼 키가 노출되는 지점을 분리시키는 것을 보다 곤란하게 하는 것에 의해 이 문제를 감소시키려고 시도하였다. 이것은, 동적인 키에 적용될 때 이러한 솔루션의 유효성에 상당한 손상을 나타낸다.

기존의 솔루션에 따른 다른 주요 문제는, 기존의 솔루션이 일반적으로 리프팅 공격으로 알려진 화이트박스 구현에 특정 등급의 공격을 처리하지 못한다는 것인데, 보다 정확한 이름은 상황외 공격(out-of-context attack)일 수 있다. 상황외 공격은, 화이트박스 구현이, 심지어 키 값을 알 필요도 없이, 공격자에 의해 사용되어, 공격자의 이익을 위하여 암호화 동작을 수행하는 공격이다. 이런 유형의 공격에 대한 특정 방어물이 없으면, 실제로, 화이트박스 구현은 표준 구현보다 더 높은 보안을 제공하지 않을 수 있다.

그리하여 실제 세계에서 암호화 동작을 충분히 보호하기 위하여, 보호를 상당히 약화시킴이 없이 동적인 키를 지원하고 리프트 공격을 방지하는 화이트박스 구현을 구비하는 것이 필요하다.

본 발명은 표준 (비-화이트박스) 구현의 소스 코드로부터 직접 임의의 암호화 알고리즘의 화이트박스 구현을 자동적으로 생성하는 방법을 개시한다.

본 방법에 의해 생성된 화이트박스 구현은, 비밀 데이터(예를 들어, 키)가 공격자에 의해 노출되거나 또는 다른 방식으로 유도되는 것을 방지하여, 이 구현을 포함하는 프로그램에 완전히 액세스하는 것과 이 프로그램을 제어하는 것을 방지하도록 설계된다.

본 발명은 또한 이 비밀 데이터가 동적인 경우, 즉 실행시간에만 알려진 경우 화이트박스 구현을 생성하는 방법을 개시한다. 이것은, 화이트박스 외부에 동적인 비밀을 노출시킴이 없이, 2개의 암호화 알고리즘을, 동적인 비밀의 사용을 지원하는 형태로, 단일 화이트박스 구현으로 결합시키는 임의의 알고리즘 변환을 수행하도록 제1 방법의 능력을 논리적으로 연장(extension)하는 것으로 달성된다.

마지막으로, 본 발명은 화이트박스 구현이 상황외에는 사용되지 못하게 하는 방법, 즉 의도된 목적을 위한 애플리케이션에 의해서가 아니라 악의적인 목적을 위한 공격자에 의해서는 직접 호출되지 못하게 하는 방법을 개시한다.

본 발명의 방법의 기본적인 목적은 암호화 알고리즘의 화이트박스 구현을 생성하는 것이지만, 본 방법 자체는 암호화 알고리즘에서 동작하는 것으로 제한되지 않고, 다른 알고리즘에 대한 그 유효성은 이 알고리즘이 암호화 알고리즘과 공유하는 특성이 얼마나 많은지에 의존할 수 있다. 특히, 실행시간 입력 데이터에 대해 매우 결정론적인 알고리즘은 일반적으로 가장 효과적인 결과를 생성한다.

실시형태들은, 메모리에 저장된 코드 형태로 표현된 알고리즘의 보호된 구현(implementation)을 생성하는 컴퓨터로-구현되는 방법으로서, 상기 방법은, 상기 알고리즘을 구현하는 원래의 소스 코드(original source code)를 리얼 동작(real operation)의 단일 세트로 확장하는 단계; 리얼 데이터(real data)를 사용하는 각 리얼 동작을, 상기 리얼 동작이 사용하는 상기 리얼 데이터를 결합시켜, 원래의 형태와는 상이한 형태로 실제 리얼 데이터 조각(actual real data fragment)을 사용하는 방식으로 표현된 조합을 획득하는 단계; 유인 데이터(decoy data)에 적용되는, 상기 알고리즘의 대안적인 구현을 나타내는 복제 및 변이된 유인 동작(duplicated and mutated decoy operation) 세트를 생성하는 단계; 유인 동작은 상기 리얼 동작과, 상기 리얼 동작에 의해 처리된 상기 리얼 데이터와 상호 작용하여, 상기 구현에서 리얼 데이터의 흐름을 분석하기 곤란하게 하며, 상기 구현을 획득하도록, 상기 유인 동작 세트를 상기 조합을 포함하는 상기 리얼 동작 세트와 결합시키는 단계로서, 상기 유인 동작 세트를 상기 리얼 동작 세트와 결합시키는 단계; 및 상기 구현을, 상기 메모리에 저장되고 실행될 수 있는 결과적인 코드로 변환하는 단계를 포함하는 것을 특징으로 하는 방법에 관한 것이다.

일 실시형태에 따르면, 상기 알고리즘은 암호화 알고리즘이고, 상기 리얼 데이터는 비밀 데이터를 포함한다.

일 실시형태에 따르면, 상기 알고리즘을 확장하는 단계는, 시뮬레이터에 의해 상기 원래의 소스 코드를 실행하고, 실행되는 동작, 일어나는 제어 흐름의 변화, 및 일어나는 메모리 변화를 레코딩하는 단계; 상기 시뮬레이터에 의해 상이한 실행시간 입력으로 상기 원래의 소스 코드를 다수회 실행하고, 상기 실행 결과를 상기 리얼 동작 세트에 결합시키는 것에 의해 실행 동안 실행되지 않는 코드를 복원(recover)하는 단계; 및 누락 코드(missing code)를 상기 리얼 동작 세트에 주입하는 것에 의해 상기 시뮬레이터에 의해 실행 동안 실행되지 않는 상기 누락 코드를 조정(reconciling)하는 단계를 포함한다.

일 실시형태에 따르면, 상기 알고리즘을 확장하는 단계는 상기 리얼 동작 세트의 동작들 사이에 데이터 의존성과, 상기 리얼 동작들 사이에 흐르는 데이터 값들을 모델링하는 데이터 의존성 그래프를 생성하는 단계를 포함한다.

일 실시형태에 따르면, 상기 알고리즘을 확장하는 단계는, 상기 리얼 동작 세트 중에서, 상기 리얼 데이터에 대한 동작을 포함하여, 정적으로-알려진 값을 생성하는 동작을 제거하여, 상기 리얼 데이터의 각 부분이 대부분 유도된 형태로만 존재하고, 결과적인 리얼 동작 세트에 가능한 한 깊이 전파되게 하는 단계를 포함한다.

일 실시형태에 따르면, 상기 알고리즘을 확장하는 단계는, 인라이닝(inlining) 및/또는 언롤링(unrolling)을 제거하는 것에 의해 획득된 이익 레벨 대(versus) 상기 제거하는 것에 의해 일어날 수 있는 리얼 데이터의 전파 손실의 비용을 나타내는 함수 및 기본 블록에 대한 스코어를 배정하는 판정 모델을 사용하여, 상기 인라인된 함수 코드 및 언롤링된 루프의 일부를, 상기 원래의 소스 코드로부터 오는 함수 호출 및 루프로 대체하는 것에 의해, 상기 리얼 동작의 세트 중에서, 상기 시뮬레이터에 의해 실행되는 것을 통해 생성된 인라인된 함수 코드 및 언롤링된 루프의 일부를 제거하는 것에 의해, 상기 리얼 동작 세트의 사이즈를 감소시키는 단계를 포함한다.

일 실시형태에 따르면, 상기 알고리즘을 확장하는 단계는, 각 새로운 동작이 상기 유도된 리얼 데이터를 사용하도록 유도된 리얼 데이터를 수반하는 상기 소스 코드의 원래의 동작들을 다수의 새로운 동작들로 분할하는 단계; 상기 유도된 리얼 데이터를, 상기 유도된 리얼 데이터를 생성하는 고유한 동작 서브셋(subset)으로 변환하는 단계로서, 상기 동작 서브셋은 실행시간에 생성된 시퀀스에-민감한 데이터 값을 소비하는, 상기 변환하는 단계; 및 상기 동작의 서브셋을 상기 리얼 동작 세트에 삽입하는 단계를 포함한다.

일 실시형태에 따르면, 복제 및 변이된 유인 동작 세트를 생성하는 단계는, 유인 동작 세트를 생성하도록 상기 확장 단계를 다수회 반복하는 단계를 포함하고, 여기서 각 유인 동작 세트는 상기 리얼 데이터 대신에 랜덤하게-생성된 데이터를 공급받고, 상기 알고리즘의 대안적인 위조 구현(fake implementation)을 나타내는 유인 동작 세트를 생성한다.

일 실시형태에 따르면, 상기 유인 동작 세트를 상기 리얼 동작 세트와 결합시키는 단계는, 각 세트로부터 오는 동작들을, 상기 동작의 모든 다른 세트로부터 오는 동작들과 인터리브하여, 결합된 세트를 획득하여, 상기 결합된 세트가 실행될 때, 모든 동작 세트가 동시에 효과적으로 실행되도록 하는 단계; 및 동작 그룹을 점진적으로 선택하는 것에 의해 상기 결합된 세트 내에 있는 상이한 세트로부터 오는 동작 데이터 흐름을 서로 융합(conflating)하고, 각 출력을 올바른 수신 동작으로 전달하는 새로이-생성된 라우팅 동작을 통해 그 출력을 라우팅하는 단계를 포함하고, 이에 의해 상기 라우팅 동작은 실행시간에 생성된 시퀀스에-민감한 데이터 값을 소비하는 고유하게-생성된 불투명한(opaque) 표현을 사용하여 구성된다.

일 실시형태에 따르면, 상기 구현의 상기 동작들은 작은 균일한 명령 세트로 표현되고, 상기 구현을 변환하는 단계는, 잘 알려진 난독화 변환(obfuscating transform)을 사용하여 상기 구현의 동작 시퀀스를 의미적으로-동등한 대안적인 형태(semantically-equivalent alternative forms)로 변환하는 단계; 새로운 명령을 포함하는 새로운 훨씬 더 큰 불균일한 명령 세트를 한정하기 위해 상기 변환된 동작 시퀀스의 동작들을 결합시키는 단계로서, 상기 새로운 명령은 상기 새로운 명령을 생성하도록 결합된 상기 동작 시퀀스에 대응하는 개별 함수로 각각 한정된, 상기 변환된 동작 시퀀스의 동작들을 결합시키는 단계; 및 상기 새로운 명령 세트의 명령에 각각 대응하는 동작들을 포함하는 변환된 구현을 획득하기 위해 상기 새로운 명령 세트를 사용하여 상기 구현을 변환하는 단계를 포함한다.

일 실시형태에 따르면, 상기 구현을 변환하는 단계는, 알고리즘을 실행하기 위해 올바른 시퀀스에서 그리고 올바른 데이터로 실행되는 동작을 야기하는 실행 제어 코드를 생성하는 단계를 포함하고, 상기 실행은 디코더 함수 세트에 의해 제어되고, 각 상기 디코더 함수는, 상기 동작을 실행하는데 요구되는 데이터의 장소, 및 대응하는 명령 함수의 장소, 및 각 디코더 함수에 고유하게 인코딩된 상기 데이터를 디코딩하는 방법을 알고 있는 하나의 동작과 연관된다.

일 실시형태에 따르면, 상기 디코더 함수는 실행시간에 생성된 시퀀스에-민감한 데이터 값을 소비한다.

일 실시형태에 따르면, 상기 구현을 변환하는 단계는 복잡성 레벨의 함수로 난독화를 수행하는 단계를 포함하고, 변환 단계에서 이용가능한 모든 난독화는 상기 복잡성 레벨이 최대 값으로 설정될 때 수행된다.

일 실시형태에 따르면, 상기 방법은 비밀 데이터가 실행시간에만 알려진 경우 상기 알고리즘에 대해 새로운 화이트박스 구현을 생성하는 단계를 포함하고, 상기 생성하는 단계는, 정적인 키를 사용하는 복호화 알고리즘을 갖는 상기 구현을, 상기 정적인 키를 사용하여 미리-암호화된 동적 비밀 데이터를 사용하여 상기 새로운 화이트박스 구현에 결합시키는 단계를 포함하고, 상기 복호화 알고리즘은 상기 구현으로 전달되는 상기 동적 비밀 데이터를 복호화한다.

일 실시형태에 따르면, 상기 방법은 상기 암호화된 데이터의 내용을 드러내지 않고, 암호화된 데이터에 데이터-처리 동작을 수행하는 새로운 화이트박스 구현을 생성하는 단계를 포함하고, 상기 생성하는 단계는 복호화 알고리즘, 상기 구현, 및 암호화 알고리즘을 상기 새로운 화이트박스 구현에 결합시키는 단계를 포함하고, 상기 복호화 및 암호화 알고리즘은 서로 역(inverse)이고 동일한 정적인 키를 사용하고, 이에 의해 상기 복호화 알고리즘은 처리될 상기 데이터를 복호화하고, 상기 구현은 복호화된 데이터에서 동작하고, 상기 암호화 알고리즘은 상기 데이터를 재-암호화한다.

일 실시형태에 따르면, 상기 방법은 상기 구현을 포함하는 프로그램에 의해 의도된 것이 아닌 상황에서는 상기 구현이 사용되는 것을 방지하는 단계를 포함하고, 상기 방지하는 단계는, 융합 제작자(conflation producer)를 상기 프로그램에 주입하는 단계로서, 상기 융합 제작자는, 랜덤하게-생성된 데이터 또는 리얼 데이터를 기존의 융합 데이터와 혼합하는 것에 의해, 상기 구현이 실행할 때, 융합 데이터를 생성하는, 상기 융합 제작자를 상기 프로그램에 주입하는 단계; 및 융합 타깃을 상기 구현에 주입하는 단계로서, 상기 융합 타깃은 융합 데이터를 판독하고, 상기 데이터를, 상기 구현 내 동작에 의해 사용되는 정적 데이터와 결합시키고, 그리고 상기 동작에 의해 사용된 상기 정적 데이터는 상기 정적 데이터가 올바르지 않도록 변경되고, 상기 정적인 데이터가 상기 융합 데이터와 결합될 때에만 올바른 데이터가 생성되어서, 상기 융합 데이터에 의존하는 동작이 상기 프로그램을 실행하는 것에 의해 올바르게 생성되게 하고, 각 융합 데이터는 상기 융합 데이터를 변경하는데 필요한 상기 융합 제작자와, 상기 구현 내 상기 융합 타깃에게만 알려진 별개의 장소를 구비하는, 상기 융합 타깃을 구현에 주입하는 단계를 포함한다.

일 실시형태에 따르면, 상기 방법은 각 중간 데이터 요소를 난독화시키는 단계, 및 각 중간 데이터 요소를, 상기 데이터 요소에 고유하고 상기 데이터 요소를 난독화시키는 방법을 지정하는 난독화 상황과 연관시키는 단계를 포함한다.

일 실시형태에 따르면, 상기 방법은 상기 리얼 동작에 의해 나타나는 메모리 액세스 패턴을 마스킹하기 위해 추가적인 랜덤화된 메모리 액세스 동작을 상기 구현에 걸쳐 주입하는 단계를 포함한다.

일 실시형태에 따르면, 상기 방법은 상기 리얼 동작에 의해 메모리에 액세스되는 상기 리얼 데이터의 데이터 조각의 위치를 랜덤화하는 단계를 포함하한다.

실시형태들은 또한, 디바이스에서 실행되고, 상기 한정된 방법을 적용하는 것에 의해 생성된 애플리케이션을 저장하는 비-일시적인 컴퓨터-판독가능한 매체에 관한 것일 수 있다.

실시형태들은 또한, 코드 형태로 표현된 알고리즘을 보호하는 디바이스로서, 상기 디바이스는 상기 한정된 방법을 구현하여, 상기 알고리즘의 보호된 구현을 생성하도록 구성된 디바이스에 관한 것일 수 있다.

도 1은 본 발명의 예시적인 실시예를 실시하는데 적절한 환경을 도시하는 도면.
도 2는 일 실시예에 따라 화이트박스 구현을 생성하는 방법의 흐름도,
도 3 및 도 4는 실시예에 따라 화이트박스 구현을 생성하는 방법의 국면(phase)의 흐름도,
도 5는 일 실시예에 따라 부분 평가 단계를 예시하는 호출 그래프(call graph)의 간략화된 예를 도시하는 도면,
도 6은 일 실시예에 따라 동작 인터리브 단계(operation interleaving step)를 예시하는 간략화된 예를 도시하는 도면,
도 7a 및 도 7b는 시예에 따라 데이터 흐름 융합(data flow conflation) 단계의 전과 후에 개별 동작 세트의 간략화된 예를 도시하는 도면.

본 발명은 예시적인 실시예에 대해 설명된다. 이 기술 분야에 통상의 지식을 가진 자라면 본 발명이 다수의 상이한 응용과 실시예에서 구현될 수 있고, 구체적으로 그 응용이 본 명세서에 도시된 특정 실시예로 제한되지 않는다는 것을 이해할 수 있을 것이다.

본 발명의 예시적인 실시예는 표준 (비-화이트박스) 구현의 소스 코드로부터 직접 임의의 암호화 알고리즘의 화이트박스 구현을 자동적으로 생성하도록 화이트박스 구현을 생성하는 방법에 관한 것이다.

다른 예시적인 실시예는 비밀 데이터가 동적인 경우, 즉 실행시간에서만 알려진 경우 화이트박스 구현을 생성하는 방법에 관한 것이다.

또 다른 예시적인 실시예는 화이트박스 구현이 상황외에는 사용되지 못하게 하는 방법, 즉 의도된 목적을 위한 애플리케이션에 의해서가 아니라 악의적인 목적을 위한 공격자에 의해서는 직접 호출되는 것을 방지하는 방법에 관한 것이다. 이들 구현 각각은 아래에서 설명된다.

도 1은 본 발명의 예시적인 실시예를 실시하는데 적절한 환경을 도시한다. 전자 디바이스(CMP)는 본 발명의 일 실시예에 따라 소프트웨어가 저장되는 메모리(MEM), 이 메모리(MEM)에 저장된 소프트웨어를 실행하는 프로세서(PRC), 및 시스템 하드웨어를 제어하는 다른 프로그램을 포함한다. 일반적으로, 전자 디바이스(CMP)와 사람 유저의 상호작용은 유저 인터페이스와 같은 입력/출력(I/O) 디바이스를 통해 일어난다. I/O 디바이스는 디스플레이 디바이스(DSP)(예를 들어, 모니터)와 하나 이상의 입력 디바이스, 예를 들어, 마우스(MS)와 키보드(KEYB), 및/또는 다른 적절한 종래의 I/O 주변 디바이스, 예를 들어, 터치 스크린, 및 네트워크 인터페이스를 포함할 수 있다.

메모리(MEM)는 알고리즘 구현의 표준 소스 코드(PGSC)로부터 직접 알고리즘의 화이트박스 구현을 자동적으로 생성할 수 있는 애플리케이션(WBGN)을 보유한다.

전자 디바이스는 컴퓨터 또는 임의의 다른 컴퓨팅 디바이스, 예를 들어, 스마트폰, 디지털 테블릿 또는 연결된 물체일 수 있다.

대안적인 실시예에서, 전자 디바이스(CMP)는 또한 네트워크, 예를 들어, 인터넷과 인터페이싱된다. 이 기술 분야에 통상의 지식을 가진 자라면 프로그램 소스 코드(PGSC)는 전자 디바이스(CMP)에서 국부적으로 저장되거나, 또는 네트워크를 통해 전자 디바이스와 인터페이싱되는 원격 장소에 저장될 수 있다는 것을 인식할 수 있을 것이다. 유사하게, 애플리케이션(WBGN)을 생성하는 화이트박스는 네트워크 연결된 서버 또는 원격 피어(remote peer)에 저장될 수 있다.

1. 화이트박스 구현의 생성

일 실시예에 따라 화이트박스 구현을 생성하는 방법은 2개의 주된 공정(P1, P2)을 포함하고, 각 공정은 도 2에 도시된 바와 같이 다수의 국면으로 분할된다. 이 공정(P1, P2)은 구현 코어(implementation core) 생성 공정(P1)과 실행 기계(execution machine) 생성 공정(P2)이다. 구현 코어 생성 공정(P1)은 암호화 알고리즘일 수 있는 입력 알고리즘의 초기 화이트박스 버전을 구현하는 저-레벨 동작의 세트를 생성한다. 이 동작의 세트는 입력 알고리즘보다 상당히 더 복잡하고, 다수의 기술을 사용하여 키 추출 공격에 저항할 수 있다.

실행 기계 생성 공정(P2)은 용이하게-실행가능한 형태에 아직 있지 않은 상기 생성된 동작 세트를, 키 추출 공격에 대해 추가적인 보호를 제공할 수 있는 실행가능한 형태로 변환한다. 이 공정의 출력은, 기존의 프로젝트로 컴파일되고 직접 실행될 수 있는 독립적인 소스 코드이다. 이것은 일반적으로 C 소스 코드이고, 자바(Java)와 같은 다른 구현 언어도 사용될 수 있다.

방법의 공정(P1, P2)은 알고리즘 소스 코드를 파싱(parsing)하는 것에 의해 생성된 중간 표현(Intermediate Representation)(IR)으로 입력 알고리즘을 수신한다. 암호화 알고리즘은 대부분 일반적으로 C로 구현되지만, 본 방법은, 컴파일되고 해석되는 프로그래밍 언어들에 모두 적용가능하다. 본 방법에 의해 생성된 코드는 컴퓨터, 스마트폰 또는 디지털 테블릿, 또는 임의의 연결된 물체와 같은 임의의 컴퓨팅 디바이스에 의해 실행되도록 적응될 수 있다. 본 방법은, 보호할 알고리즘을 실행하도록 의도된 디바이스가 개방 플랫폼으로 설계되고 및/또는 공중 네트워크에 연결될 때 더욱더 유용하다.

공정(P1, P2)은 아래에서 보다 상세히 설명된다. 구현 코어 생성 공정(P1)은 입력 알고리즘의 초기 화이트박스 버전을 구현하는 저-레벨 동작 세트를 생성하는 일을 담당한다. 일 실시예에 따라, 공정(P1)은 비밀의 폭발적 증가(explosion)와 융합(conflation), 및 유인(decoy) 생성의 2개의 국면(S11, S12)을 포함한다: 비밀의 폭발적 증가와 융합의 제1 국면(S11)은 알고리즘을 저-레벨 동작의 큰 세트로 확장시키고, 각 동작을, 각 동작이 사용하는 임의의 비밀 데이터와 결합시킨다. 동작과 비밀 데이터의 조합은 원래의 형태로 실제 비밀 데이터 조각(actual secret data fragment)을 사용하지 않는 방식으로 표현된다.

유인 생성의 제2 국면(S12)은, 나란히 존재하고, 공정(P1)에 의해 제공되는 리얼 동작(real operation)과 함께 실행되는 복제 및 변이된 유인 동작의 큰 세트를 생성한다. 이 유인은 구현을 통해 데이터의 신뢰성 있는 흐름을 수립하는 것을 극히 곤란하게 하는 방식으로 리얼 동작 및 처리될 데이터와 상호 작용한다.

일 실시예에 따라, 국면(S11)은 도 3에 표시된 바와 같이 4개의 다음 단계를 포함한다:

- 알고리즘 확장(단계 S31),

- 부분 평가(단계 S32),

- 비밀의 폭발적 증가(단계 S33), 및

- 비밀 융합(단계 S34).

알고리즘 확장 단계(S31)에서, 알고리즘은 이용가능한 정적 입력 데이터(예를 들어, 비밀 데이터)가 주어진 경우 알고리즘을 구현하는데 사용되는 전체 동작 세트로 확장된다. 이들 동작은 대부분 인라인된(inlined), 언롤링된(unrolled) 형태로 알고리즘을 표현된다. 이 단계는 또한 이 동작들 사이에 흐르는 데이터의 값들과 함께 이 동작들 사이에 모든 알 수 있는 데이터 의존성을 모델링하는 데이터 의존 그래프를 생성한다.

부분 평가 단계(S32)에서, 동작은 정적으로-알려진 값을 생성하는 동작을 제거하는 부분 평가를 받는다. 이 단계의 기본적인 목적은, 비밀 데이터가 대부분 유도된 형태로만 존재하고 이 비밀 데이터가 비-정적 데이터(예를 들어, 암호화/복호화할 데이터의 블록)와 상호작용하기 시작하는 지점에서만 존재하도록 비밀 데이터에 대한 중간 동작을 제거하는 것이다.

비밀의 폭발적 증가 단계(S33)에서, 유도된 비밀 데이터를 수반하는 임의의 남아 있는 동작들은 다수의 동작으로 분할되어, 각 새로운 동작이 원래의 동작보다 유도된 비밀 데이터의 더 작은 부분을 사용하도록 한다. 이 공정은 유도된 비밀 데이터에서 특정 개수보다 더 많은 개수의 비트를 사용하는 동작이 없을 때까지 반복적으로 적용된다(이것은 단일 비트만큼 낮을 수 있다).

비밀 융합 단계(S34)에서, 모든 유도된 비밀 데이터는 이 데이터를 저장하는 것이 아니라 데이터를 생성하는 고유한 동작 세트로 변환된다. 이 고유한 동작 세트는 (아래에 설명된 바와 같이) 시퀀스에-민감한데, 이는 동작이 생성하는 데이터가 이 지점까지 구현에 의해 수행된 거의 모든 이전의 동작에 의존한다는 것을 의미한다. 이 데이터를-생성하는 동작은 데이터의 생성과 데이터의 사용을 거의 구별할 수 없을 정도로 데이터를 사용하는 동작과 결합된다.

알고리즘 확장 단계(S31)에서, 알고리즘은 이용가능한 정적 입력 데이터(예를 들어, 정적인 키 데이터)가 주어진 경우 알고리즘을 구현하는데 사용되는 전체 동작 세트로 확장된다. 이 동작은 대부분 인라인된, 언롤링된 형태로 알고리즘을 나타낸다. 간단한 예로서, 확장 공정은 다음 의사 코드(pseudo-code)에 적용된다:

1 a = 0

2 i = 0

3 loop:

4 a = a + 10

5 i = i + 1

6 만약 i < 5이면, loop로 간다.

이 의사 코드는 간단한 루프와 이 루프 입력을 위한 "a"와 "i"를 포함한다. 이 의사 코드를 확장시키면 초기에 다음 동작을 생성한다:

1 a = 0

2 i = 0

3 a = a + 10

4 i = i + 1

5 a = a + 10

6 i = i + 1

7 a = a + 10

8 i = i + 1

9 a = a + 10

10 i = i + 1

11 a = a + 10

12 i = i + 1.

이 확장된 의사 코드에서, 루프는 언롤링되었고 조건적 ('if') 선언이 제거되었다.

함수 호출(function call)과 더 많은 프로그램 흐름 제어를 포함하는 보다 복잡한 예는 또한, 함수가 인라인된다는 것과, 도달되지 않은 코드는 제거된다는 것을 보여줄 수 있으나, 이 간단한 예는 나머지 공정을 통해 작업할 때 명료함을 제공할 수 있다. 이 확장 단계는 또한 이 동작들 사이에 흐르는 데이터의 값들과 함께 이 동작들 사이에 모든 알 수 있는 데이터 의존성을 모델링하는 데이터 의존 그래프를 생성한다. 상기 간단한 예에 대한 이 그래프의 표현은 다음과 같다:

1 a = 0

2 i = 0

3 a = a{0:#1:c} + 10

4 i = i{0:#2:c} + 1

5 a = a{10:#3:c} + 10

6 i = i{1:#4:c} + 1

7 a = a{20:#5:c} + 10

8 i = i{2:#6:c} + 1

9 a = a{30:#7:c} + 10

10 i = i{3:#8:c} + 1

11 a = a{40:#9:c} + 10

12 i = i{4:#10:c} + 1.

상기 표현에서, 다른 동작에 의존성을 갖는 각 값은 다음 포맷으로 괄호 안에 의존 정보를 갖게 장식된다:

{값:#소스:상태}

'값'이 (이 시점에서) 이 값의 실행시간의 내용인 경우, '소스'는 이 값을 생성한 동작이고, '상태'는 이 값이 ('c'로 지시된) 상수 입력으로부터만 또는 ('v'로 지시된) 적어도 하나의 변수 입력으로부터만 유도되는지 여부를 나타낸다. 예를 들어, 라인 7에서, 장식된 메모리 장소(memory location) "a"는 라인 5에서 동작에 의해 생성된 20의 실행시간 값을 구비하고, 이 값은 상수 입력 데이터로부터만 유도된다. 여기에 도시된 예는 단지 공정을 표현한 것일 뿐, 공정을 구현하는데 사용되는 물리적 표현에 직접 대응하지 않을 수 있다는 것을 언급하는 것이 주목된다. 예를 들어, 본 발명의 현재 실시예에서, 동작들은 여기에 도시된 의사 코드보다 더 낮은 레벨에 존재하고, 루프를 '위한' 구성을 가지지 않는다. 현재 실시예는 또한 의존 모델을 간략화하는 하나를 초과하는 출력을 가지지 않는 동작으로 제한된다. 그러나 공정은 넓은 범위의 물리적 표현에 적용될 수 있다.

알고리즘 확장 단계(S31)는, 알고리즘을 실행하고, 실행 동안 일어나는 것, 즉 다음 사항을 포함하는 것을 레코딩하는 시뮬레이터를 생성하는 것에 의해 달성된다:

- 그 파라미터의 실제 값과 그 상수/변수 상태와 함께 각 실행된 동작이 레코딩된다;

- 함수 호출, 함수 종료(function exit), 조건적 분기, 및 비조건적 분기를 포함하는 모든 제어 흐름 변화가 레코딩되지만, 그 영향이 레코딩된 정상 동작에 이미 존재하기 때문에 정상 동작과는 별개로 표시된다; 예를 들어, 함수가 호출된 경우, 레코딩은 다음 시퀀스: 1 ) 호출 동작; 2) 호출된 함수 내 동작; 3) 함수 종료; 및 4) 호출자 함수에 남아 있는 동작을 포함한다; 그리고

- 동작에 의해 기록된 모든 메모리 장소의 상태는 (각각에 대해) 이 장소에 기록될 마지막 동작과, 이 동작의 결과 이 장소의 상수/변수 상태를 저장하는 맵(map)에 레코딩된다. 동작의 입력 값이 모두 상수인 경우, 기록된 메모리 장소는 상수로 레코딩되고; 그렇지 않은 경우 기록된 메모리 장소는 변수로 레코딩된다.

메모리 상태 맵이 예시적인 코드에 대해 업데이트되는 방식은 아래 표 1에 도시된다:

표 1

표 1의 각 행은, 실행되는 각 동작과, 이 동작이 실행된 후 모든 메모리 장소의 상태를 나타낸다. 각 메모리 장소 "a"와 "i"는 이 장소의 값, 이 장소에 기록할 마지막 동작, 및 이 장소의 상수/변수(c/v) 상태를 보여주는 3개의 열(column)로 표현된다. 장소 "a"와 "i"는 동작 1로부터 동작 12로 가면서 교대로 변화된다. (행 7에 있는) 동작 7을 다시 볼 때, 동작이 (행 6으로부터 판독을) 실행하기 전에, "a"를 위한 장소는 20의 값을 가지고, 이 장소는 상기 데이터 의존 그래프에 레코딩된 의존 정보에 대응하는 동작 5에 의해 마지막으로 기록된 것임을 볼 수 있다. 동작 7이 실행된 후 (행 7 후), 볼 수 있는 바와 같이, 장소 "a"는 변화되었고, 이제 7로 설정된 마지막 동작에서 30의 값을 가진다.

이 간단한 예시적인 코드에서, 메모리 상태 맵핑을 사용하는 것은 지나친(overkill) 것이고; 상태 데이터는 단순히 각 변수(a 및 i)와 연관되어 동일한 결과를 달성할 수 있는 것으로 볼 수 있다. 그러나, 실제 프로그램은 어레이, 구조, 할당된 메모리, 및 포인터 에일리어싱(pointer aliasing)을 포함하는 훨씬 보다 복잡한 메모리 액세스 패턴을 가지고 있고; 메모리 상태를 맵핑하면 단일 메커니즘으로 모든 메모리 액세스 패턴을 지원할 수 있다.

시뮬레이터가 알고리즘을 실행할 때, 일부 코드는 실제로 실행되지 않을 수 있다. 일부 경우에 이것은 바람직할 수 있고; 이 알고리즘은 도달될 수 없는 코드 또는 실행될 수 없는 조건적 코드를 포함할 수 있고, 이것은 당연히 시뮬레이션 공정에 의해 폐기될 수 있다. 그러나, 이 알고리즘에 따라, 코드가 시뮬레이션 동안 실행되지 않는 경우가 있을 수 있으나 상이한 조건 하에서는 실행되는 경우가 있을 수 있다. 이것이 일어날 때, 코드가 알려진 정적인 데이터에만 기초한 판정으로 인해 실행되지 않았는지 여부가 수립된다. 만약 그렇다면, 이 코드는 단순히 미사용된 코드로 분류되고; 만약 그렇지 않다면, 이 코드는 입력-의존 코드로 분류된다. 입력-의존 코드는, 대안적인 판정을 할 수 있게 하는 입력 세트가 주어진 경우, 시뮬레이션 동안 실제로 실행된 동작이 아니라, 누락된 원래의 코드를, 동작이 실행될 수 있게 하는 판정 로직과 함께, 확장된 동작 세트에 주입하는 것에 의해 처리될 수 있다. 이것에 의해 결과적인 구현이 보이지 않는 입력에 직면했을 때 작업할 수는 있으나, 재-주입된 코드는 전체 의존 정보를 가지지 않아서, 후속 단계에서 이 때문에 능력을 제한한다.

많은 경우에, 입력-의존 코드는 존재하지 않거나, 또는 코드의 작은 비율만을 나타내어서, 상당한 문제를 구성하지 않는다. 이것이 보다 일반적인 경우에, 상기 솔루션은 후속 처리 단계를 적절히 수행하는 능력을 제한하여, 전체적으로 화이트박스 공정에 의해 제공되는 보호를 제한할 수 있기 때문에 이상적인 것은 아니다. 이것을 완화하기 위해, 시뮬레이션은 상이한 실행시간 입력으로 다수회 실행되어, 이 시뮬레이션 결과를, 일부 실행시간 판정 로직과 함께, 단일의 확장된 동작 세트로 결합시키는 것이 허용된다. 시뮬레이터가 모든 가능한 실행 경로를 볼 수 있도록 입력이 선택된 경우, 전체 확장된 동작 세트가 구성될 수 있다. 각 입력-의존 코드 경로의 모든 경우가 아니라 적어도 하나의 실행이 검출된 경우, 실행시간 값 정보 없이 의존 그래프가 여전히 구성될 수 있다.

부분 평가 단계(S32)에서, 동작들은 정적으로-알려진 값을 생성하는 동작을 제거하는 부분 평가를 받는다. 이 단계의 기본적인 목적은, 비밀 데이터가 그 대부분 유도된 형태로만 존재하고 이 비밀 데이터가 비-정적 데이터(예를 들어, 암호화/복호화할 데이터의 블록)와 상호작용하기 시작하는 지점에서만 존재하도록 이 비밀 데이터에 대해 중간 동작을 제거하는 것이다. 이 단계는 알고리즘의 인라인된 및 언롤링된 모델에 동작하기 때문에, 그리고 비밀 데이터가 정적 입력 데이터로 취급되기 때문에, 이것으로 동작의 큰 비율이 제거된다. 이것을 예시하기 위해, 간단한 예시적인 프로그램에 적용될 때 이 단계의 결과는 다음 라인으로 감소될 수 있다:

1 a = 50

2 i = 5.

이 결과는 메모리 장소 "a"와 "i"에 대한 모든 동작이 정적으로-알려진 값을 생성하기 때문에 발생한다. 이 두 장소는 상수 값으로 초기화되고 나서, 그 현재 값을 다른 상수 값과 결합시키는 것에 의해 연속적으로 변경되는데, 이는 그 출력이 항상 정적으로-알려진다는 것을 의미한다. 실제로, 심지어 이 2개의 코드 라인이 실제로 존재하지 않을 수 있다. 프로그램이 변수 "a"와 "i"를 사용한 다른 코드로 연장되었다면, 이들 동작은 상수와 변수 "a"와 "i"가 존재하지 않을 수 있기 때문에 값 50과 값 5를 직접 사용할 수 있다. 변수 "a"와 "i"는 차후 코드에 의해 사용되지 않았다면, 이들 변수는 단순히 존재하지 않았을 수 있다. 전체 부분 평가 공정은 상대적으로 복잡하지만 기본 공정은 간단한 예시적인 프로그램을 사용하여 제시될 수 있다. 데이터 의존 그래프로부터 오는 의존 정보를 갖는 확장된 형태에서 시작하면, 동작 1에서 시작하고, 동작 2와 같이, 이 동작이 정적으로-알려진 데이터를 명확히 생성하기 때문에, 이 동작을 제거할 수 있다. 동작 3도 또한 의존 정보가 지시하는 상수인 값 "a"를 문자 값(10)과 결합시키기 때문에 정적으로-알려진 데이터를 생성하므로, 이 동작도 또한 제거될 수 있다. 이는 남아 있는 동작에 대해서도 적용되고, 이는 이들 동작 모두가 제거될 수 있다는 것을 의미한다. 이것은 50의 값을 갖는 변수 "a"와 5의 값을 갖는 변수 "i"를 남겨 놓지만, 이 값을 생성하는데 임의의 동작을 요구하지는 않는다; 논리적으로, 상기 제시된 2개의 배정값이 존재하지만 이들 배정값은 실제 배정값으로 존재하지는 않는다.

이 공정은 변수 (비-정적으로-알려진) 값과, 완전히 인라인된 및 언롤링된 동작 특성이 고려될 때에는 보다 복잡해진다. 많은 경우에, 완전히 인라인된 및 언롤링된 동작으로 화이트박스 구현을 생성하는 것은 실용적이지 않다; 결과적인 구현은 너무 커서 실용적인 사용이 될 수 없다. 실용적인 구현을 생성하기 위해, 인라이닝 및/또는 언롤링 중 일부는 제거될 필요가 있다. 이런 인라이닝 및/또는 언롤링 중 일부를 제거하는 것에 따른 문제는 이런 것들이 동작 내에서 정적으로-알려진 데이터의 볼륨에 크게 기여한다는 것이다. 간단한 예시적인 프로그램을 보는 것에 의해 이유를 볼 수 있다. 언롤링된 코드가 루프로 다시 돌아간다면, "a"와 "i"는 (상수 입력으로부터만 유도됨에도 불구하고) 변수가 될 수 있고, 그리하여 이들을 사용한 임의의 후속 코드를 "오염"시킬 수 있어서, 그 출력을 변수로 만들 수 있다. 유사한 효과는 인라이닝이 제거될 때 발생한다. 이것에 따른 문제는, 기본적인 목표가 비밀 데이터를 그 대부분 유도된 형태로 가능한 한 멀리 구현으로 전파하는 것과, 이 전파는 비밀 데이터가 임의의 변수 데이터와 만날 때 종료하는 것이다.

그리하여 부분 평가 단계(S32)의 목표 중 하나는 유도된 비밀 데이터를 구현을 통해 전파할 때 이것이 가지는 영향을 최소화하면서 이것이 할 수 있는 만큼 인라이닝 및 언롤링을 많이 제거하는 것이다. 이것을 하기 위해, 인라이닝/언롤링을 제거하는 것에 의해 획득되는 이익 레벨 대(versus) 비밀 데이터를 전파하는 경우의 손실 비용을 나타내는 함수와 기본 블록에 대한 스코어를 배정하는 판정 모델이 수립된다. 이 스코어의 이익 성분은 제거하는 것이 제공할 수 있는 코드 감소의 양에 비례한다. 비용 성분은 제거하는 것에 의해 영향을 받은 모든 비밀 데이터의 전파 손실을 합산하는 것에 의해 계산된다. 개별 전파 손실은 비밀 데이터가 그 대부분 유도된 형태일 수 있는 것에 도달하기 전에 이 비밀 데이터를 수반하는 추가적인 동작의 수를 측정하는 것에 의해 계산된다. 비용 성분의 당연한 결과는 호출 그래프의 상부 부근의 코드가 호출 그래프의 잎(leaf)에 있는 코드보다 훨씬 더 많은 비용을 가지는 경향이 있다는 것이다. 이 때문에, 판정 공정은 바텀-업(bottom-up)으로 동작하고, 충분한 코드 감소가 달성되었을 때 종료된다. 이것의 간략화된 예는 도 5에 도시된다.

도 5의 상부에 있는 열의 수는 그래프의 부분을 말하고, 호출 그래프는 아래에 도시되고, 각 박스는 함수(함수 이름은 박스 내에 제시된다)를 나타내고; 더 넓은 박스는 이 박스에서 더 많은 동작을 갖는 함수를 나타낸다. 실행의 시작은 상부-좌측(top-left)에 있고; 호출은 하향 화살표로 도시되고, 함수 종료는 상향 화살표로 도시된다. 모든 호출은 부모 함수의 루프 내에서 실행되고, 호출 카운트는 하향 화살표로 지시된다.

호출 그래프 아래에는, 정보 "H"와 "CTS"의 2개의 행이 도시되고, 여기서 각 열은 이 열 바로 위에 있는 호출 그래프 요소와 연관된다. "H" 행은 대응하는 열에 있는 각 요소가 실행된 총 횟수를 나타낸다. 호출 그래프의 바텀에 있는 함수 "e"와 "f"는 여러 레벨의 루프 호출로 인해 다수회 실행된다. "CTS" 행은 대응하는 열에서 상수의 유도된 비밀 데이터를 생성하는 동작이 얼마나 많은지를 나타낸다.

이것은 간략화된 예이기 때문에, 인라이닝/언롤링을 제거하는 비용은 영향을 받은 구역 내에 상수의 유도된 비밀 데이터를 생성하는 동작의 수에 비례하는 것으로 모델링된다. 전술된 바와 같이, 실제 비용은 비밀 데이터의 전파 손실을 측정하는 것에 의해 계산된다. 비교하면, 이 예는 전파 손실이 항상 1인 것으로 가정하고; 이것은 예시적인 목적에 적절한 근사값이다.

도 2의 예로부터 획득된 계산 스코어는 다음 표 2에 제시된다:

표 2

"이익(Benefit)" 열에 있는 결과는 "사이즈*H"로 계산되고, "자체 비용(Self Cost)" 열에 있는 결과는 "CTS*H"로 계산된다. "자녀 비용(Child Cost)" 열에 있는 결과는 함수의 자녀(함수가 호출하는 함수들)의 "자체 비용" 수를 추가하는 것에 의해 계산된다. "비용" 열에 있는 결과는 단순히 "자체 비용 + 자녀 비용"으로 계산된다. 자녀 비용을 포함하는 이유는, 코드 구역에 대한 인라이닝/언롤링이 제거되면, 이것이 이 인라이닝/언롤링에 의존하는 거의 모든 것에 영향을 미칠 수 있기 때문이다. 함수의 경우에, 이것은 함수가 호출하는 함수들을 의미한다. 마지막으로, "스코어" 열에 있는 결과는 "이익/(비용 + 1)"으로 계산된다. 표 2로부터 볼 수 있는 바와 같이, 함수 "b"는 최고 스코어를 가지는 것으로 제1 후보일 수 있다. 이 후보는 상당히 작은 이익을 가진다 하더라도, 이 후보는 0의 비용을 가져서, 이 후보는 우수한 선택이 되게 한다. 그 다음 후보는 상당히 높은 비용을 가지지만 또한 매우 큰 이익을 제공하는 함수 "e"일 수 있다. 이 함수 "f"가 사용된 후; 함수 "f"의 이익과 비용은 매우 크지만, 이익이 여전히 많다. 함수 "a", "c" 및 "d"는 특히 불량 후보일 수 있고; 호출 그래프의 상부에 있어서, 이 함수가 매우 큰 비용을 가져서, 이들 함수 중 그 어느 것도 많은 이익을 제공하지 못한다는 것을 의미한다.

실제로, 각 선택이 이루어질 때 스코어 계산이 실제로 변한다는 것을 언급하는 것이 주목된다. 특히, 선택과 연관된 비용은 단 한번만 발생하여서, 또한 이 비용을 포함한 임의의 다른 선택에 의해 비용을 감소시킬 수 있다.

단계(S33)에서, 유도된 비밀 데이터를 수반하는 임의의 남아 있는 동작은 다수의 동작으로 분할되어, 각 새로운 동작이 원래의 동작보다 유도된 비밀 데이터에서 더 작은 부분을 사용하도록 한다. 각 동작 유형은 많은 상이한 방식으로 분할될 수 있다. 예를 들어, 32-비트 승산 동작(multiply operation), 즉 "s*t"를 고려해보자, 여기서 "s"는 비밀 데이터이고, "t"는 다른 (아마도 변수) 데이터이다. 이 동작은 시프트와 가산 동작의 시퀀스로 분할될 수 있고, 여기서 각 시프트 동작은 "s"로부터 단일 비트를 나타낸다. 대안적으로, 승산 동작은 승산 및 가산 시퀀스로 분할될 수 있고, 여기서 각 승산은 "s"에서 작은 개수의 비트만을 사용한다. 더 간단한 예로서, 아래 XOR 동작을 고려해 보자:

1 s = 0x1234abcd

2 t = 0x10203040

3 u = s XOR t.

이전의 예와 같이, "s"는 비밀 데이터이고, "t"는 다른 (아마도 변수) 데이터이다. 명료함을 위해, 두 변수 "s"와 "t"는 그 값이 배정된 것으로 제시되고; 실제로, "s"의 값은 문자 값으로 XOR 동작에서 직접 사용되고, "t"는 일부 변수 값에 이미 존재한다. 이 동작은 아래에 제시된 바와 같이 2개의 XOR 동작과 OR 동작으로 구성된 시퀀스로 분할될 수 있다:

1 s1 = 0x12340000

2 t1 = 0x10200000

3 s2 = OxOOOOabcd

4 t2 = 0x00003040

5 u1 = s1 XOR t1

6 u2 = s2 XOR t2

7 u = u1 OR u2.

이 경우에, 분할하는 것은, "s"와 "t"의 상위(top) 16 비트에 XOR를 수행하고, 하위 16 비트에 XOR를 수행하고 나서, 그 결과들을 OR 동작으로 결합하는 것에 의해 달성되었다. 이들 성분을 훨씬 더 작은 부분으로 분할하는 것은 이 방식을 단순 연장한 것이고; 예를 들어, 이들 성분은 4개의 XOR과 3개의 OR을 사용하여 4개의 8비트 부분으로 분할될 수 있다.

여기서 제시된 예는 단지 단일 동작에 대해 비밀 데이터를 분할하는 것을 수반한다. 실제로, 그러나, 이 분할하는 것은 비밀 데이터를 수반하는 동작을, 제1 동작의 결과(및 그리하여 비밀 데이터)에 의존하는 후속 동작과 결합시키는 것에 의해 동작 시퀀스에서 수행된다.

이의 일례는 아래에 제시된다:

1 s = 0x1234abcd

2 u = s XOR t

3 v = a + b

4 w = u * v.

이 예에서, 비밀 데이터 "s"는 "t"와 XOR되어 "u"가 생성되고, 이 u는 이후 라인 4에서 사용되어 "w"가 생성된다. 임의의 방식으로 "s"에 의존하지 않는 라인 3의 존재는, "s"의 의존이 연속하지 않을 수 있다는 것을 나타내는 기능을 하고; 실제, 이 비밀 데이터들은 많은 관련 없는 동작에 의해 분리될 수 있다. 하나를 초과하는 동작에 대해 비밀 데이터를 분할하기 위하여, 이 예는 아래에 제시된 바와 같이 재기록될 수 있다:

1 s = 0x1234abcd

2 v = a + b

3 w = (s XOR t) * v.

여기서 라인 3은 원래의 코드에 있는 "u"를 그 값을 생성하는 동작("s XOR t")으로 대체한 표현이다.

"s XOR t"에 대해 분할 동작을 생성하는 대신에, 분할 동작은 표현 "(s XOR t)*v"에 대해 생성되고, 이는 "s"에 대해 2개의 의존 동작의 시퀀스를 나타낸다. 이것은 유도된 비밀 데이터로부터 의존하는 임의의 깊이로 확장될 수 있다. 이 폭발적 증가 공정은 유도된 비밀 데이터에서 특정 개수보다 더 많은 개수의 비트를 사용하는 동작이 없을 때까지 동작 세트에 걸쳐 반복적으로 적용된다. 각 유도된 데이터가 분할되는 비트의 개수는 유도된 데이터가 원래의 비밀 데이터와 관련된 방식에도 또한 의존할 수 있고; 이들 데이터가 크게 상관되어 있다면, 이들 데이터는 더 작은 개수의 비트로 분할되는 경향이 있다.

비밀 융합 단계(S34)에서, 모든 유도된 비밀 데이터(많은 데이터는 단일 비트만큼 작을 수 있다)는 이 데이터를 저장하는 것이 아니라 데이터를 생성하는 고유한 동작 세트로 변환된다. 이 고유한 동작 세트는 (아래에서 설명된 바와 같이) 시퀀스에 민감하고, 이는 이들 동작이 생성한 데이터가 이 지점까지 구현에 의해 수행된 거의 모든 이전의 동작에 의존한다는 것을 의미한다. 이 데이터를-생성하는 동작은 이후 데이터를 사용하는 동작과 결합되어서, 데이터를 생성하고 이 데이터를 사용하는 것을 거의 구별할 수 없게 한다.

일 실시예에 따라, 유인 생성 국면(S12)은 도 4에 도시된 바와 같이 다음 단계, 즉:

- 복제 및 변이 단계(S41);

- 동작 인터리브 단계(S42); 및

- 데이터 흐름 융합 단계(S43)를 포함한다.

복제 및 변이 단계(S41)에서, 비밀의 폭발적 증가와 융합 국면은 비밀 데이터를 대체하는 랜덤한 데이터에 다수회 반복되어서, 선택된 알고리즘의 대안적인 유인 구현을 나타내는 동작 세트를 생성한다.

동작 인터리브 단계(S42)에서, 모든 생성된 동작(리얼 동작과 유인 동작)은 단일의 큰 동작 세트로 결합되고, 여기서 각 세트로부터 동작은 모든 다른 세트로부터 동작과 인터리브되어서, 결합된 세트가 실행될 때, 이 결합된 세트는 모든 동작 세트를 효과적으로 실행한다.

데이터 흐름 융합의 단계(S43)는 인터리브 후에 수행된다. 이 단계를 수행하기 전에, 결합된 동작 세트는 여전히 관련 없는 동작 세트들로 구성되고 - 이들 세트는 단순히 서로 사이에 위치된다. 이 마지막 단계에서, 이 관련 없는 동작들은 서로 융합되어, 전체 결합된 동작 세트에 걸쳐 데이터 흐름을 결정하는 것을 곤란하게 한다.

복제 및 변이 단계(S41)에서, 비밀의 폭발적 증가 및 융합 국면은 랜덤한 비밀 데이터에 다수회 반복되어, 선택된 알고리즘의 대안적인 유인 구현을 나타내는 동작 세트를 생성한다. 생성 공정이 비밀 데이터의 값에 의존하기 때문에, 각 생성된 동작 세트는 고유하다. 결과들은 효과적으로 변이되기 때문에 이것은 변이라고 언급되지만, 실제 공정은 상이한 시작 시드(starting seed)에서 이 결과를 생성한다. 디폴트로, 랜덤하게 생성된 데이터는 단순히 실제 비밀 데이터(real secret data) 대신에 사용된다. 이것은 비밀 데이터가 랜덤한 데이터와 구별될 수 없을 때에는 양호하지만, 임의의 비밀 데이터가 이 특성을 가지고 있지 않는 경우에는, 유인 데이터는 비밀 데이터의 특성과 더 잘 매치하는 융합 데이터를 사용하는 것이 필요하다. 이것은 알고리즘이 랜덤하게 생성된 데이터에 맞춰서 이 데이터를 적절히 유인 비밀 데이터로 만드는 알고리즘-특정 필터를 제공하는 것에 의해 해결된다.

동작 인터리브 단계(S42)에서, 모든 생성된 동작(리얼 동작과 유인 동작)은 도 6에 도시된 바와 같이 단일의 큰 동작 세트로 결합된다. 도 6은, 서로 인터리브되어 단일의 큰 결합된 동작 세트(CI)를 제공하는 유인 동작 세트(DI1, DI2, DI3, DI4)와 리얼 동작 세트(RI)를 도시한다. 동작 세트(CI)에서, 각 동작 세트(DI1 내지 DI4 및 RI)로부터 오는 동작은 (이 세트 위와 아래 화살표에 따라) 다른 모든 세트로부터 오는 동작과 인터리브되어, 결합된 세트(CI)가 실행될 때, 이 결합된 세트는 모든 동작 세트(DI1 내지 DI4 및 RI)를 효과적으로 실행한다. 이 인터리브는, 구체적으로 서로 근처에 있도록 있어나는 상이한 세트로부터 오는 동작들 사이에 직접 대응관계가 없도록 부분적으로 오버랩되도록 설계된다. 구체적으로, 리얼 동작 세트(RI)는 결합된 세트(CI)의 바로 시작 부분과 바로 종료 부분에서 항상 멀리 위치된다.

인터리브가 단계(S42)에서 일어난 후, 결합된 동작 세트는 단순히 서로 사이에 위치된 여전히 관련 없는 동작 세트들로 구성된다. 데이터 흐름 융합의 마지막 단계(S43)에서, 이 관련 없는 동작들은 전체 결합된 동작 세트를 통해 흐르는 데이터를 결정하기 곤란하도록 서로 융합된다. 이것은, 밖으로 나가는 데이터 흐름을 갖는 동작 그룹을 점진적으로 선택하고, 그 출력 데이터를, 올바른 수신 동작으로 라우팅하는 새로이-생성된 동작을 통해 그 출력 데이터 모두를 푸시하는 것에 의해 달성된다. 이 라우팅 동작은 또한 (아래에서 설명된 바와 같이) 시퀀스에-민감한 융합을 사용하는 고유하게-생성된 불투명한 표현을 사용하여 구성된다. 이것이 작업하는 방식을 알기 위해, 도 7a에 있는 예는 데이터 흐름 융합을 사용하여 결합할 2개의 별개의 동작 세트를 도시한다. 도 7a는 좌측에 동작 "a1 ", "a2"를 도시하고 우측에 동작 "b1", "b2"를 도시한다. 동작 "a1"은 2개의 입력 "I1a1 및 "I2a1"을 구비한다. 동작 "b1"은 2개의 입력 "I1b1 및 "I2b1"을 구비한다. 동작 "a2"는 변수 "I1a2를 수신하고, 동작 "a1"의 출력을 수신한다. 동작 "b2"은 변수 "I1b2"를 수신하고, 동작 "b1"의 출력을 수신한다. 데이터 흐름 융합을 사용하여 동작 "a1", "a2"과 동작 "b1", "b2"을 결합시키기 위해, 이 동작은, 동작 "a1"과 동작 "a2" 사이에 그리고 또한 동작 "b1"과 동작 "b2" 사이에 추가적인 동작이 추가되기 때문에, 동작 "a2" 또는 "b2" 중 어느 하나의 동작이 실행되기 전에, 동작 "a1"과 동작 "b1"이 모두 실행되도록 위치된다. 이 동작에 데이터 흐름 융합을 수행한 결과는 도 7b에 도시된다. 도 7b에서, 동작 "a1" 및 "b1"이 실행된 후이지만, 동작 "a2" 또는 "b2"가 실행되기 전에, 라우팅 동작(ROP)이 실행될 수 있도록 삽입된다. 볼 수 있는 바와 같이, 동작 "a1" 및 "b1"이 그 출력을 동작 "a2" 및 "b2"으로 각각 전달하는 대신에, 이들 동작은 그 출력을 라우팅 동작(ROP)으로 전달하고, 이 라우팅 동작은 이후 그 출력을 올바른 수신자, 즉 동작 "a2" 및 "b2"로 전달한다. 라우팅 동작(ROP)에 의해 사용된 불투명한 표현은 어느 출력이 어느 수신자에게로 가는지를 결정하는 것을 매우 곤란하게 만들고; 특히, 이것은 정적 분석을 통해 결정하는 것을 거의 불가능하게 한다. 데이터 흐름 융합 공정은 결합된 동작 세트에서 모든 데이터 흐름이 충분히 융합될 때까지 진행된다.

구현 코어 생성 공정에 의해 생성된 동작 세트는 이 형태로 실행될 수 없어서, 이 동작 세트는 실제로 사용될 수 있는 구현을 생성하도록 실행가능한 형태로 변환될 수 있다. 실행 기계 생성 공정(P2)은 이 변환을 수행하고, 소프트웨어 프로젝트에 포함되어 원하는 암호화 동작을 직접 수행하도록 직접 호출될 수 있는 소스 코드를 생성한다. 그러나, 일 실시예에 따라, 동작을 코드로 단순히 직접 변환하는 것이 아니라, 공정(P2)은 키 추출 공격에 상당한 추가적인 보호를 제공하는 동작을 실행하는 전문화된 기계를 생성한다.

개념적 레벨에서, 생성된 기계는, 가상 프로그램을 처리하고 가상 기계 모델의 상황에서 이 프로그램에 의해 지정된 동작을 수행하는 실행 엔진이 있다는 의미에서 가상 기계(Virtual Machine: VM)와 대략 유사하다. 그러나, 구현 레벨에서, 다수의 상당한 차이가 있다:

각 생성된 기계는 고유하다: 기계가 수행할 수 있는 동작, 이 동작을 수행하는 방식, 이 동작이 표현되는 방식, 및 이 동작을 실행하는 메커니즘은 각 기계에 고유하다;

기계는 명령 세트를 구비하지 않는다: 주어진 기계가 실행할 수 있는 동작 세트는 명령 세트인 것으로 고려될 수 있으나, 이들 동작 세트는 동작에 이름이 주어질 수 있고 이러한 방식으로 사용될 수 있는 구별가능한 개념적 의미를 가지고 있지 않다;

기계는 프로그램을 실행하지 않는다: 주어진 기계는 하나의 특정 프로그램만을 실행할 수 있고, 이 프로그램은 기계 그 자체의 일체 부분이고, 많은 경우에, 기계의 실행측과 프로그램 측 사이에 경계가 존재하지 않는다;

기계에는 실행 엔진이 없다: 각 기계는 동작을 수행하는 일을 담당하는 다수의 실행 요소들로 구성되고, 또한 이들 각 요소는 수행할 그 다음 동작을 결정하는 일을 담당하고, 모든 실행 단계에서 수반되는 "중심 엔진"이 없다;

기계는 가상 기계 모델을 구비하지 않는다: 임의의 주어진 동작의 구현은 동작이 구현되는 방식에 임의의 제한을 둘 수 있는 특정 가상 CPU 또는 임의의 다른 구조와 연관성이 없고, 이에 대한 유일한 예외는, 함수 호출을 구현하는데 사용되는 프로그램 스택이 있으나 기계-내부 호출에 사용되는 규정된 호출 규약 (calling convention)이 없다는 것이다;

기계는 정적으로 분석될 수 없다: 명령 세트 없음, 구별가능한 프로그램 없음, 및 기계 모델 없음을 갖는 고유한 기계를 정적으로 분석하는 것을 고유하게 곤란하게 하는 것과는 별도로, 기계를 실행하는 공정은 (아래에서 설명된 바와 같이) 시퀀스에-민감한 융합 동작에 전적으로 의존하고, 기계의 일부는 실행이 이 부분에 도달될 때까지 (기계 그 자체에 의해서도) 이해될 수 없다;

일 실시예에 따라, 기계를 생성하는 공정은 도 2에 도시된 바와 같이 다음 단계, 즉:

작은 균일한 명령 세트 면으로 표현된 구현 코어 생성 공정(P1)에 의해 생성된 동작 세트를, 훨씬 더 큰 불균일한 명령 세트 면으로 표현된 동작으로 변환하는 동작 재-표현 단계(S21);

단계(S21)로부터 획득된 재-표현된 동작의 구현을 생성하는 동작 구현 단계(S22);

정적인 분석에 저항하도록 시퀀스에-민감한 융합을 레버리지하도록 이 동작 구현을 변환하는 시퀀스 융합 단계(S23); 및

시퀀스 융합 단계(S23)에 의해 생성되고, 실행가능한 형태로 출력될 준비가 된, 이 구현의 모든 성분에 적용되는 코드 생성 단계(S24)를 포함한다.

동작 재-표현 단계(S21)의 출력은 명령 세트를 가지고 있는 것으로 언급되지만, 이 명령 세트는 엄격히 명령 세트로서 자격이 없는데, 그 이유는 각 명령에 포함된 서브-동작이, 전통적인 의미의 명령과 같이 사용되기 위해서, 각 서브-동작에 집합적 이름을 줄 수 있는, 서로에 의미 있는 개념적 관계를 가지고 있지 않기 때문이다. 예를 들어, "함수 호출" 명령은, 일반적으로 개별 의미(예를 들어, 값을 스택으로 푸시하고, 다른 프로그램 장소로 점프하는 등)를 가지지만, 또한 후속-동작을 "함수 호출" 이름을 갖는 단일 명령으로 함께 표현할 수 있는 결합된 의미를 가지는 서브-동작의 시퀀스로 구성된다. 이제 이 함수 호출 시퀀스가 레지스터 r0에 1234를 가산하는 명령과 결합하여 새로운 명령을 만드는 것을 고려해보자. 이 새로운 명령은 이것이 하는 것을 나타내기 위해 "호출 함수 및 가산 1234, r0"(또는 이와 유사한 것)이라고 언급되어야 한다". 말하자면, 10개 이상의 명령이 이런 방식으로 결합되면, 새로운 명령의 결과적인 이름은 너무 복잡하고 이 명령에 너무 특정되어 개념적으로 의미가 없을 수 있다.

원하는 변환을 달성하기 위해, 단계(S21)는 2개의 단계로 수행되는데; 즉, 동작을 재기록하는 제1 단계와, 동작을 결합시키는 제2 단계로 수행된다. 동작을 재기록하는 제1 단계는 동작의 시퀀스를, 불투명한 표현, 산술/논리 재기록, 및 무차별 대입과 동등한 코드(brute-force equivalent code) 생성과 같은, 잘 알려진 난독화 변환을 사용하여 의미적으로-동등한 대안적인 형태로 변환한다. 동작 시퀀스는 랜덤하게 선택되고 나서 랜덤하게-선택된 난독화 변환으로 변환된다. 이 공정은 충분한 레벨의 변환이 일어날 때까지 반복된다. 각 개별 동작은 이 공정 동안 다수회 변환될 수 있다. 이 단계의 기본적인 목적은 제2 단계를 위한 코드의 균일성을 감소시키는 것이다. 난독화 변환을 사용하는 것은 결과적인 코드를 이해하는 것을 더 어렵게 하는데 도움을 주지만, 이것이 전체 공정의 크리티컬 요소인 것은 아니다.

동작을 결합시키는 제2 단계는 새로운 명령 세트를 생성하는 동작 시퀀스를 결합시키는데, 여기서 각 명령은, 서로 결합되어 이 새로운 명령 세트를 생성하는 동작 시퀀스를 나타낸다. 결합 공정은, 제1 동작에서 시작하고 이 제1 동작과 결합하기 위해 랜덤한 개수의 후속 동작을 선택하는 것에 의해 (함수마다에 기초하여) 작업한다. 이들은 새로운 명령 인덱스와 결합되고 연관된다. 이 공정은 그 다음 이용가능한 (비-결합된) 동작으로 이동하고 나서, 이 동작을 랜덤한 개수의 후속 동작과 결합시키되, 모든 동작이 처리될 때까지 이와 같이 계속된다. 이 단계의 목적은 각 명령을 구성하는 동작들 사이에 개념적 관계를 갖지 않는 새로운 명령 세트를 생성하는 것이다. 이것은 결합 공정에 의해서만 달성될 수 있으나, 이 결합 공정을 재기록 단계의 불균일한 결과에 적용하면 훨씬 더 효과적인 결과를 생성한다.

전술된 동작 결합 단계는 간단하고 효과적이지만, 여러 방식으로 개선될 수 있다. 예를 들어, 공정이 함수의 종료에 도달할 때, 마지막 새로운 명령이 단일 동작으로 형성되는 최악의 경우의 시나리오에서, 결합에 이용가능한 동작의 개수는 감소된다. 이것은, 이 스테이지에서 코드의 심히-언롤링된 및 인라인된 특성이 코드의 상대적으로 작은 부분에 영향을 미치는 것을 의미할 수 있기 때문에, 실제로 상당한 문제를 야기할 것 같지는 않다. 이것이 문제시되었다면, 이 문제는, 결합 시퀀스를 미리-계산하고, 모든 시퀀스가 충분한 최소 사이즈일 때까지 그 경계를 랜덤하게 재분배하는 것에 의해 제거될 수 있다.

동작 구현 단계(S22)는 이전의 단계(S21)로부터 재-표현된 동작의 구현을 생성한다. 동작 구현은 다음 부분을 포함한다:

1. 새로운 명령을 생성하도록 결합된 동작들의 서브-동작 구현 부분;

2. 파라미터 디코딩 로직 - 일부 동작은 (프로그램을 실행하는 것과 대략 동등한) 다수의 상황에서 실행될 수 있다; 이 동작은 각 동작에 대해 고유하게 인코딩된 파라미터의 형태로 상황-특정 입력 및 출력을 수신할 수 있다;

3. 실행 연속성 로직 - 각 동작이 실행된 후, 그 다음 동작과 그 상황(이 동작이 하나를 구비하는 경우)이 디코딩되고, 실행은 이 동작의 구현에 의해 계속된다.

시퀀스 융합 단계(S23)는 (아래에서 설명된 바와 같이) 정적인 분석에 저항하도록 시퀀스에-민감한 융합을 레버리지하도록 동작 구현을 변환한다. 이 국면 이전에, 동작 구현은 서로 직접 체인으로 결합되고, 각 동작 구현은 자기의 입력/출력과 연속성 파라미터를 정적으로 디코딩한다. 이 국면 후, 각 동작 구현은 디코더 구현으로 체인 결합되고, 이 디코더 구현은 그 다음 동작 구현으로 체인 결합된다. 디코더 구현은 그 다음 동작 구현과 그 파라미터의 장소를 디코딩하는 일을 담당하고, 이들은 시퀀스에-민감한 융합 값을 사용하여 디코더마다 구현을 고유하게 인코딩된다.

동작 구현으로 체인 결합되는 특정 디코더 구현은 상황에-특정되고, 즉 동작 구현은 이것을 파라미터로서 수신하고, 이 구현이 체인으로 결합하는 디코더들이 어느 디코더인지에 대한 정적 지식을 가지고 있지 않다. 이 변환의 결과는, 동작 구현이 사용 지점에서만 해결되는 상황에-특정된 동적 디코더 세트를 통해 서로 분리되어, 동작 시퀀스의 정적 분석을 극히 곤란하게 만든다는 것이다.

시퀀스 융합 단계(S23)가 완료된 후, 구현의 모든 성분은 실행가능한 형태로 출력될 준비가 된다. 코드를 생성하는 마지막 단계(S24)에서, 모든 동작 구현은, 기존의 프로젝트로 컴파일되고 직접 실행될 수 있는 독립 소스 코드로 함께 렌더링되는데 - 이것은 일반적으로 C 소스 코드이지만 다른 구현 언어도 사용될 수 있다.

공정(P2)은 화이트박스 구현을 실행할 수 있는 실행 기계를 생성하는 것을 수반한다. 이 기계 생성은 공정(P1)에서 수행된 다른 화이트박스 생성 단계에 의해 사용되는 기술에 더하여 단계(S21, S22, S23)의 난독화 기술을 사용한다.

실행 기계를 생성하는 것은 이 모든 추가적인 난독화가 실행 기계에서 어디에서나 사용될 수 있는 것으로 가정한다. 이것은 여전히 특정 경우에는 참(true)일 수 있으나 경험에 따르면 이 난독화는 효과적인 공정(P1)의 다른 화이트박스 생성 단계에서 사용되는 난독화보다 (암호화 알고리즘을 보호하는 면에서) 덜 효과적이고, 성능 영향과 코드 사이즈 면에서 대부분 값비싼 난독화 중에 있는 것을 보여준다.

일 실시예에 따라, 대부분 효과적인 난독화의 사용을 최대화하고 전체 성능/사이즈의 영향을 더 제어하기 위하여, 실행 기계는 변수 난독화 복잡성에 따라 생성되고, 여기서 복잡성은 최대로 제어하기 위해 동작 레벨마다 변할 수 있다. 복잡성의 최저 레벨에서, 동작을 위해 생성된 코드는 본질적으로 동작과 이 동작이 동작하는 데이터 사이에 일부 (만약 있다면) 재지향 메커니즘을 갖는 간단한 C 동작 구현이다. 이 복잡성 레벨에서 생성된 코드는 최대 복잡성에서 생성된 코드보다 일반적으로 10 내지 100 배 더 빠르고, 또한 상당히 더 작다. 임의의 주어진 동작에 대해, 복잡성 레벨은 최소 복잡성과 최대 복잡성 사이에 큰 레벨 범위들 중 하나로 설정될 수 있다. 이 레벨이 증가될 때, 기계 생성에 이용가능한 여러 난독화가 점진적으로 수행되고, 여기서 최대 레벨은 모든 이용가능한 난독화를 사용한다.

각 동작이 개별 복잡성 레벨을 구비할 수 있으나, 실제로 복잡성 레벨은, 더 큰 입도(granularity)로, 기본적으로 입력 코드에서 함수 레벨마다, 그리고 특정 경우에, 함수 내 블록 레벨마다, 지정될 수 있다. 복잡성 레벨은 코드 주석(code annotation)을 통해 입력 코드에 지정된다. 입력 코드에 적용된 복잡성 레벨은 또한 전체적으로 스케일 업되거나 스케일 다운될 수 있어서, 상이한 복잡성 범위에서 실행 기계를 용이하게 생성할 수 있다. 일 실시예에 따라, 간단한 선형 스케일링 동작이 달성되지만, 비-선형 모델도 또한 가능하다.

시퀀스에-민감한 융합의 개념은 실시예에 따라 다수의 단계(S34, S43, S23)에서 사용되고, 유효성을 제공하는데 중요한 역할을 한다. 높은 레벨에서, 시퀀스에-민감한 융합은, 프로그램의 요소들이 특성상 랜덤한 것으로 보이는 실행시간에-생성된 데이터에 의존하게 하여, 프로그램 요소가 실행되는 시간에 이 데이터가 올바른 값을 정확히 가지는 경우에만 프로그램 요소들이 올바르게 실행될 수 있는 방법이다. 이 기술은, 프로그램 요소가 실제로 실행되고 있을 때까지 로직과 데이터의 일부 부분이 알려질 수 없기 때문에 정적으로 해결되는 것이 극히 곤란한 방식으로 이 프로그램 요소들의 로직과 데이터를 난독화하게 하는데 사용된다. 이것이 작업하기 위하여, 데이터 생성 시퀀스는 미리 알려져서, 데이터를 사용하는 프로그램 요소들은, 사용 지점에서 이 값을 드러냄이 없이, 생성된 데이터를 특정 알려진 값으로 변환시키는 보상 동작에 의해 변경될 수 있다.

정적 분석을 방지하는데 효과적이기 위하여, 데이터 생성 공정은 데이터 시퀀스가 공격자에 의해 미리 예측될 수 없을 만큼 충분히 복잡할 수 있다. 이것은 다수의 데이터 변이 동작을, 각 변이 동작이 데이터 생성 버퍼에 고유한 동작 시퀀스를 수행하는 프로그램에 걸쳐 주입하는 것에 의해 달성된다. 이 동작은 데이터 버퍼 내에 비트의 혼합을 최대화하도록 설계될 수 있다.

동작들 사이에 데이터의 흐름의 난독화는 리얼 동작과 유인 동작의 출력들을 결합시키는 것을 수반한다. 데이터 요소들 그 자체는 유용한 중간 데이터를 추출하는 것을 방지하도록 더 난독화될 수 있다. 중간 데이터 난독화는 사실상 화이트박스 내에 생성된 임의의 데이터 요소에 적용될 수 있고, 실제로, 이 난독화는 이상적으로는 모든 단일 데이터 요소에 적용된다. 일 실시예에 따라, 구현의 중간 데이터 요소는, 각 데이터 요소를, 이 데이터 요소에 고유하고 데이터 요소를 난독화시키는 방식을 지정하는 난독화 상황과 연관시키는 것에 의해 난독화된다. 예를 들어, 데이터 요소가 이 데이터 요소를 암호화하는 것에 의해 난독화되면, 난독화 상황은 이 요소에 대한 암호화 키를 포함할 수 있다. 데이터 요소가 동작에 의해 기록될 때, 이 데이터 요소는 난독화 상황을 사용하여 난독화될 수 있고, 이 데이터 요소가 다른 동작에 의해 판독될 때, 이 데이터 요소는 동일한 난독화 상황을 사용하여 난독화가 해제될 수 있다. 이것은, 데이터 요소가 그 난독화된 형태로 메모리에 저장되지만, 동작되고 있을 때에는 그 비-난독화된 형태로 변환되는 것을 보장한다. 각 데이터 요소가 고유한 난독화 상황을 사용하기 때문에 (예를 들어, 암호화된 경우, 각 데이터 요소는 고유한 암호화 키를 구비할 수 있다), 공격자가 전체적으로 중간 데이터를 이해하기 위해서는, 공격자는 각 개별 데이터 요소에 대한 난독화를 차단해야 하는데, 이는 일반적으로 실용적이지 않다.

2. 동적인 비밀을 갖는 화이트박스 구현

동적인 비밀을 갖는 화이트박스 구현 방법은, 비밀 데이터가 동적인 경우, 즉 실행시간에만 알려진 경우, 화이트박스 구현을 생성할 수 있다. 정적인 키는 화이트박스 솔루션의 기본 요소이다. 화이트박스를 생성하는 공정은 본질적으로 정적인 키를, 키 값을 유도하는 것을 곤란하게 하는 형태로 암호화 알고리즘의 버전에 매립하는 것을 수반한다. 이에 비해, 동적인 키는 화이트박스 내에 이미 매립되는 대신에 화이트박스로 전달되는데, 이는 화이트박스의 고유한 정적인 특성에 반하는 것이다. 일 실시예에 따라, 이 문제는, 2개의 암호화 알고리즘을 결합하고, 결합된 알고리즘으로부터 단일 화이트박스 구현을 생성하는 것에 의해 해결될 수 있다. 이것을 하는 능력은 화이트박스 생성 (도 2) 방법이 2개 이상의 알고리즘을 결합시킨 결과를 당연히 포함하는 임의의 암호화 알고리즘에서 동작하는 능력을 가진 결과이다.

동적인 키(Kd)를 선택된 알고리즘(Ad)에서 사용하기 위해, 키(Kd)는 적절한 알고리즘(예를 들어, AES)과 그 대응하는 키(Kaes)로 제일 먼저 암호화되어, 암호화된 키(Kde)가 생성된다:

Kde = EncryptAES(Kaes, Kd)

간략화를 위해, 암호화된 키(Kde)는 미리 생성되고, 키(Kd)는 화이트박스 구현이 실행되고 있는 디바이스에는 전혀 존재하지 않는 것으로 가정한다. 동적인 키(Kd)의 암호화된 버전(Kde)은 동적인 키의 값을 드러냄이 없이 화이트박스 주위로 전달되고 화이트 박스 외부에 저장될 수 있다. 동적인 키(Kd)를 안전하게 사용하기 위하여, 암호화된 버전(Kde)을 복호화하여 동적 키(Kd)를 복원할 수 있는 화이트박스 구현이 생성된다. 이후 동적인 키(Kd)를 알고리즘(Ad)에 사용하여, 선택된 동작을 수행할 수 있다. 전체 동작은 이와 같이 보인다:

출력 = Ad(DecryptAES(Kaes, Kde), 입력)

화이트박스 구현을 생성하기 위하여, 알고리즘(DecryptAES 및 Ad)을 위한 소스 코드가 단순히 결합되고, 이 알고리즘을 사용하여 상기 동작을 구현하는 상위-레벨 함수가 생성된다. 알고리즘(Ad)이 또한 알고리즘(DecryptAES)이도록 일어나는 경우, 입력 코드는, 상위-레벨 함수가 두 번 호출하는 단일 알고리즘만을 포함한다는 것이 주목된다. 화이트박스 생성 방법은 화이트박스의 보호 경계 내 단일 유닛으로서 전체 동작을 수행하는 단일 화이트박스 구현을 생성한다. 화이트박스를 통해 데이터 흐름을 관찰하는 것을 통해 키 유도를 방지하는 것과 동일한 메커니즘에 의해 복호화된 키(Kd)가 화이트박스로부터 추출되는 것을 또한 방지할 수 있다.

전술된 방법은 화이트박스 구현에서 동적인 키를 사용하는 여러 가능한 접근법 중 하나이지만, 이들 접근법이 모두 단일 화이트박스 내에 2개 이상의 암호화 알고리즘을 결합시키는 공통 요소를 공유한다. 단일 화이트박스에서 다수의 알고리즘을 결합시키는 일반적인 개념을 추가적으로 연장하여, 데이터의 내용을 드러냄이 없이, 동작이 암호화된 데이터에 수행되게 할 수 있다. 이것은, 다음 예에 제시된 바와 같이 복호화 동작(DecryptAES), 데이터에 대한 동작(dataOp), 및 암호화 동작(EncryptAES)을 결합시키는 것에 의해 달성될 수 있다:

출력 = EncryptAES(Kaes, DataOp(DecryptAES(Kaes, 입력)))

3. 상황외 사용( Out - of - Context Use ) 방지

공격자가 애플리케이션 생성자(application creator)에 의해 의도되지 않은 상황에서 화이트박스 구현을 사용하려고 시도할 수 있는 2개의 주된 방식이 있다:

공격 1: 구현을 분리하고 다른 프로그램에 복사한다. 이것은 유능한 공격자가 달성하기에는 상대적으로 쉬운 것이다. 특정 요소들은 이것을 실제로 약간 더 복잡하게 할 수 있는데 - 예를 들어, 코드는 코드를 실행하기 위해 특정 메모리 장소에 배치되어야 할 수 있으나 - 유능한 공격자는 상당히 신속히 이 복잡성을 극복할 수 있을 것이다.

공격 2: 구현을 포함하는 전체 프로그램을 복사하고 이 구현을 다른 프로그램으로부터 직접 호출한다. 이것을 수행하는데 일부 상이한 방식이 있으나, 핵심적인 요소는, 이 구현이 이 구현을 사용하는 프로그램과 분리되지 않는다는 것이다. 실제로, 이 공격은 이전의 것보다 약간 더 곤란할 수 있으나, 이것도 또한 유능한 공격자의 능력 내에 있어서, 특정 경우에는 훨씬 더 용이할 수 있다.

일 실시예에 따라, 공격 1은, 무결성(integrity)을-체크하는 변조-방지 솔루션(anti-tampering solution)을, 화이트박스 구현을 포함하는 애플리케이션에 적용하여, 화이트박스 코드가, 나머지 애플리케이션이 예상되는 메모리 장소에 실제로 존재하는지를 검증하는 변조-방지 체크를 포함하도록 하는 것에 의해 방지될 수 있다. 공격자가 화이트박스 코드를 다른 프로그램에 단순 복사하려고 시도하면, 화이트박스 코드 내에 포함된 변조-방지 체크는 실패하고 이 코드는 실행이 거부된다. 이것이 대부분 효과적이기 위하여, 변조-방지 솔루션은, 화이트박스 구현에 의해 제공되는 대부분의 코드 부분을 레버리지하고, 다수의 무결성 체크를 이 코드에 자동적으로 주입하여, 공격자가 이 무결성 체크를 좌절시켜서 상황외 코드를 사용하는 것을, 가능한 한, 곤란하게 하여야 한다.

공격 2는 방지하는 것이 상당히 더 곤란하고, 이렇게 하는 방법은 부분적으로 화이트박스 구현 외부에 있는 추가적인 메커니즘을 사용한다. 추가적인 메커니즘은 "상황적 시행(context enforcement)"이라고 언급되는 무결성을-체크하는 변조-방지 솔루션을 연장시키는 것이다. 이 메커니즘에 의해 사용되는 기초적인 접근법은 본 발명에서 사용하는 것을 넘어 응용할 수 있다는데 가치가 있다.

상황적 시행 뒤에 있는 핵심적인 아이디어는, 화이트박스 구현의 내부와 이 구현을 사용하는 프로그램 사이에 융합을 도입하여, 프로그램에 의해 화이트박스를 의도된 바와 같이 사용하는 것만이 올바른 결과를 생성할 수 있게 하는 것이다. 높은 레벨에서, 공정은 융합 제작자(conflation producer)를 프로그램에 주입하고, 융합 타깃을 화이트박스 구현에 주입하는 것을 수반한다. 융합 제작자는 프로그램이 실행될 때 융합 데이터를 생성하고, 융합 타깃은 이 데이터를, 화이트박스 구현 내에 수행되는 동작과 결합시킨다.

프로그램이 정상적으로 실행하는 것에 의해 생성된 융합 데이터는 화이트박스 동작의 결과를 변화시키지 않는 반면, (실행을 전혀 포함하지 않는) 비정상적인 프로그램이 실행되면 동작이 올바르지 않은 결과를 생성하는 방식으로 융합 데이터와 화이트박스 동작을 조합하도록 구성된다. 기본 공정은 다음 단계들로 이루어진다:

1. 융합 제작자로 사용하기 위해 애플리케이션에서 장소 세트를 선택한다;

2. 각 융합 제작자에 대해 융합 데이터를 생성하는 코드를 주입한다;

3. 융합 타깃으로 사용하기 위해 화이트박스 구현 내 동작 세트를 선택한다;

4. 융합 데이터를 기존의 동작과 결합시키기 위해 각 융합 타깃을 변환한다.

선택된 장소는 화이트박스 구현에 대한 하나 이상의 희소 실행 경로(sparse execution path)를 따라 놓여있고, 이 희소 실행 경로는 구현에 가능한 모든 경로의 수퍼세트(superset)를 나타낸다. 예를 들어, 구현에 대해 10개의 별개의 경로를 갖는 간단한 프로그램에서, 모두 10개의 경로에 보이는 3개의 장소가 있을 수 있다. 이 3개의 장소는 구현에 대한 희소 실행 경로를 나타내고, 그리하여 상황적 시행을 위한 장소로 사용될 수 있다. 다른 예는, 구현에 대해 10개의 경로를 구비하고, 여기서 이 10개의 경로 중 절반이 모두 동일한 3개의 장소를 통과하는 반면, 다른 절반은 모두 상이한 3개의 장소를 통과하는 경로를 갖는 간단한 프로그램일 수 있다. 이 프로그램은 3개의 장소를 갖는 2개의 세트에 대해 2개의 희소 실행 경로를 구비할 수 있다. 희소 실행 경로는 서로 교차할 수 있고 심지어 서로 "포함"할 수도 있고, 그 상대적인 토폴로지에 제한은 없다. 유일한 요구조건은 구현에 가능한 모든 경로가 적어도 하나의 희소 실행 경로에 의해 표현된다는 것이다.

각 제작자는 일반적으로 다수의 융합 데이터를 생성하고, 각 융합 데이터를 그 연관된 저장 장소에 저장한다. 저장 장소는 현재 제작자 또는 이 현재 제작자 전에 실행되는 임의의 제작자에 속할 수 있다. 이 장소가 현재 제작자에 속하는 경우, 현재 제작자는 이 장소를 초기화하고 데이터를 이 장소에 단순히 기록한다. 이 장소가 이전의 제작자에 속하는 경우, 현재 융합 데이터는 이 장소에 있는 이미 있는 데이터와 병합된다. 융합 데이터는 다수의 방식으로 생성된다. 가장 간단한 방법은, (정적으로 생성된) 랜덤한 입력 값을 변환하는, 생성된 고유한 동작 시퀀스를 실행하고, 이 동작의 결과를 융합 데이터로 사용하는 것을 수반한다. 융합 데이터는 또한 다른 융합 데이터(예를 들어, 이전의 제작자에 의해 생성된 데이터)를 결합시키고, 애플리케이션 그 자체에 의해 생성된 선택된 값을 사용하는 것에 의해 생성될 수 있다. 프로그램이 하나를 초과하는 희소 실행 경로(거의 모든 사소하지 않은 프로그램이 이와 같을 수 있다)를 포함하면, 융합 제작자는 또한 모든 희소 경로가 동일한 융합 데이터 세트를 생성하도록 구성된다. 이것이 없다면, 화이트박스 구현은 (기껏) 하나의 희소 경로로부터만 올바르게 동작할 수 있다.

선택 단계는 일반적으로 전체 암호화 동작에 상당한 영향을 미치는 동작을 선호한다. 그러나, 이것은 많은 암호화 알고리즘을 위한 선택 클러스터를 생성할 수 있으므로, 이것은 또한 선택된 장소를, 구현에 걸쳐, 할 수 있는 만큼 많이 분배하는 것을 선호된다. 다른 중요한 선택 기준은 융합 변환을 지원하는 동작의 적절성이다. 모든 동작이 유효한 타깃인 것은 아니지만, 많은 타깃이 실제로 있고 이들 타깃은 구현에 걸쳐 잘 분배되어서, 이 기준은 다른 기준에 거의 영향을 미치지 않게 된다. 각 변환은 융합 데이터의 예상되는 값만이 이 변환 전에 동작이 생성한 것과 동일한 결과를 이 동작이 생성하도록 구성된다. 모든 다른 값은 올바르지 않은 결과를 생성한다.

공격자가 융합 데이터가 사용되기 바로 전에 이 융합 데이터를 단순히 덤핑(dump)하고 나서 자기 자신을 위하여 화이트박스를 사용하기 전에 이 데이터를 재-생성하는 것을 중지시키기 위하여, 융합 데이터는 덤핑하는 것을 상당히 더 어렵게 만드는 방식으로 저장된다. 각 융합 데이터는, (희소 실행 경로마다) 하나의 특정 융합 제작자에 의해 소유되고, 업데이트를 요구하는 다른 제작자에 의해 액세스가능한 별개의 장소를 구비한다. 일부 상이한 유형의 장소가 있다:

· 전체 변수와 같은, 메모리 내 프로그램의 기록가능한 구획 내에 일반적으로 위치된 정적 장소;

· 힙 할당(heap allocation)을 통해 동적으로 생성된 힙 위치(heap location); 및

· 스택-시프트(stack-shifting)를 통해 동적으로 생성된 스택 장소.

스택 장소는 (실행 경로와 대조적으로) 화이트박스 구현에 대한 호출 경로에 있는 융합 제작자에 의해서만 사용될 수 있다. 장소는 각 장소에 고유하게 인코딩된 저장된 포인터 값을 통해 항상 액세스된다. 각 제작자는 사용하는 포인터 값을 디코딩하는 방식을 알고 있다. 융합 데이터를 이런 방식으로 저장하면 공격자가 모든 장소 데이터를 성공적으로 찾고 덤핑하는 것을 더 곤란하게 하고, 또한 차후 시점에 데이터를 올바르게 재-생성하는 것을 더 곤란하게 한다.

4. 알고리즘의 작은 부분을 분리하는 것에 의한 공격의 방지

알고리즘의 화이트박스 구현을 공격하는 가장 효과적인 방법들 중 하나는 일정 방식으로 비밀 데이터(예를 들어, 암호화 키)에 동작하는 것으로 알려진 화이트박스 내 알고리즘의 작은 부분을 분리하고 나서, 알고리즘의 이 부분에 무차별 대입 공격(brute-force attack)을 사용하여 비밀을 추출하는 것이다. 이것은 암호화 알고리즘이 완전히 무차별 대입이 실용적이지 않도록 설계되기 때문에 효과적이다; 대부분의 경우에, 이 알고리즘의 개별 부분은 무차별 대입을 통해 공격하는데 매우 실용적이다.

알고리즘 부분을 분리하는 극히 효과적인 방법은 알고리즘 구현의 메모리 액세스 패턴을 분석하는 것이다. 대부분의 암호화 알고리즘은 통상 그 대응하는 메모리 액세스 패턴에 상당히 정확히 반영된 잘 알려진 실행 패턴을 구비하여, 심지어 종종 메모리 액세스 패턴을 단순히 시각화하는 것을 사용하여 충분한 입도로 알고리즘의 부분들을 분리하여 무차별 대입 공격을 촉진할 수 있다.

예를 들어, AES 블록 암호화 알고리즘은 동일한 동작 시퀀스의 10개의, 12개의 또는 14개의 라운드를 실행한다. 이것은 시각화될 때를 찾는 것이 용이한 관련된 메모리 액세스의 10/12/14개의 블록의 대응하는 시퀀스로 나타난다. 공격자는 이것을 사용하여 마지막 2개의 라운드를 분리하고 나서 알려진 방법을 사용하여 이들 라운드의 입력과 출력을 관찰하는 것에 의해 AES 키를 유도할 수 있다.

일 실시예에 따라, 암호화 동작의 개별 부분들을 분리하기 위해 공격자가 의존할 수 있는 액세스 패턴을 제거하는 것에 의해 이런 유형의 공격을 더 곤란하게 할 수 있다. 메모리 액세스 패턴을 제거하는 것은 추가적인 랜덤화된 메모리 액세스 동작을 알고리즘의 화이트박스 구현에 걸쳐 주입하는 것에 의해 달성될 수 있다. 이들 동작은 리얼 동작에 의해 액세스되는 동일한 메모리 장소 세트에 액세스를 하지만, 랜덤화된 순서와 분배를 통해 충분한 잡음을 추가하여 리얼 동작에 의해 나타나는 임의의 패턴을 마스킹하는 것에 의해 액세스를 한다.

일 실시예에 따라, 메모리 액세스 패턴 난독화는 전술된 유인 생성을 연장시키는 것으로 구현된다. 이 연장은 더 큰 개수의 유인을 생성하는 것에 있고, 여기서 추가적인 유인은 메모리 액세스 동작의 사본으로 생성된다. 이 추가적인 유인은 또한 불투명한 표현을 통해 리얼 동작과 결합될 수 있으나, 실제로, 이들 중 대부분은 성능에 대한 영향을 감소시키기 위하여 결합되지 않을 수도 있다.

일 실시예에 따라, 메모리 레이아웃 난독화는 메모리 액세스 패턴 난독화와 함께 알고리즘의 작은 부분을 분리하는 것에 의해 공격에 대해 추가적인 보호를 제공하도록 수행된다. 잡음을 도입하는 것에 의해 액세스 패턴을 난독화시키려고 시도하는 메모리 액세스 패턴 난독화와 달리, 메모리 레이아웃 난독화는 메모리에서 데이터 조각의 장소를 랜덤화하는 것에 의해 그 목적을 달성한다.

레이아웃 난독화가 없다면, 관련된 데이터는 이 데이터에 액세스하는 동작과 같이 일반적으로 서로 나란히 존재하여, 시각화될 때 액세스 패턴을 식별할 수 있게 된다. 메모리 액세스 패턴을 난독화시키는 것에 의해 도입된 잡음을 통해 이 패턴을 관찰하는 것을 곤란하게 하지만, 이 패턴은 여전히 거기에 존재한다. 리얼 동작에 의해 메모리에 액세스된 데이터 조각의 장소를 랜덤화하는 것에 의해, 관련된 데이터는 서로 분리되어, 리얼 동작에 의해 나타나는 임의의 패턴을 분해할 수 있다.

본 발명은 예시적인 실시예에 대해 설명되었다. 특정 변화가 본 발명의 범위를 벗어남이 없이 상기 구성에 이루어질 수 있으므로, 상기 설명에 포함되거나 또는 첨부 도면에 도시된 모든 사항은 예시적인 것으로 해석되어야 하고 발명을 제한하는 것으로 해석되어서는 안되는 것으로 의도된다.

본 발명은 특히 암호화 알고리즘 또는 비밀 데이터를 조작하는 알고리즘에 적용되는 것이 아니라 임의의 알고리즘에 적용될 수 있다.

또한 다음 청구범위는 본 명세서에 설명된 본 발명의 모든 일반적 특징과 특정 특징, 및, 언어의 문제로서, 이 청구범위에 속하는 것으로 말할 수 있는 본 발명의 범위의 모든 진술을 포함하려는 것으로 이해된다.

Claims (21)

1. 메모리에 저장된 코드 형태로 표현된 알고리즘의 보호된 구현을 생성하는 컴퓨터로-구현되는 방법으로서, 상기 방법은,
   알고리즘을 구현하는 원래의 소스 코드를 리얼 동작의 단일 세트로 확장하는 단계;
   원래의 형태와는 상이한 형태로 실제 리얼 데이터 조각을 사용하는 방식으로 표현된 조합을 획득하기 위하여, 리얼 데이터를 사용하는 각 리얼 동작을 리얼 데이터와 결합하는 단계;
   유인 데이터에 적용되는, 상기 알고리즘의 대안적인 구현을 나타내는 복제 및 변이된 유인 동작 세트를 생성하는 단계;
   유인 동작은 리얼 동작 및 리얼 동작에 의해 처리된 리얼 데이터와 상호 작용하여, 구현에서의 리얼 데이터 흐름을 분석하기 곤란하게 하는데 상기 구현을 획득하도록, 유인 동작 세트를 결합을 포함하는 리얼 동작 세트와 결합하는 단계; 및
   상기 구현을 상기 메모리에 저장되고 실행될 수 있는 결과적인 코드로 변환하는 단계;를 포함하는 것을 특징으로 하는 방법.
2. 제1항에 있어서,
   상기 알고리즘은 암호화 알고리즘이고, 상기 리얼 데이터는 비밀 데이터를 포함하는 것을 특징으로 하는 방법.
3. 제1항 또는 제2항에 있어서, 알고리즘을 확장하는 단계는,
   시뮬레이터에 의해 상기 원래의 소스 코드를 실행하고, 실행되는 동작, 일어나는 제어 흐름의 변화, 및 일어나는 메모리 변화를 레코딩하는 단계;
   상기 시뮬레이터에 의해 상이한 실행시간 입력으로 상기 원래의 소스 코드를 다수회 실행하고, 상기 실행 결과를 상기 리얼 동작 세트에 결합시키는 것에 의해 실행 동안 실행되지 않는 코드를 복원하는 단계; 및
   누락 코드를 상기 리얼 동작 세트에 주입하는 것에 의해 상기 시뮬레이터에 의해 실행 동안 실행되지 않는 상기 누락 코드를 조정하는 단계를 포함하는 것을 특징으로 하는 방법.
4. 제1항 내지 제3항 중 어느 한 항에 있어서, 알고리즘을 확장하는 단계는,
   상기 리얼 동작 세트의 동작들 사이에 데이터 의존성 및 상기 리얼 동작들 사이에 흐르는 데이터 값들을 모델링하는 데이터 의존성 그래프를 생성하는 단계를 포함하는 것을 특징으로 하는 방법.
5. 제3항 또는 제4항에 있어서, 알고리즘을 확장하는 단계는,
   리얼 데이터에 대한 동작을 포함하는, 정적으로-알려진 값을 생성하는 동작을 제거하여, 상기 리얼 데이터의 각 부분이 대부분 유도된 형태로만 존재하고, 결과적인 리얼 동작 세트에 가능한 한 깊이 전파되게 하는 단계를 포함하는 것을 특징으로 하는 방법.
6. 제3항 내지 제5항 중 어느 한 항에 있어서, 알고리즘을 확장하는 단계는,
   인라이닝(inlining) 및/또는 언롤링(unrolling)을 제거하는 것에 의해 획득된 이익 레벨 대(versus) 상기 제거하는 것에 의해 일어나는 리얼 데이터 전파의 손실 비용을 나타내는 함수 및 기본 블록에 대한 스코어를 배정하는 판정 모델을 사용하여,
   시뮬레이터에 의해 실행되는 것을 통해 생성된 리얼 동작의 세트의 인라인된 함수 코드 및 언롤링된 루프의 일부를 제거하는 것에 의해, 상기 인라인된 함수 코드 및 언롤링된 루프의 일부를 상기 원래의 소스 코드로부터의 함수 호출 및 루프로 대체하여서, 리얼 동작 세트의 사이즈를 감소시키는 단계를 포함하는 것을 특징으로 하는 방법.
7. 제1항 내지 제6항 중 어느 한 항에 있어서, 알고리즘을 확장하는 단계는,
   각 새로운 동작이 유도된 리얼 데이터의 일부를 사용하도록, 유도된 리얼 데이터를 수반하는 소스 코드의 원래의 동작들을 다수의 새로운 동작들로 분할하는 단계;
   상기 유도된 리얼 데이터의 일부를, 상기 유도된 리얼 데이터의 일부를 생성하는 고유한 동작 서브셋으로 변환하는 단계로서, 상기 동작 서브셋은 실행시간에 생성된 시퀀스에-민감한 데이터 값을 소비하는, 상기 변환하는 단계; 및
   상기 동작의 서브셋을 상기 리얼 동작의 세트에 삽입하는 단계를 포함하는 것을 특징으로 하는 방법.
8. 제1항 내지 제7항 중 어느 한 항에 있어서, 복제 및 변이된 유인 동작 세트를 생성하는 단계는,
   유인 동작 세트를 생성하도록 상기 확장 단계를 다수회 반복하는 단계를 포함하고, 여기서 각 유인 동작 세트는 상기 리얼 데이터 대신에 랜덤하게-생성된 데이터를 공급받고, 상기 알고리즘의 대안적인 위조 구현을 나타내는 유인 동작 세트를 생성하는 것을 특징으로 하는 방법.
9. 제1항 내지 제8항 중 어느 한 항에 있어서, 리얼 동작 세트와 유인 동작 세트를 결합시키는 단계는,
   각 세트로부터 오는 동작들을, 동작의 모든 다른 세트로부터 오는 동작들과 인터리브하여, 결합된 세트를 획득하여서, 상기 결합된 세트가 실행될 때 모든 동작 세트가 동시에 효과적으로 실행되도록 하는 단계; 및
   동작 그룹을 점진적으로 선택하는 것에 의해 상기 결합된 세트 내에 있는 상이한 세트로부터 오는 동작 데이터 흐름을 서로 융합하고, 각 출력을 올바른 수신 동작으로 전달하는 새로이-생성된 라우팅 동작을 통해 그 출력을 라우팅하는 단계를 포함하고, 상기 라우팅 동작은 실행시간에 생성된 시퀀스에-민감한 데이터 값을 소비하는 고유하게-생성된 불투명한 표현을 사용하여 구성되는 것을 특징으로 하는 방법.
10. 제1항 내지 제9항 중 어느 한 항에 있어서, 구현의 동작들은 작은 균일한 명령 세트로 표현되고, 상기 구현을 변환하는 단계는,
    잘 알려진 난독화 변환을 사용하여 상기 구현의 동작 시퀀스를 의미적으로-동등한 대안적인 형태로 변환하는 단계;
    새로운 명령을 포함하는 새로운 훨씬 더 큰 불균일한 명령 세트를 한정하기 위해 변환된 동작 시퀀스의 동작들을 결합시키는 단계로서, 상기 새로운 명령은 상기 새로운 명령을 생성하도록 결합된 상기 동작 시퀀스에 대응하는 개별 함수로 각각 한정된, 상기 동작들을 결합시키는 단계; 및
    상기 새로운 명령 세트의 명령에 각각 대응하는 동작들을 포함하는 변환된 구현을 획득하기 위해, 상기 새로운 명령 세트를 사용하여 상기 구현을 변환하는 단계를 포함하는 것을 특징으로 하는 방법.
11. 제1항 내지 제10항에 있어서, 구현을 변환하는 단계는,
    알고리즘을 실행하기 위해 올바른 시퀀스에서 그리고 올바른 데이터로 실행되는 동작을 야기하는 실행 제어 코드를 생성하는 단계를 포함하고, 상기 실행은 디코더 함수 세트에 의해 제어되고, 각 상기 디코더 함수는, 상기 동작을 실행하는데 요구되는 데이터의 장소, 및 대응하는 명령 함수의 장소, 및 각 디코더 함수에 고유하게 인코딩된 상기 데이터를 디코딩하는 방법을 알고 있는 하나의 동작과 연관된 것을 특징으로 하는 방법.
12. 제11항에 있어서,
    상기 디코더 함수는 실행시간에 생성된 시퀀스에-민감한 데이터 값을 소비하는 것을 특징으로 하는 방법.
13. 제1항 내지 제12항 중 어느 한 항에 있어서,
    상기 구현을 변환하는 단계는 복잡성 레벨의 함수로 난독화를 수행하는 단계를 포함하고, 변환 단계에서 이용가능한 모든 난독화는 상기 복잡성 레벨이 최대 값으로 설정될 때 수행되는 것을 특징으로 하는 방법.
14. 제1항 내지 제13항 중 어느 한 항에 있어서,
    비밀 데이터가 실행시간에만 알려진 경우 상기 알고리즘에 대해 새로운 화이트박스 구현을 생성하는 단계를 포함하고, 상기 생성하는 단계는, 정적인 키를 사용하는 복호화 알고리즘을 갖는 상기 구현을, 상기 정적인 키를 사용하여 미리-암호화된 동적 비밀 데이터를 사용하여 상기 새로운 화이트박스 구현에 결합시키는 단계를 포함하고, 상기 복호화 알고리즘은 상기 구현으로 전달되는 상기 동적 비밀 데이터를 복호화하는 것을 특징으로 하는 방법.
15. 제1항 내지 제13항 중 어느 한 항에 있어서,
    상기 암호화된 데이터의 내용을 드러내지 않고 암호화된 데이터에 데이터-처리 동작을 수행하는 새로운 화이트박스 구현을 생성하는 단계를 포함하고, 상기 생성하는 단계는, 복호화 알고리즘, 상기 구현, 및 암호화 알고리즘을 새로운 화이트박스 구현에 결합시키는 단계를 포함하고, 상기 복호화 및 암호화 알고리즘은 서로 역(inverse)이고 동일한 정적인 키를 사용하고, 이에 의해 상기 복호화 알고리즘은 처리될 데이터를 복호화하고, 상기 구현은 복호화된 데이터에서 동작하고 암호화 알고리즘은 데이터를 재-암호화하는 것을 특징으로 하는 방법.
16. 제1항 내지 제15항 중 어느 한 항에 있어서,
    구현을 포함하는 프로그램에 의해 의도된 것이 아닌 상황에서는 상기 구현이 사용되는 것을 방지하는 단계를 포함하고, 상기 방지하는 단계는,
    융합 제작자를 프로그램에 주입하는 단계로서, 상기 융합 제작자는, 랜덤하게-생성된 데이터 또는 리얼 데이터를 기존의 융합 데이터와 혼합하는 것에 의해, 상기 구현이 실행할 때 융합 데이터를 생성하는, 상기 융합 제작자를 프로그램에 주입하는 단계; 및
    융합 타깃을 구현에 주입하는 단계로서, 상기 융합 타깃은, 융합 데이터를 판독하고 상기 데이터를 상기 구현 내 동작에 의해 사용되는 정적 데이터와 결합시키고, 그리고 상기 동작에 의해 사용된 정적 데이터는 정적 데이터가 올바르지 않도록 변경되고, 상기 정적인 데이터가 상기 융합 데이터와 결합될 때에만 올바른 데이터가 생성되어서, 상기 융합 데이터에 의존하는 동작이 상기 프로그램을 실행하는 것에 의해 올바르게 생성되게 하고, 각 융합 데이터는 상기 융합 데이터를 변경하는데 필요한 상기 융합 제작자에게만, 및 상기 구현 내 상기 융합 타깃에게만 알려진 별개의 위치를 구비하는, 상기 융합 타깃을 구현에 주입하는 단계를 포함하는 것을 특징으로 하는 방법.
17. 제1항 내지 제16항 중 어느 한 항에 있어서,
    각 중간 데이터 요소를 난독화시키는 단계, 및 각 중간 데이터 요소를 상기 데이터 요소에 고유하고 상기 데이터 요소를 난독화시키는 방법을 지정하는 난독화 상황과 연관시키는 단계를 포함하는 것을 특징으로 하는 방법.
18. 제1항 내지 제17항 중 어느 한 항에 있어서,
    리얼 동작에 의해 나타나는 메모리 액세스 패턴을 마스킹하기 위해 추가적인 랜덤화된 메모리 액세스 동작을 상기 구현에 걸쳐 주입하는 단계를 포함하는 것을 특징으로 하는 방법.
19. 제1항 내지 제18항 중 어느 한 항에 있어서,
    리얼 동작에 의해 메모리에 액세스되는 리얼 데이터의 데이터 조각의 위치를 랜덤화하는 단계를 포함하는 것을 특징으로 하는 방법.
20. 디바이스에서 실행되도록 만들어지고, 제1항 내지 제19항 중 어느 한 항에 따른 방법을 프로그램에 적용하는 것에 의해 생성된 애플리케이션을 저장하는 비-일시적인 컴퓨터-판독가능한 매체.
21. 코드 형태로 표현된 알고리즘을 보호하는 디바이스로서, 상기 디바이스는 알고리즘의 보호된 구현을 생성하도록 제1항 내지 제19항 중 어느 한 항에 따른 방법을 구현하도록 구성된 디바이스.

Images