FR3056787A1 - Methode de protection d’un programme logiciel par offuscation par virtualisation - Google Patents
Methode de protection d’un programme logiciel par offuscation par virtualisation Download PDFInfo
- Publication number
- FR3056787A1 FR3056787A1 FR1670555A FR1670555A FR3056787A1 FR 3056787 A1 FR3056787 A1 FR 3056787A1 FR 1670555 A FR1670555 A FR 1670555A FR 1670555 A FR1670555 A FR 1670555A FR 3056787 A1 FR3056787 A1 FR 3056787A1
- Authority
- FR
- France
- Prior art keywords
- instructions
- software program
- virtualization
- program
- execution
- 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 57
- 238000012545 processing Methods 0.000 claims description 18
- 230000009466 transformation Effects 0.000 claims description 7
- 238000012217 deletion Methods 0.000 claims description 5
- 230000037430 deletion Effects 0.000 claims description 5
- 230000002441 reversible effect Effects 0.000 claims description 4
- 238000010200 validation analysis Methods 0.000 claims description 2
- 230000003068 static effect Effects 0.000 description 7
- 230000015654 memory Effects 0.000 description 6
- 230000015556 catabolic process Effects 0.000 description 5
- 238000006731 degradation reaction Methods 0.000 description 5
- 230000007123 defense Effects 0.000 description 3
- 238000000844 transformation Methods 0.000 description 3
- 238000013459 approach Methods 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 238000004364 calculation method Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000000670 limiting effect Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000036961 partial effect Effects 0.000 description 1
- 230000008569 process Effects 0.000 description 1
- 230000000135 prohibitive effect Effects 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
- 230000001131 transforming effect Effects 0.000 description 1
- 230000003936 working memory Effects 0.000 description 1
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/12—Protecting executable software
- G06F21/14—Protecting executable software against software analysis or reverse engineering, e.g. by obfuscation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/74—Reverse engineering; Extracting design information from source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
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)
- Devices For Executing Special Programs (AREA)
Abstract
L'invention concerne une méthode de protection d'un programme logiciel par offuscation par virtualisation comprenant les étapes de fourniture des machines virtuelles générées indépendamment du programme logiciel ; analyse ce programme et identification des blocs indépendants ; d'association d'une machine virtuelle à chaque bloc ; d'estimation de la part contributive de chaque instruction du programme logiciel initial dans un temps d'exécution du programme protégé ; sur la base de cette part contributive, sélection des instructions dans le programme logiciel à exécuter par une machine réelle avec une reconstruction dynamique du code; compilation du programme logiciel de manière à générer un bytecode qui offusque le programme logiciel par virtualisation.
Description
DOMAINE DE L'INVENTION
La présente invention concerne une méthode de protection d'un programme logiciel, procède par offuscation
La méthode selon l'invention du code dudit programme.
L 'offuscation de ce code est effectuée au moyen d'une virtualisation.
ART ANTERIEUR
L'ingénierie inverse d'un programme logiciel est classiquement réalisée par des attaquants qui procèdent par analyse statique de ce programme logiciel, ou par analyse dynamique de celui-ci.
L'analyse statique consiste à lire et analyser le programme logiciel « à plat », c'est-à-dire à tenter de ce programme logiciel dans sa version soit la version livrée et disponible pour en blocs intelligibles, et à en faire récupérer exécutable, 1 ' analyste, l'analyse. La lecture est effectuée sans recourir à l'exécution du programme logiciel. Le seul outil nécessaire à l'attaquant est la connaissance du langage du logiciel dans sa forme exécutable. Il peut s'agir de l'assembleur si l'analyse est effectuée sur un exécutable natif, c'est à dire correspondant à une machine réelle spécifique par exemple de type Intel™ X86 ou ARM™7, ou d'un bytecode pour un langage interprété correspondant à une machine virtuelle telle que Java™ ou .NET™.
Pour faciliter l'analyse, il est possible de produire des transformations dans le programme logiciel dans sa forme exécutable en vue, par exemple, de disposer d'une forme plus abstraite de ce programme logiciel et de se rapprocher du programme dans sa forme en code source. Cela est effectué à l'aide d'un décompilateur.
L'analyse dynamique consiste par contre à tracer, au travers de l'exécution du code, chacune des instructions exécutées, ainsi que les modifications engendrées dans la mémoire et les registres de travail du processeur, lorsque ces registres existent. L'outil utilisé pour cette analyse est un débogueur. Le débogueur met en œuvre une instrumentation du programme, qui permet notamment de mettre en place des points d'arrêt dans l'exécution du programme logiciel. Il permet de récupérer la trace de l'exécution du code, c'est-à-dire la séquence des instructions exécutées et les états de la mémoire de travail du processeur associés à chaque instruction.
On connaît des méthodes qui permettent de contrer les attaques procédant par analyse statique d'un programme logiciel. Ces méthodes ont pour but de faire en sorte que le programme logiciel ne se trouve jamais « en clair » en mémoire. Le programme est donc chiffré. Néanmoins, si les techniques de chiffrement interdisent effectivement l'analyse statique, le programme doit au moins être déchiffré pour son exécution. Le chiffrement de code ne présente donc qu'une défense relative et, via l'analyse dynamique, l'attaquant pourra pointer l'état de la mémoire correspondant au fichier déchiffré et le récupérer pour produire une analyse du programme alors « en clair ».
On connaît de même des méthodes les attaques procédant par programme logiciel. Toutefois, qui permettent de contrer analyse dynamique d'un quelles que soient ces méthodes, on notera que, dès lors qu'il est possible de relier la machine portant le programme logiciel à un débogueur, il devient très difficile d'interdire une telle analyse. Certaines méthodes proposent de bloquer l'usage de débogueurs mais elles sont très pénalisantes pour les utilisateurs licites et peu efficaces, car contournables. En pratique, pour contrer l'analyse dynamique, il convient de la ralentir à un niveau tel que le niveau d'effort pour la réalisation de l'ingénierie inverse devienne rédhibitoire par un accroissement colossale de la taille du code à tracer et, dans la mesure du possible, sans qu'il soit possible de réduire cette taille par l'utilisation de résultats d'analyse antérieurement acquis. Pour ce faire, les méthodes selon l'art antérieur proposent bien souvent au moins de générer une certaine variabilité dans la génération de ce code.
Les méthodes procédant par offuscation de programmes logiciels permettent de rendre les analyses statique et dynamique beaucoup plus complexes. Certaines de ces méthodes proposent d'offusquer le code en produisant des transformations prédéfinies sur celui-ci et en substituant des séquences du code initial avec des séquences plus complexes. D'autres méthodes proposent du chiffrer certains blocs du code exécutable. De telles méthodes procédant par chiffrement partiel nécessitent cependant que le code chiffré soit déchiffré avant exécution. D'autres méthodes encore proposent de virtualiser le code.
| La mise | en | œuvre des méthodes | précitées | peut | être | |
| effectuée | à | différents stades | dans | la | chaîne | de |
| génération | du | programme exécutable | et, en | particulier | , au |
stade du développement du code source par le développeur, plus particulièrement au stade de sa compilation au moyen d'un compilateur spécifique qui produit 1'offuscation et génère les séquences de code offusqué, ou alors, dans un stade plus avancé, où on dispose du programme logiciel lui-même, sous une forme exécutable.
Par ailleurs, la mise en œuvre de ces méthodes peut être effectuée pour des chaînes de génération de programmes logiciels natifs, c'est-à-dire résultant d'un code binaire structuré pour un processeur particulier, ou pour une chaine de génération de langage interprété tel que le langage Java™ ou .NET™.
Les méthodes procédant par virtualisation de code proposent de transformer le code du programme logiciel à protéger en un code intermédiaire virtualisé ou bytecode, qui n'est pas directement exécutable sur la machine portant le programme. Ces méthodes sont connues pour être mises en œuvre sur des programmes logiciels interprétés du type Java™, .NET™ ou Python™. Le bytecode est alors décodé par une machine virtuelle comprenant des exécuteurs qui déchiffrent chaque ligne du bytecode à la volée. Toutefois, dans le cas des langages interprétés, la syntaxe de la machine virtuelle et la structure du bytecode sont connues de tous et, notamment, des attaquants. Dans le cas de la virtualisation appliquée à 1'offuscation, la syntaxe de la machine virtuelle et la structure du bytecode sont par contre inconnues de l'attaquant. En effet, cette syntaxe est produite à chaque utilisation de la machine virtuelle. De manière générale, la virtualisation de code consiste donc à transformer le programme à protéger en un code intermédiaire virtualisé et une machine virtuelle qui n'a rien en commun avec le programme original. La machine virtuelle décode le bytecode, qui est un fichier de données comprenant la fonctionnalité du code original. Elle interprète ce bytecode. La virtualisation conduit donc à une déstructuration massive et globale du programme original. Ainsi, si un attaquant réalise une analyse statique, il bute sur la machine virtuelle, car c'est le logiciel qui est exécuté, et non plus le code original.
Les méthodes procédant par virtualisation de code sont connues pour présenter un très bon niveau d'offuscation. Cela provient en particulier de la très grande variabilité dans la génération du code qu'elle permet d'obtenir, qui réduit d'autant la capacité de l'attaquant de capitaliser son travail d'analyse. Par la génération hautement variable des séquences de code pour une même instruction originale, le principe est d'éviter la reproduction de séquences identiques qui permettrait à l'analyste de traiter en une seule analyse toutes ces séquences identiques.
Toutefois, ces méthodes sont connues pour engendrer une grande expansion du code exécuté et donc pour être consommatrice de temps machine sur le processeur, aboutissant à une dégradation des performances du logiciel et notamment de sa vitesse d'exécution.
Dans le cas où le code est dans un langage interprété, et où la machine virtuelle et le bytecode sont connus, alors 1 ' off uscat ion peut être réalisée par un étage de virtualisation supplémentaire et, par suite, par la mise en cascade de deux machines virtuelles. Dans ce cas, les pertes en termes de performance du programme logiciel sont particulièrement conséquentes. C'est la raison pour laquelle, en pratique, 1 ' offuscation de programmes logiciels déjà virtualisés n'est pas mise en œuvre.
Finalement, bien que les méthodes d'offuscation par virtualisation de code selon l'art antérieur soient performantes en termes de protection, leur usage est restreint à certains cas précis. Elles n'ont pas pu être mise en œuvre de manière pertinente dans de vastes domaines où les besoins de protection sont pourtant réels. Il s'agit, à titre d'exemple, du secteur défense où les contraintes de vitesse d'exécution sont au cœur de l'efficacité opérationnelle des systèmes, et qui requièrent une parfaite maîtrise de l'impact des moyens de protection sur le délai d'exécution du logiciel. Ainsi, sans visibilité sur la dégradation de performance et sans moyen d'ajustement du niveau d'offuscation et du périmètre sur lequel elle s'applique, la virtualisation de code n'est pas utilisable, notamment, dans le secteur de la défense.
RESUME DE L'INVENTION
Considérant ce qui précède, un problème que se propose de résoudre l'invention est de fournir une méthode permettant d'offusquer un programme logiciel par virtualisation en limitant les dégradations de performance de ce programme logiciel ou, à tout le moins, d'avoir un contrôle sur cette dégradation de performances associée à 1 'offuscation par virtualisation.
La solution proposée de l'invention à ce problème a pour objet une méthode de protection d'un programme logiciel initial par offuscation par virtualisation comprenant les étapes suivantes selon lesquelles :
on fournit une ou plusieurs machines virtuelles, la ou lesdites machines virtuelles ayant été générées indépendamment dudit programme logiciel initial ;
on fournit le programme logiciel initial, ce programme comprenant un jeu d'instructions exécutable ou en code source ;
on réalise une transformation du programme logiciel initial dans une représentation intermédiaire ;
on analyse le programme logiciel initial dans sa représentation intermédiaire et on identifie un ou plusieurs blocs d'instructions indépendants ;
on associe une machine virtuelle à chaque bloc d'instructions indépendant identifié ;
on compile l'association entre la représentation intermédiaire et la ou les machines virtuelles en vue d'obtenir un bytecode;
on estime la part contributive individuelle de chaque instruction du programme logiciel initial dans un temps d'exécution de ce programme, une fois que le ou les blocs d'instructions sont offusqués par virtualisation en association avec la ou les machines virtuelle.
sur la base de cette part contributive, on sélectionne des instructions dans le programme logiciel initial à exclure de 1'offuscation par virtualisation ;
on compile le programme logiciel initial de manière à générer un nouveau bytecode qui offusque les instructions non-sélectionnées dudit programme logiciel initial par virtualisation ;
la ou les machines virtuelles interprètent le nouveau bytecode généré pour l'exécution des instructions non-sélectionnées ; et
Les instructions sélectionnées sont exécutées de manière séparée de l'exécution des instructions nonsélectionnées .
De manière avantageuse, - on fournit une pluralité de machines virtuelles, lesdites machines ayant été générées indépendamment du programme logiciel initial, on identifie une pluralité de de blocs d'instructions indépendants dans le programme logiciel initial, et on associe une machine virtuelle différente à chaque bloc identifié, de sorte à paralléliser l'exécution desdits blocs, notamment par des demandes d'octroi de disponibilité sur un cœur de traitement pour un bloc particulier de manière favoriser l'emploi d'autres cœurs de traitement pour d'autres blocs mettant en œuvre une parallélisation des traitements la méthode comporte en outre une étape d'analyse de la machine cible destinée à exécuter programme logiciel protégé par offuscation par virtualisation en vue de déterminer un nombre de cœurs de traitement disponibles sur cette machine, et en ce que le nombre de machines virtuelles et/ou blocs est déterminé en fonction de ce nombre de cœurs disponibles pour la parallélisation des traitements ; - la part contributive individuelle de chaque instruction du programme logiciel initial dans le temps d'exécution de ce programme, une fois le ou les blocs d'instructions offusqués par virtualisation en association avec la ou les machines virtuelles dépend d'un taux d'expansion du code desdites instructions lors de 1 ' offuscation par virtualisation, et/ou d'un nombre d'exécutions de cette obtenu par une les instructions instruction exécution du programme initial ; sélectionnées comprennent des instructions de boucle de programme, imbriquées ou indépendantes ; - l'estimation de la part contributive de chaque instruction du programme logiciel initial dans un temps d'exécution de ce programme, une fois le ou les blocs d'instructions offusqués par virtualisation en association avec la ou les machines virtuelles est présentée à un opérateur, qui effectue la sélection des instructions dans le programme logiciel initial à exécuter par une machine réelle avec une reconstruction dynamique du code de ces instructions ou par remplacement dans le logiciel original de séquences de code par simple offuscation ou sans aucune protection ; - en complément ou en remplacement des parts individuelles contributives présentées à l'opérateur, on présentes les boucles dans le programme original pour permettre notamment leur suppression de la virtualisation ; - les instructions sélectionnées, exécutées de maniéré separees, font l'objet d'une exécution sans protection, d'une offuscation simple ou d'une méthode de reconstruction de code dynamique ; - le code des instructions sélectionnées par le mode de reconstruction dynamique, est reconstruit par un module genere juste avant leurs exécutions puis une fois leurs exécutions produites, réalise les opérations inverses de telle manière que les instructions ne sont présentes en clair que durant un lapse de temps très succinct ; - les suppressions d'instructions du traitement de virtualisation sont réalisées de manière automatique, sans intervention de l'opérateur, par la mise en place de seuils sur différents critères portant sur les informations disponibles ; - la sélection des suppressions d'instructions du traitement de virtualisation est réalisée de façon automatique sur la de reconstruction qui l'exécution du programme base de critères validation ; et d'instructions du le code au fil de un opérateur pour des suppressions virtualisation est ou proposée a la sélection traitement de réalisée de façon automatique sur la base de critères résultant d'un paramétrage produit antérieurement par un opérateur sur un projet de protection correspondant à une version antérieure du logiciel à protéger.
BREVE DESCRIPTION DES FIGURES ίο
L'invention sera mieux comprise à la lecture description non limitative qui suit, rédigée au des dessins annexés, dans lesquels :
la figure 1 schématise des premières étapes méthode selon l'invention ; et la figure 2 schématise des secondes étapes méthode selon l'invention.
de la regard de la de la
DESCRIPTION DETAILLEE DE L'INVENTION
La présente invention concerne une méthode de protection d'un programme logiciel initial (ou partie de programme logiciel). Cette protection est effectuée par offuscation par virtualisation.
ce
Un tel programme logiciel est destiné à être exécuté par une machine munie d'un processeur. Le processeur est par exemple un processeur d'un ordinateur tel qu'un ordinateur personnel, d'une plateforme embarquée telle que, par exemple, une plateforme embarquée d'un téléphone intelligent, d'objets connectés, ou même d'une carte à puce, disposant notamment de mémoires, par exemple d'une mémoire dite morte et d'une mémoire dite vive, pour le stockage et l'exécution du programme, ainsi que de systèmes de bus d'adresses et de données. Un tel programme peut être dans sa version en langage de programmation ou code source ou dans sa version après compilation, c'est-à-dire dans sa version destinée à être exécutée sur un type de processeur spécifique ou une machine virtuelle telle que la machine virtuelle Java™ ou .NET™ Framework.
Ainsi que cela première étape fournit une ou est montré à la figure 1, selon de la méthode selon l'invention, plusieurs machines virtuelles. La ou une on les machines virtuelles sont générées indépendamment du programme logiciel initial, plus précisément, indépendamment de la connaissance a priori de ce programme logiciel initial.
Selon une seconde étape de ma méthode selon l'invention, on fournit un programme logiciel initial ou la partie de ce programme que l'on souhaite protéger, ce programme comprenant un jeu d'instructions exécutable ou un jeu d'instructions en code source.
Selon une troisième étape de la méthode selon l'invention, on réalise une transformation du programme logiciel initial ou de la partie de ce programme dans une représentation intermédiaire, c'est-à-dire en utilisant un ensemble restreint d'instructions abstraites communes à tous le processeurs réalisant des opérations élémentaires, et ce que ledit logiciel soit sous une forme exécutable ou sous la forme d'un code source. On produit cette représentation abstraite à partir du programme initial à protéger qu'il soit dans sa forme exécutable ou dans sa forme en langage de programmation (code source). Pour cette étape, on pourra utiliser des compilateurs spécifiques basés, par exemple, mais pas uniquement, sur LLVM (Low Level Virtual Machine - en français Machine Virtuelle de Bas Niveau) qui produit cette représentation intermédiaire à partir du code source, ou en utilisant tous autres moyens, ou en procédant par analyse des instructions dans leur forme exécutable directement.
Puis, selon une quatrième étape de la méthode selon l'invention, on réalise une analyse du programme logiciel initial (ou de la partie de celui-ci que l'on souhaite protéger) dans sa représentation intermédiaire.
Il s'agit d'une analyse dite statique, qui est automatisée et qui permet d'identifier la sémantique et/ou la syntaxe du programme logiciel initial dans cette représentation intermédiaire et, par suite, d'identifier un ou plusieurs blocs d'instructions indépendants dans ce programme. On identifie donc au moins, à l'issue de cette analyse, un ou plusieurs blocs d'instructions. Cette analyse est effectuée sans recourir à l'exécution du programme logiciel initial. Avantageusement, l'analyse permet de récupérer un graphe d'exécution du programme logiciel initial. Les instructions de saut conditionnel et/ou les boucles sont identifiées dans ce graphe.
Dans une cinquième étape de la méthode selon l'invention, on associe une machine virtuelle à chaque bloc d'instructions indépendant identifié à l'étape précédente. Si une pluralité de machines virtuelles a été fournie et une pluralité de blocs d'instructions a été identifiée, alors on associe, par exemple, une machine virtuelle différente à chaque bloc identifié. Il sera ainsi possible de paralléliser l'exécution des blocs, ainsi que cela sera expliqué dans la suite de la présente description de l'invention.
Dans une étape ultérieure de la méthode selon l'invention, on compile l'association entre la représentation intermédiaire du programme logiciel initial (ou de la partie de celui-ci) et la ou les machines virtuelles en vue d'obtenir un bytecode.
Dans une étape encore ultérieure de la méthode selon l'invention, on estime la part contributive individuelle de chaque instruction du programme logiciel initial dans un temps d'exécution de ce programme une fois que le ou les blocs d'instructions sont offusqués par sont virtualisation en association avec la ou les machines virtuelles. Cette étape est une étape de compilation de la représentation intermédiaire en bytecode relié à une machine virtuelle. Pour cette estimation, on réalise par calcul pour chaque instruction du logiciel original l'impact de la virtualisation, c'est-à-dire résultant des différentes opérations successives de sa virtualisation, soit des étapes de transformation en représentation intermédiaire, puis de compilation avec la ou les machines virtuelles. On procède aussi à une exécution du programme original pour y extraire d'autres données et en particulier le nombre d'exécutions de chaque instruction à l'exécution du programme. Le temps d'exécution du programme logiciel lui-même sous sa forme virtualisée est en outre déterminé. Ce temps peut être comparé au temps d'exécution du programme original. Les résultats de cette analyse sont fournis à un opérateur, par exemple, sous la forme d'un graphe mettant en lumière la part contributive des instructions, prises individuellement, dans le temps d'exécution de ce programme, une fois que le ou les blocs d'instructions sont offusqués par virtualisation en association avec la ou les machines virtuelles. Cette mise en lumière est réalisée par exemple au moyen de codes couleurs.
Dans une étape en suivant de la méthode selon l'invention, on sélectionne des instructions dans le programme logiciel initial à exclure de 1'offuscation par virtualisation. Cette sélection est effectuée sur la base de cette part contributive déterminée précédemment, c'est-à-dire en tenant compte de cette part contributive. Les instructions exclues sont destinées à être exécutées par la machine réelle soit par une reconstruction dynamique du code de ces instructions sous leur forme originale, c'est-à-dire sous leur forme contenue dans le programme logiciel initial, soit à ne pas faire l'objet d'une protection ou d'une simple offuscation. La décision de sélection ou non est avantageusement mise en œuvre pour l'ensemble des instructions identifiées dans le programme logiciel initial, et pour lesquelles on a évalué un impact sur l'exécution du programme. La sélection est effectuée sur la base de la part contributive de chaque instruction du programme, prise individuellement, dans le temps d'exécution de ce programme, une fois que le ou les blocs d'instructions sont offusqués par virtualisation en association avec la ou les machines virtuelles. Si cette part contributive est jugée importante, alors les instructions correspondantes sont avantageusement sélectionnées. Si cette part contributive est faible, alors les instructions correspondantes ne sont pas sélectionnées. La sélection permet d'identifier les instructions du programme qui seront exécutées directement par la machine réelle, et qui, de ce fait, n'impacteront que faiblement ou de manière non significative le temps d'exécution du programme protégé (selon qu'elles seront reconstruites dynamiquement, simplement offusquées ou pas protégées du tout) et par ailleurs, les instructions qui seront exécutées dans le cadre des machines virtuelles, et qui feront notamment l'objet d'une expansion de code importante, mais raisonnable en considération de leur part contributive relative. Par exemple, si le nombre d'itérations d'une boucle est important ou, à tout le moins, trop important pour la destination qui est faite du programme logiciel, alors la ou les instructions correspondant à ladite boucle devraient être sélectionnées afin de ne pas être incluses dans le code logiciel intermédiaire virtualisé à générer à partir du programme logiciel initial. La décision de sélection ou non des instructions et du mode de protection (virtualisation, reconstruction dynamique, simple offuscation ou sans protection) est prise par un opérateur auquel on aura présenté les résultats de l'estimation de la part contributive des instructions dans l'exécution du programme protégé. Toutefois, la mise en place de seuils sur différents critères peut être réalisée en automatisant la sélection des instructions qui ne seront pas virtualisées. Ces critères peuvent être la localisation de cette instruction dans une boucle et selon différents niveaux d'imbrication de boucles (boucles de premier niveau, de second niveau, ...) ou séparément, la complexité individuelle de la virtualisation traduite en nombre d'instructions exécutées résultant de la virtualisation ou le nombre d'exécution de cette instruction lors de l'exécution du programme. On peut ainsi automatiquement extraire toutes les instructions situées dans une boucle de second niveau ou dont la virtualisation engendre plus de 500 instructions exécutées.
Avec une telle technique de seuils, la sélection peut être automatisée, et ne pas nécessiter l'intervention d'un opérateur à ce stade de la méthode selon 1 ' invention.
Selon l'invention, une fois qu'on a effectué la sélection des instructions contenues dans le logiciel initial pour être exécutées par la machine réelle soit sans protection ou par une simple offuscation, soit après reconstruction dynamique du code, on compile le programme logiciel initial de manière à générer un nouveau bytecode qui reflétera cette répartition entre les différents modes de protection; les instructions sélectionnées pour une reconstruction dynamique seront présentes dans le bytecode mais sont exécutées de manière séparée, par la machine réelle directement, après reconstruction dynamique (juste avant leur exécution) du code de ces instruction. Les instructions sélectionnées pour ne pas être protégées ou simplement offusquées sont extraites du bytecode et placées directement dans le programme original et sont exécutées par la machine réelle.
Il s'agit du bytecode définitif correspondant au projet de protection et à la découpe des instructions sélectionnées/non-sélectionnées.
L'ensemble des instructions sélectionnées destinées à être exécutée par la machine réelle par le mode de reconstruction dynamique de code, fait avantageusement l'objet d'une sécurisation distincte de la sécurisation obtenue par offuscation par virtualisation selon l'invention. Il peut s'agir d'une sécurisation desdites instructions par offuscation, par exemple au moyen de transformations appliquées ponctuellement dans lesdites ou certaines desdites instructions ou séquences d'instructions. Il peut s'agir encore d'une insertion de code mort dans ces instructions, c'est-à-dire d'un code logiciel qui n'est pas destiné à faire l'objet d'une exécution. Il peut s'agir d'un encodage logique par la réalisation d'une opération ou d'une séquence d'opérations logiques élémentaires sur les registres mémoire contenant la chaîne d'instructions. Il peut s'agir enfin d'un chiffrement de certaines ou de toutes les instructions de l'ensemble.
Ainsi que cela est plus particulièrement montré en figure 2, la ou les machines virtuelles interprètent le bytecode généré pour les instructions non sélectionnées, c'est-àdire le bytecode correspondant aux parties du programme logiciel initial offusquées par virtualisation. Par contre, les instructions sélectionnées, qui ne sont pas offusquées par virtualisation, sont exécutées par la machine réelle après reconstruction dynamique de code ou directement présentes sans protection ou simplement offusquées. En effet, ces instructions ne sont pas interprétables par la ou les machines virtuelles
L'ensemble des instructions sélectionnées, et par suite exclu de 1'offuscation par virtualisation est donc exécuté de virtualisé.
manière séparée du code intermédiaire
Lorsque, dans l'exécution du bytecode, il est demandé l'exécution d'une ou plusieurs instructions particulières exclues de la virtualisation et contenue dans l'ensemble exclu, alors une requête est transmise à cet effet à la machine réelle, plus spécifiquement à un processeur de cette machine réelle. La machine réelle demande alors l'exécution des instructions visées dans cette requête et contenues dans l'ensemble des instructions sélectionnées. Il s'agit d'un transfert de contexte d'exécution de la machine virtuelle à la machine réelle. Si ces instructions exclues sont protégées, par exemple par chiffrement, un module de reconstruction des instructions reconstruit celles-ci pour les besoins de leur exécution. Les instructions sont donc exécutées en clair. Une fois que les instructions de l'ensemble exclu sont exécutées, elles sont alors de nouveau protégées, par le module précité. Le résultat de l'exécution des instructions de l'ensemble exclu est transmis à la machine réelle et il est, si cela est nécessaire, communiqué à la machine virtuelle, qui le prend en compte pour la continuation de l'exécution du programme.
L'exécution du programme logiciel protégé selon l'invention permet de d'obtenir son temps d'exécution. Ce temps d'exécution est comparé avec le temps de la version non protégée de ce programme, à savoir du programme logiciel initial. Un seuil d'acceptation de l'augmentation du temps d'exécution peut être défini. Ce seuil est représentatif de la dégradation globale du temps d'exécution du programme logiciel dans sa version sécurisée.
De manière avantageuse, l'exécution du programme logiciel protégé selon l'invention est parallélisée au moyen d'une pluralité de machines virtuelles et d'une machine réelle disposant d'une pluralité de processeurs pour le traitement ou de processeurs comportant une pluralité de cœurs. En effet, une machine virtuelle peut interpréter un bytecode correspondant à un ou plusieurs blocs d'instructions, l'exécution de ce bytecode étant réalisée au moyen de ressources correspondant à un premier processeur, tandis qu'un autre machine virtuelle peut interpréter en parallèle un bytecode correspondants à un ou plusieurs autres blocs d'instructions, l'exécution de ce bytecode étant réalisée au moyen de ressources différentes, et notamment d'un autre processeur. L'avantage de la parallélisation de l'exécution du programme logiciel protégé selon l'invention réside dans la diminution du temps d'exécution et, par suite, dans l'augmentation de la performance de ce programme protégé. Par ailleurs, la parallélisation aura pour effet de compliquer la tâche de l'analyste qui devra suivre l'exécution de plusieurs machines virtuelles réalisant des opérations simultanées.
par offuscation par
On notera que, dans le cas précédent, dans lequel l'exécution du programme est parallélisée, on analyse avantageusement la machine cible destinée à exécuter le programme logiciel protégé virtualisation en vue de déterminer un nombre de cœurs de traitement disponibles sur cette machine. Le nombre de blocs ou de machines virtuelles associées est alors avantageusement déterminé en fonction de ce nombre de cœurs disponibles pour la parallélisation des traitements.
On notera par ailleurs qu'une telle parallélisation n'est pas connue de l'art antérieur, dans le contexte de 1 'offuscation de code par virtualisation.
Si le temps d'exécution du programme logiciel sécurisé selon l'invention, à savoir du code logiciel intermédiaire virtualisé et de l'ensemble des instructions exclues, se révèle supérieur à un seuil d'acceptation, alors la méthode selon l'invention est de nouveau mise en œuvre, et de nouvelles instructions, qui n'étaient pas sélectionnées auparavant, sont sélectionnées. Il est donc possible de contrôler la performance de la méthode selon l'invention et de l'adapter selon les besoins de la destination qui en est faite.
On notera que, comme la ou les machines virtuelles sont créées indépendamment du programme logiciel à protéger, il est possible de réutiliser ces machines virtuelles. En effet, dans de nombreux usages industriels et, en particulier, dans les domaines industriels dans lesquels une normalisation est requise et où la sûreté de bon fonctionnement est essentiel, comme dans le cas de l'industrie des transports, il peut s'avérer utile de figer une machine virtuelle que l'on aura pris soin de qualifier/certifier.
La présente invention apporte donc une solution radicale et qui permet de mettre en œuvre la technique de virtualisation dans les cas les plus critiques selon lesquels le programme logiciel comprend par exemple de nombreuses boucles de programme.
Claims (12)
- REVENDICATIONS1. Méthode de protection d'un programme logiciel initial ou d'une partie de celui que l'on souhaite protéger par offuscation par virtualisation comprenant les étapes suivantes :fourniture d'une ou plusieurs machines virtuelles, la ou lesdites machines virtuelles ayant été générées indépendamment dudit programme logiciel initial ;fourniture du programme logiciel initial ou d'une partie de ce programme comprenant un jeu d'instructions exécutable ou en code source ;réalisation d'une transformation du programme logiciel initial dans une représentation intermédiaire ;analyse du programme logiciel initial dans sa représentation intermédiaire et on identifie un ou plusieurs blocs d'instructions indépendants ;association d'une machine virtuelle à chaque bloc d'instructions indépendant identifié ;compilation de l'association entre la représentation intermédiaire du programme logiciel initial et la ou les machines virtuelles en vue d'obtenir un bytecode ;d'estimation de la part contributive individuelle de chaque instruction du programme logiciel initial dans un temps d'exécution de ce programme, une fois que le ou les blocs d'instructions sont offusqués par virtualisation en association avec la ou les machines virtuelles ;sur la base de cette part contributive, de sélection des instructions dans le programme logiciel initial à exclure de 1'offuscation par virtualisation ;compilation du programme logiciel initial de manière à générer un nouveau bytecode qui offusque les instructions non sélectionnées dudit programme logiciel initial par virtualisation ;la ou les machines virtuelles interprètent le nouveau bytecode généré pour l'exécution des instructions nonsélectionnées ; et les instructions sélectionnées sont exécutées de manière séparée de l'exécution des instructions nonsélectionnées .
- 2. Méthode selon la revendication 1, caractérisée en ce qu'elle comprend les étapes de fourniture d'une pluralité de machines virtuelles, lesdites machines ayant été générées indépendamment du programme logiciel initial, d'identification d'une pluralité de de blocs d'instructions indépendants dans le programme logiciel initial, et d'association d'une machine virtuelle différente à chaque bloc identifié, de sorte à paralléliser l'exécution desdits blocs, notamment par des demandes d'octroi de disponibilité sur un cœur de traitement pour un bloc particulier de manière à favoriser l'emploi d'autres cœurs de traitement pour d'autres blocs mettant en œuvre une parallélisation des traitements.
- 3. Méthode de la revendication 2, caractérisée en ce qu'elle comporte en outre une étape d'analyse de la machine cible destinée à exécuter le programme logiciel initial protégé par offuscation par virtualisation en vue de déterminer un nombre de cœurs de traitement disponibles sur cette machine, et en ce que le nombre de machines virtuelles et/ou blocs est déterminé en fonction de ce nombre de cœurs disponibles pour la parallélisation des traitements.
- 4. Méthode selon l'une des revendications 1 ou 2 ou 3, caractérisée en ce que la part contributive individuelle de chaque instruction du programme logiciel initial dans le temps d'exécution de ce programme, une fois le ou les blocs d'instructions offusqués par virtualisation en association avec la ou les machines virtuelles dépend d'un taux d'expansion du code desdites instructions lors de 1'offuscation par virtualisation, et/ou d'un nombre d'exécutions de cette instruction obtenu par une exécution du programme initial.
- 5. Méthode selon l'une des revendications précédentes, caractérisée en ce que les instructions sélectionnées comprennent des instructions de boucle de programme, imbriquées ou indépendantes.
- 6. Méthode selon l'une des revendications précédentes, caractérisée en ce que l'estimation de la part contributive de chaque instruction du programme logiciel initial dans un temps d'exécution de ce programme, une fois le ou les blocs d'instructions offusqués par virtualisation en association avec la ou les machines virtuelles est présentée à un opérateur, qui effectue la sélection des instructions dans le programme logiciel initial à exécuter par une machine réelle avec une reconstruction dynamique du code de ces instructions ou par remplacement dans le logiciel original de séquences de code par simple offuscation ou sans aucune protection.
- 7. Méthode selon l'une des revendications précédentes, caractérisée en ce qu'en complément ou en remplacement des parts individuelles contributives présentées à l'opérateur, les boucles dans le programme original sont présentées pour permettre notamment leur suppression de la virtualisation.
- 8. Méthode selon l'une des revendications précédentes, caractérisée en ce que les instructions sélectionnées, exécutées de manière séparées, font l'objet d'une exécution sans protection, d'une offuscation simple ou d'une méthode de reconstruction de code dynamique.
- 9. Méthode selon l'une des revendications précédentes, caractérisée en ce le code des instructions sélectionnées par le mode de reconstruction dynamique, est reconstruit par un module de reconstruction qui génère le code au fil de l'exécution du programme, juste avant leurs exécutions puis une fois leurs exécutions produites, réalise les opérations inverses de telle manière que les instructions ne sont présentes en clair que durant un lapse de temps très succinct.
- 10. Méthode selon l'une des revendications précédentes, caractérisée en ce que les suppressions d'instructions du traitement de virtualisation sont réalisées de manière automatique, sans intervention de l'opérateur, par la mise en place de seuils sur différents critères portant sur les informations disponibles.
- 11. Méthode selon l'une des revendications précédentes, caractérisée en ce que la sélection des suppressions d'instructions du traitement de virtualisation est réalisée de façon automatique sur la base de critères ou proposée à un opérateur pour validation.
- 12. Méthode selon l'une des revendications précédentes, caractérisée en ce que la sélection des suppressions d'instructions du traitement de virtualisation est réalisée de façon automatique sur la base de critères résultant d'un paramétrage produit antérieurement par un opérateur sur un projet de protection correspondant à une version antérieure du logiciel à protéger.1/2Machines VirtuellesProgramme logiciel initialReprésentation intermédiaireAnalyse - identification blocsΨAssociation Machines Virtuelles/BlocsCompilation associationEstimation de la part contributive des instructionsExécution par machine réelleOffuscation par virtualisation
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| FR1670555A FR3056787B1 (fr) | 2016-09-27 | 2016-09-27 | Methode de protection d’un programme logiciel par offuscation par virtualisation |
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| FR1670555A FR3056787B1 (fr) | 2016-09-27 | 2016-09-27 | Methode de protection d’un programme logiciel par offuscation par virtualisation |
| FR1670555 | 2016-09-27 |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| FR3056787A1 true FR3056787A1 (fr) | 2018-03-30 |
| FR3056787B1 FR3056787B1 (fr) | 2018-11-23 |
Family
ID=58609553
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| FR1670555A Active FR3056787B1 (fr) | 2016-09-27 | 2016-09-27 | Methode de protection d’un programme logiciel par offuscation par virtualisation |
Country Status (1)
| Country | Link |
|---|---|
| FR (1) | FR3056787B1 (fr) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109684794A (zh) * | 2018-12-07 | 2019-04-26 | 成都盈海益讯科技有限公司 | 一种代码保护虚拟机kvm系统实现方法、装置、计算机设备及存储介质 |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090119515A1 (en) * | 2005-10-28 | 2009-05-07 | Matsushita Electric Industrial Co., Ltd. | Obfuscation evaluation method and obfuscation method |
| EP3062256A1 (fr) * | 2015-02-26 | 2016-08-31 | Nxp B.V. | Ensembles d'instructions souple pour machines virtuelles masquées |
-
2016
- 2016-09-27 FR FR1670555A patent/FR3056787B1/fr active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090119515A1 (en) * | 2005-10-28 | 2009-05-07 | Matsushita Electric Industrial Co., Ltd. | Obfuscation evaluation method and obfuscation method |
| EP3062256A1 (fr) * | 2015-02-26 | 2016-08-31 | Nxp B.V. | Ensembles d'instructions souple pour machines virtuelles masquées |
Non-Patent Citations (1)
| Title |
|---|
| KUANG KAIYUAN ET AL: "Exploiting Dynamic Scheduling for VM-Based Code Obfuscation", 2016 IEEE TRUSTCOM/BIGDATASE/ISPA, IEEE, 23 August 2016 (2016-08-23), pages 489 - 496, XP033063364, DOI: 10.1109/TRUSTCOM.2016.0101 * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109684794A (zh) * | 2018-12-07 | 2019-04-26 | 成都盈海益讯科技有限公司 | 一种代码保护虚拟机kvm系统实现方法、装置、计算机设备及存储介质 |
| CN109684794B (zh) * | 2018-12-07 | 2023-06-23 | 成都盈海益讯科技有限公司 | 一种代码保护虚拟机kvm系统实现方法、装置、计算机设备及存储介质 |
Also Published As
| Publication number | Publication date |
|---|---|
| FR3056787B1 (fr) | 2018-11-23 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109992935B (zh) | 一种源代码保护方法及装置 | |
| Zhang et al. | A first step towards algorithm plagiarism detection | |
| US8589897B2 (en) | System and method for branch extraction obfuscation | |
| EP2649523B1 (fr) | Méthode de compilation d'un code intermédiaire d'une application | |
| US8429637B2 (en) | System and method for conditional expansion obfuscation | |
| KR20140053754A (ko) | 부 채널 및 반복 호출 공격들의 방지를 위한 동적 시간 가변 연산 경로 시스템 및 방법 | |
| FR2961922A1 (fr) | Procede de compilation selective, dispositif et produit programme d'ordinateur correspondant. | |
| CA2752259C (fr) | Procede de protection du code source d'un programme d'ordinateur | |
| FR3011354A1 (fr) | Procede d'execution par un microprocesseur d'un code binaire polymorphique d'une fonction predeterminee | |
| Molitorisz et al. | Automatic parallelization using autofutures | |
| Gorantala et al. | Unlocking the potential of fully homomorphic encryption | |
| FR3056787A1 (fr) | Methode de protection d’un programme logiciel par offuscation par virtualisation | |
| CN113626773B (zh) | 一种基于中间语言的代码保护方法 | |
| KR101942010B1 (ko) | 모듈의 암호화/복호화 프로그램 | |
| You et al. | Reversing obfuscated control flow structures in android apps using redex optimizer | |
| Bao et al. | HACCLE: metaprogramming for secure multi-party computation | |
| EP3304531B1 (fr) | Procédé de chiffrement, procédé de chiffrement, dispositifs et programmes correspondants | |
| CN114003868A (zh) | 一种处理软件代码的方法和电子设备 | |
| Aburas et al. | A method dependence relations guided genetic algorithm | |
| Wang et al. | Large language model supply chain: A research agenda | |
| Cho et al. | Implementation of an obfuscation tool for c/c++ source code protection on the xscale architecture | |
| Okonta et al. | Deploying Java Platform to Design a Framework of Protective Shield for Anti–Reversing Engineering | |
| CN113010855B (zh) | 一种获取数据的方法、装置、介质及计算机设备 | |
| FR2942558A1 (fr) | Procede d'obscurcissement d'un programme d'ordinateur. | |
| Vivekananthan et al. | Dynamic Watermarking Using Python AST |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PLFP | Fee payment |
Year of fee payment: 2 |
|
| PLSC | Publication of the preliminary search report |
Effective date: 20180330 |
|
| PLFP | Fee payment |
Year of fee payment: 3 |
|
| PLFP | Fee payment |
Year of fee payment: 4 |
|
| PLFP | Fee payment |
Year of fee payment: 5 |
|
| PLFP | Fee payment |
Year of fee payment: 6 |
|
| PLFP | Fee payment |
Year of fee payment: 7 |
|
| PLFP | Fee payment |
Year of fee payment: 8 |