Algorithmic Information Theory for Obfuscation Security

Rabih Mohsen

and Alexandre Miranda Pinto

2, 3

Department of Computing, Imperial College London, London, U.K.

Information Security Group, Royal Holloway University of London, Egham, U.K.

Instituto Universit´ario da Maia, Maia, Portugal

Keywords:

Code Obfuscation, Kolmogorov Complexity, Intellectual Property Protection.

Abstract:

The main problem in designing effective code obfuscation is to guarantee security. State of the art obfuscation

techniques rely on an unproven concept of security, and therefore are not regarded as provably secure. In this

paper, we undertake a theoretical investigation of code obfuscation security based on Kolmogorov complexity

and algorithmic mutual information. We introduce a new deﬁnition of code obfuscation that requires the algo-

rithmic mutual information between a code and its obfuscated version to be minimal, allowing for controlled

amount of information to be leaked to an adversary. We argue that our deﬁnition avoids the impossibility

results of Barak et al. and is more advantageous then obfuscation indistinguishability deﬁnition in the sense it

is more intuitive, and is algorithmic rather than probabilistic.

1 INTRODUCTION

Malicious reverse engineering represents a great risk

to software conﬁdentiality, especially for software

that runs on a malicious host controlled by a software

pirate intent on stealing intellectual artifacts. Thwart-

ing vicious reverse engineering, using software pro-

tection techniques such as code obfuscation, is vi-

tal to defend programs against malicious host attacks.

An obfuscating transformation attempts to transform

code so that it becomes unintelligible to human and

automated program analysis tools, while preserving

their functionality. It is a low-cost technique that does

not affect portability and has promise for defending

mobile programs against malicious host attacks.

One of the major challenges of code obfuscation

is the lack of a rigorous theoretical background. The

absence of a theoretical basis makes it difﬁcult to for-

mally analyse and certify the effectiveness of these

techniques against malicious host attacks. In particu-

lar, it is hard to compare different obfuscating trans-

formations with respect to their resilience to attacks.

Often, obfuscation transformation techniques are pro-

posed with no provable properties presented.

Software developers strive to produce structured

and easy to comprehend code, their motivation is to

simplify maintenance. Code obfuscation, on the other

hand, transforms code to a less structured and intel-

ligible version. It produces more complex code that

looks patternless, with little regularity and is difﬁcult

to understand. We argue that irregularities and noise

makes the obfuscated code difﬁcult to comprehend.

Kolmogorov complexity (Li and Vit´anyi, 2008) is a

well known theory that can measure regularities and

randomness. The size of the shortest program that de-

scribes a program tendsto be bigger as more noise and

irregularities are present in a program. Kolmogorov

complexity is the basic concept of algorithmic infor-

mation theory, that in many respects adapts the view-

point of well-established Information Theory to focus

on individual instances rather than random distribu-

tions. In general, algorithmic information theory re-

places the notion of probability by that of intrinsic

randomness of a string.

Kolmogorov complexity is uncomputable; how-

ever it can be approximated in practice by loss-

less compression (Kieffer and Yang, 1996) (Li and

Vit´anyi, 2008), which helps to intuitively understand

this notion and makes this theory relevant for real

world applications. Our aim in this paper is to provide

a theoretical framework for code obfuscation in the

context of algorithmic information theory: to quanti-

tatively capture the security of code obfuscation, to

discuss its achievability and to investigate its limita-

tions and resilience against an adversary.

We introduce the notion of unintelligibility to de-

ﬁne confusion in code obfuscation and argue this is

not good enough. We then propose our notion of se-

Mohsen R. and Miranda Pinto A..

Algorithmic Information Theory for Obfuscation Security.

DOI: 10.5220/0005548200760087

In Proceedings of the 12th International Conference on Security and Cryptography (SECRYPT-2015), pages 76-87

ISBN: 978-989-758-117-5

 2015 SCITEPRESS (Science and Technology Publications, Lda.)

curity and compare both deﬁnitions. We argue that

our model of security is fundamentally different from

the virtual black-box model of Barak et al., and that

because of this their impossibility result does not ap-

ply. Then, we show that under reasonable conditions

we can have secure obfuscation. Finally, we study the

security of two main approaches to obfuscated code

in software, encoding and hiding, at the subprogram

level.

To the best of our knowledge, this paper is the

ﬁrst to propose algorithmic information theory as a

theoretical basis for code obfuscation and its threat

model; we believe our work is the ﬁrst step to derive

consistent metrics that measure the protection quality

of codeobfuscation. The framework can be applied to

most code obfuscation techniques and is not limited to

any obfuscation method or language paradigm.

Paper structure: In Section 2, we provide an

overview of related work. Section 3 provides the pre-

liminaries and the required notations. In Sections 4,

we discuss the intuition behind our approach, propose

the formal deﬁnition of code obfuscation and present

some results for security code obfuscations against

passive attackers. In section 5, we study the secu-

rity of two main approaches to code obfuscation at

the subprogram level. Section 6 concludes with the

proposed future work.

2 RELATED WORK

Collberg et al. (Collberg et al., 1997) were the ﬁrst to

deﬁne obfuscation in terms of a semantic-preserving

transformation. Barak et al. (Barak et al., 2001) in-

troduced a formal deﬁnition of perfect obfuscation in

an attempt to achieve well-deﬁned security, which is

based on the black-box paradigm. Intuitively, a pro-

gram obfuscator O is called perfect if it transforms

any program P into a virtual black box O (P ) so that

anything that can be also efﬁciently computed from

O(P ), can be efﬁciently computed given just oracle

access to P . However, they also proved that the black-

box deﬁnition cannot be met byshowing the existence

of set of functions that are impossible to obfuscate.

On the other hand, a recent study conducted by Garg

et al (Garg et al., 2013) provided positive results, us-

ing indistinguishability obfuscation, for which there

are no known impossibility results. However, as ar-

gued by (Goldwasser and Rothblum, 2007) there is

a disadvantage of indistinguishability obfuscation: it

does not give an intuitive guarantee about the security

of code obfuscation.

3 PRELIMINARIES

We use the U as the shorthand for a universal Tur-

ing machine, x for a ﬁnite-length binary string and ∣x∣

for its length. We use ǫ for a negligible value, and Λ

for an empty string. We use the notation O(1) for a

constant, p(n) for a polynomial function with input

n ∈ N. ∥ is used to denote the concatenation between

two programs or strings.

P is a set of binary programs and P

′

is a set

of binary obfuscated programs, L = {λ

∶ λ

∈

{0, 1}

, n ∈ N} is a set of (secret) security parame-

ters used in the obfuscation process

. A = {A

}

n∈N

represents a set of adversaries (deobfuscators) where

an adversary A ⊆ A uses a set of deobfuscation tech-

niques (e.g. reverse engineering); the term adversary

is used interchangeably with deobfuscator.

We consider only the preﬁx version of Kol-

mogorov complexity (preﬁx algorithmic complexity)

which is denoted by K(.). Complexity and Kol-

mogorov complexity terms are sometimes used inter-

changeably; for more details on preﬁx algorithmic

complexity and algorithmic informationtheory, we re-

fer the reader to (Li and Vit´anyi, 2008). The necessary

parts of this theory are brieﬂy presented in the follow-

ing.

Deﬁnition 1. Let U(P ) denote the output of U when

presented with a program P ∈ {0, 1}

1. The Kolmogorov complexity K(x) of a binary

string x with respect to U is deﬁned as:

K(x) = min{∣P ∣ ∶ U (P ) = x}.

2. The ConditionalKolmogorovComplexity relative

to y is deﬁned as:

K(x ∣ y) = min{∣P ∣ ∶ U(P, y) = x}.

Deﬁnition 2. Mutual algorithmic information of two

binary programs x and y is given by

(x; y) = K(y) − K(y ∣ x).

Theorem 1 (chain rule (G´acs, 1974)). For all x, y ∈ N

1. K(x; y) = K(x)+K(y ∣ x) up to an additive term

O(log K(x, y)).

2. K(x)−K(x ∣ y) = K(y)−K(y ∣ x) i.e. I

(x; y) =

(y; x), up to an additive term O(log K(x, y)).

Logarithmic factors like the ones needed in the

previous theorem are pervasive in the theory of Kol-

mogorov complexity. As commonly is done in the

literature, we mostly omit them in our results, making

a note in the theorem statements that they are there.

This also “hides” smaller constant terms, and for this

reason we regularly omit them in the derivations.

The security parameter may include the obfuscation

key, the obfuscation transformation algorithm or any nec-

essary information that the obfuscation function can use.

AlgorithmicInformationTheoryforObfuscationSecurity

Deﬁnition 3. The Mutual algorithmic information of

two binary strings x and y conditioned to a binary

string z is deﬁned as: I(x; y∣z) = K(y∣z)− K(y∣x, z)

Theorem 2 ((Li and Vit´anyi, 2008)). There is a con-

stant c such that for all x and y

K(x) ≤ ∣x∣ + 2 log ∣x∣ + c and K(x ∣ y) ≤ K(x) + c.

Theorem 3 ((Shen, 1982; Taveneaux, 2011)). Given

a recursive computable function f ∶ {0, 1}

∗

→

{0, 1}

∗

, for all x the algorithmic information content

of f (x) is bounded by: K(f(x)) ≤ K(x) + O(1).

Theorem 4 ((Shen et al., 2014)). Given a recursive

computable function f ∶ {0, 1}

∗

× {0, 1}

∗

→ {0, 1}

∗

for any strings x, y the algorithmic information con-

tent of f (x, y) is bounded by:

K(f(x, y)∣y) ≤ K(x∣y) + O(1).

If we are aware that x belongs to a subset S of

binary strings, then we can consider its complexity

K(x∣S). Also, we can measure the level of random-

ness (irregularities) using randomness deﬁciency.

Deﬁnition 4. (Li and Vit´anyi, 2008) The randomness

deﬁciency of x with respect to a ﬁnite set S containing

x is deﬁned as δ(x∣S) = log #S − K(x∣S).

Lemma 5. (Li and Vit

anyi, 2008) Let S be an enumer-

able binary set of programs such that x ∈ S, Then,

K(x) ≤ K(S) + log #S + O(1)

4 CODE OBFUSCATION USING

KOLMOGOROV COMPLEXITY

4.1 Motivation

The main purpose of code obfuscation is to confuse

an adversary, making the task of reverse engineer-

ing extremely difﬁcult. Code obfuscation introduces

noise and dummy instructions that produce irregular-

ities in the targeted obfuscated code. We believe that

these make the obfuscated code difﬁcult to compre-

hend. Classical complexity metrics have a limited

power for measuring and quantifying irregularities in

obfuscated code, because most of these metrics are

designed to measure certain aspects of code attributes

such as ﬁnding bugs and code maintenance. Human

comprehension is a key in this case; an adversary has

to understand the obfuscated code in order to recover

the original. Measuring code obfuscation has to take

into consideration this human factor. Although mea-

suring code comprehension is very subjective, there

were some successful attempts to measure human cog-

nitive reasoning and cognitive science based on Kol-

mogorov complexity (Gauvrit et al., 2011).

Code regularity (and irregularity) can be quanti-

ﬁed, as was suggested in (Lathrop, 1997) and (Jbara

and Feitelson, 2014), using Kolmogorov complexity

and compression. Code regularity means a certain

structure is repeated many times, and thus can be rec-

ognized. Conversely, irregularities in code can be ex-

plained as the code exhibiting different types of struc-

ture over the code’s body. Regularities in programs

were introduced by Jbara et al. in (Jbara and Feitel-

son, 2014) as a potential measure for code compre-

hension; they experimentally showed using compres-

sion that long regular functions are less complex than

the conventional classical metrics such as LOC (Line

of Code) and McCabe (Cyclomatic complexity) could

estimate.

The main intuition behind our approach is based

on the following argument: if an adversary fails to

capture some patterns (regularities) in an obfuscated

code, then the adversary will have difﬁculty com-

prehending that code: it cannot provide a valid and

brief, i.e., simple description. On the other hand, if

these regularities are simple to explain, then describ-

ing them becomes easier, and consequently the code

will not be difﬁcult to understand.

We demonstrate our motivation using the example

in Fig. 1. We obfuscate the program in Fig. 1-(a) that

calculates the sum of the ﬁrst n positive integers, by

adding opaque predicates

with bogus code and data

encoding. If we apply Cyclomatic complexity (Mc-

Cabe (McCabe, 1976)), a classical complexity mea-

sure, to Fig. 1-(b) the result will be 6. Cyclomatic

complexity is based on control ﬂow graph (CFG), and

is computed by: E − N + 2, where E is the number of

edges and N is the number of nodes in CFG. Fig. 1-

(b) contains N = 8 nodes, E = 13 edges then the

Cyclomatic complexity is (13 − 8 + 2) = 7. We can

see some regularity here: there is one opaque predi-

cate repeated three times. Furthermore, the variable

y is repeated three times in the same place of the If-

branch. We conjecture that we can ﬁnd the short de-

scription of the program in Fig. 1-(b), due to presence

of regularity by using lossless compression.

We take another obfuscated version in Fig. 1-(c)

(of the same program); this code is obfuscated by

adding three different opaque predicates. The patterns

are less in this version comparing to Fig. 1-(b); the

shortest program that describes Fig. 1-(c) is likely to

be very similar to the code itself, where the Cyclo-

An opaque predicate is an algebraic expression which

always evaluates to same value (true or false) regardless of

the input.

SECRYPT2015-InternationalConferenceonSecurityandCryptography

while(i<n){

i=i+1;

x=x+i;}

(a) Sum code

while(i<n){

i=i+1;

if (7

y-1==x

x){ //false

y=x

else

x=x+4

i;}

if (7

y-1==x

x){

y=x

else

x=x-2

i;}

if (7

y-1==x

x){

y=x

else

x=x-i;}}

(b) One opaque predicate

while(i<n){

i=i+1;

if (7

y-1==x

x){ //false

y=x

(i+1);

else

x=x+4

i;}

if (x

x-34

y==-1){ //false

y=x

else

x=x-2

i;}

if ((x

x+x)mod 2==0){ //true

x=x-i;

else

y=x

(i-1);}}

Figure 1: Obfuscation example: (a) is the original code for the sum of n integers; (b) is an obfuscated version of (a) with one

opaque predicate and data encoding which has some patterns and regularities; (c) is another obfuscated version of (a) with

three opaque predicate and data encoding, which has less patterns and regularities comparing to (b).

matic complexity is the same 7, and it does not ac-

count for the changes that occurred in the code. As-

suming the opaque predicates of Fig. 1-(c) are equally

difﬁcult to break, attacking this code requires at least

twice more effort than the code in Fig. 1-(b), as we

need to ﬁgure out the value of two more opaque pred-

icates. Furthermore, Fig. 1-(b) can be compressed at

higher rate than Fig. 1-(c); again, this is due to the

inherent regularity in Fig. 1-(b).

We argue that an obfuscated program which is se-

cure and confuses an adversary will exhibit a high

level of irregularity in its source code and thus require

a longer description to characterize all its features.

This can be captured by the notion of Kolmogorov

Complexity, which quantiﬁes the amount of informa-

tion in an object. An obfuscated program will have

more non-essential information, and thus higher com-

plexity, than a non-obfuscated one. Thus, we can use

Kolmogorov Complexity to quantify the level of con-

fusion in obfuscated programs due to the obfuscation

process.

4.2 Applying Kolmogorov Complexity

to Code Obfuscation

In this section, we present a novel approach for code

obfuscation based on notions from algorithmic infor-

mation theory. We start with an intuitive deﬁnition

that is inspired by practical uses of obfuscation. The

rationale behind this deﬁnition is that an obfuscated

program must be more difﬁcult to understand than the

original program. This uses the separate notion of c -

unintelligibility:

Deﬁnition 5. A program P

′

is said to be c-

unintelligible with respect to another program P if it

is c times more complex than P , i.e. the added com-

plexity is c times the original one, and thus more dif-

ﬁcult to understand. Formally:

K(P

′

) ≥ (c + 1)K(P ),

for some constant c > 0.

Deﬁnition 6. A c-Obfuscator O ∶ P × L → P

′

is a

mapping from programs with security parameters L

to their obfuscated versions such that ∀P ∈ P, λ ∈

L . O(P, λ) ≠ P and satisﬁes the following proper-

ties:

• Functionality: O(P, λ) and P compute the same

function.

• PolynomialSlowdown: the size and runningtime

of O(P, λ) are at most polynomially larger than

the size andrunningtime of P , i.e. for polynomial

function p. ∣O(P, λ)∣ ≤ p(∣P ∣), and if P halts in

k steps on an input i, then O(P, λ) halts within

p(k) steps on i.

• Unintelligibility: O(P, λ) is c-unintelligible with

respect to P .

It is interesting to ask to what extent unintelligibil-

ity is related to the quality of the obfuscation parame-

ter λ. Is a large λ necessary for high unintelligibility?

Is it sufﬁcient?

We answer the ﬁrst question in the positive by

showing that c-unintelligibility sets a lower bound on

the size of λ.

Lemma 6. Consider a program P and an obfuscated

version P

′

= O(P, λ) such that P

′

is c-unintelligible

with respect to P . Then, ∣λ∣ ≥ cK(P ) − O(1).

AlgorithmicInformationTheoryforObfuscationSecurity

Proof. By assumption, K(O(P, λ)) ≥ (c + 1)K(P ).

To compute P

′

, we only need P , λ and the obfuscator

program O and so we can upper bound K(P

′

K(P ) + K(λ∣P ) + K(O) ≥ K(O(P, λ))

≥ (c + 1)K(P )

⇒ K(λ∣P ) ≥ cK(P ) − K(O).

Assuming the obfuscator program is simple, that

is, K(O) = O(1), we have by basic properties of

Kolmogorov complexity: ∣λ∣ ≥ K(λ) ≥ K(λ∣P ) ≥

cK(P ) − O(1).

To answer the second question, we show a counter-

example. So far, we have not addressed the nature

of O and how well it uses its obfuscation parameter.

It could well be the case that O only uses some bits

of λ to modify P . In an extreme case, it can ignore

λ altogether and simply return O(P, λ) = P . The

result satisﬁes the ﬁrst two properties of an obfusca-

tor, but can be considered unintelligible only in the

degenerate case for c = 0 and surely we would not

call the resulting code obfuscated. Another extreme

case is when λ = P . Now, we would have at most

K(O(P, λ)) ≤ K(P ) + K(O) + O(1) which again

would lead to a very small c. These two cases, al-

though extreme, serve only to show that the quality

of an obfuscator depends not only on λ but also on

the obfuscation algorithm itself, O. This is addressed

later in Theorem 12.

Deﬁnition 6 is perhaps the ﬁrst natural deﬁnition

one can ﬁnd, but it has one shortcoming. Merely re-

quiring the obfuscated program to be complex overall

does not mean that it is complex in all its parts, and

in particular, that it hides the original program. To

illustrate this point, consider the following example.

Example 1. Consider an obfuscated program P

′

O(P, λ) = P ∥ λ, which is a simple concatenation of

P and λ. Deﬁne n = ∣P

′

∣. We know K(P ∥ λ) ≃

K(P, λ) within logarithmic precision (see (Li and

Vit

anyi, 2008) page 663). Then, by applying the chain

rule of Theorem 1, K(P

′

) = K(P ∥ λ) ≃ K(P ) +

K(λ∣P ) + O(log n). For large λ independent of P ,

this might signify a large unintelligibility, but the orig-

inal program can be extracted directly from the ob-

fuscated version requiring only O(log n) to indicate

where P ends and λ starts.

This leads us to our second deﬁnition, where we

require not that the obfuscated program be more com-

plex than the original but rather, that it reveal almost

no information about the original. This is captured by

the notion of algorithmic mutual information and can

be stated formally as:

Deﬁnition 7. Consider a program P and its obfus-

cated program P

′

= O(P, λ). We say P

′

is a γ-secure

obfuscationof P if the mutual information betweenP

and P

′

is at most γ, that is:

(P ; O(P, λ)) ≤ γ.

We say P

′

is a secure obfuscation of P if is γ-

secure and γ is negligible.

It is common to consider, in the literature about

Kolmogorov Complexity, that logarithmic terms are

negligible. Thus, if both P and P

′

have lengths of

order n, we migth consider that P

′

would be a secure

obfuscation for γ = log n. This intuition, however, is

bound to fail in practice.

Programs are typically redundant, written in very

well-deﬁned and formal languages, with common

structures, design patterns, and even many helpful

comments. It is expected that the complexity of a non-

obfuscated program be low, compared to its length.

Consider then the case that for a given P and n = ∣P ∣

we have K(P ) = O(log n). Consider a scenario like

that of Example 1, where the obfuscated reveals the

original program and so the mutual information be-

tween both programs is maximum, i.e.,

(P ; O(P, λ)) = K(P ) − O(log n) = O(log n).

Even though this obfuscation can not be considered

secure, the resulting mutual information is so small

that Deﬁnition 7 would declare it secure. We have

two ways out of this:

• we do not consider programs with K(P ) =

O(log n), since this is the error margin of the im-

portant propertiesof Kolmogorovcomplexity, and

at this level we can not achieve signiﬁcant results;

• or we consider a relative deﬁnition of security,

requiring that the mutual information be only at

most a negligible fraction of the information in P .

The second option leads us to the following deﬁni-

tion:

Deﬁnition 8. Consider a program P and its obfus-

cated program P

′

= O(P, λ). We say P

′

is a ǫ-secure

obfuscation of P if the mutual information between

P and P

′

is at most ǫK(P ), that is:

(P ; O(P, λ)) ≤ ǫK(P ),

for 0 ≤ ǫ ≤ 1.

We say P

′

is a secure obfuscation of P if is ǫ-

secure and ǫ is negligible in some appropriate sense.

The next proposition provides an example of how

to test the security of an obfuscated code against an

adversary.

Proposition 1. Consider a clear program P of length

n with K(P ) ≥ n−O(log n) and A an adversary that

extracts at least m ≤ n consecutive bits of P from

′

= O(P, λ) then:

SECRYPT2015-InternationalConferenceonSecurityandCryptography

1. K(P ∣P

′

) ≤ n − m + O (log n).

2. I

(P ; P

′

) ≥ m − O(log n)

Proof. We prove this proposition by building the fol-

lowing algorithm:

Algorithm:

• Build A of length O(1).

• Compute A(P

′

), we obtain m ≤ n bits of P . De-

note these by string ω.

• Now, build a program β such that P = β(ω)

which computes two blocks of bits: those that

come before and those that come after ω.

To produceP , β needs at most to producea pair of

two strings (s

, s

) with combined length n − m.

To describe the pair, we need at most O(lo g n)

bits saying where to divide s

from s

. Thus,

K(β) ≤ n − m + O(log n).

By construction,K(P ∣O(P, λ))+O(1) ≤ K(β)+

O(1) ≤ n−m+O(log n). Using the assumption about

K(P ), it is straight forward to compute

(P ; P

′

) ≥ m − O(log n)

On the other hand, the adversary can fully obtain

P , with only a logarithmic error, if it knows λ the

security parameter, as the next theorem shows.

Theorem 7. Let P

′

= O(P, λ), for an adversary A

who knows λ:

1. K(P ∣P

′

, λ) = O(log n).

2. I

(P, P

′

∣λ) = K(P ∣λ) − O(log n).

where n is the maximum length of P, P

′

and λ.

Proof. If λ contains all the knowledge that A requires

to obtain P given P

′

, then the shortest program for a

universal Turing machine U that describes P given

A, P

′

and λ, is negligible i.e. empty string. It is suf-

ﬁcient for U to describe P from A, P

′

and λ with no

need of any extra programs i.e. U(Λ, A(P

′

), λ) = P

where Λ is an empty string. O(log n) is needed as an

overhead cost required by U to combine A, P

′

and λ

and to locate them on U tape. The advantage of A

given λ is obtained as follows:

(P ; P

′

∣λ) = K(P ∣λ) − K(P ∣P

′

, λ)

= K(P ∣λ) − O(log n)

These results are not surprising. Intuitively, an ad-

versary can easily recover the original code from the

obfuscated version once the security parameter that is

used for obfuscation is known.

4.3 On the Impossibility of Obfuscation

There exist other deﬁnitions of obfuscation in the lit-

erature. Of particular importance to us is the work of

(Barak et al., 2012), due to its famous impossibility

result. As the authors argue in that paper, the black-

box model they propose for obfuscation is too strong

to be satisﬁable in practice.

The black-box model considers a program

P ob-

fuscated if any property that can be learned from P

can also be obtained by a simulator with only oracle

access to P . This essentially states that P does not

give any particular information about that property,

since it is possible to learn it without having access

to P . Notice that this model does not compare an ob-

fuscated program with an original one, but rather with

its functionality.

This is different from the deﬁnitions that we have

proposed so far. Our deﬁnitions canbe used to capture

this purpose, namely, measuring how much informa-

tion a programP gives about the functionit computes,

which we denote by JP K.

It sufﬁces to note that every function F has a min-

imal program for it, say, Q. Then, its Kolmogorov

complexity is the size of Q and for every other pro-

gram P computing F we have

K(F ) = ∣Q∣ ≤ ∣P ∣.

For every such program it must be that K(F ) ≤

K(P ) + O(1), otherwise we could build a program R

of size K(P ) that produced P and then ran in succes-

sion R and U (R).

This composition of programs is

itself a programwith complexity K(P )+O(1) which

would be smaller than the assumed minimal program

F , i.e., a contradiction. Therefore, our deﬁnition can

be changed to compare the obfuscated program not

with any simpler program but with the simplest pro-

gram computing the same function.

Deﬁnition 9. Consider a program P

′

. We say P

′

ǫ-securely obfuscated if

(JP

′

K; P

′

) ≤ ǫK(JP

′

K),

for 0 ≤ ǫ ≤ 1.

We say P

′

is a secure obfuscated program if is ǫ-

secure and ǫ is negligible.

We believe our deﬁnitions of obfuscation differ

from the simulation black-box model in important

ways, and that because of this they avoid the impos-

sibility result of (Barak et al., 2012).

Or rather, a circuit or a Turing machine representation

thereof.

That is, we run R to produce P then we execute the

result of this ﬁrst execution, that is P itself.

AlgorithmicInformationTheoryforObfuscationSecurity

Our deﬁnition is a less stringent form of obfusca-

tion rather than a weak form of black box obfusca-

tion. We assume the functionality of an obfuscated

program is almost completely known and available to

an adversary, and only require hiding the implementa-

tion rather than the functionality itself. This approach

to obfuscation is very practical and pragmatic, espe-

cially for software protection obfuscation, as usually

the customer likes to know exactly what a product

does, although s/he might not care about how it was

implemented.

Our deﬁnition for security takes a program P

(clear code), which supposedly is an easy and smart

implementation of functionality F , and compares it

with P

′

, which is a different and supposedly unintel-

ligible implementation of F , such that the original P

can not be perceived or obtained from P

′

. The de-

fenders’ aim is not to prevent an adversary from un-

derstanding or ﬁnding F , but to prevent her/him from

ﬁnding their own implementations P .

This intuition best matches the idea of best possi-

ble obfuscation which was advanced by Goldwasser

and Rothblum (Goldwasser and Rothblum, 2007).

According to (Goldwasser and Rothblum, 2007) an

obfuscator O is considered as best possible if it trans-

forms a program P so that any property that can

be computed from the obfuscated program P

′

, can

also be computed from any equivalent program of the

same functionality. However, despite the close intu-

itive correspondence, our deﬁnition also differs from

best possible obfuscation, in the sense that it relies on

some form of black-box simulation. It was proved in

(Goldwasser and Rothblum, 2007) that best possible

obfuscation has a strong relation with indistinguisha-

bility obfuscation (Barak et al., 2001) (Garg et al.,

2013), if O is an efﬁcient obfuscation i.e. run in poly-

nomial time.

In contrast, the black box model deﬁnition re-

quires that all properties of a given obfuscated pro-

gram P must be hidden from any adversary that ig-

nores its source code but has access to at most a poly-

nomial number of points of JP K.

1. We can see that in our case, the adversary knows

more about the functionality. Since the function-

ality is mostly public, this would be equivalent to

giving the simulator in the black-box model ac-

cess to this extra knowledge, reducing the advan-

tage of the adversary and possibly making some

functions obfuscatable.

2. On the other hand, our deﬁnition allows the leak-

age of a small, but non-zero, amount of informa-

tion. Compare with the black-box model where

a single-bit property that is non-trivially com-

puted by an adversary, renders a function un-

obfuscatable. Our deﬁnition requires the adver-

sary to be able to compute more than a few bits in

order for obfuscation to be broken.

3. Our deﬁnition considers only deterministic adver-

saries, again making adversaries less powerful

and reducing their advantage.

We can try to model the implications for our def-

inition of a successful black-box adversary against

obfuscation. Consider an adversary A attacking a

predicate π by accessing an algorithm A , such that

A(P

′

) = 1 if and only P

′

satisﬁes π. In this case,

A is able to compute 1 bit of information about P

′

and we want to measure how much this helps A in

describing some simpler program P that implements

the same function JP

′

Since the adversary A knows A, s/he can enumer-

ate the set S of all programs that satisfy A. Then,

for some program P ∈ S, we would have K(P ∣A) ≤

K(S∣A) + log ∣S∣.

Note that the set S may be inﬁnite, and so enu-

meration is the best that can be done: we enumerate

all relevant programs and run A with each of them,

noting the result. We could try to avoid this inﬁnity

problem by noticing we are only interested in pro-

grams simpler than the original, and thus satisfying

K(P ) ≤ K(P

′

) ≤ ∣P

′

∣. This does not give abso-

lute guarantees, since in general there are programs

with ∣P ∣ > ∣P

′

∣ and K(P ) ≤ K(P

′

), but our hope is

that these are few and far between as they increase

in length. Thus, even if we make this assumption

and disregard a whole class of possibly relevant pro-

grams, we still have in the order of 2

specimens.

If A were a deterministic algorithm, we would have

K(S∣A) = O(1), and if S has less than a half of

all possible programs, then indeed we would ﬁnd that

K(P ∣A) ≤ K(S∣A) + log ∣S∣/2 ≤ n − 1.

However, A is randomized, and in order to accu-

rately produce S, for each program q, A must be run

with a set of random coins r such that A(q, r) ⇔

q ∈ S. One way to describe S from A would need

a polynomial number of bits for each program in S.

Now, we no longer have the comfort of a negligi-

ble K(S∣A) term, and we can no longer be sure that

knowing this property would in any way reduce the

complexity of our target program.

We can still try to go around this problem, by al-

lowing our enumerator to list not only all programs

but also all possible random strings, and choosing the

majority vote for each program. The length, and there-

fore the number, of possible random strings is bound

by the running time of the program, which in turn is

bound by a function of its length. Therefore, if we

limit the length of our programs we limit the number

SECRYPT2015-InternationalConferenceonSecurityandCryptography

of random strings to search

This would eliminate the necessity of considering

the extra information due to the random coins, but on

the other hand the running time would increase ex-

ponentially. Any successful adversary would be very

different to the PPT adversaries of (Barak et al., 2001),

and althoughour deﬁnition has been made, for ease of

exposition, with unbounded Kolmogorov complexity

(for unbounded adversaries), it is easy to change it to

consider polynomially-bounded adversaries by using

an alternative deﬁnition of mutual information:

∗

(P ; P

′

) = K(P ) − K

t()

(P ∣P

′

where t() is a polynomial on the length of P

′

that acts

as a hard limit to the number of steps the universal

machine can be run for.

This notion of information can be negative in

some cases, but clearly limits the ability of any ad-

versary trying to ﬁnd P from P

′

in a consistent way

with the black-box model. With this deﬁnition of

obfuscation, the above reasoning would lead to ex-

amples where non-obfuscatability by the black-box

model does not prevent obfuscatability in the algorith-

mic information-theoretic model.

4.4 Security and Unintelligibility

Our ﬁrst attempt to characterize obfuscation was

based on unintelligibility, and then we evolved to a

notion of security based on mutual information. The

ﬁrst notion seemed more immediately intuitive, tra-

ditional obfuscation techniques seem to rely only on

making the code as complex as possible in an attempt

to hide its meaning. But precisely this notion of “hid-

ing meaning” is nothing more than reducing the infor-

mation that the obfuscated program leaks about the

original one, and so we believe the second approach

to be the correct one. However, we can ask the natural

question: is there any relation between these two con-

cepts? Does high unintelligibility imply high security,

or vice-versa?

We give a partial answer to this question. In cer-

tain situations, high unintelligibility will imply high

security, as stated in the following theorem.

Theorem 8. Consider a program P of length m and

its obfuscated version P

′

= O(P, λ) of length n > m

(where n is at most polynomially larger than m), sat-

isfying c-unintelligibility for c ≥

K(P )

. Assuming

that the obfuscation security parameter λ satisﬁes

K(P

′

∣P ) ≥ K(λ∣P ) − α, then up to O(log n):

I(P ; O(P, λ)) ≤ α − O(1)

Conversely, if we really want to enumerate all pro-

grams, then we also have to enumerate an inﬁnite number

of random strings.

\\ variable that holds authentication

password

string user-Input = input();

string secure-password = ...;

if secure-password == user-Input {

grant-access();

else

deny-access();}

P : simple password checker

string O@ = x0();

string $F=...;

if O@== $F{

x1();

else

x2(); }

′

: obfuscating P

Figure 2: An example for obfuscating a program using re-

naming technique.

Proof. By Theorem 3, K(P

′

) = K(O(P, λ)) ≤

K(P, λ) + K(O) = K(P, λ)

and by assumption

K(P

′

) ≥ (c + 1)K(P ). Then,

K(P, λ) ≥ (c + 1 )K(P )

K(P, λ) − K(P ) ≥ cK(P )

K(λ∣P ) ≥ cK(P )

Now, for mutual information, we have

I(P ; P

′

) = K(P

′

) − K(P

′

∣P )

≤ K(P

′

) − K(λ∣P ) + α (by assumption)

≤ n − cK(P ) + α

≤ n − n + α (by assumption)

= α

Intuitively, if we consider an optimal obfuscation

key (it has all the information needed to produce P

′

from P , but not much more than that), we can say that

if P

′

is c-unintelligible for large enough c, then P

′

a secure obfuscation of P .

The above theorem shows when high c-

unintelligibility implies security of code obfuscation.

It turns out that the reverse implication does not exist,

as the following theorem illustrates.

Claim 9. There are obfuscated functions O(P, λ)

that are arbtrarily secure and yet do not satisfy c-

unintelligibility for c ≥ 0.

The O(1) term is absorbed by the logarithmic additive

term that we are not notating

AlgorithmicInformationTheoryforObfuscationSecurity

Proof. Consider ﬁrst the case of program P of Fig. 2,

that simply checks a password for access, and its ob-

fuscated version P

′

, which was computed using lay-

out obfuscation (Collberg et al., 1997): variable and

function renaming and comment deleting. The obfus-

cated variable and function names are independent of

the original ones and so the information that P

′

con-

tains about P is limited to the unchanging structure of

the code: assignment, test and if branch.

The complexity of the original code can be bro-

ken in several independent parts: the comment, the

structure, the variable and function names, and there-

fore we can write K(P ) = n

+ n

. The only

thing that P

′

can give information about is the struc-

ture part, since all the other information was irrevoca-

bly destroyed in the process: there is no data remain-

ing that bears any relation to the lost comment or the

lost function names. Therefore, I

(P ; P

′

) ≤ n

K(P ). We can make the fraction

as small as necessary by inserting large comments,

long names and representing structure as compactly

as possible, for example, keeping names in a dictio-

nary block and indicating their use by pointers to this.

However the complexity of P

′

is less than that

of P , since there is less essential information to de-

scribe: the same structure, no comments and the func-

tion names could be described by a simple algorithm.

Therefore, we have that c-unintelligibility can not be

satisﬁed for any non-negative value of c. This shows

that high ǫ-security does not imply high unintelligibil-

ity.

The next theorem shows how we can obtain se-

curity if the obfuscated code is complex enough and

the obfuscation key is independent of the original pro-

gram.

Theorem 10. Let P be a program of length n and λ

an independent and random obfuscation key, satisfy-

ing K(λ) ≥ n − α and K(P, λ) ≥ K(P ) + K(λ) − β,

where α, β ∈ N. Suppose the obfuscation O(P, λ) sat-

isﬁes K(O(P, λ)∣P ) ≥ K(λ∣P ) − O(1). Then up to

a logarithmic factor:

(P ; O(P, λ)) ≤ α + β

Proof.

(P ; O(P, λ)) = K(O(P, λ)) − K(O(P, λ)∣P )

≤ K(O(P, λ)) − K(λ∣P )

Applying Theorem 1

≤ K(O(P, λ)) − K(λ, P ) + K(P )

≤ n − K(P ) − n + α + β + K(P )

≤ α + β

The ﬁrst two assumptions are natural: picking λ at

random and independently of P will satisfy high com-

plexity and low mutual information with high proba-

bility, so we can simply assume those properties at

the start. The third assumption, however, is not im-

mediately obvious: it describes a situation where the

obfuscation key is optimal, in the sense that it con-

tains just the amount of information to go from P to

′

, within a small logarithmic term. The following

lemma shows how λ must have a minimum complex-

ity to allow the derivation of P to P

′

Lemma 11. Consider P

′

= O (P, λ) is the result

of obfuscating a program P . Then, K(λ∣P ) ≥

K(P

′

∣P ) − O(1)

Proof. Given the obfuscator O and any λ, construct

the function q

(⋅) = O(⋅, λ). Let Q

be a program

that implements it. Then, clearly, U (Q

, P ) = P

′

and so ∣Q

∣ ≥ K(P

′

∣P ). To describe Q

, we only

need to specify λ and instructions to invoke O with

the proper arguments, but since P is already known,

we can use it to ﬁnd a shorter description for λ. This

gives K(P

′

∣P ) ≤ K(λ∣P ) + O(1).

An optimal obfuscation key λ is then the one that

uses as little information as possible.

Obfuscation techniques can use randomness or

not. In Claim 9, we showed one case where names

could be obfuscated in a deterministic way, without

any randomness. However, we could equally have

used instead highly random names, with the same ef-

fect in security but increasing unintelligibility as well.

We can as well consider that the set of obfuscation

techniques is ﬁnite and describe each of them by a

unique number. This way, we can characterize a sin-

gle application of obfuscation by a key composed of

the technique’s index and the randomness needed.

We now proceed to show that it is possible to

achieve obfuscation security according to our deﬁni-

tions, but restricted to a passive adversary, that is, one

that does not realize transformations over the inter-

cepted code. The intuition is to use obfuscation tech-

niques that behave as much as possible as secure en-

cryption functions, namely, using random keys that

are independent from the code and large enough that

they obscure almost all original information. The cru-

cial difference that enables security is that because an

obfuscation technique preserves functionality, we do

not need to decrypt the obfuscated code and so don’t

need to hide the key.

First, we prove the effect of obfuscating an ele-

mentary piece of code, by application of a single ob-

fuscation technique. Then, we reason about the case

of a full program, composed of several of these inde-

pendent blocks.

SECRYPT2015-InternationalConferenceonSecurityandCryptography

Theorem 12. Let p represent a program block, O

an obfuscation technique and λ ∈ L an obfuscation

key with ﬁxed length n. Let p

′

= O(p, λ) be the ob-

fuscated block. Assume O produces an output with

length ℓ ≤ n + γ and is “nearly-injective” in the fol-

lowing sense: for every p, any subset of L of keys

with the same behaviour for p has cardinality at most

polynomial in n. That is, for all p and λ

∈ L,

∣{λ ∶ O(p, λ) = O(p, λ

)}∣ ≤ n

, for some positive in-

teger k.

Then, if the key is random, K(λ) ≥ n− α and inde-

pendent from p, K(λ∣p) ≥ K(λ) − β, the obfuscated

code p

′

is (α + β + γ)-secure up to a logarithmic term.

Proof. By symmetry of information, we can write

K(p∣p

′

) = K(p

′

∣p) + K(p) − K(p

′

). Since p

′

O(p, λ), it’s easy to see that K(p

′

∣p) ≤ K(O) +

K(λ∣p) = K(λ∣p), since K(O) is a constant in-

dependent of p, λ or p

′

. As well, we can show

the reverse inequality. To produce λ from p, we

can ﬁrst produce p

′

from p (with a program that

takes at least K(p

′

∣p) bits) and then build the set

p,p

′

= {λ ∶ ∣λ∣ ≤ n, O(p, λ) = p

′

} of all compati-

ble λ, by a program whose length is O(1). Finally,

we just have to give the index of λ in this set, and

so K(λ∣p) ≤ K(p

′

∣p) + log #S

p,p

′

. Then, by as-

sumptions on λ, K(p

′

∣p) ≥ K(λ∣p) − log #S

p,p

′

≥

n − α − β − log #S

p,p

′

. By assumption on the out-

put of O, K(p

′

) ≤ ∣O(p, λ)∣ ≤ n + γ. This gives

K(p∣p

′

) ≥ K(p) + n − α − β − O(log n) − K(p

′

) ≥

K(p) − α − β − γ − O(log n).

The randomness and independence conditions for

the keys are natural. The other two conditions may

seem harder to justify, but they ensure that O effec-

tively mixes p with the randomness provided by λ:

the limit on the size of subsets of L implies a lower

bound on the number of possible obfuscations for p

(the more the better); on the other hand, the limit on

the length of the output of O forces the information

contained in p to be scrambled with λ, since it can

take only a few more bits than those required to de-

scribe λ itself. The extreme case is similar to One-

Time Pad encryption

, when both the output and λ

have the same size n, and O is injective for each p:

there are 2

keys, as well as possible obfuscations

for each p. Furthermore, because the obfuscated code

has the same length of λ, the exact same obfuscated

strings are possible for each p, maximizing security.

In general, a program is composed of several of

these minimal blocks in sequence. The above proof

shows when the obfuscated block p

′

gives no informa-

tion about its original block, say p

. As well, p

′

can

Which is proved to be an unconditionally secure sym-

metric cypher

not give any more information about any other block

, as there is no causal relation between p

and p

′

At best, there is some information in p

about p

, but

then the information given by p

′

about p

should be at

most that given by about p

. Therefore, we conclude

that if all the sub-blocks in a program are securely ob-

fuscated, then the whole program is. The above the-

orem, then, shows that secure obfuscation is possible

under very reasonable assumptions.

5 INDIVIDUAL SECURITY OF

CODE OBFUSCATION

Studying the security of individual instances of obfus-

cated code provides more granularity. Even if the ob-

fuscated program is considered secure according to

our deﬁnition, it may have parts which can provide

some information about other obfuscated parts, which

reduce the security of the obfuscated code. It could be

that a program is obfuscated but that some module is

not: some part of the obfuscated code stays still in

its original form. We can demonstrate this relation

by providing some boundaries on the complexity of

subprograms in the same program.

We can view (obfuscated) programs as ﬁnite,

and therefore recursively enumerable, sets of subpro-

grams (blocks or modules) such that P

′

= {p

′

}

n∈N

Given an obfuscated program P

′

, it may consist of ob-

fuscated and unobfuscated modules, that is: ∃p

′

, p

′

∈

′

, where p

′

is an obfuscated module and p

′

is an

unobfuscated module.

Theorem 10 demonstrates the effect of security pa-

rameters λ on the whole obfuscation process. The

following results show the effect of each individual

security parameter on each obfuscated subprogram.

Choosing a good λ (with a good source of random-

ness) requires a minimum amount of information to

be shared with obfuscated code and the clear code. It

is important to study the relation between the security

parameter and the original (clear) code. In the follow-

ing theorem, we use a simple way to check the inde-

pendence between λ and P on the subprogram level.

Theorem 13. Let P

′

be a set of obfuscated subpro-

grams and P a set of clear subprograms, such that

each subprogram p

′

of P

′

has length at most n, and

is the obfuscation of a corresponding block in P :

∃p

∈ P, κ

∈ λ. p

′

= O(p

, κ

). If K(κ

, p

) ≥

K(p

) + K(κ

) − α, then (up to a logarithmic term):

(κ

; p

) ≤ α

Proof. Since K(p

, κ

) ≤ K(κ

∣p

) + K(p

) +

AlgorithmicInformationTheoryforObfuscationSecurity

O(log n), we have by assumption

K(p

) + K(κ

) − α ≤ K(κ

∣p

) + K(p

) + O(log n)

K(κ

) − α ≤ K(κ

∣p

) + O(log n)

K(κ

) − K(κ

∣p

) ≤ α + O(log n)

(κ

, p

) ≤ α + O(log n)

The following two theorems address the secu-

rity of two different forms of code obfuscation:

obfuscation-as-encoding and obfuscation-as-hiding.

In the obfuscation-as-encoding technique, the origi-

nal program is transformed in such a way it changes

the structure of original code, but preserving the func-

tionality, for example Data transformation techniques

such as array splitting, splitting variable, Restruc-

ture Arrays and Merge Scalar Variables (Collberg

et al., 1997). The encoding process is considered as

the security parameter that dictates how the obfusca-

tion should be performed and where it should take

place. Encoding differs from encryption, if some-

body knows the encoding process, then the original

code can be recovered. In encoding obfuscation, the

clear program is not presented in the obfuscated code;

what still exists, but hidden, is the encoding process.

Reversing the encoded program (obfuscated) requires

ﬁnding and understanding the encoding process. For

instance we used a simple encoding in Fig. 1, x=x+i

is encoded as x=x+4

i;x=x-2

i;x=x-i; the en-

coding process converts i to 4

i;-2

i;-i, to

ﬁgure out x=x+i , we have to ﬁnd and combine

i;-2

i;-i, which is the security parameter in

this case.

The next theorem addresses the security of obfus-

cation code when we apply encoding to P (as a set

of subprograms ), here, the encoding process is pre-

sented as a part of security parameter.

Theorem 14 (Encoding). Let P

′

be a collectionof ob-

fuscated subprograms p

′

using κ

∈ λ, each of length

at most n. Then,

(κ

; p

′

) ≤ δ

− O(1),

for δ

= δ(κ

∣P

′

Proof. Since P

′

is a collection of sub-programs, we

can assume that it contains all the information in p

′

well as that of all other sub-programs. Then,

K(κ

∣P

′

) = K(κ

∣p

′

, . . . , p

′

, . . . , p

′

) ≤ K(κ

∣p

′

)

and so

(κ

; p

′

) = K(κ

) − K(κ

∣p

′

)

≤ K(κ

) − K(κ

∣P

′

)

≤ K(κ

) − (log #P

′

− δ

) by Deﬁnition 4

Because each subprogramhas lengthat most n, P

′

can contain at most 2

distinct programs. Assuming

that each appears at most a constant number of times,

we have that #P

′

= O(2

) and log #P

′

= n + O(1).

Then,

(κ

; p

′

) ≤ n − n + δ

− O(1)

≤ δ

− O(1)

In hiding obfuscation techniques the original sub-

program still exists in the obfuscated program (set of

obfuscated subprograms), the security of such tech-

niques depends on the degree of hiding in the set ob-

fuscated subprograms. An example of such technique

is the control ﬂow obfuscations such as Insert Dead

basic-blocks, Loop Unrolling, Opaque Predicate and

Flatten Control Flow (Collberg et al., 1997). Nor-

mally these techniques are combined and used with

encodingobfuscation techniques,in order to make the

code more resilient to reverse engineering techniques.

For code obfuscation, an opaque predicate is used

as a guard predicate that cannot statistically be com-

puted without running the code; however the original

code still exists too in the obfuscated code, but pro-

tected by the predicate. In Fig. 1 we used opaque pred-

icates with simple data encoding technique. Consider

the following obfuscated code of Fig. 1-(a), where the

encoding has been removed. Obviously, x=x+i is

still in the code, but is hidden under the protection of

opaque predicate.

while(i<n){

i=i+1

if (7

y-1==x

x){ //false

y=x

else

x=x+i;}}

opaque predicate with no encoding

Theorem 15 (Hiding). Let P

′

be a collection of ob-

fuscated subprograms p

′

, each of length at most n.

Then,

; p

′

) ≤ δ

− O(1),

for δ

= δ(p

∣P

′

Proof. The proof is very similar to Theorem 14. The

block p

is hidden in P

′

but in its original form, due

to the obfuscation process. Since P

′

is a collection

of sub-programs, we can assume that it contains all

the information in p

′

as well as that of all other sub-

programs. Then,

K(p

∣P

′

) = K(p

∣p

′

, . . . , p

′

, . . . , p

′

) ≤ K(p

∣p

′

)

SECRYPT2015-InternationalConferenceonSecurityandCryptography

; p

′

) = K(p

) − K(p

∣p

′

)

≤ K(p

) − K(p

∣P

′

)

≤ K(p

) − (log #P

′

− δ

) by Deﬁnition 4

Similarly to the proof of Theorem 14, #P

′

= O(2

)

and log #P

′

= n + O(1). Then,

; p

′

) ≤ n − n + δ

− O(1)

≤ δ

− O(1)

6 CONCLUSION AND FUTURE

WORK

In this paper, we provide a theoretical investigation

of code obfuscation. We deﬁned code obfuscation us-

ing Kolmogorov complexity and algorithmic mutual

information. Our deﬁnition allows for a small amount

of secret information to be revealed to an adversary,

and it gives an intuitive guarantee about the security

conditions that have to be met for secure obfuscation.

We argued our deﬁnition is more lenient than the vir-

tual black-box model of Barak et al. and that for that

reason the impossibility result does not apply. In con-

trast, we showed that under reasonable circumstances

we can have secure obfuscation according to our deﬁ-

nition.

To the best of our knowledge, this paper is the ﬁrst

to propose algorithmic information theory as a the-

oretical basis for code obfuscation. We believe that

our new deﬁnition for code obfuscation provides the

ﬁrst step toward establishing quantitative metrics for

certifying code obfuscation techniques. Currently, we

are working toward derivingnew metrics based on our

model, aimingto validate andapply these metrics, em-

pirically, to real obfuscated programs using state of

the art obfuscation techniques.

There are still some questions we want to address

in future work. For example, it is still not clear

whether the complexity of security parameter (key)

has always a positive effect on the the security of ob-

fuscated programs based on algorithmic mutual infor-

mation deﬁnition. Furthermore, algorithmic mutual

information has a parallel counterpart based on classi-

cal information theory such as Shannon mutual infor-

mation, it would be interesting to explore the relation

between our deﬁnition and Shannon mutual informa-

tion in the context of code obfuscation security. We

are also planning to study and characterize the secu-

rity of particular techniques and to analyze more care-

fully the scenario of active adversaries.

ACKNOWLEDGEMENTS

This research is partially funded by EPSRC-DTA

(Mohsen). We would like to thank Steffen van Bakel

and Emil Lupu for their comments.

REFERENCES

Barak, B., Goldreich, O., Impagliazzo, R., Rudich, S., Sa-

hai, A., Vadhan, S., and Yang, K. (2012). On the

(im)possibility of obfuscating programs. J. ACM,

59(2):6:1–6:48.

Barak, B., Goldreich, O., Impagliazzo, R., Rudich, S., Sa-

hai, A., Vadhan, S. P., and Yang, K. (2001). On the

(im)possibility of obfuscating programs. IACR Cryp-

tology ePrint Archive, 2001:69.

Collberg, C., Thomborson, C., and Low, D. (1997). A Tax-

onomy of Obfuscating Transformations.

G´acs, P. (1974). On the symmetry of algorithmic informa-

tion. Soviet Math. Dokl, 15:1477–1480.

Garg, S., Raykova, M., Gentry, C., Sahai, A., Halevi, S.,

and Waters, B. (2013). Candidate indistinguishability

obfuscation and functional encryption for all circuits.

In In FOCS.

Gauvrit, N., Zenil, H., and Delahaye, J. (2011). Assessing

cognitive randomness: A kolmogorov complexity ap-

proach. CoRR, abs/1106.3059.

Goldwasser, S. and Rothblum, G. N. (2007). On best-

possible obfuscation. In Proceedings of the 4th con-

ference on Theory of cryptography, TCC’07, pages

194–213, Berlin, Heidelberg. Springer-Verlag.

Jbara, A. and Feitelson, D. G. (2014). On the effect of code

regularity on comprehension. In Proceedings of the

22Nd International Conference on Program Compre-

hension, ICPC 2014, pages 189–200, New York, NY,

USA. ACM.

Kieffer, J. C. and Yang, E. H. (1996). Sequential codes, loss-

less compression of individual sequences, and Kol-

mogorov complexity. IEEE Trans. on Information

Theory, 42(1):29–39.

Lathrop, J. I. (1997). Compression depth and the behavior

of cellular automata. Complex Systems.

Li, M. and Vit´anyi, P. M. (2008). An Introduction to Kol-

mogorov Complexity and Its Applications. Springer

Publishing Company, Incorporated, 3 edition.

McCabe, T. J. (1976). A complexity measure. IEEE Trans.

Software Eng., 2(4):308–320.

Shen, A. (1982). Axiomatic description of the entropy

notion for ﬁnite objects. VIII All-USSR Conference

(Logika i metodologija nauki),Vilnjus, pages 104 –

105. The paper in Russian.

Shen, A., Uspensky, V., and Vereshchagin, N. (2014).

Kolmogorov complexity and algorithmic randomness.

MCCME Publishing house.

Taveneaux, A. (2011). Towards an axiomatic system for kol-

mogorov complexity. Electronic Colloquium on Com-

putational Complexity (ECCC), 18:14.

AlgorithmicInformationTheoryforObfuscationSecurity