EP1390831A1 - Dispositif et procede pour la signature, le marquage et l'authentification de programmes d'ordinateur - Google Patents

Dispositif et procede pour la signature, le marquage et l'authentification de programmes d'ordinateur

Info

Publication number
EP1390831A1
EP1390831A1 EP02735488A EP02735488A EP1390831A1 EP 1390831 A1 EP1390831 A1 EP 1390831A1 EP 02735488 A EP02735488 A EP 02735488A EP 02735488 A EP02735488 A EP 02735488A EP 1390831 A1 EP1390831 A1 EP 1390831A1
Authority
EP
European Patent Office
Prior art keywords
program
software
secret
instructions
variables
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
EP02735488A
Other languages
German (de)
English (en)
Inventor
Patrick Thales Intellectual Property COUSOT
Michel Thales Intellectual Property RIGUIDEL
Arnaud Thales Intellectual Property VENET
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Thales SA
Original Assignee
Thales SA
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority claimed from FR0106024A external-priority patent/FR2824401A1/fr
Application filed by Thales SA filed Critical Thales SA
Publication of EP1390831A1 publication Critical patent/EP1390831A1/fr
Withdrawn legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
    • G06F21/16—Program or content traceability, e.g. by watermarking
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/10—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM]
    • G06F21/101—Protecting distributed programs or content, e.g. vending or licensing of copyrighted material ; Digital rights management [DRM] by binding digital rights to specific entities

Definitions

  • the present invention belongs to the field of devices and methods for preventing and / or auditing a use of a computer program not authorized by its author, publisher or distributor.
  • Audit and audit are the devices and methods which modify the program in a characteristic manner of the copy of the program, in a manner that is not easily detectable by the user, without altering its functionalities.
  • US Pat. No. 5,559,884 discloses a method and a device for characteristically modifying the copy of the program the order of execution of blocks of said program.
  • the present invention aims to remedy the drawbacks of this second type by disclosing a device and a method for calculating a signature of the software to be protected, characteristic of said program, resistant to tracking methods without affecting the performance of the program to be protected and making it possible to mark the software in a secret manner, the holders of the secret being able to identify the mark and the signature.
  • the invention discloses a product / computer program for processing the instructions of a computer program in source code, characterized in that it comprises a module for choosing according to predefined criteria the instructions of said software. to which a transcoding program will be applied and a module for choosing from among several the secret transcoding method to be applied to said instructions.
  • the invention also discloses a product / computer program of the above type, the secret method of transcoding of which produces a semantic signature of the software.
  • the product / computer program of the above type comprises a module for inserting the transcoded instructions into the software.
  • the invention also discloses a method for processing the instructions of software in source code comprising a step for choosing according to predefined criteria the instructions of said program to which a transcoding program is applied and a step for choosing from among several the secret method of transcoding to be applied to said instructions as well as a preferred embodiment of the method where the secret method of transcoding produced by a semantic signature of the software as well as a variant of the invention where the method further comprises a step for inserting the instructions transcoded into the software.
  • FIG. 1 shows a block diagram of the device and method for choosing the transcoding method and transcoded instructions in the program
  • FIG. 2 shows the diagram of the device and method in one of its alternative embodiments
  • FIG. 3 shows the block diagram of the device and method for decoding a program modified according to the principle of Figure 1;
  • FIG. 4 shows the diagram of the device and the method for decoding a program modified according to the device and the method of FIG. 2.
  • the invention finally discloses a computer product / program and a method for recognizing the signature of the software.
  • a software protection / prevention process is a set of techniques that make copying and fraudulent use of software more difficult.
  • a computer program is an interpretable program or can be compiled into an interpretable program. • A program is written in a certain programming language called the computer program language.
  • the labeling of a document or a code consists in including visible or invisible marks, separated from the content of the object, which identify by fields the software object (designation, name of the author, name of the recipient, terms of the user license) and a final digital signature field which completely links the label to the content of the object and at the same time guarantees the integrity of the object.
  • the tattoo consists of inserting visible or invisible marks embedded in the body of the object. These marks distributed in the body of the object are otherwise undetectable at least indelible for those who do not know the secret key which generated the underlying motif.
  • a tattoo is information hidden in digital data that does not change its meaning.
  • Tattooing a code consists in transforming it into an equivalent code without modifying its semantics, by adding hidden and recoverable information thanks to a secret called key.
  • Two software codes are semantically equivalent if they have the same observable behavior, ie for example, if for any possible input, the outputs of the program are the same.
  • a signature process consists in joining to an object a characteristic segment of data (summary), obtained using a secret method.
  • a leaching technique is an attempt to erase the mark without changing the semantics.
  • a program written in a particular language (for example Java), represents a series of instructions operating on the state of the computer system.
  • the state of the system at an instant t consists of the value of the program variables and the system variables (input / output flow queues). “ The state of the associated system is called a set of variables made up of existing variables and / or other additional variables.
  • a semantics is a mathematical model defining all the possible behaviors of a program at execution at a certain level of observation.
  • “Obfuscation” is the transformation of a program into a semantically equivalent program in a form difficult for a computer scientist to understand.
  • Semantic Static Analysis is the automatic determination of semantic properties of programs. To ensure the security of any digital document
  • the security rules for example the data relating to the software license, but these rules can be more personalized and more complex relating to the document for the authorized user. These rules are written in another digital document (generally apart, such as a header, a label, etc.).
  • the document is protected (or not) by cryptographic methods (content encryption, for example).
  • the label is protected by cryptographic techniques.
  • the whole is generally welded by cryptographic mechanisms (electronic signature, for example).
  • the identification data of a program even if these depend on the time, place and context, can be deviated from their own context.
  • prevention and devices are the methods and methods which verify that the person or the machine which seeks to use the program in a certain way has the necessary rights. Many devices and methods in this category have been provided for this purpose. These are software protection devices (their use generally depends on a hardware device: smart card, "dongle") or deterrent of fraudulent use of software (label, banner, brand outside or outside. inside a source program, instructions in machine language in the executable program to identify a context of use).
  • patent 5,559,884 discloses a method and a device for characteristically modifying the order of execution of blocks of said program, by insertion of call and return instructions.
  • the invention belongs to a third category, that of static semantic devices and methods.
  • the proposed device applies specifically to software programs which have a given semantics, ie programs written in a programming language ("programming languages"): it is particularly applicable to interpreted programs (Java, PostScript, etc.) because these programs, once written in machine languages, are easily decipherable by reverse engineering in their original form, understandable by a computer scientist. But it is understood that this device is also applicable to programs written in compilable languages (C, C ++, Basic, Ada, Pascal, VHDL, Estérel, ...) to authenticate and control the origin, the content or the destination.
  • programming languages ie programs written in a programming language
  • interpreted programs Java, PostScript, etc.
  • this device is also applicable to programs written in compilable languages (C, C ++, Basic, Ada, Pascal, VHDL, Estérel, ...) to authenticate and control the origin, the content or the destination.
  • the device in its preferred embodiment depends on the semantics of the language. So, tattoo artists Java, VHDL, etc. are different. They can have similar parts (for the semantics of their arithmetic operations) but sometimes specific (Pointers in C language).
  • the device is applicable to tag languages for parts that contain programs (“scripts”). For XML, the other parts fall under image tattooing procedures (imperceptible modifications of the presentation on screen or paper).
  • the device is also applicable to parts that include operations (“macro” programs to “center”, “justify”, etc.).
  • the invention is based on the principles of semantic analysis.
  • the problem that the inventor proposes to solve is the same approach: if the instructions added to the program to be protected belong to a subset of the invariants of said program, then the said instructions will execute without error and will not modify the functionalities said program. There are several relevant subsets. It is wise to choose a subset that is particularly representative of the type of programs to be protected.
  • the selection of the instructions to be transcoded is carried out according to predefined criteria including the selection of subset of program invariants as defined above.
  • the module (310) of FIG. 1 makes it possible to carry out this selection of the instructions to be transcoded from the definition of the characteristics of said instructions (operations on integers, operations on floats, initialization of variables, conditional loop, branching. .) in application of at least partially predefined criteria.
  • the configuration of the module (310) of the compiler (30) then allows the automatic selection of the instructions to transcode. Operator intervention will also be possible to select an autonomous part of the program to be signed semantically.
  • a program is assimilated to several classes made up of several methods, themselves being able to call upon methods of other classes and other packages. It is for this reason that in this particular case we prefer to sign the smallest autonomous entity of a java program: the method.
  • the parts of the program to be signed must be the innovative and / or sensitive parts of the program. In general they concern the algorithmic part of the program.
  • the module (320) contains the possible transcoding methods for each language.
  • a transcoding method can have a degree of sophistication corresponding to the level of protection desired. For a given level of protection, an allocated number of possible parameters will be attributable to users or classes of users.
  • each transcoding method has a secret to keep. Indeed, its knowledge will allow the decoding and therefore the removal of the additional instructions, which will delete any evidence of a possible later unauthorized copy.
  • a transcoding table is an application which, with any operation carried out on the state of the system, associates another operation carried out on the state of the associated system.
  • Creating a secret semantics therefore amounts to creating a corresponding static analysis, which consists in defining the associated variables, and the relationship between the actions operating on the state of the system and those operating on the associated variables.
  • the invention takes into account all the actions operating on the state of the environment system of the computer program: such an action can affect the execution stack, modify the content of a system variable, call a function, order reading. another variable, perform a logical or mathematical operation, create an object, send or receive an I / O flow, read an element of an array ...
  • Using a secret transcoding table strengthens the signature and watermarking devices . Without this secret, it is very difficult to find the same signature (according to the classic argument in crypto: one cannot reasonably try all possible combinations) just as it is almost impossible to find a brand.
  • the proposed semantic signature characterizes the algorithm developed as such, and makes it possible to find programs that have equivalent semantics.
  • the tattoo mark is obtained by static analysis (after transcoding) of the program, which is the key to our secret. There is little noise added, and the brand is therefore more resistant.
  • the secret transcoding table makes it more difficult to detect the mark.
  • the software signature (10) is inserted in the software (10) in the form of a mark.
  • the module (330) performs on the one hand the transcoding of the classified instructions with the chosen method and on the other hand the insertion of the transcoded instructions in the program to be protected.
  • the main algorithm of the module (330) aims to optimize the placement of the transcoded instructions. She must be adapted to the typology of instructions and transcoding methods. Compilers normally contain tools for optimizing code and checking the propagation of constants.
  • the insertion of transcoded instructions into the program to be protected must therefore respect a certain number of minimum robustness rules: it must be ensured that the variables containing the tattoo marks have an influence on the outputs of the program. In other words, to avoid outright deletion by an optimizer, it must be ensured that the content of the variable will be taken up by an instruction from the initial program.
  • the instructions to be added to the initial program are calculated by the reverse transcoding table.
  • the instructions added must be executed without error and must not modify the functionality of the programmed.
  • the brand is therefore a set of semantic properties of the transcoded program.
  • Our watermarking device therefore consists in calculating the instructions to be added in the initial program which will make it possible to obtain these new properties in the hidden space.
  • the insertion of transcoded instructions into the program to be protected must respect a certain number of minimum robustness rules: it must be ensured that the variables and operations containing the tattoo marks give the impression that they have an influence on the program outputs. For example, to avoid outright deletion by an optimizer, you must ensure that the content of the variable will be taken up by an instruction from the initial program. (dynamic value allocation)
  • Figure 2 shows an exemplary embodiment.
  • the method (310) of FIG. 2 will therefore be applied to each method of the program (or at least to those which have an algorithmic content which one wishes to protect).
  • the selection of instructions to transcode takes into account the dynamic execution of Java code: the allocation of objects is done "on the job", that is to say according to the context of use of processor resources , memory and inputs / outputs and, if applicable, other members of the network.
  • the instructions relating to the objects are therefore not recommended for the tattoo since it must be independent of the context.
  • the watermarking must therefore relate to scalar values or references to objects which are the only operands to be allocated on the program stack.
  • the predetermined criterion can include the choice as instructions to transcode operations on integers, floats or Boolean values. For standard programs, operations on integers will be chosen. For computer-aided design, simulation or three-dimensional modeling programs where operations on floating scalars dominate, these operations will be chosen instead.
  • the module (310) of FIG. 2 is then only used to select the instructions (110), (130), (150) of the methods of the program (10) which include operations on the integers.
  • a transcoding which respects the semantics of the instruction then consists in carrying out the same modulo operation at any integer N less than 2 32 .
  • An alternative consists in carrying out a different operation chosen in a permutation table, still in modular algebra.
  • the module (320) has, in this case, the main function of keep the table of secrets assigned to given user classes for given programs.
  • the module (330) for calculating and inserting the transcoded instructions is a series of instructions from the compiler (30) of the type described below.
  • the generic method of reading the watermarking is presented in FIG. 3. It supposes the knowledge of at least part of the watermarking parameters. It is thus possible to assign to several levels of a software distribution chain (buyer, wholesaler, distributor, retailer) brands of their own.
  • the knowledge of the secret number or numbers N k makes it possible to find, by a step-by-step execution of the program in the compiler, the variables which have a modulo congruence N at a given instant and then to trace this variable until initialization.
  • the table of secrets can be easily contained on a microprocessor card which will be connected to the computer containing the interpreter.
  • the authorized user only has to know a public key which will activate the program for reading secrets corresponding to his user identification.
  • the private keys that define the table of secrets therefore do not have to be disclosed.
  • Two examples given in appendices 2 and 3 make it possible to illustrate the application of semantic static analysis to the authentication of the signature of the software with two simple cases of calculation of the fixed points of the hidden variables.
  • this device and this watermarking method can be combined with devices and methods of the prior art to render the program unusable to an unauthorized user (prevention) to trace the possible dissemination of said program by an authorized user to users. not authorized (audit). It will suffice for this not to communicate to authorized users the keys allowing them to find the tattoo.
  • the device and the method for automatically authenticating the codes which one will authorize to enter on a network or on a given station is also possible.
  • the watermark is similar to an authentication certificate which the network monitoring station or the station will have the reading key.
  • Annex 4 presents a glossary.
  • Annex 5 presents an embodiment of the invention with a finer division into modules.
  • Annex 6 and Annex 7 present new examples of embodiments (examples 3 and 4).
  • the tattooed method is the primary method of Fibonacci class, which calculates the value of n 'th term of the Fibonacci sequence, defined by the
  • the first will insert the hidden value 2507, the second 3012.
  • Our two tables associate with each algebraic operation on integers the identical algebraic operation modulo a number N.
  • N is 10,000 and V 17.
  • V is 50.
  • the watermarking of our method consists of the insertion of two variables j and k, taking respectively the values 2507 and 3012 in our secret space.
  • the tattoo consists of two stages:
  • the mark is found by Static Analysis, and the method of approximation of the fixed point by iterations.
  • the method from which the semantic signature is extracted is a method of sorting bubbles.
  • the signature of the method consists in the semantic static analysis of the method and the detection of properties. Analysis of the program the properties are found by Static Analysis, and the method of approximation of the fixed point by iterations.
  • a software or hardware protection-prevention process is a set of techniques that make copying and fraudulent use of software or electronic circuits more difficult.
  • a program is written in a certain programming language called the computer program language.
  • the interpretation of a program is the translation of the series of words composing it into a series of actions called program execution.
  • a software computer program is an interpretable program or compilable into an interpretable program.
  • a hardware computer program is a program achievable by an electronic circuit and specified by a circuit description language.
  • An element of a computer program is a part not necessarily related to the text of the program corresponding to one or more instructions, possibly composed (such as a conditional choice command or by case, a loop, etc.), a declaration or description of one or more data structures possibly including the operation or operations acting on these data structures, one or more procedures or methods, one or more modules, etc.
  • a semantics of a software or hardware program is a mathematical model defining the set of possible behaviors of a program at execution at a certain level of observation.
  • Two software programs are semantically equivalent (or functionally equivalent) if they have the same observable behavior, i.e. they execute functionally equivalent, (for example, if for any possible entry, the program exits are the same).
  • An abstract semantics of a software or hardware program is a mathematical model defining an over-approximation or a sub-approximation of the set of possible behaviors of a program at execution.
  • a signature is characteristic information (label, sticker or summary) associated with an object (here, a software or hardware program). This information can depend on an intrinsic or extrinsic property of the object. These properties can authenticate the form and content of the object's content (coding, format, syntax, aesthetics, semantics) or its traceability (the history and / or the future of this object).
  • a secret signature is a signature obtained using a method using a secret.
  • a semantic signature is one. signature specified according to the semantics of the object (here, of the program written in a programming language, with a defined semantics).
  • An authenticator is a secret proof of the possession of information or a right (for example designation of the object, name of the author, name of the recipient, terms of the license of use, etc.).
  • a mark is a component of an object which identifies it and which, in the context of the invention, makes it possible to find a signature of the object.
  • the labeling of an object or a program consists in making a label which is generally separated from the content of the object or embedded in the object in an easily identifiable place.
  • tattooing involves embedding one (or more) mark (s) in the body of the object.
  • This mark distributed in the body of the object is generally if not undetectable at least indelible.
  • the object grafted with this mark is called the tattooed object.
  • Obfuscation is the transformation of a program into a semantically equivalent program in a form difficult to understand by a computer scientist but usable by a user. To the Unlike tattooing, obfuscation makes a program confidential (thanks to the difficulty of understanding it) but does not allow authentication [cf.
  • a program watermark is robust if it resists compilation optimization, obfuscation, labeling and another watermarking, all these operations being applied later.
  • the inventor uses the principles and techniques of semantic static analysis of programs by abstract interpretation, cf. [P. Cousot & R. Cousot, “Abstract Interpretation: A unified lattice model for static analysis of programs by construction or approximation of fixpoints”, International conference “Principles of programming languages, POPL'77”, p. 238 - 252, ACM Press, January 1977] and [P. Cousot & R. Cousot, “Systematic design of program analysis frameworks”, International conference “Principles of programming languages, POPL'77”, p. 269—282, ACM Press, January 1979].
  • This SAS secret abstract semantics consists of the secret abstract domain D (N) and the corresponding abstract operations for the constructs and primitives of the family of programming languages considered, obtained using the principles of abstract interpretation.
  • any abstract domain D (N), parameterized by a number N can be reused with any keys.
  • an infinity of abstract domains D (K), parameterized by a key K which can be used.
  • the abstract domains published in the scientific literature are not suitable, in the sense that they are not parameterized by a key K (even chosen isomorphically to integers or to ordinals).
  • the transformation of any abstract domain usable for classical static semantic analysis, the concretization of which provides information on integer values (except for an injective coding) into an abstract domain D (N) parameterized by an integer N constituting the secret key K N (close to said coding).
  • the method consists in abstracting (in the sense of abstract interpretation) concrete operations into an abstract operation considering the concrete operation performed modulo N. This abstraction is then extended to the program control elements according to the principles of semantic static analysis by abstract interpretation, possibly using the widening and shrinking techniques known to those skilled in the art.
  • module A is secret, it is not possible to break it by brute force. In fact, there is no possible enumeration of all the abstract parametric domains that can be used.
  • the invention also discloses a device (which can be produced by a computer product / program) including: A module DA based on an abstract domain Dj (K) parameterized by a secret key K chosen from among a very large number possible, making it possible to generate a program implementing the secret abstract semantics SAS of the family of software or hardware programming languages considered;
  • the method / module S uses a secret abstract semantics SAS for the constructions and primitives of the family of programming languages considered, to make the semantic static analysis of the original program P software or hardware, the result of this analysis providing the secret semantic signature SSS of the program P.
  • the module S builds a representation of the system of fixed-point equations, the approximate solution of which defines the SASP abstract semantics of said software or hardware program P.
  • This SASP abstract semantics of the software or hardware program P is defined according to the principles of static analysis by abstract interpretation of the concrete semantics of the program according to the secret abstract semantics SAS for the constructions and primitives of the family of programming languages considered.
  • This SASP abstract semantics is calculated by elimination, or by iteration with acceleration of convergence.
  • the secret semantic signature SSS of a software or hardware program P makes it possible to verify whether a software or hardware program P 'has an equivalent semantic signature.
  • TPC Third Party of Trust
  • the authentication of the software or hardware program P will then be carried out with the TPC by comparison of the signature produced SSS 'of the software or hardware program P 1 to be analyzed with that (SSS) which has been filed.
  • the software or hardware program P is not copy protected P 1 , but two cases arise:
  • SSS ' is different from SSS: the modifications that P has undergone are detectable, since in the case of semantic modifications (for example, addition of a virus, modification of an algorithm), the signature is different;
  • SSS ' is equal to SSS: the software or hardware program P' is a copy of P or if the software or hardware program P has been obfuscated (manually or automatically) to become P ', the signature SSS' of P 'will be equal to that of P, which will prove, with an extremely low probability of error, that the software or hardware program P has been pirated, this piracy being masked by an editing make-up.
  • a marking method M For the invention, a mark m is a software or hardware program element which can be inserted into a software or hardware program by the method described in module B below.
  • Pm be the simplest possible software or hardware program into which the mark m can be inserted.
  • this program Pm has a secret semantic signature, computable by the module S, called the secret semantic signature of said mark m and denoted SSS (m).
  • a “mark” m is a triplet consisting of a “mark location”, a “initialization mark” and a “induction mark”, one of the latter two possibly being empty.
  • Pm be a software or hardware program of the family of languages considered, as simple as possible, which declares if necessary
  • the marking method M is parameterized by a secret abstract semantics SAS (for example, produced by the module A from an abstract domain Di (K) as a function of a secret key K) and a secret semantic signature SSS;
  • a secret abstract semantics SAS for example, produced by the module A from an abstract domain Di (K) as a function of a secret key K
  • the module M calculates an abstract value 's' of the abstract domain Di (K) as a function of the secret semantic signature SSS, according to the coding of the secret abstract semantics SAS.
  • This abstract value 's' is chosen so that there are many concrete values 'x' whose abstraction according to the principles of abstract interpretation or that of the singleton ' ⁇ x ⁇ ' is the abstract value 's' .
  • this value 'x' can be that of a variable in the case of a non-relational analysis or of a vector of variables for a relational analysis or the value of any object analogous to a vector of variables;
  • the method M chooses, according to the principles of abstract interpretation, any one of the concrete values 'a' whose abstraction or that of the singleton ' ⁇ a ⁇ ' is the abstract value s;
  • the method M then chooses, according to the principles of abstract interpretation, a concrete operation 'f whose functional abstraction leaves invariant the abstract value' s 'but not the corresponding concrete values (i.e. if' x 'is a concrete value whose abstraction according to the principles of abstract interpretation or that of the singleton' ⁇ x ⁇ 'is the abstract value' s' then 'f (x)' is generally different from 'x' while that the abstraction according to the principles of the abstract interpretation of 'f (x)' or that of the singleton ' ⁇ f (x) ⁇ ' is equal to 's');
  • the method M then chooses a "mark location"'X' which can be an existing program variable which is useless or is not alive in the elements of the program P to be tattooed, a new auxiliary variable, a useless or additional field a data structure dynamically allocated, etc. whose values are taken into account in the semantic static analysis used to determine the secret abstract semantics of the program;
  • the method M determines an “initialization mark” 'la' which consists of one or more primitives or constructions of the family of languages considered to be interpreted as an assignment of the concrete value 'a' defined above to the 'X' brand location;
  • the method M determines an “induction mark” 'If comprising one or more primitives or constructions of the family of languages considered interpreted as an assignment of the value of' f (X) 'to the mark location' X '.
  • these primitives or constructions will be assignments, parameter passages, unifications, etc.
  • the mark m is chosen such that, according to the principles of abstract interpretation, the static semantic analysis of the program Pm, according to the secret abstract semantics and in accordance with the directives of module S, determines in a recognizable manner by the holder of the SAS secret, the abstract value 's' defined above and such that the secret semantic signature of the program Pm, as defined above, is that SSS (m) of the mark.
  • the invention also discloses a device DM (which can be produced by a computer product / program) which, from the program implementing the secret abstract semantics SAS and data representing the secret semantics SSS of the program P, calculates the text of the mark m.
  • the camouflage method / module B takes as parameter the original software or hardware program P, a selection of the elements of the program P to be tattooed and a mark m.
  • Module B provides the tattooed program PT which is a fusion of the original program P and the mark m. This fusion is made without altering the secret abstract semantics of the mark, nor the functionality, of the original program, which makes it possible to find the secret semantic signature SSS (m) of the mark m from the secret semantic signature SSS (PT) from the tattooed program PT.
  • the insertion of the instructions into the software or hardware program to be protected P must comply with a certain number of minimum robustness rules. For example, to avoid outright deletion by an optimizer using “slicing” extraction techniques, it is necessary to ensure that the variables and operations containing the tattoo marks give the impression that they have a possible influence on the observable semantics (for example the outputs) of the program.
  • Said potential dependence can be a simple syntactic dependence chosen so that the demonstration that this syntactic dependence does not entail a semantic dependence requires complex proof of a semantic equivalence of software or hardware programs. This is the case for example of the dynamic allocation of value (semantically useless but this is undecidable) of certain values calculated by the operations containing the tattoo marks.
  • the mark m created by the module M the selection of the elements to be tattooed in a software or hardware program P as chosen by the PS module and used by module B must meet the criteria set out below.
  • the “initialization marks” 'la' are used to make the initializations required by the semantics of the family of languages considered. In addition, if necessary, for the language family considered, any declarations must be added to the tattooed program PT if the nature of the "mark location" 'X' requires it.
  • the camouflage module B adds primitives or constructions to the tattooed program PT making active the values possibly used in the “mark locations” 'X'.
  • One possible solution consists in using the values possibly used in the “brand locations” in the calculation of active variables of the tattooed hardware or software program PT, or else in assigning the values of the “brand locations” 'X' to dynamic variables. of the PT tattooed program, more generally by ensuring that the dynamic lifetime of the “brand locations” 'X' is that of the PT tattooed program.
  • a camouflage DB module Among the preferred embodiments of method B above, the invention also discloses a DB device (which can be produced by a computer product / program) which, from the text of the software or hardware program P, data for selecting the elements to be tattooed in P and text of the mark m, produces the text of the program software or hardware PT whose semantics is functionally equivalent to that of P and which conceals the mark m.
  • the process PS for selecting the abstract tattoo domain and the elements to be tattooed in the software or hardware program P depends on the security policy to be applied to this program P:
  • the mark can be distributed in the program in different and distant places by choosing for example static semantic analyzes by abstract interpretation based on abstract domains making it possible to ignore the control structures in the calculation of the secret semantic signature so that the random distribution of the marks has no effect on this analysis; this strategy is for example applicable when the mark is used to authenticate an entire program P, relatively large in size.
  • Another security policy consists in tattooing the innovative and / or sensitive parts of the P program.
  • the elements selected for watermarking relate to the algorithmic part of the program (algebraic operations or manipulation of variables in RAM).
  • this algorithmic part can be: - Significant elements of the program which are semantically autonomous.
  • Java TM for example, a program is assimilated to several classes composed of several methods, themselves being able to call upon methods of other classes and other packages.
  • a security policy for Java TM can therefore consist in tattooing the methods which are the smallest significant autonomous entities of the program. Another choice would be to tattoo Beans TM.
  • the elements to be tattooed can be selected automatically on syntactic (procedures, modules, etc.) or semantic criteria (by a static dependency analysis) or manually by intervention of an operator.
  • syntactic procedures, modules, etc.
  • semantic criteria by a static dependency analysis
  • Several different security policies can be implemented on the same program P by repeating successive tattoos of the same original software or hardware program for different actors. It is thus possible to assign to several levels of a hardware or software distribution chain (buyer, wholesaler, distributor, retailer) brands that will be their own.
  • this device and this watermarking method can be combined with devices and methods of the prior art to make the hardware or software program unusable for an unauthorized user (prevention) to trace the possible dissemination of said program by an authorized user. to unauthorized users (audit). It will suffice for this not to communicate to authorized users the keys allowing them to find the tattoo.
  • the device and the method for automatically authenticating the software or hardware programs which one will authorize to transit on a network or to be hosted on a given computer station can be compared to an authentication certificate for which the network monitoring station or the computer station has the reading key.
  • the invention also discloses a DPS device (which can be produced by a computer product / program) which, from the text of the software or hardware program P and a family of abstract domains D ⁇ ..., D m , chooses an abstract domain D and selects the elements of the program P to be tattooed.
  • the watermarking method T uses an encryption module C, which implements a bijective function to calculate a secret semantic signature SSS as a function of an authenticator Auth, possibly using the secret abstract semantics SAS. From this secret semantic signature SSS and from said secret abstract semantics SAS, the marking module M described above produces a mark m.
  • the module T also uses the module B described above which, from said mark m, from the software or hardware program P and from the selection of the elements to be tattooed in P provides the tattooed software or hardware program PT.
  • the invention also discloses a device DT (which can be produced by a computer product / program) to conceal an authenticator Auth in the text of an original program P software or hardware thanks to a program implementing secret SAS abstract semantics and data for selecting the elements of P to be tattooed.
  • the general method G is used to tattoo a program P.
  • the PS module described above is used to automatically choose or interactively the parameterized abstract domain which will later be used to perform the static analysis by abstract interpretation by the authentication module Au as well as to automatically or interactively select the elements of the software or hardware program to be tattooed P.
  • the module A describes above is used to calculate the secret abstract semantics SAS from the previously selected parameterized abstract domain and a secret key, generally chosen in interaction with an operator but which can also be automatically, even randomly.
  • the module T described above uses the program P, the secret abstract semantics SAS, an authenticator Auth and the selection of the elements to be tattooed in P to produce the tattooed software or hardware program PT.
  • Variants consist in fixing once and for all the abstract domain which is used by the module G and in choosing the secret key K using a standard cryptographic method.
  • DAo and DSo devices conform to modules A and S for the concrete semantics of the object code and such that the composition of DA then DS for PT gives the same secret semantics SSS (with the exception of morphism) as the composition of DAo and DSo for PTo. Consequently, the device DAu using the device DSo calculates a representation of the secret semantic signature SSS of the program PTo, which is also that of the PT program and can therefore be used by the DAu device to find the authenticator of the PT program.
  • a Dca authenticating compiler integrates the device DG of FIG. a compiler for a hardware or software computer language which can be used as an option for tattooing object code.
  • the device DAu makes it possible to find the authenticator of the tattooed object program.
  • the General DG Module Among the preferred embodiments of the above G watermarking method, the invention also discloses a DG device (which can be produced by a computer product / program) to conceal an Auth authenticator in the text of an original program P software or hardware (depending on the choice of an abstract domain configured by a secret key).
  • An authentication process Au takes as parameters the software or hardware program marked PT and the secret abstract semantics SAS. It calculates the original Auth authentication.
  • This module A is composed of two sub-modules: the module S, described above, which from the watermarked software program PT and the secret semantics extracts the secret semantic signature SSS (PT) and consequently that SSS (m) of the mark m hidden in PT; a decryption and extraction module F, which is the inverse of the encryption module C used in the watermarking module T, takes into account sets the secret semantic signature SSS (PT) to extract the original authenticator Auth from P.
  • the decryption module F can also constitute a secret, just like the module C.
  • the invention also discloses an authentication device DAu (which can be produced by a product / computer program using the device DS above and a device for DF decryption) for the authentication of a tattooed program PT by calculating its authenticator Auth.
  • FIG. 5 shows a block diagram of method A for generating the secret abstract semantics SAS from an abstract domain Di (K) dependent on a secret key K;
  • FIG. 6 shows a block diagram of the method S for calculating the signature SSS according to the secret semantics SAS of a software or hardware program P;
  • FIGS. 5A and 6A show the diagram of the devices DA and DS corresponding to the methods A and S in one of their variant embodiments; 7 FIG. 7 (respectively 7A) shows the block diagram of the method M (respectively of the device DM in one of its variant embodiments) for producing a mark knowing a secret abstract semantics SAS (resulting for example from the application of the principle of method of FIG.
  • FIG. 8 shows the block diagram of method B (respectively of the device DB in one of its variant embodiments) for tattooing a software or hardware program P by inserting a mark m in a selection of elements to be tattooed of said P;
  • 9 Figure 9 shows the block diagram of the PS process (respectively of the DPS device in one of its variant embodiments) which, given a software or hardware program P, chooses an abstract domain D from a family of domains possible abstracts and selects elements of P to tattoo; 10 FIG.
  • FIG. 11 shows the block diagram of the method T (respectively of the device DT in one of its variant embodiments) for inserting a mark m characteristic of an authenticator Auth in a selection of elements of a program original P software or hardware using SAS secret abstract semantics;
  • FIG. 11 shows the block diagram of the method T (respectively of the device DT in one of its variant embodiments) for choosing an abstract domain parameterized by a key, a particular secret key and an authenticator for tattooing a software or hardware program P by transformation into a functionally equivalent tattooed program PT;
  • Figure 12 shows the block diagram of the method Au (respectively of the device DAu in one of its variant embodiments) for authenticating a tattooed program PT.
  • the DPS device of FIG. 9A selects methods to be tattooed, such as the main method.
  • a very simple example of tattooing of Java TM methods consists in using a collector semantics which is the set of descendants of the input states of the method (other alternatives being the semantics of the ascendants of the exit states or combinations like l intersection of these collector semantics).
  • the secret abstract semantics SAS is the abstraction of the collecting semantics of a method which retains only whole local variables and completely disregards the other variables, the control flow graph, external elements and the context of the method. Therefore static analysis is insensitive to program transformations (for example for obfuscation or scrambling) modifying the control flow graph and transformations by equivalence of arithmetic expressions.
  • SAS secret abstract semantics only the basic arithmetic operations +, - and * are considered (including all the other arithmetic operations allowing to rewrite arithmetic expressions including these basic operations in an arithmetically equivalent form, like least unary, etc.).
  • the concrete semantics is chosen on the ring (Z, +, * ) of mathematical integers (and not as modulo 2 32 integers as in Java TM, the arithmetic equivalences mentioned above must take this fact into account).
  • the SAS secret abstract semantics uses a finite height domain for whole local variables, which makes it insensitive to the chaotic iteration strategies used and avoids, always with a view to greater simplicity of the example, the use of widening and shrinking operators.
  • the abstract domain D (K), used to calculate the secret abstract semantics SAS by abstract interpretation of the collector semantics, is that of the propagation of the modulo K constants.
  • KnZ is isomorphic to the product ring Z / ⁇ z x ••• x Z / KnZ-
  • the device DC of FIG. 6 bis calculates the secret semantic signature (2507, 3012) from the authenticator of the program.
  • the device DA of FIG. 5A therefore consists of a program of successive static analyzes by propagation of the modulo constants (K1, ..., Kn).
  • the device DM of FIG. 7A uses the secret abstract semantics SAS and the secret semantic signature SSS 5 defined above to produce a mark m whose text is as follows:
  • the value of the variable ⁇ watermark: Ki: s> is always constant in a static analysis by propagation of the modulo Ki constants and equal to s. This value does not appear in clear in the mark and is all the more difficult to find that the secret key Ki is unknown.
  • Ki s> constant and therefore easily identifiable by a static analysis propagating the constants.
  • a more sophisticated DM device will add an induction mark making it possible to give a dynamic to the mark variable ⁇ watermark: Ki: s> so that it takes stochastic values in Z but remains constant in Z / KJZ- O n uses an advanced Q 'polynomial that has the property of stability, that is to say:
  • the device DB of FIG. 8A can place this induction mark in a loop or in a recursive call to the method to be tattooed in P because its execution does not modify the value of ⁇ watermark: Ki: s> in the ring Z / KJZ chosen to calculate the secret static semantics s.
  • the value observed in the domain of interpretation of Java integers will be totally stochastic.
  • the mark defined above uses two local variables ⁇ watermark: Ki: s> and ⁇ tmp: Ki: s>.
  • the initialization mark is the initial code segment formed by a polynomial Q calculating the initial value of ⁇ watermark: Ki: s>.
  • the coefficients a and b are drawn by lot, while c is chosen so as to ensure the stability property for the secret key as explained above.
  • the watermarked program PT corresponding to the program P including m above is as follows:
  • the location of the marks is random, in the order of the marks, the initialization mark being placed at the start of the program and the induction mark being preferably placed in a loop or in a recursive call branch of the method .
  • the device DB of FIG. 8A must ensure that the transformation of the original program does not introduce any errors at runtime which can modify the semantics of the original program. For this we will use the classical techniques of abstract interpretation.
  • the device DB of FIG. 8A will use more sophisticated methods to link the mark m to the original program P in the watermarked program PT.
  • x% 2 J s% 2 J
  • x% y denotes the operation which returns the rest of the Euclidean division of x by y. that this property remains trivially true in Zl2 ⁇ 2 ⁇ which is the domain of Java TM integers.
  • the other constants or values of variables of the watermarked program PT can also be easily calculated as a function of this value. For example 1 in P will simply be replaced by (x% 4) -1 in PT.
  • the device DF calculates the original authenticator of the program P as indicated in FIG. 8 bis.
  • a fourth example is the following sorting program:

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Multimedia (AREA)
  • Technology Law (AREA)
  • Computer Hardware Design (AREA)
  • Computer Security & Cryptography (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Storage Device Security (AREA)

Abstract

Le produit/programme et le procédé selon l'invention permettent d'insérer dans un logiciel en code source, notamment Java, des marques de tatouage qui respectent la sémantique du programme et sont très difficiles à détecter. Ils permettent de: calculer une signature sémantique secrète d'un programme informatique logiciel ou matérial parmi une infinité de signatures sémantiques secrètes possibles; marquer un programme informatique logiciel ou matériel en insérant par tatouage une marque visible ou invisible permettant de retrouver un authentifiant du programme original; retrouver la marque et extraire cet authentifiant à partir de la signature sémantique secrète du programme informatique logiciel ou matériel tatoué. La marque visible ou invisible insérée par tatouage d'un programme informatique original, logiciel ou matériel et permettant de retrouver un authentifiant ne peut être identifiée qu'en retrouvant la signature sémantique secrète du programme tatoué, ce qui nécessite la détention du secret (ou une puissance de calcul allant au-delà des possibilités des matériels informatiques). La marque résiste aux méthodes de repérage et de lessivage, sans affecter les performances du programme à protéger.

Description

DISPOSITIF ET PROCEDE POUR LA SIGNATURE, LE MARQUAGE ET L'AUTHENTIFICATION DE PROGRAMMES D'ORDINATEUR.
La présente invention appartient au domaine des dispositifs et procédés pour prévenir et/ou auditer une utilisation d'un programme d'ordinateur non autorisée par son auteur, son éditeur ou son distributeur.
Relèvent de ia prévention les dispositifs et méthodes qui vérifient que la personne ou l'automate qui cherche à utiliser le programme d'une certaine manière dispose des droits nécessaires. De nombreux dispositifs et méthodes de cette catégorie ont été prévus à cet effet. En particulier le brevet US 6,108,420 divulgue un procédé et un dispositif pour produire une empreinte cryptographique comportant les données de la licence attribuée à un utilisateur ou une classe d'utilisateurs puis pour chiffrer cette empreinte attachée au programme à protéger.
L'inconvénient de ces dispositifs et méthodes est qu'ils supposent la coopération de l'utilisateur qui ne doit pas communiquer les données de sa licence à d'autres utilisateurs ni supprimer la partie du programme, aisément repérable dans un code source car non fonctionnelle, qui comporte ces données d'identification.
Relèvent de l'audit les dispositifs et méthodes qui modifient le programme de manière caractéristique de l'exemplaire du programme, de manière non aisément décelable par l'utilisateur, sans en altérer les fonctionnalités. En particulier, le brevet US 5,559,884 divulgue une méthode et un dispositif pour modifier de manière caractéristique de l'exemplaire du programme l'ordre d'exécution de blocs dudit programme.
L'inconvénient des dispositifs et méthodes de ce type est qu'ils supposent l'insertion dans les dits blocs d'instructions d'appel et de retour qui sont aisément reperables de manière automatique et affectent les performances du programme à protéger.
La présente invention a pour but de remédier aux inconvénients de ce deuxième type en divulguant un dispositif et une méthode pour calculer une signature du logiciel à protéger, caractéristique dudit programme, résistant aux méthodes de repérage sans affecter les performances du programme à protéger et permettant de marquer le logiciel de manière secrète, les détenteurs du secret pouvant identifier la marque et la signature. A ces fins, l'invention divulgue un produit/programme d'ordinateur pour traiter les instructions d'un programme d'ordinateur en code source, caractérisé en ce qu'il comprend un module pour choisir en fonction de critères prédéfinis les instructions dudit logiciel auxquelles un programme de transcodage sera appliqué et un module pour choisir parmi plusieurs la méthode secrète de transcodage à appliquer aux dites instructions.
Parmi les modes de réalisation préférés, l'invention divulgue également un produit/programme d'ordinateur du type ci-dessus dont la méthode secrète de transcodage produit une signature sémantique du logiciel.
Selon une variante de l'invention, le produit/programme d'ordinateur du type ci-dessus comprend un module pour insérer les instructions transcodées dans le logiciel.
L'invention divulgue également un procédé pour traiter les instructions d'un logiciel en code source comprenant une étape pour choisir en fonction de critères prédéfinis les instructions dudit programme auxquelles un programme de transcodage est appliqué et une étape pour choisir parmi plusieurs la méthode secrète de transcodage à appliquer aux dites instructions ainsi qu'un mode de réalisation préféré du procédé où la méthode secrète de transcodage produit par une signature sémantique du logiciel ainsi qu'une variante de l'invention où le procédé comprend en outre une étape pour insérer les instructions transcodées dans le logiciel.
L'invention sera mieux comprise et ses différentes caractéristiques et avantages ressortiront de la description qui suit et d'exemples de réalisation, et de ses figures annexées dont :
- la figure 1 montre un schéma de principe du dispositif et du procédé pour choisir la méthode de transcodage et instructions transcodées dans le programme ;
- la figure 2 montre le schéma du dispositif et du procédé dans une de ses variantes de réalisation ;
- la figure 3 montre le schéma de principe du dispositif et du procédé pour décoder un programme modifié selon le principe de la figure 1 ; - la figure 4 montre le schéma du dispositif et du procédé pour décoder un programme modifié selon le dispositif et le procédé de la figure 2.
L'invention divulgue enfin un produit/programme d'ordinateur et un procédé pour reconnaître la signature du logiciel.
Dans les revendications, la description et les dessins, les expressions ci-dessous sont utilisées avec la signification indiquée :
• Un procédé de protection/prévention de logiciel, est un ensemble de techniques qui rendent plus difficiles la copie et l'utilisation frauduleuse des logiciels.
• La compilation d'un programme est sa traduction dans un autre langage.
• Un programme informatique est un programme interprétable ou compilable en un programme interprétable. • Un programme est écrit dans un certain langage de programmation appelé langage informatique du programme.
• L'interprétation d'un programme est la traduction de la suite de mots le composant en une suite d'actions.
• L'étiquetage d'un document ou d'un code consiste à inclure des marques visibles ou invisibles, séparées du contenu de l'objet, qui identifient par des champs l'objet logiciel (désignation, nom de l'auteur, nom du destinataire, termes de la licence d'utilisation) et un dernier champ de signature numérique qui lie complètement l'étiquette au contenu de l'objet et du même coup garantit l'intégrité de l'objet. • Le tatouage consiste à insérer des marques visibles ou invisibles incrustées dans le corps de l'objet. Ces marques réparties dans le corps de l'objet sont sinon indécelables du moins indélébiles pour qui ne connaît pas la clé secrète qui a engendré le motif sous-jacent. Un tatouage est de l'information cachée dans des données numériques et qui n'en modifient pas le sens.
• Tatouer un code consiste à le transformer en un code équivalent sans modifier sa sémantique, en ajoutant de l'information cachée et récupérable grâce à un secret appelé clef. • Deux codes logiciels sont sémantiquement équivalents s'ils ont le même comportement observable, c'est à dire par exemple, si pour toute entrée possible, les sorties du programme sont les mêmes.
• Un procédé de signature consiste à joindre à un objet un segment de données caractéristique (résumé), obtenu à l'aide d'une méthode secrète.
• Une technique de lessivage est une tentative d'effacement de la marque sans changer la sémantique.
• Un programme, écrit dans un langage particulier (par exemple Java), représente une suite d'instructions opérant sur l'état du système informatique.
• L'état du système à un instant t est constitué par la valeur des variables du programme et des variables systèmes (files d'attente de flux entrée/sortie). « On appelle état du système associé, un ensemble de variables composé des variables existantes ou/et d'autres variables supplémentaires.
• Une sémantique est un modèle mathématique définissant l'ensemble des comportements possibles d'un programme à l'exécution à un certain niveau d'observation. • L' « obfuscation » est la transformation d'un programme en un programme sémantiquement équivalent sous une forme difficile à comprendre par un informaticien.
• L' Analyse Statique Sémantique - est la détermination automatique de propriétés sémantiques des programmes. Pour assurer la sécurité d'un document numérique quelconque
(image, son, texte, programme, etc.), on peut utiliser les techniques classiques de cryptologie (signatures électroniques, etc). On adjoint au contenu à sécuriser, les règles de sécurité (par exemple les données relatives à la licence du logiciel, mais ces règles peuvent être plus personnalisées et plus complexes) relatives au document pour l'utilisateur autorisé. Ces règles sont écrites dans un autre document numérique (en général à part, comme par exemple un entête, une étiquette, etc).
Le document est protégé (ou non) par des méthodes de cryptographie (chiffrement du contenu, par exemple). L'étiquette est protégée par les techniques cryptographiques. Le tout est en général soudé par des mécanismes cryptographiques (signature électronique, par exemple).
L'inconvénient de ces dispositifs ou méthodes est qu'ils supposent, dans la chaîne de confiance de distribution, une coopération de tous les acteurs.
Aucun ne doit divulguer le contenu de l'étiquette ou modifier ou supprimer l'étiquette, si celle-ci est à l'extérieur ou à l'intérieur du programme. Personne ne doit usurper l'identité d'un utilisateur licite.
Les données d'identification d'un programme, même si celles-ci dépendent de l'heure, du lieu et du contexte peuvent être déviées de leur contexte propre.
Ces méthodes sont universelles et fonctionnent quelle que soit la nature du document (texte, signal, image ou programme, ...).
Elles ont un défaut majeur. Elles garantissent un contenu "bit à bit" :
- elles ne font pas la différence entre des modifications infimes ou profondes.
- elles ne font pas la différence entre une modification qui altère le contenu sémantique ou esthétique du document original et une modification qui change le "sens" de ce document.
Les techniques cryptographiques traditionnelles se contentent de broyer tout contenu en une "farine" numérique. La méthode de broyage n'est pas dépendante de la nature, du format, de la syntaxe, ni de la sémantique de l'image ou du texte. La sécurité d'un logiciel dépend de la politique de sécurité mise en vigueur par le propriétaire du logiciel. Il s'agit en général de garantir :
- la disponibilité du logiciel : éviter la copie par des pirates (pour une revente ou une utilisation illicite) ; éviter l'utilisation non autorisée à partir d'un support physique original (CDROM) ; - la confidentialité du logiciel : éviter la compréhension du logiciel
(confidentialité des algorithmes du logiciel source, afin de ne pas divulguer le secret du contenu du programme, la connaissance des algorithmes permettant une compréhension, une réécriture similaire, une modification, etc.) ; - l'intégrité du logiciel : éviter la modification du logiciel, soit en ne changeant pas le contenu sémantique, mais en changeant seulement la syntaxe (en modifiant le nom des variables, en rajoutant des instructions inutiles, etc comme dans les "obfuscateurs" pour les programmes Java par exemple), soit en changeant son contenu (ajout d'un virus, ajout ou retrait d'un "patch", modification classique, emprunt d'un morceau, ...) ;
- l'authentification pour garantir l'origine et le contenu du logiciel (sceau à une certaine date) : pour assurer l'antériorité d'un tatouage par rapport à un autre, on a recours à une infrastructure de sécurité (Tierce Partie de Confiance à Valeur Ajoutée).
Les méthodes de tatouage logiciel s' inspirant des méthodes de tatouage d'autres types d'objets (images et sons) sont vouées à l'échec. En effet, un code informatique, par nature, est complètement différent des objets audio, vidéo et des images. Pour ces derniers, une légère perte d'information ne modifie pas le sens : nos capteurs sensoriels sont imparfaits. Ce n'est pas le cas du code informatique. Il ne supporte que les compressions sans perte d'information. Une modification, aussi infime soit- elle, peut le rendre non fonctionnel. Seules les modifications qui prennent en compte la sémantique sont valides, par exemple les opérations d'optimisation de code machine effectuées par les compilateurs ou Pobfuscation.
L'inconvénient des méthodes et dispositifs de tatouage de logiciel est qu'ils considèrent le code en tant qu'objet syntaxique et n'exploitent .pas sa sémantique. Pour cette raison, il est facile de retrouver la marque de tatouage par analyse syntaxique du programme, et d'enlever la marque par transformation syntaxique.
De plus les méthodes générales de tatouage de logiciel développées jusqu'à présent induisent des modifications du programme facilement reperables. L'insertion des instructions de saut et de retour sont par exemple reperables de manière automatique. En ce qui concerne l'ajout de structures de graphes, ces structures sont également facilement identifiables dans les codes non complètement compilés. Elles alourdissent aussi le fonctionnement du programme de façon significative.
Pour la sécurité des logiciels, relèvent de là prévention les dispositifs et méthodes qui vérifient que la personne ou l'automate qui cherche à utiliser le programme d'une certaine manière dispose des droits nécessaires. De nombreux dispositifs et méthodes de cette catégorie ont été prévus à cet effet. Il s'agit de dispositifs de protection de logiciels (leur utilisation dépend généralement d'un dispositif matériel : carte à puce, "dongle") ou de dissuasion d'utilisation frauduleuse de logiciels (étiquette, bannière, marque à l'extérieur ou à l'intérieur d'un programme source, instructions en langage machine dans le programme exécutable pour identifier un contexte d'utilisation).
Avec l'avancée des nouvelles technologies et l'accroissement du nombre d'utilisateurs d'Internet, la protection de la propriété intellectuelle devient une priorité pour les producteurs et les vendeurs de logiciels. De nombreux dispositifs et méthodes de protection ont été prévus à cet effet. On notera la famille des dispositifs qui fonctionnent avec un matériel spécialisé. Parmi les méthodes de protection logicielles, on distingue le tatouage de logiciel et l'obfuscation. Les méthodes de tatouage qui en font partie se répartissent en deux familles :
• les méthodes dites dynamiques, qui prennent en compte la dimension temporelle de l'exécution du programme. La marque insérée peut être obtenue : - en lisant la sortie du programme pour une entrée donnée.
- en lisant le contenu d'une variable pendant l'exécution, pour une entrée donnée.
- en notant l'ordre d'exécution des blocs d'instructions. En particulier, le brevet 5,559,884 divulgue une méthode et un dispositif pour modifier de manière caractéristique l'ordre d'exécution de blocs dudit programme, par insertion d'instructions d'appel et de retour.
• les méthodes dites syntaxiques statiques, grâce auxquelles on insère et on lit la marque sans l'exécution du programme. La marque peut être obtenue : - en étudiant l'ordre des instructions
- en examinant les données utilisées par le programme (texte, photos, sons)
Un descriptif de l'ensemble des méthodes existantes est présenté dans l'article de Coolberg et Thomborson, Software Watermarking : odels and Dvnamic Embeddinqs (1998 . L'invention appartient à une troisième catégorie, celle des dispositifs et méthodes statiques sémantiques.
Dans cette catégorie, on peut trouver des signatures qui auront un sens arbitraire mais qui resteront néanmoins cachées car le logiciel comporte lui-même une part importante de texte non structuré.
Mais dans son mode de réalisation préféré, le dispositif proposé s'applique de manière spécifique aux programmes logiciels qui ont une sémantique donnée, c'est à dire les programmes écrits dans un langage de programmation (« programming languages ») : il est particulièrement applicable aux programmes interprétés (Java, PostScript, etc) car ces programmes, une fois écrits en langages machines, sont facilement déchiffrables par de la rétro-ingénierie dans leur forme originelle, compréhensible par un informaticien. Mais il est bien entendu que ce dispositif est aussi applicable aux programmes écrits en langages compilables (C, C++, Basic, Ada, Pascal, VHDL, Estérel, ...) pour authentifier et contrôler l'origine, le contenu ou la destination.
Le dispositif dans son mode de réalisation préféré dépend de la sémantique du langage. Ainsi, les tatoueurs Java, VHDL, etc sont différents. Ils peuvent avoir des parties similaires (pour la sémantique de leurs opérations arithmétiques) mais parfois spécifiques (Les pointeurs en langage C). Le dispositif est applicable aux langages à balises pour les parties qui contiennent des programmes (« des scripts »). Pour XML, les autres parties relèvent des procédés de tatouages d'images (modifications imperceptibles de la présentation sur écran ou papier). Le dispositif est également applicable aux parties qui comportent des opérations (programmes « macros » pour « centrer », « justifier », etc).
Dans son mode de réalisation préféré, l'invention s'appuie sur les principes de l'analyse sémantique.
L'analyse sémantique a été appliquée avec succès à la certification des programmes à exigence draconienne de fiabilité, (référence 1 : Abstract Interprétation : a unified lattice model for static analysis of programs by construction or approximations of fixpoints, P.Cousot & R. Cousot January 17-19, 1977 référence 2 : P.Lacan, J.N. Montfort, Le Vinh Quy Ribal, A. Deutsch, and F. Gouthin. The software reliability vérification process : The Ariane 5 example. In Proceedings DA/A 98 - Data Systems in Aerospace, Athènes, Grèce. ESA Publications, SP-422,25-28 mai 1998). Pour prouver qu'un programme s'exécute sans défaillance en contexte opérationnel, il faut en théorie étudier toutes les exécutions possibles dudit programme. Les travaux ci-dessus, ont montré que l'on pouvait élargir à l'ensemble de toutes les exécutions possibles la preuve du bon fonctionnement. On considère qu'un programme est construit à partir d'un ensemble de nœuds liés entre eux. Les instructions relient les nœuds entre eux et provoquent ainsi des transitions d'états matérialisées par un changement d'une ou plusieurs variables ou/et un changement de nœud. Lorsque l'on fait une analyse sémantique d'un programme par interprétation abstraite, on calcule par itération [cf. « Abstract Interprétation : A unified lattice model for static analysis of programs by construction or approximation of fixpoints, P.Cousot & R.Cousot January 17-19, 1977], pour chaque variable et pour chaque nœud, un sur-ensemble de l'ensemble des valeurs que pourra prendre une variable à un nœud donné.
Trouver ces sur-ensembles revient à résoudre une équation de point-fixe, dont on obtient une approximation par itération. Les exemples montreront des méthodes d'itération dans des cas précis.
Le problème que l'inventeur se propose de résoudre relève de la même approche : si les instructions ajoutées au programme à protéger appartiennent à un sous-ensemble des invariants dudit programme, alors les dites instructions s'exécuteront sans erreur et ne modifieront pas les fonctionnalités dudit programme. Il existe plusieurs sous-ensembles pertinents. Il est judicieux de choisir un sous-ensemble particulièrement représentatif du type de programmes à protéger.
Bien que d'autres solutions puissent être envisagées, il est actuellement préféré que la sélection des instructions à transcoder soit effectuée selon des critères prédéfinis incluant la sélection de sous- ensemble d'invariants du programme tels que définis ci-dessus. Le module (310) de la figure 1 permet d'effectuer cette sélection des instructions à transcoder à partir de la définition des caractéristiques des dites instructions (opérations sur des entiers, opérations sur les flottants, initialisation de variables, boucle conditionnelle, branchement...) en application de critères au moins partiellement prédéfinis. Le paramétrage du module (310) du compilateur (30) permet alors la sélection automatique des instructions à transcoder. L'intervention de l'opérateur sera également possible pour sélectionner une partie autonome du programme à signer sémantiquement. En java par exemple, un programme est assimilé à plusieurs classes composées de plusieurs méthodes, elles-mêmes pouvant faire appel à des méthodes d'autres classes et d'autres packages. C'est pour cette raison que dans ce cas particulier nous préférerons signer la plus petite entité autonome d'un programme java : la méthode.
Les parties du programme à signer doivent être les parties innovantes et/ou sensibles du programme. En général elles concernent la partie algorithmique du programme.
II s'agit ensuite de choisir parmi plusieurs la méthode de transcodage en application de critères au moins partiellement prédéfinis. Ce choix dépendra du caractère sensible des informations à protéger. Le transcodage sera donc plus ou moins complexe, étant entendu qu'il devra respecter la sémantique des instructions à transcoder, c'est-à-dire utiliser le même vocabulaire et la même grammaire. Le module (320) contient les méthodes de transcodage possibles pour chaque langage. Une méthode de transcodage peut avoir un degré de sophistication correspondant au niveau de protection souhaité. Pour un niveau donné de protection, un nombre alloué de paramètres possibles seront attribuables à des utilisateurs ou des classes d'utilisateurs.
Dans cette liste, chaque méthode de transcodage comporte un secret à préserver. En effet, sa connaissance permettra le décodage et donc l'enlèvement des instructions supplémentaires, ce qui supprimera toute preuve d'une copie éventuelle ultérieure non autorisée.
Une table de transcodage est une application qui, à toute opération effectuée sur l'état du système, associe une autre opération effectuée sur l'état du système associé. Créer une sémantique secrète revient donc à créer une analyse statique correspondante, ce qui consiste à définir les variables associées, et la relation entre les actions opérant sur l'état du système et celles opérant sur les variables associées.
On peut par exemple garder les même variables que celles utilisées par le programme. Notre table de transcodage donnera une autre interprétation des instructions du programme, et affectera aux variables associées d'autres valeurs que celles qu'auraient prises les variables initiales. On peut également considérer une et une seule variable associée V, quelles que soient les variables initiales. La suite des instructions du programme sera alors interprétée en une suite d'actions sur la variable V.
L'invention prend en compte toutes les actions opérant sur l'état du système d'environnement du programme informatique : une telle action peut affecter la pile d'exécution, modifier le contenu d'une variable système, appeler une fonction, ordonner la lecture d'une autre variable, effectuer une opération logique ou mathématique, créer un objet, envoyer ou recevoir un flux I/O, lire un élément d'un tableau... Utiliser une table de transcodage secrète renforce les dispositifs de signature et de tatouage. Sans ce secret, il est très difficile de trouver la même signature (selon l'argument classique en crypto : on ne peut pas raisonnablement essayer toutes les combinaisons possibles) de même qu'il est quasiment impossible de retrouver une marque. La signature sémantique proposée caractérise l'algorithme développé en tant que tel, et permet de trouver les programmes qui ont une sémantique équivalente.
La marque de tatouage est obtenue par analyse statique (après transcodage) du programme, qui constitue la clef de notre secret. Il y a peu de bruit ajouté, et la marque est donc plus résistante.
La table de transcodage secrète rend plus difficile la détection de la marque.
A ce stade, il est possible de déposer la signature du logiciel (10) telle que produite en sortie du module (320) chez une Tierce Partie de Confiance (TPC). Elle n'a donc pas à être insérée dans le logiciel (10). L'authentification du logiciel s'effectuera alors auprès de la TPC par comparaison de la signature produite avec le logiciel à analyser avec celle qui a été déposée. Dans ce cas, le logiciel n'est pas protégé contre la copie mais les modifications qu'il a éventuellement subies sont détectables. Dans une variante de l'invention, la signature est insérée dans le logiciel (10) sous forme de marque.
Le module (330) réalise d'une part le transcodage des instructions classées avec la méthode choisie et d'autre part l'insertion des instructions transcodées dans le programme à protéger. L'algorithme principal du module (330) a pour but d'optimiser le placement des instructions transcodées. Elle doit être adaptée à la typologie des instructions et des méthodes de transcodage. Les compilateurs contiennent normalement des outils d'optimisation de code et de vérification de la propagation des constantes. L'insertion des instructions transcodées dans le programme à protéger devra donc respecter un certain nombre de règles minimales de robustesse : il faut s'assurer que les variables contenant les marques de tatouage aient une influence sur les sorties du programme. En d'autres termes, pour éviter la suppression pure et simple par un optimiseur, il faut s'assurer que le contenu de la variable sera repris par une instruction du programme initial. Il faut également dissimuler les constantes. Il faut pour cela éviter les initialisations de variable v par une valeur constante K, suivies par une instruction du type w=f(v), au début du programme, car il est alors facile pour un optimiseur de calculer directement w. On pourrait par contre privilégier les boucles : dans une boucle, il est naturel d'initialiser une variable (souvent à 1),et de l'incrémenter à chaque exécution de boucle. Supposons que dans la boucle, i prenne des valeurs de a à b. On pourrait insérer l'instruction w=f(i) dans la boucle et calculer f de telle sorte que w prenne la valeur de la clef pour une valeur de i comprise entre a et b.
Une fois les propriétés sémantiques du programme conjugué déterminées, on calcule par la table de transcodage inverse, les instructions à ajouter au programme initial. Les instructions ajoutées doivent s'exécuter sans erreur et ne pas modifier les fonctionnalités dudit programmé. Ces transformations seront iso-sémantiques : pour toute entrée identique, les programmes initiaux et tatoués produiront la même sortie. Mais par contre, les environnements internes d'exécution ne seront pas identiques.
La marque est donc un ensemble de propriétés sémantiques du programme transcodé. Notre dispositif de tatouage consiste donc à calculer les instructions à ajouter dans le programme initial qui permettront d'obtenir ces nouvelles propriétés dans l'espace caché. L'insertion des instructions transcodées dans le programme à protéger devra respecter un certain nombre de règles minimales de robustesse : il faut s'assurer que les variables et les opérations contenant les marques de tatouage donnent l'impression qu'ils aient une influence sur les sorties du programme. Par exemple, pour éviter la suppression pure et simple par un optimiseur, il faut s'assurer que le contenu de la variable sera repris par une instruction du programme initial. (allocation dynamique de valeur)
Il est important de noter que l'observation des valeurs prises par les variables lors de l'exécution ne permet pas de retrouver la marque. D'une part il faut connaître la table secrète pour établir notre programme conjugué. D'autre part, le calcul de propriétés sémantiques ne pourra se faire dans la plupart des cas que par analyse statique, et non pas par une exécution pas à pas.
La figure 2 expose un exemple de réalisation. La méthode (310) de la figure 2 sera donc appliquée à chaque méthode du programme (ou au moins à celles qui ont un contenu algorithmique que l'on souhaite protéger). La sélection des instructions à transcoder tient compte de la dynamique d'exécution du code Java : l'allocation des objets s'effectue "sur le tas", c'est-à-dire en fonction du contexte d'utilisation des ressources des processeurs, de la mémoire et des entrées/sorties et, le cas échéant, des autres membres du réseau. Les instructions portant sur les objets ne sont donc pas recommandées pour le tatouage puisque celui-ci doit être indépendant du contexte.
Le tatouage doit donc porter sur des valeurs scalaires ou des références à des objets qui sont les seuls opérandes à allouer sur la pile du programme.
Le critère prédéterminé peut comprendre le choix comme instructions à transcoder des opérations sur les entiers, les flottants ou les valeurs booléennes. Pour les programmes standards on choisira les opérations sur les entiers. Pour les programmes de conception assistée sur ordinateur, de simulation ou de modelage en trois dimensions où les opérations sur scalaires flottants dominent, on choisira plutôt ces opérations.
Le module (310) de la figure 2 est alors uniquement utilisé pour sélectionner les instructions (110), (130), (150) des méthodes du programme (10) qui comportent des opérations sur les entiers.
Un transcodage qui respecte la sémantique de l'instruction consiste alors à effectuer la même opération modulo à un entier quelconque N inférieur à 232. Une alternative consiste à effectuer une opération différente choisie dans une table de permutation, encore en algèbre modulaire. Le module (320) a, dans ce cas, pour fonction principale de conserver la table des secrets attribués à des classes d'utilisateurs donnés pour des programmes donnés.
Le module (330) pour calculer et insérer les instructions transcodées est une suite d'instructions du compilateur (30) du type décrit ci- après.
On veut insérer p marques dans chaque méthode sélectionnée.
Soient p nombres n-i, n2 np et p valeurs de marques cι<nι ; c≥ <x)2 ; ....
Cp<np constituant l'ensemble secret.
On répétera la suite des macro-instructions de l'annexe 1 pour chaque méthode à tatouer.
Il est bien entendu possible de répéter plusieurs fois le processus avec des valeurs différentes de marques.
Il est également possible d'améliorer la robustesse du tatouage en utilisant différentes techniques de l'algèbre modulaire. La technique la plus forte pour lier le tatouage au programme est de faire interférer les variables de tatouage avec la méthode originale. Il faut pour cela pouvoir utiliser des propriétés de la variable de tatouage qui soient transposables en arithmétique signée sur 32 bits. C'est possible lorsque la clef K est une puissance de 2. En effet, supposons que K = 2k. Alors on a : X = v + a. 2k dans Z
Nous savons, toujours dans Z, que, pour tout j < k :
X% 2j = v% 2j Où x%y désigne l'opération qui renvoie le reste de la division euclidienne de x par y. On remarque que cette propriété reste trivialement vraie dans Z/232 qui est le domaine des entiers Java. Nous pouvons donc utiliser des propriétés arithmétiques du tatouage pour modifier des calculs de la méthode. Par exemple, supposons que K = 216 et que v = 18. Alors quelle que soit la valeur de x, on a toujours x% 4 = 2.
Si on a par exemple une constante explicite 1 dans le programme original, on peut la remplacer par x% 4-1. Si maintenant on a rajouté une dynamique à x, on a une variable qui prend en apparence des valeurs stochastiques mais dont on utilise un invariant caché. Le programme ainsi modifié est dégradé de manière irréversible tout en conservant sa sémantique originale. Un pirate qui chercherait à éliminer la variable de tatouage x rendrait alors le programme inutilisable. Il faut une étude poussée du comportement de x pour pouvoir retrouver l'information ainsi dissimulée. Notons que cette technique de dissimulation de constantes peut se faire simplement de manière automatique et aléatoire.
La méthode générique de la lecture du tatouage est présentée sur la figure 3. Elle suppose la connaissance d'une partie au moins des paramètres de tatouage. Il est ainsi possible d'affecter à plusieurs niveaux d'une chaîne de distribution de logiciel (acheteur, grossiste, distributeur, détaillant) des marques qui leur seront propres.
Dans l'exemple de réalisation de la figure 4, la connaissance du ou des nombres secrets Nk permet de retrouver par une exécution pas à pas du programme dans le compilateur les variables qui comportent une congruence modulo N à un instant donné puis de tracer cette variable jusqu'à son initialisation.
La table des secrets peut être aisément contenue sur une carte à microprocesseur qui sera connectée à l'ordinateur comportant l'interpréteur. L'utilisateur habilité n'a à connaître qu'une clé publique qui activera le programme de lecture des secrets correspondant à son identification d'utilisateur. Les clés privées qui définissent la table des secrets n'ont donc pas à être divulguées. Deux exemples donnés en annexes 2 et 3 permettent d'illustrer l'application de l'analyse statique sémantique à l'authentification de la signature du logiciel avec deux cas simples de calcul des points fixes des variables cachées.
Ces dispositifs et procédés peuvent être mis en œuvre sans difficulté sur des ordinateurs de commerce. En fonction de la complexité du logiciel et de la signature, les temps d'exécution seront plus ou moins longs, notamment pour le calcul des variables cachées par la méthode du point fixe.
Pour limiter ces temps de calcul, on appliquera les méthodes d'élargissement et de rétrécissement connues de l'homme du métier. On peut tatouer autant de fois que l'on veut un logiciel
(superposition de tatouages), contrairement aux tatouages de sons ou d'images qui subissent une certaine saturation du canal subliminal (selon le modèle de perception choisi). On n'altérera pas le logiciel, on le surchargera, les ressources mémoire et temporelles seront affectées.
On peut utiliser pour chacun de ces tatouages des sémantiques secrètes différentes, si bien que la chaîne de confiance peut avoir des secrets différents.
Bien entendu, ce dispositif et ce procédé de tatouage peuvent être combinés avec des dispositifs et procédés de l'art antérieur pour rendre le programme inutilisable à un utilisateur non autorisé (prévention) pour tracer la dissémination éventuelle dudit programme par un utilisateur autorisé à des utilisateurs non autorisés (audit). Il suffira pour cela de ne pas communiquer aux utilisateurs autorisés les clés leur permettant de retrouver le tatouage.
Il est également possible d'utiliser le dispositif et le procédé pour authentifier de manière automatique les codes que l'on va autoriser à pénétrer sur un réseau ou sur un poste donné. Le tatouage est assimilable à un certificat d'authentification dont le poste de surveillance du réseau ou du poste disposera de la clé de lecture.
L'Annexe 4 présente un glossaire.
L'Annexe 5 présente un mode de réalisation de l'invention avec un découpage en modules plus fin. L'Annexe 6 et l'Annexe 7 présentent de nouveaux exemples de réalisations (exemples 3 et 4).
ANNEXES
ANNEXE 1
1.1 Décomposition de la méthode en 2 blocs A et B de taille équivalente. 1.2 Pour i variant de 1 à p faire
1.2.a trouver une position aléatoire dans le bloc A 1.2.b faire la liste des variables ayant une valeur déterminée à ce niveau d'exécution - 2 cas : cas 1 : il n'y en a pas
Créer une variable w initialisée à une valeur x. Insérer cette initialisation entre le début de la méthode et notre position actuelle. cas 2 : il y en a au moins une Sélectionner une de ces variables w, soit x sa valeur à notre position actuelle d'exécution.
1.2.c créer un polynôme P quelconque de degré 2 vérifiant P(x) = q + k*nj (k entier aléatoire petit)
1.2.d insérer l'instruction d'initialisation suivante : int vι=P(w)
1.2.e trouver une position aléatoire dans le bloc B 1.2.f créer un polynôme Q quelconque de degré 2 vérifiant Q(vi)=Vj+1 *nj (1 entier aléatoire petit)
1.2. g insérer l'instruction
ANNEXE 2
Exemple 1
La méthode tatouée est la méthode principale de la classe Fibonacci, qui calcule la valeur du n'eme terme de la suite de Fibonacci, définie par les
relations u0 = 0 w, = 1 Programme initial
public class Fibonacci {
public Fibonacci() {
}
public static void main(String[] args)
{ int n=lnteger.parselnt(args[0]); int a=0; int b=1 ;
for (int i=1 ;kn;i++)
{ int c=a+b; a=b; //a vaut Uj
b=c; //b vaut ui+ι
System.out.println("La valeur de la suite pour n="+n+" est
"+b);
}
Choix de tables de correspondances sémantiques Nous choisissons d'insérer deux valeurs de marque. Pour cela nous utilisons deux tables de transcodage.
La première permettra d'insérer la valeur cachée 2507, la seconde 3012. Nos deux tables associent à chaque opération algébrique sur des entiers I' opération algébrique identique modulo un nombre N. A tout retour de valeur entière consécutif à l'appel d'une méthode de type int, on associe l'initialisation à une valeur V. Pour la première table, N vaut 10000 et V 17. Pour la seconde, N vaut 5421 et V vaut 50.
1. Table de transcodage pour 2507
2. Table de transcodage pour 3012
Tatouage de la méthode
Le tatouage de notre méthode consiste en l'insertion de deux variables j et k, prenant respectivement les valeurs 2507 et 3012 dans notre espace secret.
Le tatouage consiste en deux étapes :
- Initialisation de j et k en fonction de n en début de programme. Cette initialisation nous permet de calculer la valeur de j et k dans notre espace conjugué, par contre les valeurs de j et k au cours de l'exécution du programme sont inconnues. Cela nous permet d'éviter la transformation de ces instructions par un optimiseur.
- Ajout d'instructions dans l'algorithme assurant l'invariance de j et k dans notre espace secret.
Ces instructions sont des calculs de j et k à l'aide de polynômes de degré 2. Ancrage de la marque
La marque est ancrée en fin de méthode. En effet, les valeurs de j et k sont apparemment utilisées pour le calcul du résultat b. Ceci est un leurre, car la suite des opérations effectuées sur b laissent in fine cette variable invariante. Programme tatoué public class Fibonacci
{ public Fibonacci() {
} public static void main(String[] args)
{ int n=lnteger.parselnt(args[Oj); int a=0; int j=-34*n*n-500*n+833; // j vaut 2507 dans l'espace conjugué n°1
// (c'est à dire modulo 10000, n->17) int b=1 ; int k=2*n-n*n-9; // k vaut 3012 dans l'espace conjugué n°2 (c'est // à dire modulo 5421 , n->50) for (int i=1 ;kn;i++)
{ int c=a+b; a=b; // a vaut u(i) j=j*5-28; // j vaut toujours 2507 dans l'espace conjugué 1 b=c; // b vaut u(i+1) k=k*k+201 ; // k vaut toujours 3012 dans l'espace conjugué 2
} b+=k+j; b=b-1 -k*j+(1 -k)*(1 -j); // ancrage de k et j
System.out.println("La valeur de la suite pour n="+n+" est :
"+b);
} Analyse de la marque
La marque se retrouve par Analyse Statique, et la méthode d'approximation du point fixe par itérations.
Le programme conjugué dans l'espace n°1 est le suivant : public static void main(String[] args)
{ int n=17; int a=0; int j=(-34*n*n-500*n+833) % 10000; int b=1 ; int k=(2*n-n*n-9) % 10000; for (int i=1 ;i<n;i++)
{ int c=(a+b) % 10000; a=b; j=G*5-28) % 10000; b=c; k=(k*k+201) % 10000;
} b=(b+k+j) % 10000; b=( b-1-k*j+(1-k)*(1-j) ) % 10000; System. out.println("La valeur de la suite pour n="+n+" est :"+b) ;
} }
Transformons tout d'abord le programme en graphe de flux d'exécution :
Analyse Sémantique Statique : approximation du point fixe
ANALYSE STATIQUE SEMANTIQUE
Pour chaque état, on étudie l'ensemble des valeurs possibles prises par les variables. On ne considérera que les variables qui ont changé de valeur par rapport à tous les états précédents possibles.
Écriture de l'interdépendance des états
ANALYSE STATIQUE SEMANTIQUE
Pour chaque état, on étudie l'ensemble des valeurs possibles prises par les variables. On ne considérera que les variables qui ont changé de valeur par rapport à tous les états précédents possibles. On approximera ces ensembles par des intervalles
retrouve notre première marque : la variable J garde toujours la valeur 2507 Le programme conjugué dans l'espace n°2 est le suivant : public static void main(String[] args)
{ int n=50; int a=0; int j=(-34*n*n-500*n+833) % 5421; int b=l; int =(2*n-n*n-9) % 5421;
for (int i=l;i<n;i++) { int c=(a+b) % 5421; a=b; j=(j*5-28) % 5421; b=c; k=(k*k+201) % 5421; } b=(b+k+j) % 5421; b=(b-l-k* +(l-k)*(l-j)) % 5421;
System.out .println( "La valeur de la suite pour n="+n+" est
"+b); }
Transformons comme précédemment le programme en graphe de flux d'exécution :
ANALYSE STATIQUE SEMANTIQUE
Pour chaque état, on étudie l'ensemble des valeurs possibles prises par les variables. On ne considérera que les variables qui ont changé de valeur par rapport à tous les états précédents possibles.
Écriture de l'interdépendance des états
x )} ANALYSE STATIQUE SEMANTIQUE
Pour chaque état, on étudie l'ensemble des valeurs possibles prises par les variables. On ne considérera que les variables qui ont changé de valeur par rapport à tous les états précédents possibles. On approximera ces ensembles par des intervalles
Nous retrouvons notre deuxième marque : 3012. ANNEXE 3
Exemple 2
La méthode dont on extrait la signature sémantique est une méthode de tri bulles. Programme initial
public class Bulle
{ public static void ain(String[] args)
{ int[] table=ne int [args . length] ; for (int i=0; i<args . length; i++) table [i] =lnteger.parselnt (args [i] ) ; print (table) ; print (tri (table) ) ; } public static void print (int [] table) {
System.out.println( "" ) ; for (int i=0; i<table. length; i++)
System.out .print (table [i] +" " ) ; System.out.println( " " ) ; } public static int[] tri(int[] table)
{ int[] table2=table; boolean flag=false; int i=0; int v=0; hile( !f lag)
{ f lag=true; for (i=0;i<table2. length-l;i++)
{ if (table2[i]>table2[i+l]) { v=table2[i] ; table2[i]=table2[i+l] ; table2[i+l]=v; flag=false;
} } } return(table2) Choix d'une table de correspondance sémantique
Nous souhaitons obtenir une propriété sémantique après transcodage. Pour cela nous utilisons une table de transcodage.
Pour les variables de notre espace conjugué, nous ajouterons aux variables de notre espace initial deux nouvelles variables W et W de type entier qui sont initialisées avec la valeur 0.
Ensuite nous tâchons de repérer les transpositions effectuées sur les tableaux du programme, et nous remplacerons ces opérations effectuées sur le tableau par des opérations sur la variable W. Une analyse statique sur W montrera qu'elle garde une valeur constante égale à 1 dans toutes les situations.
Table de transcodage
Signature de la méthode
La signature de la méthode consiste en l'analyse statique sémantique de la méthode et la détection de propriétés Analyse du programme les propriétés se retrouvent par Analyse Statique, et la méthode d'approximation du point fixe par itérations.
xécution du programme conjugué est le suivant :
Écriture de l'interdépendance des états
Iv„ tel que tableii) >- table(i + 1)} ) tel que tableii) >- table(i + 1)}
Signature :
On note la signature de notre méthode de tri bulles :
En considérant la table de transcodage secrète, on note que :
- « la variable associée W garde une valeur constante égale à 1 » - « notre variable X' prend les valeurs 0 et 2 ».
ANNEXE 4
Glossaire
- Un procédé de protection-prévention de logiciel ou matériel est un ensemble de techniques qui rendent plus difficiles la copie et l'utilisation frauduleuse des logiciels ou circuits électroniques.
- Un programme est écrit dans un certain langage de programmation appelé langage informatique du programme. - L'interprétation d'un programme est la traduction de la suite de mots le composant en une suite d'actions appelée exécution du programme.
- La compilation d'un programme source, écrit dans un langage de haut niveau, est sa traduction dans un autre langage ou matérialisation en un automate, en général langage machine ou circuit électronique. - Un programme informatique logiciel est un programme interprétable ou compilable en un programme interprétable.
- Un programme informatique matériel est un programme réalisable par un circuit électronique et spécifié par un langage de description de circuit. - Un élément d'un programme informatique est une partie non nécessairement connexe du texte du programme correspondant à une ou plusieurs instructions, éventuellement composées (comme une commande de choix conditionnel ou par cas, une boucle, etc.), une déclaration ou description d'une ou plusieurs structures de données comprenant éventuellement les ou des opérations agissant sur ces structures de données, une ou plusieurs procédures ou méthodes, un ou plusieurs modules, etc.
- Une sémantique d'un programme logiciel ou matériel est un modèle mathématique définissant l'ensemble des comportements possibles d'un programme à l'exécution à un certain niveau d'observation.
- L'analyse statique sémantique est la détermination automatique de propriétés sémantiques des programmes.
- Deux programmes logiciels sont sémantiquement équivalents (ou fonctionnellement équivalents) s'ils ont le même comportement observable c'est-à-dire qu'ils s'exécutent de manière fonctionnellement équivalente, (par exemple, si pour toute entrée possible, les sorties du programme sont les mêmes).
- Une sémantique abstraite d'un programme logiciel ou matériel est un modèle mathématique définissant une sur-approximation ou une sous- approximation de l'ensemble des comportements possibles d'un programme à l'exécution.
- Une sémantique abstraite est secrète si sa spécification pour un programme logiciel ou matériel nécessite la connaissance d'un secret.
- Une signature est une information caractéristique (étiquette, vignette ou résumé) associée à un objet (ici, un programme logiciel ou matériel). Cette information peut dépendre d'une propriété intrinsèque ou extrinsèque de l'objet. Ces propriétés peuvent authentifier la forme et fond du contenu de l'objet (le codage, le format, la syntaxe, l'esthétique, la sémantique) ou sa traçabilité (l'histoire et/ou le devenir de cet objet). - Une signature secrète est une signature obtenue à l'aide d'une méthode faisant appel à un secret.
- Une signature sémantique est une . signature spécifiée en fonction de la sémantique de l'objet (ici, du programme écrit dans un langage de programmation, avec une sémantique définie). - Un authentifiant est une preuve secrète de la détention d'une information ou d'un droit (par exemple désignation de l'objet, nom de l'auteur, nom du destinataire, termes de la licence d'utilisation, etc.).
- Une marque est une composante d'un objet qui permet de l'identifier et qui, dans le contexte de l'invention, permet de retrouver une signature de l'objet.
- L'étiquetage d'un objet ou d'un programme consiste à fabriquer une étiquette qui est en général séparée du contenu de l'objet ou incrustée dans l'objet à un endroit facilement repérable.
- À la différence, le tatouage consiste à incruster une (ou des) marque(s) dans le corps de l'objet. Cette marque répartie dans le corps de l'objet est en général sinon indécelable du moins indélébile. L'objet greffé avec cette marque s'appelle l'objet tatoué.
- L' obfuscation est la transformation d'un programme en un programme sémantiquement équivalent sous une forme difficile à comprendre par un informaticien mais utilisable par un utilisateur. À la différence du tatouage, l'obfuscation rend un programme confidentiel (grâce à la difficulté de le comprendre) mais ne permet pas l'authentification [cf.
Obfuscation techniques for enhancing software security, New Zealand Patent
Application #328057, WO 99/01815, PCT/US98/12017, 9 June 1997]. - Le lessivage de marque est une tentative d'effacement ou de modification de la marque ou bien une surcharge du programme pour noyer la marque, sans changer la sémantique du programme.
- Un tatouage de programme est robuste s'il résiste à une optimisation de compilation, une obfuscation, un étiquetage et à un autre tatouage, toutes ces opérations étant appliquées ultérieurement.
ANNEXE 5
Description analytique des modules et arrière-plan théorique
Un procédé A de sémantique abstraite
L'inventeur utilise les principes et techniques de l'analyse statique sémantique des programmes par interprétation abstraite, cf. [P. Cousot & R. Cousot, « Abstract Interprétation : A unified lattice model for static analysis of programs by construction or approximation of fixpoints », Conférence internationale « Principles of programming languages, POPL'77 », p. 238 — 252, ACM Press, Janvier 1977] et [P. Cousot & R. Cousot, « Systematic design of program analysis frameworks », Conférence internationale « Principles of programming languages, POPL'77 », p. 269—282, ACM Press, Janvier 1979].
Le procédé/module A définit une infinité de sémantiques abstraites secrètes dépendantes :
- d'un domaine abstrait D(K) paramétré par une clé secrète K (qui, à une injection près, peut être considérée comme un nombre N = b(K), cette injection b pouvant elle-même constituer un secret );
- d'une clé secrète K particulière qui définit le domaine abstrait D(K) utilisé dans la sémantique abstraite secrète SAS.
Cette sémantique abstraite secrète SAS est constituée du domaine abstrait secret D(N) et des opérations abstraites correspondantes pour les constructions et primitives de la famille de langages de programmation considérés, obtenues en utilisant les principes de l'interprétation abstraite.
Tout domaine abstrait D(K) obtenu par une abstraction, au sens de la théorie de l'interprétation abstraite, cf. [P. Cousot & R. Cousot, « Abstract Interprétation : A unified lattice model for static analysis of programs by construction or approximation of fixpoints », Conférence internationale « Principles of programming languages, POPL'77 », p. 238 — 252, ACM Press, Janvier 1977] et [P. Cousot & R. Cousot, « Systematic design of program analysis frameworks », Conférence internationale « Principles of programming languages, POPL'77 », p. 269—282, ACM Press, Janvier 1979], paramétré par une clé secrète K est utilisable comme paramètre pour le module A. Grâce à l'utilisation d'une injection N = b(K), qui peut rester secrète, tout domaine abstrait D(N), paramétré par un nombre N, est réutilisable avec des clés quelconques. Il existe donc une infinité de domaines abstraits D(K), paramétrés par une clé K, qui sont utilisables. Cependant, les domaines abstraits publiés dans la littérature scientifique ne conviennent pas, en ce sens qu'ils ne sont pas paramétrés par une clé K (même choisie de manière isomorphe aux entiers ou aux ordinaux). Fait partie de l'invention, la transformation d'un domaine abstrait quelconque utilisable pour l'analyse sémantique statique classique dont la concrétisation fournit une information sur des valeurs entières (à un codage injectif près) en un domaine abstrait D(N) paramétré par un entier N constituant la clé secrète K = N (audit codage près). Le procédé consiste à abstraire (au sens de l'interprétation abstraite) des opérations concrètes en une opération abstraite considérant l'opération concrète réalisée modulo N. Cette abstraction est ensuite étendue aux éléments de contrôle du programme selon les principes de l'analyse statique sémantique par interprétation abstraite, en utilisant éventuellement les techniques d'élargissement et de rétrécissement connues de l'homme de métier.
Des exemples de transformation de tels domaines D en domaines D(N) sont décrits ci-dessous :
Pour un programme P écrit en langage algorithmique (avec des additions, des multiplications, des boucles, des branchements, ...) et dont l'auteur veut sécuriser le contenu algorithmique sensible, on peut définir, pour le module A, un domaine abstrait D(K) pour les variables entières ou à virgule fixe ou flottante, voire les réels correspondant à la propagation des constantes, aux puissances, aux intervalles, aux octogones, aux invariants d'égalité ou d'inégalité linéaires, etc. modulo une valeur entière positive N constituant la clé secrète K = N ;
Pour un programme P écrit en langage de programmation avec des données symboliques (avec des pointeurs, des listes, des tableaux, ...), et dont l'auteur veut sécuriser le déroulement sensible de manipulation de variables et de tableaux, on peut utiliser un domaine abstrait symbolique (par exemple un automate ou des domaines d'arbres) paramétré par des entiers (par exemple compteurs de boucles dans l'automate ou une mesure de la taille des données symboliques) en réutilisant le domaine abstrait précédent D(N) pour analyser les paramètres entiers, modulo une valeur entière positive N constituant la clé secrète K, à nouveau à une injection (pouvant être secrète) près.
Il existe d'une part une infinité de domaines abstraits Di possibles et d'autre part une infinité d'instances Di(K) de chaque domaine particulier en fonction de la clé secrète K.
Contrairement à la cryptologie classique, si le module A est secret, il n'est pas envisageable de le casser par la force brute. En effet il n'existe pas d'énumération possible de tous les domaines abstraits paramétrés utilisables.
Pour un domaine abstrait secret donné Di(N), des clés différentes conduisent à des sémantiques abstraites secrètes SAS différentes, comme c'est le cas pour les exemples ci-dessus. Quand le domaine abstrait secret a été divulgué ou est public, le secret de la clé doit être géré comme en cryptographie classique pour limiter les attaques à la force brute (comme dans le cas de la cryptologie classique basée sur les problèmes NP-complets ou les mécanismes de chiffrement à clé secrète). La sémantique abstraite secrète SAS doit être invariante pour les transformations des primitives et constructions de la famille de langages logiciels ou matériels considérés, qui laissent leur sémantique standard invariante, comme c'est le cas pour les exemples ci-dessus. Ceci est important pour éviter les attaques d'obfuscation qui consistent à transformer un programme P en un programme syntaxiquement différent mais sémantiquement équivalent, par exemple, l'expression mathématique (a =
2b) étant changée en (a = b + b).
(Voir Figure 5)
Un Module DA de sémantique abstraite
Parmi les modes préférés de réalisation du procédé ci-dessus, l'invention divulgue également un dispositif (pouvant être réalisé par un produit/programme d'ordinateur) incluant : Un module DA basé sur un domaine abstrait Dj(K) paramétré par une clé secrète K choisie parmi un très grand nombre possible, permettant d'engendrer un programme implantant la sémantique abstraite secrète SAS de la famille de langages de programmation logiciel ou matériel considérés ;
(Voir Figure 5A)
Un procédé S de signature
Le procédé/module S utilise une sémantique abstraite secrète SAS pour les constructions et primitives de la famille de langages de programmation considérés, pour faire l'analyse statique sémantique du programme original P logiciel ou matériel, le résultat de cette analyse fournissant la signature sémantique secrète SSS du programme P. Pour ce faire, le module S construit une représentation du système d'équations de point-fixe dont la solution approchée définit la sémantique abstraite SASP dudit programme logiciel ou matériel P. Cette sémantique abstraite SASP du programme logiciel ou matériel P est définie selon les principes de l'analyse statique par interprétation abstraite de la sémantique concrète du programme en fonction de la sémantique abstraite secrète SAS pour les constructions et primitives de la famille de langages de programmation considérés. Cette sémantique abstraite SASP est calculée par élimination, ou par itération avec accélération de la convergence. La signature sémantique secrète SSS du programme P est une fonction injective SSS = i(SASP) de la sémantique abstraite secrète SASP. Cette fonction injective i peut elle-même constituer un secret.
La signature sémantique secrète SSS d'un programme logiciel ou matériel P, calculée selon le module S ou par le dispositif DS permet de vérifier si un programme logiciel ou matériel P' a une signature sémantique équivalente. À ce stade, il est possible de déposer la signature SSS du programme logiciel ou matériel P telle que produite selon le module S ou en sortie du dispositif DS chez une Tierce Partie de Confiance (TPC). Elle n'a donc pas à être insérée dans le programme logiciel ou matériel P. L'authentification du programme logiciel ou matériel P s'effectuera alors auprès de la TPC par comparaison de la signature produite SSS' du programme logiciel ou matériel P1 à analyser avec celle (SSS) qui a été déposée. Dans ce cas, le programme logiciel ou matériel P n'est pas protégé contre la copie P1, mais deux cas se présentent :
SSS' est différent de SSS : les modifications que P a subies sont détectables, puisque dans le cas de modifications sémantiques (par exemple, ajout d'un virus, modification d'un algorithme), la signature est différente;
SSS' est égal à SSS : le programme logiciel ou matériel P' est une copie de P ou si le programme logiciel ou matériel P a été obfusqué (manuellement ou automatiquement) pour devenir P', la signature SSS' de P' sera égale à celle SSS de P, ce qui prouvera, avec une probabilité extrêmement faible d'erreur, que le programme logiciel ou matériel P a été piraté, ce piratage étant masqué par un maquillage d'édition.
(Voir Figure 6)
Un module DS de signature
Un module DS permettant de calculer la signature SSS d'un programme logiciel ou matériel P selon la sémantique abstraite secrète SAS obtenue en utilisant le module précédent DA.
(Voir Figure 6A)
Un procédé M de marquage Pour l'invention, une marque m est un élément de programme logiciel ou matériel qui peut être insérée dans un programme logiciel ou matériel par le procédé décrit dans le module B ci-dessous. Soit Pm le programme logiciel ou matériel le plus simple possible dans lequel la marque m peut être inséré. Pour toute sémantique abstraite secrète SAS, ce programme Pm a une signature sémantique secrète, calculable par le module S, dite signature sémantique secrète de ladite marque m et notée SSS(m).
Une « marque » m est un triplet constitué d'un « emplacement de marque », d'une « marque d'initialisation » et d'une « marque d'induction », l'une des deux dernières pouvant éventuellement être vide. Soit Pm un programme logiciel ou matériel de la famille de langages considérée, le plus simple possible, qui déclare si nécessaire
I'« emplacement de marque » 'X', exécute la « marque d'initialisation » 'la', puis exécute une ou plusieurs voire un nombre infini de fois la « marque d'induction » 'If.
Le procédé M de marquage est paramétré par une sémantique abstraite secrète SAS (par exemple, produite par le module A à partir d'un domaine abstrait Di(K) en fonction d'une clé secrète K) et une signature sémantique secrète SSS ;
En utilisant une bijection β qui peut être secrète, le module M calcule une valeur abstraite 's' du domaine abstrait Di(K) en fonction de la signature sémantique secrète SSS, selon le codage de la sémantique abstraite secrète SAS. Cette valeur abstraite 's' est choisie de sorte qu'il existe de très nombreuses valeurs concrètes 'x' dont l'abstraction selon les principes de l'interprétation abstraite ou celle du singleton '{x}' est la valeur abstraite 's' . Par exemple cette valeur 'x' peut être celle d'une variable dans le cas d'une analyse non-relationnelle ou d'un vecteur de variables pour une analyse relationnelle ou la valeur de tout objet analogue à un vecteur de variables ;
Le procédé M choisit, selon les principes de l'interprétation abstraite, l'une quelconque des valeurs concrètes 'a' dont l'abstraction ou celle du singleton '{a}' est la valeur abstraite s ;
Le procédé M choisit ensuite, selon les principes de l'interprétation abstraite, une opération concrète 'f dont l'abstraction fonctionnelle laisse invariante la valeur abstraite 's' mais pas les valeurs concrètes correspondantes (c'est-à-dire que si 'x' est une valeur concrète dont l'abstraction selon les principes de l'interprétation abstraite ou celle du singleton '{x}' est la valeur abstraite 's' alors 'f(x)' est en général différent de 'x' tandis que l'abstraction selon les principes de l'interprétation abstraite de 'f(x)' ou celle du singleton '{f(x)}' est égale à 's') ;
Le procédé M choisit ensuite un « emplacement de marque » 'X' qui peut être une variable existante du programme qui est inutile ou n'est pas vivante dans les éléments du programme P à tatouer, une nouvelle variable auxiliaire, un champ inutile ou supplémentaire d'une structure de données allouée dynamiquement, etc. dont les valeurs sont prises en compte dans l'analyse statique sémantique utilisée pour déterminer la sémantique abstraite secrète du programme ;
Le procédé M détermine ensuite une « marque d'initialisation » 'la' qui est constituée d'une ou plusieurs primitives ou constructions de la famille de langages considérés s'interprétant comme une affectation de la valeur concrète 'a' définie ci-dessus à l'emplacement de marque 'X' ;
Le procédé M détermine ensuite une « marque d'induction » 'If comprenant une ou plusieurs primitives ou constructions de la famille de langages considérés s'interprétant comme une affectation de la valeur de 'f(X)' à l'emplacement de marque 'X'. Selon la famille de langages considérés, ces primitives ou constructions seront des affectations, des passages de paramètre, des unifications, etc.
La marque m est choisie telle que, selon les principes de l'interprétation abstraite, l'analyse sémantique statique du programme Pm, selon la sémantique abstraite secrète et conformément aux directives du module S, détermine de façon reconnaissable par le détenteur du secret SAS, la valeur abstraite 's' définie ci-dessus et telle que la signature sémantique secrète du programme Pm, comme définie ci-dessus, est celle SSS(m) de la marque.
En utilisant des domaines abstraits qui sont des produits cartésiens ou des produits réduits de domaines abstraits élémentaires, il est toujours possible de considérer les marques qui sont des ensembjes finis de marques élémentaires.
(Voir Figure 7)
Un Module DM de marquage
Parmi les modes préférés de réalisation du procédé M ci-dessus, l'invention divulgue également un dispositif DM (pouvant être réalisé par un produit/programme d'ordinateur) qui, à partir du programme implantant la sémantique abstraite secrète SAS et des données représentant la sémantique secrète SSS du programme P, calcule le texte de la marque m.
(Voir Figure 7A) Un procédé B de camouflage
Le procédé/module B de camouflage prend en paramètre le programme logiciel ou matériel original P, une sélection des éléments du programme P à tatouer et une marque m. Le module B fournit le programme tatoué PT qui est une fusion du programme original P et de la marque m. Cette fusion est faite sans altérer la sémantique abstraite secrète de la marque, ni la fonctionnalité, du programme original, ce qui permet de retrouver la signature sémantique secrète SSS(m) de la marque m à partir de la signature sémantique secrète SSS(PT) du programme tatoué PT.
Il est important de noter que, dans le mode de réalisation préféré de l'invention, l'observation des valeurs prises par les variables lors de l'exécution du programme logiciel ou matériel tatoué PT ne permet pas de retrouver la marque. D'une part, il faut connaître la sémantique abstraite secrète pour établir le programme tatoué PT. D'autre part, le calcul de propriétés sémantiques de ce programme logiciel ou matériel tatoué PT ne pourra se faire, dans les cas de domaines abstraits D(K) non triviaux, que par analyse sémantique statique, et non pas par une exécution pas à pas.
L'insertion des instructions dans le programme logiciel ou matériel à protéger P devra respecter un certain nombre de règles minimales de robustesse. Par exemple, pour éviter la suppression pure et simple par un optimiseur utilisant les techniques d'extraction « slicing », il faut s'assurer que les variables et les opérations contenant les marques de tatouage donnent l'impression qu'ils ont une influence possible sur la sémantique observable (par exemple les sorties) du programme. Ladite dépendance potentielle peut être une simple dépendance syntaxique choisie de sorte que la démonstration que cette dépendance syntaxique n'entraîne pas une dépendance sémantique requiert la preuve complexe d'une équivalence sémantique de programmes logiciels ou matériels. C'est le cas par exemple de l'allocation dynamique de valeur (sémantiquement inutile mais ceci est indécidable) de certaines valeurs calculées par les opérations contenant les marques de tatouage.
La marque m créée par le module M, la sélection des éléments à tatouer dans un programme logiciel ou matériel P telle qu'elle est choisie par le module PS et utilisée par le module B doivent satisfaire aux critères énoncés ci-après.
Les « marques d'induction » 'If doivent être incluses dans les parties du programme logiciel ou matériel contenant des primitives ou constructions de répétition (itérations, récursivités, etc.).
Les « marques d'initialisation » 'la' sont utilisées pour faire les initialisations requises par la sémantique de la famille de langages considérés. De plus, si nécessaire, pour la famille de langages considérée, d'éventuelles déclarations doivent être ajoutées au programme tatoué PT si la nature des l'« emplacement de marque » 'X' le nécessite.
Finalement, le module de camouflage B ajoute des primitives ou constructions au programme tatoué PT rendant actives les valeurs éventuellement utilisées dans les « emplacements de marque » 'X'. Une solution possible consiste à utiliser les valeurs éventuellement utilisées dans les « emplacements de marque » dans le calcul de variables actives du programme matériel ou logiciel tatoué PT, ou encore à affecter les valeurs des « emplacements de marque » 'X' à des variables dynamiques du programme tatoué PT, plus généralement en s'assurant que la durée de vie dynamique des « emplacements de marque » 'X' est celle du programme tatoué PT. À nouveau ces transformations du programme P en le programme tatoué PT doivent être faites sans altérer la sémantique abstraite secrète de la marque, ni la fonctionnalité du programme original, de façon que, selon les principes de l'analyse statique par interprétation abstraite, cela permette de retrouver la signature sémantique secrète SSS(m) de la marque m à partir de la signature sémantique secrète SSS(PT) du programme tatoué PT.
(Voir Figure 8)
Un Module DB de camouflage Parmi les modes préférés de réalisation du procédé B ci-dessus, l'invention divulgue également un dispositif DB (pouvant être réalisé par un produit/programme d'ordinateur) qui, à partir du texte du programme logiciel ou matériel P, de données de sélection des éléments à tatouer dans P et du texte de la marque m, produit le texte du programme logiciel bu matériel PT dont la sémantique est fonctionnellement équivalente à celle de P et qui dissimule la marque m.
(Voir Figure 8A)
Un procédé PS de politique de sécurité
Le procédé PS de sélection du domaine abstrait de tatouage et des éléments à tatouer dans le programme logiciel ou matériel P dépend de la politique de sécurité à appliquer à ce programme P : À l'image des techniques stéganographiques, la marque peut être répartie dans le programme à des endroits différents et éloignés en choisissant par exemple des analyses sémantiques statiques par interprétation abstraite basées sur des domaines abstraits permettant d'ignorer les structures de contrôle dans le calcul de la signature sémantique secrète de sorte que la répartition aléatoire des marques est sans effet sur cette analyse ; cette stratégie est par exemple applicable lorsque la marque sert à authentifier tout un programme P, relativement important en taille.
Une autre politique de sécurité consiste à tatouer les parties innovantes et/ou sensibles du programme P. En général les éléments sélectionnés pour le tatouage concernent la partie algorithmique du programme (opérations algébriques ou manipulations de variables en mémoire vive). Selon la famille de langages de programmation considérés et la méthodologie de programmation utilisée, cette partie algorithmique peut être : - Des éléments significatifs du programme qui sont sémantiquement autonomes. En Java™ par exemple, un programme est assimilé à plusieurs classes composées de plusieurs méthodes, elles- mêmes pouvant faire appel à des méthodes d'autres classes et d'autres packages. Une politique de sécurité pour Java™ peut donc consister à tatouer les méthodes qui sont les plus petites entités autonomes significatives du programme. Un autre choix serait de tatouer des Beans™.
- Des éléments répartis dans le programme constituant un ensemble sémantiquement cohérent comme par exemple un type abstrait algébrique qui serait implémenté par des structures de données et des procédures et fonctions réparties dans tout le programme ; Dans ce cas les éléments à tatouer peuvent être sélectionnés automatiquement sur des critères syntaxiques (procédures, modules, etc.) ou sémantiques (par une analyse statique de dépendance) ou manuellement par intervention d'un opérateur. Plusieurs politiques de sécurité différentes peuvent être mise en oeuvre sur le même programme P en répétant des tatouages successifs du même programme logiciel ou matériel original pour des acteurs différents. Il est ainsi possible d'affecter à plusieurs niveaux d'une chaîne de distribution de matériel ou de logiciel (acheteur, grossiste, distributeur, détaillant) des marques qui leur seront propres. On peut ainsi tatouer autant de fois que l'on veut un programme logiciel ou matériel (par superposition de tatouages), contrairement aux tatouages de sons ou d'images qui subissent une certaine saturation du canal subliminal (selon le modèle de perception choisi). On n'altérera pas le programme logiciel ou matériel, on le surchargera, les ressources mémoire et temporelles en seront seules affectées.
On peut utiliser pour chacun de ces tatouages des sémantiques secrètes différentes, si bien que la chaîne de confiance peut avoir des secrets différents.
Bien entendu, ce dispositif et ce procédé de tatouage peuvent être combinés avec des dispositifs et procédés de l'art antérieur pour rendre le programme matériel ou logiciel inutilisable à un utilisateur non autorisé (prévention) pour tracer la dissémination éventuelle dudit programme par un utilisateur autorisé à des utilisateurs non autorisés (audit). Il suffira pour cela de ne pas communiquer aux utilisateurs autorisés les clés leur permettant de retrouver le tatouage.
Il est également possible d'utiliser le dispositif et le procédé pour authentifier de manière automatique les programmes logiciels ou matériels que l'on va autoriser à transiter sur un réseau ou à être hébergés sur un poste informatique donné. Le tatouage est assimilable à un certificat d'authentification dont le poste de surveillance du réseau ou du poste informatique disposera de la clé de lecture.
(Voir Figure 9) Un Module DPS de politique de sécurité
Parmi les modes préférés de réalisation du procédé PS ci-dessus, l'invention divulgue également un dispositif DPS (pouvant être réalisé par un produit/programme d'ordinateur) qui, à partir du texte du programme logiciel ou matériel P et d'une famille de domaines abstraits D^ ..., Dm, choisit un domaine abstrait D et sélectionne les éléments du programme P à tatouer.
(Voir Figure 9A)
Un procédé T de tatouage
Le procédé T de tatouage utilise un module C de chiffrement, qui implante une fonction bijective pour calculer une signature sémantique secrète SSS en fonction d'un authentifiant Auth, en utilisant éventuellement la sémantique abstraite secrète SAS. À partir de cette signature sémantique secrète SSS et de ladite sémantique abstraite secrète SAS, le module de marquage M décrit ci-dessus produit une marque m. Le module T utilise encore le module B décrit ci-dessus qui, à partir de ladite marque m, du programme logiciel ou matériel P et de la sélection des éléments à tatouer dans P fournit le programme logiciel ou matériel tatoué PT.
(Voir Figure 10)
Un Module DT de tatouage
Parmi les modes préférés de réalisation du procédé T de tatouage ci-dessus, l'invention divulgue également un dispositif DT (pouvant être réalisé par un produit/programme d'ordinateur) pour dissimuler un authentifiant Auth dans le texte d'un programme original P logiciel ou matériel grâce à un programme implantant une sémantique abstraite secrète SAS et des données de sélection des éléments de P à tatouer.
(Voir Figure 10A)
Un procédé G général
Le procédé général G sert à tatouer un programme P. Pour ce faire, le module PS décrit ci-dessus est utilisé pour choisir automatiquement ou interactivement le domaine abstrait paramétré qui sera ultérieurement utilisé pour réaliser l'analyse statique par interprétation abstraite par le module Au d'authentification ainsi que pour sélectionner automatiquement ou interactivement les éléments du programme logiciel ou matériel à tatouer P. Ensuite, le module A décrit ci-dessus est utilisé pour calculer la sémantique abstraite secrète SAS à partir du domaine abstrait paramétré précédemment sélectionné et d'une clé secrète, en général choisie en interaction avec un opérateur mais qui peut également l'être automatiquement, voire aléatoirement. Enfin, le module T décrit ci-dessus utilise le programme P, la sémantique abstraite secrète SAS, un authentifiant Auth et la sélection des éléments à tatouer dans P pour produire le programme logiciel ou matériel tatoué PT. Des variantes consistent à fixer une fois pour tout le domaine abstrait qui est utilisé par le module G et à choisir la clé secrète K en utilisant une méthode cryptographique standard.
Application à la compilation authentifiante La compilation conserve la sémantique concrète des programmes logiciels ou matériels à un morphisme près. Par conséquent la compilation conserve également la sémantique abstraite secrète du programme logiciel ou matériel objet Po, qui est la même que celle du programme source P, à ce même morphisme près. De ce fait, la compilation d'un programme matériel ou logiciel tatoué source PT par un compilateur correct ne lessive pas le tatouage dans le programme matériel ou logiciel objet PTo. Connaissant l'ordinateur cible, on connaît la sémantique concrète du code objet et donc celle du programme matériel ou logiciel objet PTo. En adaptant les dispositifs DA et DS, selon les principes de la théorie de l'interprétation abstraite, à la sémantique concrète du langage machine de l'ordinateur ou du système informatique objet en utilisant ledit morphisme de compilation, on obtient des dispositifs DAo et DSo conformes aux modules A et S pour la sémantique concrète du code objet et tels que la composition de DA puis DS pour PT donne la même sémantique secrète SSS (audit morphisme près) que la composition de DAo et DSo pour PTo. Par conséquent, le dispositif DAu utilisant le dispositif DSo calcule une représentation de la signature sémantique secrète SSS du programme PTo, qui est également celle du programme PT et peut donc être utilisée par le dispositif DAu pour retrouver l'authentifiant du programme PT.
Une des applications de ce brevet est un module Ca de compilation authentifiante compilant un programme tout en y insérant un tatouage selon les principes du module G. Dans son mode de réalisation préféré, un compilateur authentifiant Dca intègre le dispositif DG de la figure 7 bis dans un compilateur pour un langage informatique matériel ou logiciel qui est utilisable en option pour tatouer le code objet. Comme expliqué ci- dessus, le dispositif DAu permet de retrouver l'authentifiant du programme objet tatoué.
(Voir Figure 11)
Le Module DG général Parmi les modes préférés de réalisation du procédé G de tatouage ci-dessus, l'invention divulgue également un dispositif DG (pouvant être réalisé par un produit/programme d'ordinateur) pour dissimuler un authentifiant Auth dans le texte d'un programme original P logiciel ou matériel (en fonction du choix un domaine abstrait paramétré par une clé secrète).
(Voir Figure 11 A)
Un procédé Au d'authentification Le procédé Au d'authentification prend en paramètres, le programme logiciel ou matériel marqué PT et la sémantique abstraite secrète SAS. Il calcule l'authentification originale Auth. Ce module A est composé de deux sous-modules : le module S, décrit ci-dessus, qui à partir du programme logiciel tatoué PT et de la sémantique secrète extrait la signature sémantique secrète SSS(PT) et par conséquent celle SSS(m) de la marque m cachée dans PT ; un module F de déchiffrement et d'extraction, qui est l'inverse du module C de chiffrement utilisé dans le module T de tatouage, prend en paramètre la signature sémantique secrète SSS(PT) pour extraire l'authentifiant original Auth de P.
Le module de déchiffrement F peut également constituer un secret, tout comme le module C.
(Voir Figure 12)
Un Module DAu d'authentification
Parmi les modes préférés de réalisation du procédé d'authentification Au ci-dessus, l'invention divulgue également un dispositif d'authentification DAu (pouvant être réalisé par un produit/programme d'ordinateur utilisant le dispositif DS ci-dessus et un dispositif de déchiffrement DF) pour l'authentification d'un programme tatoué PT en calculant son authentifiant Auth.
(Voir Figure 12A)
Présentation des figures supplémentaires
5 La figure 5 montre un schéma de principe du procédé A pour engendrer la sémantique abstraite secrète SAS à partir d'un domaine abstrait Di(K) dépendant d'une clé secrète K ;
6 La figure 6 montre un schéma de principe du procédé S pour calculer la signature SSS selon la sémantique secrète SAS d'un programme logiciel ou matériel P ;
Les figures 5A et 6A montrent le schéma des dispositifs DA et DS correspondant aux procédés A et S dans une de leurs variantes de réalisation ; 7 La figure 7 (respectivement 7A) montre le schéma de principe du procédé M (respectivement du dispositif DM dans une de ses variantes de réalisation) pour produire une marque connaissant une sémantique abstraite secrète SAS (résultant par exemple de l'application du principe du procédé de la figure 1) et une signature sémantique secrète SSS ; 8 La figure 8 (respectivement 8A) montre le schéma de principe du procédé B (respectivement du dispositif DB dans une de ses variantes dé réalisation) pour tatouer un programme logiciel ou matériel P en insérant une marque m dans une sélection d'éléments à tatouer dudit P ; 9 La figure 9 (respectivement 9A) montre le schéma de principe du procédé PS (respectivement du dispositif DPS dans une de ses variantes de réalisation) qui, étant donné un programme logiciel ou matériel P, choisit un domaine abstrait D parmi une famille de domaines abstraits possibles et sélectionne des éléments de P à tatouer; 10 La figure 10 (respectivement 10A) montre le schéma de principe du procédé T (respectivement du dispositif DT dans une de ses variantes de réalisation) pour insérer une marque m caractéristique d'un authentifiant Auth dans une sélection d'éléments d'un programme logiciel ou matériel P original en utilisant une sémantique abstraite secrète SAS ; 11 La figure 11 (respectivement 11 A) montre le schéma de principe du procédé T (respectivement du dispositif DT dans une de ses variantes de réalisation) pour choisir un domaine abstrait paramétré par une clé, une clé secrète particulière et un authentifiant pour tatouer un programme logiciel ou matériel P par transformation en un programme tatoué fonctionnellement équivalent PT ;
12 La figure 12 (respectivement 12A) montre le schéma de principe du procédé Au (respectivement du dispositif DAu dans une de ses variantes de réalisation) pour authentifier un programme tatoué PT.
ANNEXE 6 Exemple 3
Considérons un programme original P à tatouer très simple par le dispositif DG de la figure 11 A, qui est le suivant :
public class Fibonacci
{ public Fibonacci() {}
public static void main(String[] args)
{ int n=lnteger.parselnt(args[0]); int a=0; int b=1 ; for (int i=1 ;i<n;i++)
{ int c=a+b; a=b; //a vaut ui b=c; //b vaut ui+1
}
System. out.println("La valeur de la suite pour n="+n+" est : "+b); }
}
À titre d'exemple, le dispositif DPS de la figure 9A sélectionne des méthodes à tatouer, comme la méthode main.
Un exemple très simple de tatouage de méthodes Java™ consiste à utiliser une sémantique collectrice qui est l'ensemble des descendants des états d'entrée de la méthode (d'autres alternatives étant la sémantique des ascendants des états de sortie ou des combinaisons comme l'intersection de ces sémantiques collectrices).
Dans cet exemple, la sémantique abstraite secrète SAS est l'abstraction de la sémantique collectrice d'une méthode qui ne retient que les variables locales entières et fait complètement abstraction des autres variables, du graphe de flot de contrôle, des éléments extérieurs et du contexte de la méthode. De ce fait l'analyse statique est insensible aux transformations du programme (par exemple à des fins d'obfuscation ou de brouillage) modifiant le graphe de flot de contrôle et des transformations par équivalence des expressions arithmétiques. Par simplicité pour cet exemple de sémantique abstraite secrète SAS, seules les opérations arithmétiques de base +, - et * sont considérées (y compris toutes les autres opérations arithmétiques permettant de réécrire des expressions arithmétiques comprenant ces opérations de base sous une forme arithmetiquement équivalente, comme le moins unaire, etc.). La sémantique concrète est choisie sur l'anneau (Z,+, *) des entiers mathématiques (et non comme des entiers modulo 232 comme en Java™, les équivalences arithmétiques mentionnées ci-dessus devant tenir compte de ce fait). Dans cet exemple, la sémantique abstraite secrète SAS utilise un domaine de hauteur finie pour les variables locales entières, ce qui la rend insensible aux stratégies d'itération chaotique utilisées et évite, toujours dans l'optique d'une plus grande simplicité de l'exemple, l'utilisation d'opérateurs d'élargissement et de rétrécissement. Dans cet exemple, la clé secrète K est le produit K1*K2*...*Kn d'entiers naturels strictement positifs et premiers entre eux. Dans l'exemple considéré ci-dessous, n=2, K1 =10000 et K2=5421. Le domaine abstrait D(K), utilisé pour calculer la sémantique abstraite secrète SAS par interprétation abstraite de la sémantique collectrice, est celui de la propagation des constantes modulo K. D'après le lemme chinois, 7J = Z/|< ...*KnZ est isomorphe à l'anneau produit Z/κιz x ••• x Z/KnZ- Étant donné la signature sémantique secrète SSS du programme tatoué PT dans Z /KZ = Z/ ι*...*KnZ> on considère son image (si , ..., sn) dans Z/KI Z x ••• x ^KnZ dont les composantes sont données par la projection canonique sur l'anneau Z/ JZ. i = 1 > ---»n. Dans l'exemple considéré, on suppose que le dispositif DC de la figure 6 bis calcule la signature sémantique secrète (2507, 3012) à partir de l'authentifiant du programme. La sémantique statique secrète est alors obtenue par n analyses statiques, pour toutes les variables entières locales à la méthode des domaines abstraits Z/\Q Z, i = 1,.--,n, correspondant à la propagation des constantes modulo Ki. Le dispositif DA de la figure 5A consiste donc en un programme d'analyses statiques successives par propagation des constantes modulo (K1 , ..., Kn).
Dans cet exemple, le dispositif DM de la figure 7A utilise la sémantique abstraite secrète SAS et la signature sémantique secrète SSS 5 définies ci-dessus pour produire une marque m dont le texte est le suivant :
int <watermark:10000:2507>; int <tmp:10000:2507>;
l o <watermark: 10000:2507>=1 ;
<tmp:10000:2507>=<watermark:10000:2507>+227492;
<tmp: 10000:2507>≈<watermark: 10000:2507>*<tmp: 10000:2507>;
<watermark:10000:2507>=<tmp: 10000:2507>+155014;
15 <tmp: 10000:2507>=<watermark: 10000:2507>*1323;
<tmp: 10000:2507>=<tmp: 10000:2507>+153; <tmp: 10000:2507>=<tmp: 10000:2507>*<watermark: 10000:2507>; <watermark:10000:2507>=<tmp:10000:2507>+9109;
0 int <watermark:5421 :3012>; int <tmp:5421 :3012>;
<watermark:5421 :3012> = 1 ; <tmp:5421 :3012>=<watermark:5421 :3012>+-35539; 5 <tmp:5421 :3012>=<:watermark:5421 :3012>*<tmp:5421 :3012>;
<watermark:5421 :3012>=<tmp:5421 :3012>+11445;
<tmp:5421 :3012>=<watermark:5421 :3012>*658; <tmp:5421 :3012>=<tmp:5421 :3012>+971 ; 0 <tmp:5421 :3012>=<tmp:5421 :3012>*<watermark:5421 :3012>;
<watermark:5421 :3012>=<tmp:5421 :3012>+4623;
Dans un cas simplifié où Ki n'est pas trop grand et pour une signature sémantique secrète s donnée dans Z ^JZ» 'e texte 'de la marque m créé par le dispositif DM de la figure 7A peut consister en une seule marque d'initialisation qui peut être une affectation : <watermark:Ki:s>= s'; où s' = s + aKi et la valeur a dans Z n'est pas choisie trop grande de manière à éviter que s' ne déborde pas hors des 32 bits des entiers Java. La valeur de la variable <watermark : Ki : s> est toujours constante dans une analyse statique par propagation des constantes modulo Ki et égale à s. Cette valeur n'apparaît pas en clair dans la marque et est d'autant plus difficile à trouver que la clé secrète Ki est inconnue. Une instanciation plus sophistiquée du dispositif DM de la figure
7A permet de choisir cette marque d'initialisation comme étant un polynôme Q (en la variable <watermark:Ki:s>) de la forme : a[<<watermark:Ki:s>'< + ... + a-] <watermark:Ki:s> + a où afc, ..., a-j sont des valeurs aléatoires et la valeur a est donnée par a ≡ s - akvk - a|<_ιv k-1 - ... - a-|v mod Ki où la valeur initiale v est choisie quelconque de manière aléatoire. Dans ce cas, la marque d'initialisation est constituée par les affectations : <watermark:Ki:s>=v; <watermark:Ki:s>= ak<watermark:Ki:s>k+...+a-j<watermark:Ki:s>
+ a; de sorte que l'on a toujours : <watermark:Ki:s> = s mod Ki
L'utilisation d'une seule marque d'initialisation a l'inconvénient de laisser la valeur de <water ark: Ki : s> constante et donc aisément repérable par une analyse statique propageant les constantes. Pour l'éviter, un dispositif DM plus sophistiqué ajoutera une marque d'induction permettant de donner une dynamique à la variable de marque <watermark : Ki : s> de façon qu'elle prenne des valeurs stochastiques dans Z mais reste constante dans Z/KJZ- On utilise pour cela un polynôme Q' qui possède la propriété de stabilité, c'est-à-dire :
Q'(s) ≡ s mod Ki Le polynôme Q' est engendré comme expliqué ci-dessus et la marque d'induction est constituée par l'instruction : <watermark:Ki:s>= a'k'<watermark:Ki:s>k'+...+a'ι <watermark:Ki:s> + a'; ou tout équivalent, par exemple en utilisant le principe de calcul de Hôrner. Le dispositif DB de la figure 8A peut placer cette marque d'induction dans une boucle ou dans un appel récursif de la méthode à tatouer dans P car son exécution ne modifie pas la valeur de <watermark : Ki : s> dans l'anneau Z/KJZ choisi pour calculer la sémantique statique secrète s. Par contre la valeur observée dans le domaine d'interprétation des entiers Java sera totalement stochastique.
Dans l'exemple du tatouage du programme P ci-dessus, la marque définie ci-dessus utilise deux variables locales <watermark : Ki : s> et <tmp : Ki : s>. La marque d'initialisation est le segment de code initial constitué par un polynôme Q calculant la valeur initiale de <watermark : Ki : s>. La marque d'induction est constituée par un polynôme Q' possédant la propriété de stabilité pour s dans l'anneau Z/KJZ considéré. On utilise des polynômes du second degré par commodité. Les valeurs des coefficients du polynôme du second degré assurant l'initialisation sont aléatoires. Ce polynôme est donné comme suit dans Z/KJZ : Q(x) = (x - 1 )(x - s) = x2 + coeff 1.x + coeff2,
Un nombre aléatoire de périodes du modulo Ki est ajouté ou retranché aux coefficients afin de ne pas dévoiler la clef s. La valeur initiale de <watermark : Ki : s> est donc :
<watermark : Ki : s> = Q ( 1 ) = s dans Z/^jZ- La marque initiale consiste à calculer ce polynôme Q en utilisant le principe de calcul de Hôrner. La marque d'induction est constituée par un polynôme Q' (également du second degré, là aussi par commodité) satisfaisant la propriété de stabilité : Q'(s) = s dans Z/KJZ Le polynôme Q' s'écrit :
Q'(x) = ax2 + bx + c
Les coefficients a et b sont tirés au sort, tandis que c est choisi de manière à assurer la propriété de stabilité pour la clef secrète comme expliqué ci-dessus. La marque d'induction est constituée par l'instruction d'affectation : <watermark:Ki:s> = Q'(<watermark:Ki:s>); où le polynôme est calculé par la méthode de Hôrner. Le programme tatoué PT correspondant au programme P incluant m ci-dessus est le suivant :
public class FibonacciTatoue
{ public FibonacciTatoue()
{}
public static void main(String[] args)
{ int n=lnteger.parselnt(args[0]); int a=0; int b=1 int d=1 int e=35538; int f=1 ; int g=227493; e=d*e; d=e+11445; g=f*g; f=g+155014; for (int i=1 ;i<n;i++) { int c=a+b; e=d*658; f=f*1323; a=b; lia. vaut ui g=g+153; e=e+971 ; g=g*f; e=e*d; b=c; //b vaut ui+1 d=e+4623; f=g+9109;
}
System. out.printlnfLa valeur de la suite pour n="+n+" est : "+b); }
}
L'emplacement des marques est aléatoire, dans l'ordre des marques, la marque d'initialisation étant placée au début du programme et la marque d'induction étant placée de préférence dans une boucle ou dans une branche d'appel récursif de la méthode.
Dans l'exemple considéré de dispositif DB de la figure 8A, une transformation supplémentaire du programme est ensuite nécessaire pour lier le tatouage au programme original (pour résister par exemple au détatouage par « slicing » automatique), comme par exemple) :
public class FibonacciTatoue
{ public FibonacciTatoue() {}
public static void main(String[] args)
{ int n=lnteger.parselnt(args[0]); int a=0; int b=1 ; int d=1 ; int e=35538; int f=1; int g=227493; e=d*e; d=e+11445; g=f*g; f=g+155014; for (int i=1 ;i<n;i++) int c=a+b; e=d*658; f=f*1323; a=b+(155014/f); //a vaut ui g=g+153; e=e+971 ; g=g*f; e=e*d; b=c+(e/f); //b vaut ui+1 d=e+4623; b=b-(e/f); a=a-(155014/f); f=g+9109; }
System. out.printlnfLa valeur de la suite pour n="+n+" est : "+b);
}
}
La suppression des variables d, e, f et g utilisées pour le tatouage rendrait le programme erroné donc inutilisable.
Dans un exemple plus réaliste, le dispositif DB de la figure 8A doit s'assurer que la transformation du programme original n'introduit pas d'erreurs à l'exécution pouvant modifier la sémantique du programme original. On utilisera pour cela les techniques classiques de l'interprétation abstraite.
Dans un exemple plus réaliste, le dispositif DB de la figure 8A utilisera des méthodes plus sophistiquées pour lier la marque m au programme original P dans le programme tatoué PT. Dans le cadre de l'exemple considéré ci-dessus, il faut pour cela pouvoir utiliser des propriétés invariantes secrètes de la variable de tatouage qui soient transposables en arithmétique signée sur 32 bits. C'est possible très simplement lorsque, par exemple, la clef Ki est une puissance de 2. En effet, supposons que Ki =2^ . Alors on a : x = s +a.2 k dans Z
Nous avons, toujours dans Z, que, pour tout j inférieur ou égal à k : x % 2 J = s % 2 J où x % y désigne l'opération qui renvoie le reste de la division euclidienne de x par y .On remarque que cette propriété reste trivialement vraie dans Zl2^2χ qui est le domaine des entiers Java™. Les propriétés arithmétiques du tatouage peuvent être utilisées pour modifier des calculs de la méthode. Par exemple, supposons que Ki = 2^ 6 et que s =18. Alors quelle que soit la valeur de x , l'invariant x % 4=2 est toujours satisfait. De ce fait, une constante explicite 2 dans le programme original P, peut être remplacée par x % 4 dans le programme tatoué PT. Les autres constantes ou valeurs de variables du programme tatoué PT peuvent également être aisément calculées en fonction de cette valeur. Par exemple 1 dans P sera simplement remplacé par (x % 4)-1 dans PT.
Ceci conclut la description du dispositif de tatouage DT sur l'exemple considéré par enchaînement des dispositifs DC, DM et DB comme indiqué à la figure 10A et du dispositif DG par enchaînement des dispositifs DPS, DA et DT comme indiqué à la figure 11 A. Dans cet exemple, le dispositif DS de la figure 6A calcule la sémantique statique secrète s = (si , ...,sn) en faisant n analyses statiques successives du programme tatoué selon l'interprétation abstraite définie ci- dessus consistant en une analyse en avant, pouvant ignorer le flot de contrôle ou non, avec propagation des constantes modulo les clés restées secrètes K1 Kn.
À partir de cette sémantique statique secrète s = (si , ...,sn), le dispositif DF calcule l'authentifiant original du programme P comme indiqué à la figure 8 bis.
Si le domaine D(K) utilisé dans l'exemple ci-dessus est public (mais pas la clé K), alors la sémantique statique secrète s peut être découverte par la force brute, du moins pour de très petits programmes comportant peu de variables entières. Dans un exemple plus réaliste on utilisera donc, non pas des clés si ,..., sn codées sur 32 bits, mais une ou plusieurs clés s de 512 bits utilisant, par exemple, un codage arithmétique de la valeur de <watermark:Ki : s> sur 16 variables de 32 bits ou 8 de 64 bits ou utilisant toute autre technique de codage informatique de grands entiers.
Ceci conclut la description du dispositif DAu de la figure 12A pour l'exemple considéré.
ANNEXE 7 Exemple 4
Un quatrième exemple est le programme de tri suivant :
private static void bubbleSort (double [] data, int size) { int indexl , index2; double temp; boolean exchanged; for (indexl = size; indexl >= 2; indexl--) { exchanged = false; for (index2 = 1 ; index2 <= indexl - 1 ; index2++) { if (data [index2] > data [index2 + 1]) { temp = data [index2]; data [index2] = data [index2 + 1]; data [index2 + 1] = temp; exchanged = true;
} } if (lexchanged) break;
} }
À nouveau n=2, K1 =10000 et K2=5421. La méthode bubbleSort est tatouée deux fois, une première fois par la même signature sémantique secrète (2507, 3012) que ci-dessus et la deuxième fois par la signature secrète (9876, 2345). Le deuxième tatouage aurait aussi bien pu être réalisé pour des valeurs différentes de K1 et K2. Après compilation, tatouage, obfuscation et décompilation, on obtient la classe bubbleSort comme suit :
private static void bubbleSort (double [] rO, int iO) { int il , i2, 13, i4, i5, i6, i7, i8, i9, il 0, il 1 ; double dO; 11 = 1 ; i2 = i1; i3 = i2; i4 = i3; i5 = i2 - 35539; i6 = il - 62508; i7 = ï3- 129877; i6 = i1 *i6; i5 = i2 * i5; il =i6- 144986; i8 = i4 + 84390; i7 = i3 * i7; i2 = i5- 75291; i8 = i4 * i8; i3 = i7 + 169752; i4 = i8 + 10111; for (i9 = iO; i9 >= 2 i9-) { i10 = 0; for (111 = 1; i11 <=i9-1;i11++){ if (r0[i11]>r0[i11 +1]){ i6 = il * 620; ι'6 = i6 + 1151; d0 = r0[i11]; i6 = i6*i1; il = i6 + 6570; r0[i11] = r0[i11 +1]; i8 = i4 * 936; i5 = i2 * 620; i5 = i5 + 1151; i5 = i5 * i2; iδ = i8 + 1057; i2 = i5 + 2961; r0[i11 +1] = d0;
Î7 = i3* 1231; i7 = i7 + 1699; if ((i2 - 2961) == i5) i10 = 1;
} i8 = iδ * i4; i7 = i7 * i3;
} i3 = i7 + 2696; i4 = i8 + 1389; if (i10 ===== 0) break;
}

Claims

REVENDICATIONS
1. Produit/programme d'ordinateur pour traiter les instructions d'un logiciel (10), caractérisé en ce qu'il comprend un module (310) de choix en fonction de critères prédéfinis des instructions (110, 130, 150) dudit logiciel en entrée du programme de transcodage et un module (320) de choix parmi plusieurs d'une méthode secrète de transcodage (220) appliquée aux dites instructions.
2. Produit/programme d'ordinateur selon la revendication 1 , caractérisé en ce que la méthode secrète de transcodage (220) a pour sortie une signature sémantique du logiciel (10).
3. Produit/programme d'ordinateur selon l'une des revendications précédentes, caractérisé en ce que la signature sémantique du logiciel (10) est constituée par tout ou partie de l'ensemble des propriétés du logiciel (10) transcodé par la méthode secrète (220).
4. Produit/programme d'ordinateur selon l'une des revendications précédentes, caractérisé en ce que ledit logiciel (10) est écrit en langage de programmation.
5. Produit/programme d'ordinateur selon l'une des revendications précédentes, caractérisé en ce que le logiciel (10) est écrit en langage du type Java, Java Script ou Java bytecode.
6. Produit/programme d'ordinateur selon l'une des revendications précédentes, caractérisé en ce que le logiciel (10) est écrit en langage du type Very High Définition Language, Verilog ou Assembleur.
7. Produit/programme d'ordinateur selon l'une des revendications précédentes, caractérisé en ce que les instructions auxquelles un programme de transcodage sera appliqué sont choisies parmi celles comportant des opérations algébriques ou des allocations sur des variables à valeurs entières.
8. Produit/programme d'ordinateur selon l'une des revendications précédentes, caractérisé en ce que les instructions auxquelles un programme de transcodage sera appliqué sont choisies parmi celles comportant des opérations algébriques ou des allocations sur des références à valeurs entières.
9. Produit/programme d'ordinateur selon la revendication 7 ou la revendication 8, caractérisé en ce que la méthode secrète de transcodage est déterminée par le choix de nombres entiers secrets comme opérateurs de congruence appliqués aux opérations algébriques ou aux allocations sur des variables ou des références à valeurs entières.
10. Produit/programme d'ordinateur selon la revendication 8, caractérisé en ce que la méthode secrète de transcodage est déterminée par le choix secret d'une ou plusieurs variables à valeurs entières en association aux références.
11. Produit/programme d'ordinateur selon l'une des revendications précédentes, caractérisé en ce qu' il comprend en outre un module (330) pour insérer les instructions transcodées inverses (110",130",150") dans le logiciel (10).
12. Produit/programme d'ordinateur selon la revendication 11 , caractérisé en ce que les instructions transcodées inverses sont insérées à des positions choisies en fonction de critères prédéfinis dans le logiciel (10) sous forme d'instructions de calcul desdites variables, lesdites instructions comportant l'application auxdites -variables d'opérations qui laissent invariante la signature sémantique du logiciel (10).
13. Produit/programme d'ordinateur selon la revendication
12, caractérisé en ce que les instructions transcodées inverses sont insérées à des positions choisies en fonction de critères prédéfinis dans le logiciel (10) sous forme d'instructions d'initialisation de variables et d'instructions de calcul des dites variables, les dites instructions comportant l'application auxdites variables de fonctions par des polynômiales de degré 1 ou de degré 2 créés à partir d'un coefficient aléatoire et des valeurs de nombres entiers secrets.
14. Produit/programme d'ordinateur selon l'une des revendications 11 à 13, caractérisé en ce que le module (330) comprend un sous-module de chiffrement (330 A) pour calculer une signature sémantique secrète (SSS) en fonction d'un authentifiant (Auth), un sous-module (330 B) pour déterminer une marque (m) à partir de la méthode secrète de transcodage (220) et de ladite signature sémantique secrète (SSS), et un sous-module de camouflage (330 C) pour produire le programme tatoué (40) à partir du texte du programme (10), de la marque (m) et des instructions choisies pour le tatouage (110, 130, 150).
15. Procédé pour traiter les instructions d'un logiciel (10), caractérisé en ce qu'il comprend une étape pour choisir en fonction de critères prédéfinis les instructions (110, 130, 150) dudit programme (10) auxquelles un programme de transcodage est appliqué et une étape pour choisir parmi plusieurs la méthode secrète de transcodage (220) à appliquer aux dites instructions.
16. Procédé selon la revendication 14, caractérisé en ce que la méthode secrète de transcodage produit une signature sémantique du logiciel (10).
17. Procédé selon la revendication 14, caractérisé en ce que la signature sémantique du logiciel (10) est constituée par tout ou partie de l'ensemble des propriétés du logiciel (10) transcodé par la méthode secrète (220).
18. Procédé selon l'une des revendications 14 ou suivantes, caractérisé en ce que ledit logiciel (10) est écrit en langage de programmation.
19. Procédé selon l'une des revendications 14 ou suivantes, caractérisé en ce que ledit logiciel (10) est écrit en langage du type Java,
Java Script ou Java bytecode.
20. Procédé selon l'une des revendications 14 ou suivantes, caractérisé en ce que le logiciel (10) est écrit en langage du type Very High Définition Language, Verilog ou Assembleur.
21. Procédé selon l'une des revendications 14 ou suivantes, caractérisé en ce que les instructions auxquelles un programme de transcodage sera appliqué sont choisies parmi celles comportant des opérations algébriques ou des allocations sur des variables à valeurs entières.
22. Procédé selon l'une des revendications 14 ou suivantes, caractérisé en ce que les instructions auxquelles un programme de transcodage sera appliqué sont choisies parmi celles comportant des opérations algébriques ou des allocations sur des références à valeurs entières.
23. Procédé selon l'une des revendications 20 ou 21 , caractérisé en ce que la méthode secrète de transcodage est déterminée par le choix de nombres entiers secrets comme opérateurs de congruence appliqués aux opérations algébriques ou aux allocations sur des variables ou des références à valeurs entières.
24. Procédé selon la revendication 21 , caractérisé en ce que la méthode secrète de transcodage est déterminée par le choix secret d'une ou plusieurs variables à valeurs entières en association aux références.
25. Procédé selon l'une des revendications 14 ou suivantes, caractérisé en ce qu' il comprend en outre une étape pour insérer les instructions transcodées inverses (110", 130", 150") dans le logiciel (10).
26. Procédé selon la revendication 24, caractérisé en ce que les instructions transcodées inverses sont insérées à des positions choisies en fonction de critères prédéfinis dans le logiciel (10) sous forme d'instructions de calcul desdites variables, lesdites instructions comportant l'application auxdites variables d'opérations qui laissent invariante la signature sémantique du logiciel (10).
27. Procédé selon la revendication 25, caractérisé en ce que les instructions transcodées inverses sont insérées à des positions choisies en fonction de critères prédéfinis dans le logiciel (10) sous forme d'instructions d'initialisation de variables et d'instructions de calcul des dites variables, les dites instructions comportant l'application auxdites variables de fonctions polynômiales de degré 1 ou de degré 2 créées à partir d'un coefficient aléatoire et de valeurs de nombres entiers secrets.
28. Produit programme d'ordinateur pour traiter les instructions d'un logiciel (40), caractérisé en ce qu'il comprend un module (50) permettant à un utilisateur connaissant le/les paramètres de la méthode secrète (220) selon l'une des revendications précédentes de reconnaître la signature du logiciel (10).
29. Produit/programme d'ordinateur selon la revendication précédente, caractérisé en ce que le module (50) comporte un programme d'analyse statique sémantique pour reconnaître la signature.
30. Produit/programme d'ordinateur selon la revendication
27 ou la revendication 28, caractérisé en ce que le module (50) comporte un programme de calcul du point fixe des valeurs de tout ou partie des variables.
31. Procédé pour traiter les instructions d'un programme d'ordinateur en code source (40), caractérisé en ce qu'il permet à un utilisateur connaissant le/les paramètres de la méthode secrète (220) selon l'une des revendications précédentes de reconnaître la signature du logiciel (10).
32. Procédé selon la revendication 30, caractérisé en ce qu'il comporte une étape d'analyse statique sémantique pour reconnaître la signature.
33. Procédé selon l'une des revendications 30 ou 31 , caractérisé en ce qu'il comporte une étape de calcul du point fixe des valeurs de tout ou partie des variables.
EP02735488A 2001-05-04 2002-04-23 Dispositif et procede pour la signature, le marquage et l'authentification de programmes d'ordinateur Withdrawn EP1390831A1 (fr)

Applications Claiming Priority (5)

Application Number Priority Date Filing Date Title
FR0106024 2001-05-04
FR0106024A FR2824401A1 (fr) 2001-05-04 2001-05-04 Dispositif et procede pour la signature, le marquage et l'authentification de programmes d'ordinateur
FR0110459 2001-08-03
FR0110459A FR2824402A1 (fr) 2001-05-04 2001-08-03 Dispositif et procede pour la signature, le marquage et l'authenticification de programmes d'ordinateur
PCT/FR2002/001389 WO2002091141A1 (fr) 2001-05-04 2002-04-23 Dispositif et procede pour la signature, le marquage et l'authentification de programmes d'ordinateur

Publications (1)

Publication Number Publication Date
EP1390831A1 true EP1390831A1 (fr) 2004-02-25

Family

ID=26213002

Family Applications (1)

Application Number Title Priority Date Filing Date
EP02735488A Withdrawn EP1390831A1 (fr) 2001-05-04 2002-04-23 Dispositif et procede pour la signature, le marquage et l'authentification de programmes d'ordinateur

Country Status (4)

Country Link
EP (1) EP1390831A1 (fr)
CA (1) CA2446291A1 (fr)
FR (1) FR2824402A1 (fr)
WO (1) WO2002091141A1 (fr)

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5559884A (en) 1994-06-30 1996-09-24 Microsoft Corporation Method and system for generating and auditing a signature for a computer program
US6108420A (en) 1997-04-10 2000-08-22 Channelware Inc. Method and system for networked installation of uniquely customized, authenticable, and traceable software application
US6668325B1 (en) * 1997-06-09 2003-12-23 Intertrust Technologies Obfuscation techniques for enhancing software security

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
See references of WO02091141A1 *

Also Published As

Publication number Publication date
WO2002091141A1 (fr) 2002-11-14
CA2446291A1 (fr) 2002-11-14
FR2824402A1 (fr) 2002-11-08

Similar Documents

Publication Publication Date Title
US20060010430A1 (en) Device and process for the signature, the marking and the authentication of computer programs
Cui et al. A robust FSM watermarking scheme for IP protection of sequential circuit design
Qu et al. Intellectual property protection in VLSI designs: theory and practice
US7017043B1 (en) Methods and systems for the identification of circuits and circuit designs
US9602289B2 (en) Steganographic embedding of executable code
US20160364707A1 (en) Potentate: A Cryptography-Obfuscating, Self-Policing, Pervasive Distribution System For Digital Content
EP0883284A2 (fr) Procédé d&#39;authentification de données numériques
Nagra et al. A functional taxonomy for software watermarking
Abdel-Hamid et al. IP watermarking techniques: Survey and comparison
Hachez A comparative study of software protection tools suited for e-commerce with contributions to software watermarking and smart cards
EP3127034A1 (fr) Protection de logiciel
CN112073807B (zh) 基于区块链的视频数据的处理方法和装置
KR101153085B1 (ko) 이소제니-기반 서명의 생성과 유효화를 위한 시스템 및방법
Chang et al. A blind dynamic fingerprinting technique for sequential circuit intellectual property protection
FR2914081A1 (fr) Procede de protection de documents numeriques contre des utilisations non autorisees.
Martínez et al. On watermarking for collaborative model-driven engineering
EP3304531B1 (fr) Procédé de chiffrement, procédé de chiffrement, dispositifs et programmes correspondants
Sengupta et al. Exploring unified biometrics with encoded dictionary for hardware security of fault secured IP core designs
Mambo et al. Fingerprints for copyright software protection
US7392523B1 (en) Systems and methods for distributing objects
EP1390831A1 (fr) Dispositif et procede pour la signature, le marquage et l&#39;authentification de programmes d&#39;ordinateur
JP2007157021A (ja) 耐タンパ証明携帯プログラム配信システム及びその方法
Kumar et al. Smart Contract Obfuscation Technique to Enhance Code Security and Prevent Code Reusability
FR2824401A1 (fr) Dispositif et procede pour la signature, le marquage et l&#39;authentification de programmes d&#39;ordinateur
Colombier Methods for protecting intellectual property of IP cores designers

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

17P Request for examination filed

Effective date: 20031124

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AT BE CH CY DE DK ES FI FR GB GR IE IT LI LU MC NL PT SE TR

AX Request for extension of the european patent

Extension state: AL LT LV MK RO SI

17Q First examination report despatched

Effective date: 20091022

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN

18D Application deemed to be withdrawn

Effective date: 20151103