Sécurité et permissions pour hoster des plugins

Version imprimable

Hello World !

J'ai codé une petite lib de moteur de plugins. Elle fonctionne nickel, mais pour pouvoir ajouter de la sécurité, je veux gérer les permissions de chaque plugin "à la main" (dynamiquement en fonction du plugin). On peut dire que ça serait analogue à la sandbox de ClickOnce.

Pour expliquer comment ma lib fonctionne :
- J'ai une classe de gestion des plugins (un "serveur")
- Chaque plugin est chargé dans son propre AppDomain, avec des autorisations restreintes pour limiter les failles de sécurité.

Dans ma version actuelle, les persmissions sont codées en dur :
Code:

1 2 3 4 5 6 7 8 9 10 //Set file as "Load a shadow copy" AppDomainSetup info = new AppDomainSetup(); info.ShadowCopyFiles = true.ToString(); info.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase; //Set permisions to "None" PermissionSet perms = new PermissionSet(PermissionState.None); perms.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution)); //Create new application domain AppDomain domain = AppDomain.CreateDomain(pluginDefinition.ReflectedAssembly.Location, null, info, perms);
Ce que je voudrai, c'est arriver à gérer les demandes de permissions à la main, dans le style : Quand le plugin demande une permission, si elle n'est pas déjà accordée, on vérifie si l'application a l'autorisation. Si elle n'a pas l'autorisation, ne pas l'accorder au plugin, sinon, vérifier si le plugin a le droit d'avoir cette permission. Si oui, alors l'accorder, sinon la refuser.

Mes quelques jours de recherche m'ont conduit à une piste assez complexe me disant que je dois changer de SecurityManager et de AppDomainManager, et pour faire ça, je doit changer deux variables d'environnement.

Si quelqu'un a une piste à me proposer pour arriver à faire tourner un assembly dans un bac à sable (ou sandbox) "à la ClickOnce", je suis prenneur.

Merci d'avance.

31/12/2007, 20h49
Rakoun

Salut,

Mon intervention ne t'apportera pas de réponse. Toutefois moi aussi je travaille sur un petit moteur de plugin issu de mes différentes recherches sur le web. En ce moment j'ai du mal avec le chargement de mes plugins dans un domaine d'application. Tous les exemples que j'ai pu trouver en la matière ne traitent pas du cas ou les plugins sont des IHM. Si ton serveur de plugin gère des plugins graphiques, ton travail m'intéresse.

A bientôt.

Rakoun
/°\

Salut,

Actuellement, j'ai codé ce moteur parce que j'avais un peu de temps libre. Il n'a pas été créé dans le cadre d'un projet précis.

Par contre, la gestion d'une IHM via plugins n'est pas chose compliquée. Je pense que ça peut être facilement intégrable à mon moteur, il suffit juste de gérer les permissions correspondantes.

Si tu veux te faire un avis, tu peux aller voir le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
    * using System;
    * using System.Collections.Generic;
    * using System.Text;
    * using System.Threading;
    * using System.IO;
    *
    * namespace MaitreDede.Plugins
    * {
    * /// <summary>
    * /// Sample plugin : write the current time on the Console each second
    * /// Plugin d'exemple : affiche l'heure actuelle sur la Console chaque seconde
    * /// </summary>
    * [Plugin("Sample plugin", "1.0.0.0")]
    * public sealed class ClsPluginSample:ClsThreadPluginBase
    * {
    * /// <summary>
    * /// Main loop
    * /// </summary>
    * protected override void Run()
    * {
    * while(this.Running)
    * {
    * Console.WriteLine(DateTime.Now.ToLongTimeString());
    * Thread.Sleep(1000);
    * }
    * }
    *
    * /// <summary>
    * /// Save the plugin state (for restarting)
    * /// </summary>
    * /// <param name="saveStream">Stream where to save data</param>
    * public override void SaveState(Stream saveStream)
    * {
    * //Nothing to save
    * }
    *
    * /// <summary>
    * /// Load the plugin state (for restarting)
    * /// </summary>
    * /// <param name="saveStream">Stream where to load data</param>
    * public override void LoadState(Stream saveStream)
    * {
    * //Nothing to load
    * }
    * }
    * }

03/01/2008, 14h01
Rakoun

Très bien merci, j'irai consulté ton code. J'ai l'intention de créer un moteur de plugin pour un projet précis. Je n'ai pas trouvé l'équivalent d'eclipse en .Net, mais c'est toujours mieux de maîtriser son code.
La philosophie de moteur de plugin que j'utilise est fondée sur l'utilisation d'interface pour identifier une assemblie comme étant un plugin. J'ai lu dans ton résumé que tu utilisais la notion d'attributs.
Merci d'avoir plublier ton code.

Rakoun
/°\
03/01/2008, 14h17
maitredede

J'utilise la notion d'attributs, mais les plugins doivent aussi implémenter l'interface IPlugin pour être reconnus comme tels par le moteur, afin d'avoir un minimum de fonctions pour permettre au moteur de fonctionner correctement.

Après, rien ne t'empèche de faire tes propres interfaces ;)