Automatic Program Inversion using Symbolic Transducers

Transcription

1 Automatic Program Inversion using Symboic Transducers Qinheping Hu University of Wisconsin-Madison Loris D Antoni University of Wisconsin-Madison oris@cs.wisc.edu Abstract We propose a fuy-automated technique for inverting functiona programs that operate over ists such as string encoders and decoders. We consider programs that can be modeed using symboic extended finite transducers (s-efts), an expressive mode that can describe compex ist-manipuating programs whie retaining severa decidabe properties. Concretey, given a program P expressed as an s-eft, we propose techniques for: ) checking whether P is injective and, if that is the case, ) buiding an s-eft P describing its inverse. We first show that it is undecidabe to check whether an s-eft is injective and propose an agorithm for checking injectivity for a restricted, but a practica cass of s-efts. We then propose an agorithm for inverting s-efts based on the foowing idea: if an s-eft is injective, inverting it amounts to inverting a its individua transitions. We everage recent advances in program synthesis and show that the transition inversion probem can be expressed as an instance of the syntax-guided synthesis framework. Finay, we impement the proposed techniques in a too caed GENIC and show that GENIC can invert 3 out of 4 rea compex string encoders and decoders, producing inverse programs that are amost identica to manuay written ones. CCS Concepts Theory of computation Forma anguages and automata theory Keywords Extended Symboic Transducers, Program Inversion, GENIC. Introduction Program inversion is an od but everasting topic in computer science. Aready in 978, Dijkstra was investigating domainspecific techniques for manuay inverting simpe arraymanipuating programs []. Besides being intriguing and foundationa, the probem of efficienty and automaticay producing correct inverse programs has practica appications in many fieds of computer science, such as data extraction, transformation, compression, and encryption. Consider the task of writing a string encoder such as BASE64 and the corresponding decoder i.e., two programs that transform a pain text from one format to another. After successfuy writing the encoder, the programmer aso has to write a decoder and test whether the two programs invert each other. Since these programs are very simiar, the programmer is repeating the same work twice and is more ikey to introduce mistakes. In fact, mistakes in this type of programs are common and, in the past, buggy string encoders have caused arge-scae security vunerabiities [9]. Inspired by such scenarios, we investigate the probem of competey automated program inversion. Since the first Dijkstra s effort, this probem has been investigated in severa areas and many techniques have been proposed. However, these techniques are ony effective on simpe programs [5,, 4, 6 8] or are ony semi-automated []. Moreover, not a such techniques guarantee the soundness of the generated inverse program. We propose a sound and fuy automated approach for inverting programs that manipuate ists, such as string encoders and CSV fie transformations. Programs as transducers Our approach is forma and ays its foundations in the theory of finite state automata and finite state transducers i.e., automata with outputs. In this paper, we focus on programs that can be modeed using symboic extended finite transducers (s-efts), a transducer mode that can capture compex manipuating programs, such as rea encoders, whie retaining severa decidabe properties. However, the paradigm we propose coud be extended to more powerfu modes such as tree transformations using trees and visiby push-down transducers [4, ]. s-efts extend traditiona transducer modes in two ways. First, s-eft transitions are abeed with predicates and functions drawn from decidabe first-order theories (e.g. Presburger arithmetic over the integers). Thanks to this feature, s-efts can mode transformations over ists that contain eements beonging to compex and potentiay infinite domains. Second, s-eft transitions can read mutipe adjacent input symbos and use the inputs to produce mutipe adjacent output symbos. For exampe, consider the foowing transition t of an s-eft A

2 operating over ists of integers. p x 0 x 0/[x,x ] q When in state p and reading a ist (e.g., [, 4, 6, 0]), the s- EFT A checks whether the first two eements of the ist (e.g., and 4) are greater than 0, then appends two numbers to the output ist (e.g., 5 and 0), moves the contro to the state q, and continues reading the rest of the ist (e.g., [6, 0]). Despite the generaity of this mode, if the predicates appearing in the transitions are conjunctions of unary predicates, it is decidabe to check whether two s-efts describe the same ist transformation. This property was used by D Antoni and Veanes to prove the correctness of compex impementations of encoders and decoders such as BASE64 [7]. In this paper, we move a step further and ask the foowing question. Given an s-eft A, can we construct an s-eft A that computes the inverse transformations of A? Whie this probem has been studied for simpe transducer modes [4, 5], automatic inversion of s-efts is a much more chaenging probem due to the use of arbitrary first order theories. Proving transducer injectivity When trying to automaticay invert a transducer A, a natura question arises: is the transducer A actuay invertibe? A necessary condition for invertibiity is that A computes an injective function. We study the probem of checking whether an s-eft is injective and show that, in genera, this probem is undecidabe. We then propose an agorithm for checking injectivity of a restricted but practica cass of s-efts. To check injectivity of an s-eft A, we compute predicates describing the output of each transition and use them to construct an automaton A O describing the output anguage of A. Our restriction requires a the predicates in A O to be Cartesian i.e., the predicates are expressibe as conjunction of unary predicates and we provide an agorithm for checking whether a predicate is Cartesian. We then prove that an s-eft is injective iff, for each possibe ist, there exists at most one accepting path in its output automaton A O ; we provide an agorithm for checking this property. We show that Cartesian s-efts can sti describe compex programs. Inverting transducers We propose an agorithm for inverting s-efts based on the foowing idea: if an s-eft T is injective, inverting T amounts to inverting a its individua transitions. For exampe, the transition t that inverts the transition t from the earier exampe is the foowing. p y 0 y /[y+,y] q To invert a transition we need to compute the predicate appearing in the guard and the functions generating the output. The predicate for the guard can be computed symboicay using quantifier eimination. For exampe, the guard of t is the quantifier-free formua equivaent to x, x.x 0 x 0 y = x y = x. text M a n ASCII 77 (#x4d) 97 (#x6) 0 (#x6e) bit pattern index BASE64 T W F u Figure : Exampe BASE64 encoding from Wikipedia. Computing the output components requires inverting functions expressed in an arbitrary first order theory. We formaize this probem and show that it can be naturay encoded in the framework of syntax-guided synthesis (SYGUS). For exampe, the output functions g (y, y ) = y + and g (y, y ) = y of the inverted transition t are soutions of the SYGUS specification ϕ(g, g ) = x, x.x 0 x 0 g (x, x ) = x g (x, x ) = x. The too GENIC We impemented our techniques in a programming anguage, GENIC, for which the semantics is given using s-efts. We expoit some of the domain knowedge and anguage features of GENIC to propose synthesis techniques that improve the performance SYGUS instances generated when inverting transitions e.g., we synthesize auxiiary functions to speed up the synthesis. We evauate the effectiveness of GENIC on 4 rea encoders and decoders, and 40 synthetic programs, with size ranging from 6 to 3 ine of code. GENIC is abe to automaticay invert 3 of the rea programs and produces sma inverses, which are substantiay identica to the manuay written ones. Contributions In summary, our contributions are: GENIC, a anguage for the probem of automaticay inverting ist manipuating programs that are expressibe as s-efts ( 3). A forma study of the probem of checking injectivity of s-efts, incuding a proof of undecidabiity for the genera case and an agorithm for checking injectivity for a practica subcass of s-efts ( 4). A forma study of the probem of inverting s-efts, incuding an agorithm for inverting injective s-efts ( 5), and a concrete instantiation of the agorithm in the framework of Syntax Guided Synthesis ( 6). A comprehensive evauation of GENIC on both rea and synthetic benchmarks ( 7). A ong version of this paper containing a the proofs has been submitted as suppementary materia.. Motivating Exampe We use the BASE64 encoder and its variants to iustrate how GENIC works. The standard encoding BASE64 is used to transate binary data in textua format. A BASE64 encoder transforms sequences of bytes, aso caed octets, into sequences of 6-bit characters. This is done by reading 3 characters at a time, spitting the resuting sequence of 4 bits into

3 // Axuiiary functions fun E (x: x <= # x40) := 3 (ite (x <= #x9) (x + #x4) 4 (ite (x <= #x33) (x + # x47) 5 (ite (x <= #x3d) (x - #x04) 6 (ite (x == #x3e) #xb #xf)))) 7 fun B h x := (x << (7 - h)) >> (7 - h + ) 8 // List transformations 9 trans B64E (: ( BitVec 8) ist ) : ( BitVec 8) := 0 match with // ( input ist ) when ( predicate ) -> ( output ist ) x::y::z:: tai when true -> 3 E (B 7 x) :: 4 E (((B 0 x) << #x04) (B 7 4 y)) :: 5 E (((B 4 0 y) << ) (B 7 6 z)) :: 6 E (B 5 0 z) :: B64E ( tai ) 7 x::y ::[] when true -> 8 E (B 7 x) :: 9 E (((B 0 x) << 4) (B 7 4 y)) :: 0 E ((B 4 0 y) << ) :: #x3d :: [] x ::[] when true -> E (B 7 x)) :: 3 E ((B 0 x) << 4) :: #x3d :: #x3d :: [] 4 [] when true -> [] 5 // Operations on the ist transformation 6 isinjective B64E 7 invert B64E Figure : GENIC program for the BASE64 encoder. #x3d is the ASCII code of the symbo =. groups of 6 bits, and appying a character mapping to each 6-bit number. The character mapping receives as input vaues between 0 and 63 to produce safe ASCII characters e.g., etters, numbers, +, / and =. If the source stream is not divisibe by 3 then the ast four output characters wi contain padding characters = to make it ceany divisibe. An exampe of this encoding is given in Figure. The GENIC program showed in Figure impements the standard BASE64 encoder. The program starts by defining two auxiiary functions (ines -7): the function E performs the character mapping iustrated in the ast two ines of Figure and the function B extracts the bits between positions and h in a bit-vector x. The function B64E performs the actua ist transformation: it takes as input a ist of bytes and uses pattern-matching to decide which rue to fire. The first rue (ines -6) fires when the input ist contains at east 3 eements. This rue reads the first three characters of ; it outputs the four ASCII characters corresponding to the BASE64 encoding of the consumed characters, and it appends to the output the resut of recursivey invoking B64E on the remainder of the ist. The other three rues are fired when has fewer than 3 eements. Notice that the second and third rues add the padding character = i.e., #x3d to make the ength of the output divisibe by 4. In the ast two ines of the program, GENIC checks whether the ist transformation B64E is injective and, if that is the case, GENIC computes the inverse of B64E. A skeeton of the GENIC program B64D produced by invert B64E is depicted in Figure 3. In this case, GENIC aso synthesizes an auxiiary function D that inverts our origina auxiiary function E and uses it in the body of the program B64D, making the inverted // We omit the detai in auxiiary functions fun D (x :...) :=... // Synthesized by genic 3 fun B h x :=... 4 fun pred x :=... // Synthesized by genic 5 === 6 // Synthesized by genic 7 trans B64D (: ( BitVec 8) ist ) : ( BitVec 8) := 8 match with x::y::z::w ::[] when ( and ( pred x) ( pred y) (z == # x3d ) (w == # x3d )) -> ((D x) << # x0 ) (B # x05 # x04 (D y)) :: [] 3... Figure 3: Skeeton of the impementation of the BASE64 decoder synthesized by GENIC. program more natura to read. GENIC takes approximatey seconds to prove that B64E is injective and approximatey 0 seconds to compute its inverse. We now introduce a variant of the standard BASE64 and show how a sma change in the encoder can trigger nontrivia changes in the corresponding decoder. The modified BASE64 for XML tokens differ from the standard BASE64 because it uses a different mapping function E, which maps vaues 6 and 63 to characters. and - respectivey, and it does not use padding characters. It is easy to modify the program in Figure to refect these changes. However, this sma change in the encoder triggers non-trivia changes in the corresponding decoder. For exampe, for the skeeton of the decoder presented in Figure 3, we need to modify the function D and the predicate pred to operate over a different set of symbos, and we need to change the pattern of the rue in ine 0 to read ony two symbos. Despite this non-trivia change, GENIC can prove the injectivity of the modified encoder and compute its inverse in approximatey 0 seconds, reieving the programmer from the burden of manuay writing a correct modified decoder. 3. The GENIC anguage The anguage GENIC is designed with the foowing goas in mind. First, GENIC shoud be expressive enough to mode usefu and practica ist manipuating programs. Second, it shoud be possibe to automaticay check whether GENIC programs are injective and to invert them. We introduce the anguage constructs of GENIC and simutaneousy define their forma semantics using s-efts. 3. Aphabet Theories GENIC programs and s-efts manipuate ists that contain eements from compex domains. We assume a background To better appreciate the compexity of the probem the reader can ook at the Javascript impementation of BASE64 at To adopt the change proposed in our motivating exampe, one wi need to ) modify ines and since now there are no = characters, ) add a mechanism to detect the eary end of input and react appropriatey (e.g., change ines 79 and 9), 3) modify the decoding tabe in ine 6. We beieve that these changes are non-trivia and error-prone.

4 universe D with buit-in function and reation symbos. The universe D is muti-typed with D τ denoting the sub-universe of eements of type τ. We use λ-expressions for representing anonymous functions that we ca λ-terms. A λ-term λx.ϕ(x) of type σ BOOL is caed a σ-predicate or a predicate over σ. We use σ i to denote the Cartesian product of σ i times i.e., σ 0 =, σ = σ and σ i+ = σ σ i. An aphabet theory is given by a set Ψ of terms that is cosed under Booean operations (i.e., the theory forms a Booean agebra), substitution, equaity, and if-then-ese terms. Uness stated differenty, we assume that the aphabet theory Ψ is decidabe i.e., checking satisfiabiity of formuas ϕ Ψ, IsSat(ϕ), is decidabe. The aphabet theory is recursivey enumerabe if the set Ψ is recursivey enumerabe. We use [ϕ] D σ to denote the set of a vaues that satisfy ϕ; ϕ is vaid, IsVaid(ϕ), when [ϕ]=d σ. GENIC currenty supports the theories of bit-vector arithmetic and inear integer arithmetic, which are ones supported by SYGUS sovers. 3. Auxiiary Functions The first part of a GENIC program contains auxiiary partia functions defined using terms in the aphabet theory. Auxiiary functions can be used as within the ist transformations and we wi discuss ater how they can speed up synthesis. Exampe 3.. The GENIC program presented in Figure contains two auxiiary functions (ines -7). The partia function E maps characters in the range [#00-#3f] to the corresponding BASE64 symbos and is undefined on characters outside the range [#00-#3f]. The function B extracts the bits between position h and in a bit-vector x. In the foowing exampes we use b h (x) and x to refer to the terms in the aphabet theory D corresponding to the GENIC functions B h x and E x, respectivey. 3.3 List Transformations The core constructs of GENIC are ist-to-ist transformations, for which the semantics is given in terms of Symboic Extended Finite Transducers (s-efts). Definition 3.. An Extended Symboic Finite Transducer (s-eft) with input type σ and output type γ is a tupe A = (Q, q 0, ) where: Q is a finite set of states and q 0 Q is the initia state. is a set of transitions of the form r = (p,, ϕ, ˆf, q) ϕ/ ˆf (denoted p q) such that p Q, q Q { }, is the ookahead of r, and ϕ, the guard of r, is a predicate over σ ; ˆf, the output of r, is a ist of functions [f 0,..., f n ] such that n 0 and for every i, f i : (σ γ). The ookahead of A is the maximum of a ookaheads of rues in. An s-eft where a the rues output the empty ist is an Extended Symboic Finite Automaton (s-efa). For s-efas, we omit the output component from the transitions. A finaizer is a rue with target state q = and is a generaization of the notion of fina state. A finaizer with ookahead is used when the end of the input sequence has been reached with exacty input eements remaining. We use the foowing abbreviated notation for rues, by omitting expicit λ s. We write p ϕ( x)/[f0( x),...,f k( x)] q for p λ x.ϕ( x)/λ x.[f0( x),...,fk( x)] q, where ϕ and f i are terms whose free variabes are among x = (x 0,..., x ). We often abbreviate [f 0 ( x),..., f k ( x)] with f( x). In the foowing we expain how GENIC programs are transated into s-efts. In GENIC a ist transformation is decared using the signature trans p and it represents a state p of an s-eft together with the corresponding transitions out of p. Transformations contain two kinds of matching rues. The first kind is of the form x 0 ::... ::x n ::tai when ϕ(x 0,..., x n ) -> f (x 0,..., x n )::... ::f k (x 0,..., x n )::p (tai) and it corresponds to an s-efts transition of the form p ϕ(x0,...,xn)/[f0(x0,...,xn),...,f k(x 0,...,x n)] p. n+ The second kind of matching rues is of the form x 0 ::... ::x n ::[] when ϕ(x 0,..., x n ) -> f 0 (x 0,..., x n )::... ::f k (x 0,..., x n )::[] and it corresponds to an s-efts finaizer transition p ϕ(x0,...,xn)/[f0(x0,...,xn),...,f k(x 0,...,x n)] n+ Intuitivey, rues that pattern-match against a ist of fixed ength correspond to finaizer transitions. The predicates and functions appearing in GENIC rues are required to be we-typed and to be eements of the aphabet theory. The initia state of the s-eft is the one corresponding to the transformation for which the user wants to compute the inverted program i.e., the name appearing after the keyword invert. Exampe 3.3. The s-eft T B64E = ({p}, p, B64E ) describes the BASE64 encoder presented in Figure. T B64E operates over the theory of bit-vectors and has BITVEC 8 as both its input and output type. The set B64E contains the foowing transitions. is the true predicate. p /[ b7 (x0), (b 0 (x0) 4) b7 4 (x), (b3 0 (x) ) b7 6 (x), b5 0 (x) ] p /[ ] 0 p /[ b 7 3 (x0), b 0 (x0) 4, =, = ] p /[ b7 (x0), (b 0 (x0) 4) b7 4 (x), b3 0 (x), = ] The state p corresponds to the ist transformation function B64E and, since the program asks to invert B64E, the state p is aso the initia state. p

5 We now define the semantics of s-efts and therefore of GENIC programs. In the remainder of the section, et A = (Q, q 0, ) be a fixed s-eft with input type σ and output type γ. For each rue in we define the set of corresponding non-symboic rues as foows. [p ϕ(x0,...,x )/[f 0(x 0,...,x ),...,f k (x 0,...,x )] q ] = def {p ā/[t0,...,t k] q ā = ā [ϕ] t i = [f i ](ā)} Intuitivey, a rue with ookahead reads adjacent input symbos ā and produces a sequence of output symbos t 0,..., t k by appying the output functions in f to ā. In the foowing, et [ ]] = def r [r ] and et s s denote the concatenation of two sequences s and s. Definition 3.4. For u Σ, v Γ, q Q, q Q { }, define q u/v A q as foows: there exists n 0 and u i/v i {r i r i = p i pi+ i n} [ ]] such that u = u 0 u u n, v = v 0 v v n, q = p 0, and q = p n+. Let aso q ε/ε A q for a q Q. Definition 3.4 describes a path between two states in an s-eft where transitions are traversed by reading symbos in the input ist. Transduction paths are required to start at the initia state and end in the finaizer state. We use P aths A (u, ) = {(p 0, r 0 ) (p n, r n )} to denote the set of paths with which u can reach a finaizer i.e., the transition u n/v n r n is of the form p n. Definition 3.5. The transduction of A is defined as T A (u) = def {v q 0 u/v }. s-efts have nondeterministic semantics and transductions typicay represent reations rather than functions. Unambiguous s-efts are an interesting subcass of s-efts that compute functions. Definition 3.6. An s-eft A is unambiguous if for every ist u, P aths A (u, ). When an s-eft A is unambiguous, T A (u) is either a singeton set or the empty set. We write T A (u) = t when T A (u) = {t} and T A (u) = when T A (u) = {}. When T A (u), we write P ath A (u, ) = (p 0, r 0 ) (p n, r n ) to denote the unique run of A on u. Unfortunatey, it is undecidabe to check whether an s- EFT is ambiguous [8], which means that in genera we cannot check whether a GENIC program is ambiguous or not. Instead, we require GENIC programs to be deterministic because this property can be automaticay checked. We define ϕ ψ, where ϕ is a σ m -predicate and ψ a σ n -predicate, as the σ max(m,n) -predicate λ(x,..., x max(m,n) ).ϕ(x,..., x m ) ψ(x,..., x n ). We define equivaence of f and g moduo ϕ, f ϕ g, as: IsVaid(λ x.(ϕ( x) f( x) = g( x))). Definition 3.7. An s-efa A is deterministic if for a transitions p ϕ/f q and p ϕ /f q one of the foowing properties hod. (a) If q, q Q and IsSat(ϕ ϕ ), then q = q, = and f ϕ ϕ f. (b) If q = q =, IsSat(ϕ ϕ ), and =, then f ϕ ϕ f. (c) If q Q, q =, and IsSat(ϕ ϕ ), then >. Ceary, a deterministic s-efa is aso unambiguous. Intuitivey, determinism means that no two rues may overap. To check whether a GENIC program is deterministic we check whether the induced s-eft is deterministic. Exampe 3.8. The GENIC program in Figure is deterministic because at most one rue can be triggered for any input. Without oss of generaity, we assume that a states are reachabe from the initia state and can reach the finaizer. 3.4 Operations GENIC supports the foowing operations over ist transformations. isinjective f checks whether the transformation f is injective and returns two different input ists that produce the same output otherwise (Section 4). invert f constructs a program f, which is the inverse of the injective transformation f i.e., for every input x, f (f(x)) = x (Section 5). 4. Checking s-eft Injectivity To invert a GENIC program we first need to check whether the program is injective i.e., whether for any two distinct inputs the program produces distinct outputs. This property is necessary for invertibiity, but not sufficient (We wi expand on this aspect in Section 5). In this section, we formay study the probem of checking whether an s-eft is injective. We first show that the probem is undecidabe and then present a technique for checking injectivity for a restricted but practica cass of s-efts. For the sake of generaity, we state our theorems for unambiguous s-efts, but a theorems aso hod for deterministic s-efts. 4. A Theory of Injectivity for s-efts We first define what it means for an s-eft to be injective and then show that this property is equivaent to the conjunction of two simper properties caed transition-injectivity and path-injectivity. Definition 4. (Injectivity). An s-eft A is injective iff for every two ists u and v, if T A (u), T A (v), and u v, then T A (u) T A (v). The foowing definition captures the case in which an s-eft is not injective because an individua transition can produce the same output when provided with different input. Definition 4. (Transition-injective s-eft). A transition p ϕ( x)/ f q is injective iff every two ists ā and b of size

6 , if ā b, ϕ(ā) and ϕ( b), then [ f ](ā) [[ f ]( b). An s-eft A is transition-injective iff a its transitions are injective. Exampe 4.3. The transition p /[x0+,x] q is injective because both its output functions are injective. The transition p /[x 0 ] q is not injective because the function x is not injective. If we restrict the domain of the transition to the set of positive numbers we obtain an injective transition p x0>0/[x 0 ] q. The foowing notion captures the case in which an s-eft is not injective because two different input ists with different accepting paths produce the same output. Definition 4.4 (Path-injective s-eft). An unambiguous s- EFT A is path-injective iff for every two ists u and v, if T A (u), T A (v), and P ath A (u, ) P ath A (v, ), then T A (u) T A (v). Exampe 4.5. Consider the s-eft P = ({p, q}, p, P ) with the foowing transitions. p x0>0/[x0 5] q, q x0>0/[x0 5], p x0<0 x<0/[x0+5,x+5] This s-eft P is transition-injective, but not path-injective, because on both the inputs [5, 5] and [ 5, 5] it outputs the ist [0, 0]. We now show the reations between s-eft injectivity and the two properties we just defined. Theorem 4.6. An unambiguous s-eft A is injective iff A is both transition-injective and path-injective. Our characterization of injectivity in terms of transitionand path-injectivity is unique to symboic transducers. In finite transducers, which operate over finite aphabets, a transitions are triviay injective 4. Checking Transition-Injectivity We provide an agorithm for checking whether an s-eft is transition-injective. Lemma 4.7. It is decidabe to check whether an s-eft is transition-injective. Proof. Checking whether an s-eft A is transition-injective amounts to checking whether a its transitions are injective. ϕ( x)/ f( x) To see whether a transition p q is injective we can test whether the foowing Booean formua is satisfiabe. ( x x ) ϕ( x ) ϕ( x ) ([f ]( x ) = [f ]( x )) This test is decidabe because the aphabet theory of A forms a decidabe Booean agebra. 4.3 Checking Path-Injectivity In genera, checking path injectivity is undecidabe. Theorem 4.8. It is undecidabe to check whether a deterministic s-eft is path-injective or injective. Proof. Reca that a Minsky machine is a program with a finite sequence of instructions that has two registers r and r that can hod natura numbers. Each instruction is one of the foowing: INC i (increment r i and continue with the next instruction); DEC i (decrement r i if r i > 0 and continue with the next instruction); JZ i (j) (if r i = 0 then jump to the j th instruction ese continue with the next instruction). The machine hats when the end of the program is reached. Let M be a Minsky machine with program P. We use a tupe (program counter, r, r ) of type σ = γ = N 3 to represent a configuration of M. Let π j : σ N be the function that projects the j th eement of a k-tupe where 0 j < k. We construct an s-eft A, which is ambiguous iff the Minsky machine M hats on input (0, 0) with a non-zero output in r. Let ϕ 000 be the predicate λx.x = (0, 0, 0) and et ϕ be the predicate λx.x = (,, ). Let ϕ fin be the fina predicate λx.π 0 (x) = P π (x) 0. The predicates ϕ 000 and ϕ fin describe the initia and fina configurations of M, respectivey. We define a binary predicate ϕ step that describe pairs of correct adjacent configurations in M. The predicate ϕ step is of the form λ(x, x ). i< P ϕstep i, where ϕ step i is the formua describing the vaid step reation of M from a configuration x to the next configuration x, when executing the i-th instruction. For exampe, if the i th instruction is INC, then ϕ step i is π 0 (x) = i π 0 (x ) = i+ π (x ) = π (x)+ π (x ) = π (x). The encoding is simiar for the other instructions. The s-eft A is the tupe ({q 0, q, q, q 3 }, q 0, ) where contains the foowing transitions. q 0 ϕ 000 (x )/[ ] /[ ] ϕ q 0, q (x )/[ ] 0 ϕ q step (x,x )/[x,x ] q, q ϕ step (x,x )/[x,x ] q, ϕ q, q 000 (x )/[x ] q q, q ϕ fin (x )/[x ] The s-eft A is deterministic and transition-injective. Given a ist of the form (0, 0, 0)a... a n, A outputs a... a n iff, for every i n, the symbos a i and a i are correct adjacent configurations of the machine M. The transduction is undefined on a other ist starting with (0, 0, 0). Given a ist of the form (,, )a... a n, A outputs a... a n iff, for every i < n, the symbos a i and a i+ are correct adjacent configurations of the machine M, a is the initia configuration of M, and a n is the fina configuration of M. The transduction is undefined on a other ists starting with (,, ).

7 Notice that each individua transition computes an injective function. The s-eft A is not injective iff there exists a sequence a... a n for which A is defined on both (0, 0, 0)a... a n and (,, )a... a n, as these two inputs woud produce the same output a... a n. The existence of such a sequence impies that a... a n is an accepting run of the Minsky machine M as it satisfies the step reations at a positions and it has the correct initia and fina configuration. It foows that A is not injective iff M hats on input (0, 0) with a non-zero output in r. The atter is an undecidabe probem as an instance of Rice s theorem. This concudes our proof. The proof reies on the use of symboic aphabets; in fact, checking injectivity of finite transducers, which operate over finite aphabets, is decidabe [3]. In the foowing, we provide a technique for checking pathinjectivity for a restricted but practica cass of s-efts. Given an s-eft A, we show how to construct a non-deterministic s-efa A O that accepts the set of a output ists produced by A and show that A is path-injective iff A O is ambiguous i.e., there exists an input with two different accepting paths. Finay, if a the predicates appearing in the transitions of A O are expressibe as conjunctions of unary predicates, we provide an agorithm for checking whether A O is ambiguous. Definition 4.9 (Output s-efa). Given an s-eft A = (Q, q 0, ), the output automaton of A is the s-efa A O = (Q, q 0, O ) such that for every transition t = p ϕ( x)/ f( x) q, O contains two transitions t ɛ = p true 0 q t and t out = q t ā.ϕ(ā) x= [ f ](ā) f representing t. q where q t denotes the state For every ist v accepted by A O, there exists a ist u such that T A (u) = v. We can now define the reation between path-injectivity of A and ambiguity of A O. Lemma 4.0. An unambiguous s-eft A is path-injective iff its output automaton A O is unambiguous. Intuitivey, this emma foows from the fact that for each input of A there exists a path in A O accepting the corresponding output. Therefore, if A on two different inputs produces the same output, there wi be two distinct paths in A O accepting the ist. Exampe 4.. Consider the s-eft P from Exampe 4.5. The output automaton of P O has the foowing transitions. p true p true y.y>0 x 0=y 5 pt, pt q, 0 q true y.y>0 x 0=y 5 qt, qt, 0 y 0,y.y 0<0 y <0 x 0=y 0+5 x =y +5 pt 3, pt 3 0 The s-efa P O is ambiguous because the ist [0, 0, 0] is accepted by the two paths containing the sequences of states p, pt, q, qt, and p, pt 3,. Using Theorem 4.8 we have that it is undecidabe to check whether an s-efa is unambiguous. We introduce a subcass of s-efas for which checking ambiguity is decidabe. A binary reation R over X is Cartesian over X if R is the Cartesian product R R of some R, R X. The definition is ifted to n-ary reations and σ n -predicates for n in an obvious way. To decide if a satisfiabe predicate ϕ( x) of arity n is Cartesian over a type σ (denoted IsCartesian(ϕ)), given a mode (a 0,..., a n ) of ϕ we can check whether the foowing formua is vaid. x (ϕ( x) i<n ϕ(a 0,..., a i, x i, a i+,..., a n )) In other words, a predicate ϕ( x) is Cartesian over σ iff ϕ can be rewritten equivaenty as a conjunction of n independent unary predicates. Notice that we can use the vaidity decision procedure of the aphabet theory to decide whether a predicate is cartesian. Definition 4. (Cartesian s-efa [8]). An s-efa is Cartesian if a its guards are Cartesian. Exampe 4.3. The s-efa P O in Exampe 4. is Cartesian. The ony transition containing a binary predicate is the ast one, which contains the predicate y 0, y.y 0 < 0 y < 0 x 0 = y x = y + 5. This predicate is equivaent to x 0 < 5 x < 5. An exampe of non-cartesian predicates is the predicate x 0 = x over the type N. Cartesian s-efas can be transformed into equivaent s-fas by spitting each transition of ookahead k into k transitions of ookahead. Since it is decidabe to check whether an s-fa is ambiguous, we have that checking ambiguity is aso decidabe for Cartesian s-efas. The agorithm is based on the product construction used for checking NFA ambiguity. Lemma 4.4 (s-efa ambiguity). Checking whether a Cartesian s-efas is unambiguous is decidabe. Exampe 4.5. Reca the s-eft for BASE64 in Exampe 3.3. The corresponding output automaton is a Cartesian s-efa and has the foowing transitions p β64(x0) β64(x) β 64 (x) x3= = 4 p p 0 p β64(x0) β 64 (x) x= = x3= = 4 3 i=0 β64(xi) p 4 where the predicate β 64 (y) is true iff y is a vaid BASE64 digit, i.e., y = x for some x, 0 x 64. The predicates β 64(y) and β 64(y) are restricted versions of β 64 (y) and the ASCII of = is not a vaid BASE64 digit. This automaton is deterministic and therefore unambiguous, which impies that the s-eft in Exampe 3.3 is path-injective. We can now state our main decidabiity resut.

8 Theorem 4.6 (Cartesian-output s-eft injectivity). Given an unambiguous s-eft A = (Q, {q 0 }, ), if the output automaton A O is Cartesian, then it is decidabe to check whether A is injective. Moreover, there exists an agorithm for checking injectivity with compexity O((n + t) + (t) f(k)), where n = Q, t =, is the ookahead of A, k is the size of the argest transition in A, and f(x) is the compexity of checking satisfiabiity of predicates of size x in the aphabet theory of A. Proof. Decidabiity foows from Theorems 4.6 and 4.7, and Lemmas 4.0 and 4.4. Checking whether A is transitioninjective requires one satisfiabiity check for every transition and has compexity O(tf(k)). The s-efa A O has the same ookahead of A and the same number of states and transitions. Moreover, each predicate in A O has size O(k). The Cartesian s-efa A O equivaent to A O has O(n + t) states, O(t) transitions, the argest predicate has size O(k). Finay, the product automaton B has O((n + t) ) states, O((t) ) transitions, and the argest predicate has size O(k) because of the conjunctions appearing on each transition. The emptiness of B can be checked using a depth-first search. Hence, the compexity O((n + t) + (t) f(k)). 5. Inverting s-efts In this section, we formaize the theory of s-eft inversion and describe how to transate it into practice using SYGUS sovers. For the sake of generaity, we state our theorems for unambiguous s-efts, but a theorems aso hod for deterministic s-efts. The functions we invert may be partia. We start by defining the inverse of an s-eft. Definition 5. (Inverse s-eft). An unambiguous s-eft A is an inverse of an unambiguous s-eft B iff, for every ist u and v, T A (u) = v iff T B (v) = u. Ceary a necessary condition for admitting an inverse is that A is injective. We provide a symboic s-eft construction for characterizing the structure of an inverse s-eft. We first define the notion of inverse transitions and then use it to buid inverse s-efts. Definition 5. (Transition inverse). A transition (p, k, ψ, ḡ, q) inverts a transition (p,, ϕ, f, q) iff k = f, = ḡ, ψ(ȳ) x.ϕ( x) (ȳ = f( x)), and x.ϕ( x) (ḡ( f( x)) = x). Given a transition r, we use inv(r) to denote the set of a transitions that invert r and r to denote some eement of inv(r). Intuitivey, if a transition r outputs the ist v when reading a ist u, the inverse transition r outputs u when reading v. This definition is symmetric i.e., t inverts r iff r inverts t. For r to have an inverse, r must be injective. Exampe 5.3. Consider two s-eft s transitions p x0<0 x<0/[x0+5,x+5] q p y0<5 y<5/[y0 5,y 5] q The two transition invert each other. The guard of the right transition, y 0 < 5 y < 5, is equivaent to the quantified formua describing the set of possibe outputs of the eft transition. The composition of their output functions is equivaent to identity function when evauated over eements satisfying the guard x 0 < 0 x < 0. If we have an effective way for inverting transitions, we can construct an inverse of an s-eft A = (Q, q 0, ) as s-eft A = (Q, q 0, def ) where = {r r }. Theorem 5.4. Given an unambiguous injective s-eft A, the s-eft A is an inverse of A and is unambiguous. Theorem 5.4 shows that the inverse of a deterministic s-eft might be nondeterministic but unambiguous. Exampe 5.5. Consider the s-eft D with the foowing transitions and initia state q 0. x 0<0/[x 0] q 0 true/[x 0] q 0 q, q x 0>0/[ x 0] 0 q q, q true/[ ] 0 The s-eft D is deterministic and injective, and its inverse D contains the foowing transitions. x 0<0/[x 0] q 0 true/[x 0] q q, q x 0<0/[ x 0] 0 q q, q true/[ ] 0 The s-eft D is non-deterministic and unambiguous. Theorem 5.4 shows that, if we have an agorithm for inverting transitions, we can directy use it to compute inverse s-efts. We say that an aphabet theory admits inverse functions if for every two types σ and γ, for every predicate ϕ( x) of type σ BOOL, and for every function f( x) of type σ γ, there exists a function g of type σ γ in D such that x.ϕ( x) (g(f( x)) = x). This cass of aphabet theories guarantees the existence of the inverse of a transition (Definition 5.). The foowing coroary immediatey foows from Theorem 5.4. Coroary 5.6. Given an unambiguous injective s-eft A over a recursivey enumerabe aphabet theory that admits inverse functions, there exists an s-eft B that is the inverse of A. Moreover, constructing B is decidabe. To compute B, we can simpy invert each transition by enumerating a functions in the aphabet theory. The existence of such functions is guaranteed because the aphabet theory admits inverse functions. In the concrete impementation of GENIC, we use more effective synthesis techniques to produce inverse functions. An interesting aspect of this agorithm is that a the transitions can be inverted independenty and the computation of B is amenabe for paraeization. Exampe 5.7. The theory of bit-vector arithmetic admits inverse functions because it operates over a finite domain.

9 The theory of arithmetic with transcendenta functions is not recursivey enumerabe and it does not admit inverse functions. For exampe, the inverse of a function f(x) = x sin x cannot be expressed using a term of finite size. 6. Inverting s-efts in GENIC The previous section presented a framework for buiding the inverse of an s-eft by computing the inverse of a its transitions. However, the proposed techniques are far from being practica. First, if we use Definition 5. directy to produce the guard of the inverse transition, we get a predicate containing quantifiers. Predicates containing quantifiers are not practica because they cannot be programmed efficienty and they are not directy expressibe in GENIC. To address the first issue, GENIC uses quantifier eimination to produce a guard that does not contain quantifiers. As we discussed in Section 3, GENIC supports the theories of inear integer arithmetic and bit-vector arithmetic, and these theories both admit decidabe quantifier eimination. Second, if we ook at Coroary 5.6, the agorithm proposed for generating the output term in the inverse transition requires an exhaustive enumeration of a the functions in the aphabet theory. In this section, we show how the probem of computing inverse functions of a transition can be encoded in the framework of Syntax-Guided Synthesis []. Background A Syntax-Guided Synthesis (SYGUS) probem is specified with respect to a background theory T that fixes the type of variabes, operations on types, and their interpretation. The goa of a SYGUS probem is to synthesize a function f of a given type which satisfies two constraints provided by users. The first constraint describes a semantic property that f shoud satisfy and is given as a predicate ψ(e) = def x.φ(e, x) with a free variabe e i.e., the unknown function. The second constraint imits the syntactic structure f is aowed to have and is given as a set E of expressions specified by a context-free grammar defining a subset of a the terms in T. A soution to the SYGUS probem is an expression f in E such that the formua ψ(f) is vaid. Inverting functions with SYGUS Definition 5. gives us a natura way to encode the probem of computing the function ḡ as a SYGUS probem. Assume that we have a transition t = (p,, ϕ, f, q) and want to generate one inverted transition t = (p, k, ψ, ḡ, q). We showed how to compute the guard ψ, but we need a ist of functions ḡ = def [g, g,..., g ] such that x.ϕ( x) (ḡ( f( x)) = x). We observe that the output functions g i are independent from each other and refine the specification for each function g i as x.ϕ( x) (g i ( f( x)) = x i ). We now have a separate SYGUS semantic constraint for each function g i. Since we do not know what terms the function g i might need, the SYGUS syntactic constraint for g i is the context-free grammar describing a the terms in the aphabet theory. Exampe 6.. The foowing SYGUS probem asks to synthesize the function g 0 (y 0, y ) : Z Z Z, which represents the first output component of the transition r in Exampe 5.3. The semantic constraint ensures that r inverts the transition t. ψ(g 0 ) = def (x 0, x ).x 0 > 0 x > 0 g 0 (x 0 +5, x +5) = x 0 A possibe syntactic constraint for g 0 is the foowing contextfree grammar. Start ::= (Start + Start) (Start Start) Var Const Var ::= y 0 y Const ::= A soution to this probem is g 0 (y 0, y ) = y 0 5. GENIC optimizations We design two techniques that are specific to the probem of inverting functions in GENIC and use them to improve the performance and the resut quaity of GENIC. We evauate both these techniques in Section 7. The goa of our first technique is to use auxiiary functions to generate GENIC programs that are sma in size and natura to read. We use SYGUS to invert the auxiiary functions that are defined in the preambe of the GENIC program and then add these functions to the SYGUS syntactic constraint when trying to invert transitions. For exampe, the GENIC program in Figure has two auxiiary functions (ines -6). GENIC checks which of these functions are injective and it computes their inverses using SYGUS. After synthesizing the inverses of the auxiiary functions, GENIC produces new SYGUS instances for synthesizing the transitions. This time, the SYGUS sover is provided with an enriched grammar that aows the synthesizer to produce terms containing the synthesized auxiiary functions and the auxiiary functions of the origina program. This optimization aso aows GENIC to produce more succinct programs. Our second technique aims at reducing the size of the SYGUS grammar and therefore the search space. Consider the foowing transition and its inverse: t = p x 0,x 0/[x+x,x] q t = p y y,y 0/[y,y y] q. First, since the functions appearing in t ony use the pus operator, their inverses ony require the minus operator. We can use this observation to simpify what operators we aow in the SYGUS grammar. Second, we observe that the first function appearing in t ony uses the variabe y as input. Intuitivey, the variabes y is enough to recover the origina vaue of x because the function f (x, x ) = x in the output of t is injective on x and constant i.e., does Even though a numerica constants can be derived using the terms +, -, 0, and, to simpify the search, we aso add a the constants appearing in the input program to the grammar given a syntactic constraint.

10 famiy program states trans auxfun max size isdet isinj inversion theory (bytes) (secs) (secs) tota max-tr res BASE64 mod BASE64 BASE3 BASE6 UTF-8 UTF-6 UU encoder s.0s 9.3s 5.8s BitVec 8 decoder s.9s s BitVec 8 encoder s.8s 0.30s 6.06s BitVec 8 decoder s.73s 34.43s.64s BitVec 8 encoder s 6.45s 0.55s 9.06s BitVec 8 decoder s 4.66s s BitVec 8 encoder s 0.30s.0s.0s BitVec 8 decoder s 0.5s.9s.3s BitVec 8 encoder s.05s 80.7s 69.0s 3/4 BitVec 3 decoder s 0.86s 8.3s 3.57s BitVec 3 encoder s 0.64s 3.9s 30.56s BitVec 3 decoder s 0.87s 3.7s.7s BitVec 3 encoder s.85s 6.4s 4.06s BitVec 8 decoder s.95s 4.6s 8.56s BitVec 8 Tabe : Performance and effectiveness of GENIC on 4 encoders and decoders. The coumn tota shows the tota time to invert the program, whie the coumn max-tr shows the maximum time of inverting a singe transition. In the coumn res, the symbo denotes that a transitions were inverted. For the UTF-8 encoder, GENIC coud ony invert 3 transitions out of 4 and we report the tota time taken to invert the 3 transitions. not depend on x. In genera, when inverting a transition p ϕ( x)/[f( x),...,f k( x)] q, each function in p might ony require a subset of the variabes {y,..., y k }. Intuitivey, a subset of the variabes ȳ = {y i,..., y ij } {y,..., y k } is enough for recovering x i if f = [f i,..., f ij ] is injective with respect to ȳ and constant with respect to Y \ ȳ. With abuse of notation we use ā to denote an assignment to the variabes in ȳ, c # to denote an assignment to the variabes in Y \ ȳ, and f(ā, c # ) (resp. ϕ(ā, c # )) to denote the resut of substituting the variabes in ȳ with ā and the variabes in Y \ ȳ with c # in f (resp. ϕ). Formay, the set of variabes ȳ is enough for recovering x i iff for every ā, b, c #, d #, such that ā b, then the foowing impications hod: ϕ(ā, c # ) ϕ( b, c # ) f (ā, c # ) f ( b, c # ) () ϕ(ā, c # ) ϕ(ā, d # ) f (ā, c # ) = f (ā, d # ) () Equation guarantees that f is injective with respect to ȳ, whie equation guarantees that f is constant with respect to Y \ȳ. Using this definition, we can exhaustivey search for a minimum set of variabes ȳ needed to synthesize each output function. This set might not be unique. The variabe reduction procedure does not sacrifice competeness, but, in genera, reducing the SYGUS grammar may prevent the existence of inverse functions. In practice, we run the synthesis agorithm in parae with and without optimization. 7. Evauation We now describe the impementation detais of GENIC and evauate its effectiveness and performance on a comprehensive set of benchmarks. The experiments were run on an Inte Core i7 4.00GHz CPU with 3 GB of RAM. Impementation GENIC is written in JAVA, and uses the symboic automata ibrary SVPAib [6] for the required automata operations. The aphabet theories of bit-vector and inear integer arithmetic are impemented using the SMT sover Z3 [0] and are aso the ony theories supported by existing SYGUS sovers. We experimented with a the SYGUS sovers from SYGUS-comp 04, 05, and 06 [3] and chose the Enumerative CEGIS sover 3, the winner of the 04 competition, as our SYGUS sover. 4 The other sovers were either sower or did not support the fu SYGUS syntax. Benchmarks We evauate our technique on both rea programs and artificia benchmarks. A programs are deterministic. First, we assess whether GENIC can invert 4 efficient bit-vector impementations of string encoders and decoders that are commony used in networking. The set of considered coders can be found in Tabe. A these programs operate over the theory of bit-vectors and represent characters as groups of bytes. The BASEX encodings are binary-to-text encoding schemes that represent binary data in ASCII string format. The modified BASE64 encoder is the specia version of the BASE64 encoding mentioned in Section. The UTFX encodings transate Unicode characters int groups of bytes of fixed ength. The UU encoding is simiar to BASE64. The programs have 0 to 3 auxiiary functions, to states, to 6 transitions, and sizes varying between 473 and 974 bytes. Second, we use an artificia set of 7 programs of varying size to evauate how the number of states and transitions in the program affects the performance of GENIC. These programs operate over the theory of inear integer arithmetic and are described in Section Avaiabe at 4 The sover CVC4, which won the 05 competition, was aso abe to hande severa of our benchmarks. However, it was sower than Enumerative CEGIS and produced very arge and unreadabe resuts, especiay for the theory of bit-vectors.

11 seconds TO seconds TO both ony-mining ony-aux none size of target function Figure 4: Synthesis time vs size of target functions. 0 B64E B64D mb64e mb64d B3E B3D B6E B6D UTF8D UTF6E UTF6D UUE UUD 7. Effectiveness of GENIC In this experiment we evauate how effective GENIC is at inverting rea string coders. The resuts are shown in Tabe. The timeout for inverting a transition was set to 0 minutes. GENIC successfuy inverted 3 programs out of 4 and coud prove injectivity and determinism for a the 4 programs. Checking determinism took ess than 0. seconds per program (avg: 0.s) and each injectivity check took ess than 0 seconds (avg:.s). Inverting programs is the most costy operation. GENIC took between and 38 seconds (avg: 5s) to invert each program and faied on one program. For the UTF-8 encoder, GENIC was ony abe to invert 3 transitions out of 4 because the faiing transitions required synthesising an inverse functions that contained 5 operators and terms. Currenty, this size is beyond the reach of existing SYGUS sovers. Athough Theorem 5.4 shows that the output of GENIC can be a nondeterministic unambiguous program, in this experiment, GENIC aways produced a deterministic program. As we observed in Section 5, our inversion agorithm is amenabe for paraeization because each transition can be inverted independenty. For each program we report the maximum time it took to invert a singe transition (max-tr) and observe that, in many cases, a singe transition dominates the tota runtime. Despite this fact, inverting each transition in parae yieds a.69x average speedup. 7. Detaied Evauation We now discuss and evauate quantitative aspects of our agorithms. Size of inverted functions In Section 7. we mentioned that the SYGUS sover coud not synthesize functions with more than 5 operators and terms. In this experiment we report the runtime of each ca to the SYGUS sover performed during the experiments showed in Tabe and measure how the performance of SYGUS degrades when the size of the inverse function increases. The resuts are shown in Figure 4. In genera, we can observe an exponentia trend in the size of the target function. This fact further shows how GENIC Figure 5: Inversion time with and without optimizations. ony-aux indicates that ony the optimization that synthesizes inverse of auxiiary functions is used, ony-mining indicates that ony the optimization that simpifies the grammar given to the SYGUS sover was used, both indicates that both optimizations were used, and none that no optimization was used. A ine reaching 00 indicates a timeout. is abe to break the arge synthesis probem of inverting a program into sma synthesis probems that are within reach of existing SYGUS sovers. Impact of optimizations We evauate the impact of the optimizations we discussed at the end of Section 6. Figure 5 shows the time taken to invert the programs in Tabe when using a optimizations (a), ony the technique for synthesizing auxiiary functions (ony-aux), ony the technique for reducing the grammar given to the SYGUS sover (onymining), and no optimization (none). GENIC can invert 3 programs when a optimizations are used. When both optimizations are turned off, GENIC can ony invert 5 programs and this number does not change when we do not synthesize auxiiary functions. When we ony enabe the technique for synthesizing auxiiary functions, GENIC can invert 9 programs. This experiment motivates the need for both our optimizations and shows how the design of GENIC is beneficia in the synthesis process. In particuar, thanks to the structure of GENIC programs, we are abe to synthesize auxiiary functions which are shown to be crucia for performance. Size of inverted programs Figure 6 compares the sizes of the programs generated by GENIC against the sizes of programs written by us. The sizes of the generated programs are, on average,.7 times arger than those written by us. There are two factors eading to the increased sizes of the generated programs. First, the predicates generated by the SMT sover and the functions generated by the SYGUS sover are typicay not minima. Second, sometimes the synthesized programs do not use the auxiiary functions in paces where these functions coud hep reducing the size of the programs. Despite this fact, the programs generated by