Le monitorage (monitoring) est une approche pour la sécurisation du code qui permet l'exécution d’un code potentiellement malicieux en observant son exécution, et en intervenant au besoin pour éviter une violation d’une politique de sécurité. Cette méthode a plusieurs applications prometteuses, notamment en ce qui a trait à la sécurisation du code mobile. Les recherches académiques sur le monitorage se sont généralement concentrées sur deux questions. La première est celle de délimiter le champ des politiques de sécurité applicables par des moniteurs opérant sous différentes contraintes. La seconde question est de construire des méthodes permettant d’insérer un moniteur dans un programme, ce qui produit un nouveau programme instrumenté qui respecte la politique de sécurité appliquée par ce moniteur. Mais malgré le fait qu’une vaste gamme de moniteurs a été étudiée dans la littérature, les travaux sur l’insertion des moniteurs dans les programmes se sont limités à une classe particulière de moniteurs, qui sont parmi les plus simples et les plus restreint quant à leur champ de politiques applicables. Cette thèse étend les deux avenues de recherches mentionnées précédemment et apporte un éclairage nouveau à ces questions. Elle s’attarde en premier lieu à étendre le champ des politiques applicables par monitorage en développabt une nouvelle approche pour l’insertion d’un moniteur dans un programme. En donnant au moniteur accès à un modèle du comportement du programme, l’étude montre que le moniteur acquiert la capacité d’appliquer une plus vaste gamme de politiques de sécurité. De plus, les recherches ont aussi d´emontré qu’un moniteur capable de transformer l’exécution qu’il surveille est plus puissant qu’un moniteur qui ne possède pas cette capacité. Naturellement, des contraintes doivent être imposées sur cette capacité pour que l’application de la politique soit cohérente. Autrement, si aucune restriction n’est imposée au moniteur, n’importe quelle politique devient applicable, mais non d’une manière utile ou désirable. Dans cette étude, nous proposons deux nouveaux paradigmes d’application des politiques de sécurité qui permettent d’incorporer des restrictions raisonnables imposées sur la capacité des moniteurs de transformer les exécutions sous leur contrôle. Nous étudions le champ des politiques applicables avec ces paradigmes et donnons des exemples de politiques réelles qui peuvent être appliquées à l’aide de notre approche. / Execution monitoring is an approach that seeks to allow an untrusted code to run safely by observing its execution and reacting if need be to prevent a potential violation of a user-supplied security policy. This method has many promising applications, particularly with respect to the safe execution of mobile code. Academic research on monitoring has generally focused on two questions. The first, relates to the set of policies that can be enforced by monitors under various constraints and the conditions under which this set can be extended. The second question deals with the way to inline a monitor into an untrusted or potentially malicious program in order to produce a new instrumented program that provably respects the desired security policy. This study builds on the two strands of research mentioned above and brings new insights to this study. It seeks, in the first place, to increase the scope of monitorable properties by suggesting a new approach of monitor inlining. By drawing on an a priori model of the program’s possible behavior, we develop a monitor that can enforce a strictly larger set of security properties. Furthermore, longstanding research has showed that a monitor that is allowed to transform its input is more powerful than one lacking this ability. Naturally, this ability must be constrained for the enforcement to be meaningful. Otherwise, if the monitor is given too broad a leeway to transform valid and invalid sequences, any property can be enforced, but not in a way that is useful or desirable. In this study, we propose two new enforcement paradigms which capture reasonable restrictions on a monitor’s ability to alter its input. We study the set of properties enforceable if these enforcement paradigms are used and give examples of real-life security policies that can be enforced using our approach.

Lors des dix dernières années, les technologies basées sur les agents logiciels ont été appliquées dans plusieurs domaines tels que les jeux vidéo, les films où évoluent des personnages animés, en réalité virtuelle, dans le développement d’interfaces où sont fournis des agents « assistants », dans les applications Web éducatives utilisant des personnages virtuels, pour ne nommer que ceux-là. Dans plusieurs de ces domaines, les simulations à base d’agents nécessitent l’intégration de données géographiques. Celles-ci intègrent une dimension spatiale et permettent la simulation de divers phénomènes complexes tels que ceux qui sont liés aux dynamiques urbaines. Ce qui a mené à un nouveau domaine de recherche : les simulations géoréférencées à base d’agents (ou SGBA). Certaines plateformes logicielles développées pour les SGBA permettent à l’aide de différentes techniques, la spécification et l’implantation de simulations à base d’agents. Par contre, les comportements des agents qui peuvent y être spécifiés sont encore très limités, ce qui est insuffisant pour le développement de simulations géoréférencées de phénomènes sociaux. Dans ce type de simulations, les agents doivent agir de façon autonome et posséder des capacités d’appréhension de l’espace et de prise de décisions en rapport avec l’environnement géographique dans lequel ils évoluent. Pour posséder de telles caractéristiques, nous considérons que ces agents doivent au minimum posséder un mécanisme de perception autonome et individuel (de l’espace physique, des autres objets et agents), en plus d’être proactifs et posséder des comportements autonomes prenant en compte de leur connaissance du monde dans lequel ils évoluent (leur environnement virtuel). La spécification de ce type d’agents est une tâche très difficile et, à notre connaissance, aucun environnement de développement actuel n’offre de langage de programmation permettant de créer ce type d’agents. Dans le contexte du projet PLAMAGS (Programming LAnguage for MultiAgent GeoSimulations), nous avons développé un nouveau langage de programmation orienté-agent, une démarche de conception appliquée et un environnement de développement permettant la création et l’exécution rapide et simple de simulations géoréférencées à base d’agents. Les principales contributions du projet PLAMAGS sont : - Un langage de programmation descriptif, procédural et orienté-objet complet et utilisable à toutes les étapes du processus de développement et totalement dédié aux SGBA. Ce qui permet d’éliminer l’étape de transition et de transposition du modèle théorique en langage de programmation et ainsi éviter toutes les difficultés qui y sont rattachées. - Une démarche de conception appliquée où les étapes de modélisation, conception, implémentation, exécution et validation sont fusionnées et intégrées à chaque étape de la démarche. - Un modèle comportemental puissant (pour les agents), intuitif, modulaire, extensible et flexible permettant un développement itératif incrémental à l’aide d’abstractions prenant la forme de décompositions (sous-comportements). - Un modèle d’interactions spatialisées clairement défini et directement intégré dans les primitives du langage de programmation. / In the last decade, technologies based on software agents have been used in many domains such as video games, movies containing animated characters, virtual reality, in visual interfaces development where “wizards” are supplied and in educative Web applications using virtual characters, just to name a few. In many of these domains, agent-based simulations require the integration of geographic data. These add a spatial dimension and allow the simulation of many complex phenomena such as those included in urban dynamics. This has spawned a new research field: Multi-Agent- Geo-Simulation (MAGS for short). Some of the frameworks developed for MAGS use many different techniques to specify and implement tagent-based simulations. However, the agents’ behaviors that can be specified are usually very limited and are insufficient for the development of geo-referenced simulation of social phenomena. In this type of simulation, the agents must act autonomously and have the ability to perceive the environment in which they evolve, and then take decision based on these perceptions. To benefit from such characteristics, we consider that these agents must minimally have a perception mechanism that is autonomous and unique to each agent which need as well as to be proactive and have autonomous behavior in relation to their virtual environment. The specification of this type of agent is a difficult task and, to the best of our knowledge, none of the existing development environment offers a language able to fulfill it. In the context of the PLAMAGS (Programming LAnguage for Multi-Agent Geo-Simulations) Project, we developed a new agent-oriented programming language, an applied design methodology and an integrated development environment that allow a quick and simple design and execution cycle of agent-based geo-referenced simulations. The main contributions of this work are as follows: - A full-fledged descriptive programming language, procedural and object-oriented that is usable at every stage of the development cycle and that is dedicated to MAGS. This language eliminates the transition and transposition from the theoretical model to the programming language and thus avoids all the difficulties inherent to such a transposition task. - An applied development methodology where the modeling, design and implementation, execution and validation steps are merged and integrated throughout the development cycle. - A behavioral model that is powerful (agent wise), intuitive, modular, extensible and flexible and thus allows a sequential and iterative development using abstractions based on decomposition (sub-behaviors). - A spatialized interaction model that is clearly defined and directly integrated in the primitives of the programming language.

Prendre de bonnes décisions dans des environnements multiagents est une tâche difficile dans la mesure où la présence de plusieurs décideurs implique des conflits d'intérêts, un manque de coordination, et une multiplicité de décisions possibles. Si de plus, les décideurs interagissent successivement à travers le temps, ils doivent non seulement décider ce qu'il faut faire actuellement, mais aussi comment leurs décisions actuelles peuvent affecter le comportement des autres dans le futur. La théorie des jeux est un outil mathématique qui vise à modéliser ce type d'interactions via des jeux stratégiques à plusieurs joueurs. Des lors, les problèmes de décision multiagent sont souvent étudiés en utilisant la théorie des jeux. Dans ce contexte, et si on se restreint aux jeux dynamiques, les problèmes de décision multiagent complexes peuvent être approchés de façon algorithmique. La contribution de cette thèse est triple. Premièrement, elle contribue à un cadre algorithmique pour la planification distribuée dans les jeux dynamiques non-coopératifs. La multiplicité des plans possibles est à l'origine de graves complications pour toute approche de planification. Nous proposons une nouvelle approche basée sur la notion d'apprentissage dans les jeux répétés. Une telle approche permet de surmonter lesdites complications par le biais de la communication entre les joueurs. Nous proposons ensuite un algorithme d'apprentissage pour les jeux répétés en ``self-play''. Notre algorithme permet aux joueurs de converger, dans les jeux répétés initialement inconnus, vers un comportement conjoint optimal dans un certain sens bien défini, et ce, sans aucune communication entre les joueurs. Finalement, nous proposons une famille d'algorithmes de résolution approximative des jeux dynamiques et d'extraction des stratégies des joueurs. Dans ce contexte, nous proposons tout d'abord une méthode pour calculer un sous-ensemble non vide des équilibres approximatifs parfaits en sous-jeu dans les jeux répétés. Nous montrons ensuite comment nous pouvons étendre cette méthode pour approximer tous les équilibres parfaits en sous-jeu dans les jeux répétés, et aussi résoudre des jeux dynamiques plus complexes. / Making good decisions in multiagent environments is a hard problem in the sense that the presence of several decision makers implies conflicts of interests, a lack of coordination, and a multiplicity of possible decisions. If, then, the same decision makers interact continuously through time, they have to decide not only what to do in the present, but also how their present decisions may affect the behavior of the others in the future. Game theory is a mathematical tool that aims to model such interactions as strategic games of multiple players. Therefore, multiagent decision problems are often studied using game theory. In this context, and being restricted to dynamic games, complex multiagent decision problems can be algorithmically approached. The contribution of this thesis is three-fold. First, this thesis contributes an algorithmic framework for distributed planning in non-cooperative dynamic games. The multiplicity of possible plans is a matter of serious complications for any planning approach. We propose a novel approach based on the concept of learning in repeated games. Our approach permits overcoming the aforementioned complications by means of communication between players. We then propose a learning algorithm for repeated game self-play. Our algorithm allows players to converge, in an initially unknown repeated game, to a joint behavior optimal in a certain, well-defined sense, without communication between players. Finally, we propose a family of algorithms for approximately solving dynamic games, and for extracting equilibrium strategy profiles. In this context, we first propose a method to compute a nonempty subset of approximate subgame-perfect equilibria in repeated games. We then demonstrate how to extend this method for approximating all subgame-perfect equilibria in repeated games, and also for solving more complex dynamic games.

L'évolution des systèmes informatiques ayant des programmes parallèles, des processeurs multi-cores et des réseaux fortement interconnectés rend la détection des activités malicieuses plus difficile. Dans un tel contexte, le traçage du noyau s:est révélé être une solution appropriée. Ce travail présente un framework complet pour les analyses des traces du noyau. On a proposé un langage scripte déclaratif et simple à utiliser pour la spécification des patrons. Les patrons compilés sont insérés dans le moteur de détection qui par la suite analyse les traces et progressivement communique avec le module d'affichage. Le module d1 affichage est responsable d'avertir l'administrateur sur les problèmes qui exécutent en arrière plan sur le système. On considère que notre approche est suffisamment générale pour être utiliser avec n'importe quel types de trace (réseaux ou systèmes) ou même des traces combinés. Le langage proposé peut efficacement décrire des patrons reliés aux différents types de domaines : sécurité, performance, débogage et abstraction.

Tableau d'honneur de la Faculté des études supérieures et postdoctorales, 2011-2012 / Une des questions incontournables qu'on se pose en théorie des langages est de savoir si une logique est décidable. Autrement dit, pour une logique donnée, on veut savoir s'il existe un algorithme qui détermine si un langage donné est exprimable dans cette logique. Depuis les travaux de Schützenberger, McNaughton et Papert sur la logique de premier ordre sur les mots, on reconnait l'importance de la théorie algébrique des langages pour résoudre ces questions de décidabilité. Un autre exemple historique est la caractérisation de Simon des langages testables par morceaux de mots par les monodes J -triviaux. On dit qu'un langage est testable par morceaux si on peut le définir par une combinaison booléenne d'expressions régulieres de la forme [symbol]. Ces langages sont exactement ceux qui sont définis par la clôture booléenne de [symbol] et le théorème de Simon engendre un algorithme qui en resout la décidabilité. Suite aux succès sur les mots, on a attaque les mêmes questions de décidabilité de logiques sur les langages de forêts, plus spéciquement sur les langages d'arbres. Dernièrement, Bojanczyk, Segoufin et Straubing ont pu démontrer un analogue du théorème de Simon pour les forêts. En effet, ils ont pu caractériser la clôture booléenne de [symbol], c'est-à-dire les langages testables par morceaux, en fonction d'une structure algébrique nommée algèbre de forêts. Ce mémoire est d'abord un état de l'art de la théorie algébrique des langages testables par morceaux. Entre autres, nous présentons le théorème de Simon sur les mots en passant par un résultat de Straubing et Thérien qui utilise la théorie des monodes partiellement ordonnés. Ensuite, nous étudions un pendant de ce résultat pour les algèbres de forêts. Finalement, nous règlons la décidabilité des langages de mots bien emboîtés testables par morceaux, une sous-classe des langages visiblement à pile. En efet, nous proposons un algorithme qui utilise le résultat de Bojanczyk, Segoufin et Straubing sur les langages de forêts.

L’analyse statique des programmes est une technique de vérification qui permet de statuer si un programme est conforme à une propriété donnée. Pour l’atteinte de cet objectif, il faudrait disposer d’une abstraction du programme à vérifier et d’une définition des propriétés. Dans la mesure où l’outil de vérification prend place dans un cadre algébrique, la définition des propriétés ainsi que la modélisation du programme sont représentées sous la forme d’expressions régulières. Ce mémoire traite en premier lieu de la traduction des programmes écrits en langage C vers une abstraction sous forme d’expressions régulières. La méthode de traduction proposée, ainsi que les différentes étapes de transformations y sont exposées. Les premiers chapitres du présent mémoire énoncent les connaissances élémentaires de la théorie des langages ainsi que de la compilation des programmes. Un bref aperçu des différentes méthodes de vérification des programmes est présenté comme une mise en contexte. Finalement, la dernière partie concerne la traduction des programmes ainsi que la description de l’outil de traduction qui a été réalisé.

Durant ces dernières décennies, nous avons assisté à une automatisation massive de la société selon toutes ses sphères. Malheureusement, cette révolution technologique n’a pas eu que des bienfaits. En effet, une nouvelle génération de criminels en a profité, afin d’occasionner davantage d’activités illégales. De ce fait, afin de protéger les systèmes informatiques, il est devenu plus que primordial de définir rigoureusement des politiques de sécurité ainsi que de mettre en oeuvre des mécanismes efficaces capables de les appliquer. L’objectif majeur d’un mécanisme de sécurité consiste souvent à contrôler des logiciels, afin de les contraindre à “bien” se comporter. Cependant, la plupart des mécanismes de sécurité procèdent par des méthodes ad hoc qui sont loin d’être efficaces. En outre, ils sont peu fiables, puisqu’il n’y a aucune preuve sur leur capacité à faire respecter les politiques de sécurité. De là apparaît la nécessité de concevoir des mécanismes de sécurité alternatifs qui résolvent le problème de l’application de la sécurité d’une manière formelle, correcte et précise. Dans ce contexte, notre thèse cible principalement la caractérisation formelle de l’application effective des politiques de sécurité via des mécanismes basés sur la réécriture de programmes. On entend par application effective, le fait d’éliminer tous les “mauvais” comportements d’un programme, tout en conservant tous les “bons” comportements qu’il engendre, et ce, sans compromettre la sémantique du programme à sécuriser. Nous avons opté pour la réécriture de programmes, vu sa grande puissance par rapport aux autres mécanismes de sécurité qui sont soit laxistes soit très restrictifs. Les principaux résultats qui ont été réalisés, afin d’atteindre les objectifs ciblés par cette thèse sont les suivants : – Caractérisation formelle de l’application des propriétés de sûreté par la réécriture de programmes. Il s’agit d’appliquer les propriétés de sûreté qui constituent la classe de propriétés de sécurité la plus communément appliquée par les mécanismes de sécurité. – Caractérisation formelle de l’application de n’importe quelle propriété de sécurité par la réécriture de programmes. Cette contribution montre comment la réécriture de programmes permet l’application de politiques de sécurité qu’aucune autre classe de mécanismes de sécurité ne peut appliquer. – Caractérisation alternative de l’application de la sécurité par une approche algébrique. Cette contribution propose un formalisme algébrique afin de réduire l’écart entre la spécification et l’implantation des mécanismes de sécurité basés-réécriture. / During the last decades, we have witnessed a massive automation of the society at all levels. Unfortunately, this technological revolution came with its burden of disadvantages. Indeed, a new generation of criminals emerged and is benefitting from continuous progress of information technologies to cause more illegal activities. Thus, to protect computer systems, it has become very crucial to rigorously define security policies and provide the effective mechanisms required to enforce them. Usually, the main objective of a security mechanism is to control the executions of a software and ensure that it will never violate the enforced security policy. However, the majority of security mechanisms are based on ad hoc methods and thus, are not effective. In addition, they are unreliable, since there is no evidence on their ability to enforce security policies. Therefore, there is a need to develop novel security mechanisms that allow enforcing security policies in a formal, correct, and accurate way. In this context, our thesis targets the formal characterization of effective security policies enforcement that is based on programs rewriting. We mean by “effective” enforcement preventing all the “bad” behaviors of a program while keeping all its "good" behaviors. In addition, effective enforcement should not compromise the semantics of controlled programs. We have chosen for rewriting programs, because it has a great power compared to other security mechanisms that are either permissive or too restrictive. Themain contributions of this thesis are the following : – Formal characterization of security enforcement of safety properties through program rewriting. Safety properties represent the main class of properties usually enforced by security mechanisms. – Formal characterization of any security property using program rewriting. This contribution shows how program rewriting allows the enforcement of security policies that no other class of security mechanisms can enforce. – Algebraic approach as an alternative formal characterization of program rewriting based security enforcement. In this contribution, we investigate an algebraic formal model in order to reduce the gap between the specification and the implementation of program rewriting based security mechansisms.

Les analyses interprocédurales automatiques de programmes qui sont basées sur des théories mathématiques rigoureuses sont complexes à réaliser, mais elles sont d'excellents outils pour augmenter notre conance envers les comportements possibles d'un programme. Les méthodes classiques pour réaliser ces analyses sont l'analyse de modè- les, l'interprétation abstraite et la démonstration automatique de théorèmes. La base d'un démonstrateur automatique de théorèmes est une logique ou une algèbre et le choix de celle-ci a un impact sur la complexité de trouver une preuve pour un théorème donné. Cette dissertation développe un formalisme algébrique concis pouvant être utilisé en démonstration automatique de théorèmes. Ce formalisme est appellé algèbre de Kleene à pile visible. Cette dissertation explique comment ce formalisme peut être utilisé pour réaliser des analyses interprocédurales de programmes, comme des vérications formelles et des vérications d'optimisations efectuées par des compilateurs. Cette dissertation apporte aussi des preuves que ces analyses pourraient être automatisées. L'algèbre de Kleene à pile visible est une extension de l'algèbre de Kleene, un excellent formalisme pour réaliser des analyses intraprocédurales de programmes. En bref, l'algèbre de Kleene est la théorie algébrique des automates nis et des expressions régulières. Donc, cette algèbre à elle seule n'est pas appropriée pour faire des analyses interprocédurales de programmes car la puissance des langages non contextuels est souvent nécessaire pour représenter le lot de contrôle d'un tel programme. L'algèbre de Kleene à pile visible étend celle-ci en lui ajoutant une famille d'opérateurs de plus petit point xe qui est basée sur une restriction des grammaires non contextuelles. En fait, cette algèbre axiomatise exactement la théorie équationnelle des langages à pile visibles. Ces langages sont une sous-classe des langages non contextuels et ont été dénis par Alur et Madhusudan pour faire de l'analyse de modèles. La complexité résultante de la théorie équationnelle de l'algèbre proposée est EXPTIME-complète. / Automatic interprocedural program analyses based on rigorous mathematical theories are complex to do, but they are great tools to increase our condence in the behaviour of a program. Classical ways of doing them is either by model checking, by abstract interpretation or by automated theorem proving. The basis of an automated theorem prover is a logic or an algebra and the choice of this basis will have an impact in the complexity of nding a proof for a given theorem. This dissertation develops a lightweight algebraic formalism for the automated theorem proving approach. This formalism is called visibly pushdown Kleene algebra. This dissertation explains how to do some interprocedural program analyses, like formal veri cation and verication of compiler optimizations, with this formalism. Evidence is provided that the analyses can be automated. The proposed algebraic formalism is an extension of Kleene algebra, a formalism for doing intraprocedural program analyses. In a nutshell, Kleene algebra is the algebraic theory of nite automata and regular expressions. So, Kleene algebra alone is not well suited to do interprocedural program analyses, where the power of context-free languages is often needed to represent the control flow of a program. Visibly pushdown Kleene algebra extends Kleene algebra by adding a family of implicit least xed point operators based on a restriction of context-free grammars. In fact, visibly pushdown Kleene algebra axiomatises exactly the equational theory of visibly pushdown languages. Visibly pushdown languages are a subclass of context-free languages dened by Alur and Madhusudan in the model checking framework to model check interprocedural programs while remaining decidable. The resulting complexity of the equational theory of visibly pushdown Kleene algebra is EXPTIME-complete whereas that of Kleene algebra is PSPACE-complete.

L’objectif de ce travail est de mettre en place une méthode d’analyse de sensibilité paramétrable, pour qu’elle puisse être utilisée avec différentes méthodes d’aide à la décision multicritères, qui génère des résultats exacts en un temps raisonnable. Afin d’atteindre notre objectif, nous avons utilisé une méthode d’analyse de stabilité de (Vetschera, 1986). Cette méthode a été présentée à l’origine pour Electre I, nous l’avons adapté à Electre II. Les résultats retournés par cette méthode avec Electre II seront utilisés pour l’analyse de sensibilité. Nous avons expérimenté la méthode d’analyse de sensibilité de (Ben Mena, 2001). Cette méthode détermine la sensibilité des paramètres d’Electre III. Suite à plusieurs expérimentations à l’aide du logiciel MCDM, nous avons pu améliorer la méthode de Ben Mena. Nous avons adapté notre nouvelle méthode à Electre II. À la fin, nous avons combiné les deux méthodes pour avoir une méthode d’analyse de sensibilité précise, rapide et qui ne demande pas une intervention humaine pour fixer les paramètres.

Ce mémoire propose un modèle de programmation distribuée basé sur la migration de processus pouvant communiquer à l’aide de canaux de communication. Ce travail cadre bien avec le contexte actuel où l’augmentation de la puissance de traitement passe par les processeurs multicoeurs et les systèmes distribués, qui permettent l’exécution de plusieurs processus en parallèle. L’étude de différentes algèbres de processus et langages de programmation permettant le parallélisme a tout d’abord permis de comparer leurs différentes caractéristiques. Suite à cette étude, nous présentons différents concepts nécessaires à la mise en place de notre modèle distribué par migration de processus, dans le cadre des langages objets qui imposent certaines contraintes. Finalement, l’implé- mentation de notre modèle à l’aide des fonctionnalités de Stackless Python permet de voir comment chacun des concepts a été mis en place. Cette implémentation se présente sous la forme d’une extension qui permet la transformation de programmes existants en programmes distribués.