Question Listing DACL

Mephisto écrit:

Je n'ai jamais essayé le C# et par conséquent de créer des cmdlettes.

Le langage d'une cmdlette est-il bien C# ?

Si oui, est ce que l'on peut se créer des classes perso dans une cmdlette ?

Donc formuler autrement, est ce qu'il y a des limitations du code dans une cmdlette ou tout est possible ?

Tu n'as pas forcément besoin de coder une commandelette en C#, tu pourrais simplement charger dans ton script la DLL proposée par l'auteur de l'article et utiliser les classes exposées par cette DLL. Par contre, il faut éplucher les exemples en C# pour savoir comment utiliser ces classes. Ca doit pouvoir se faire mais je n'ai pas pris le temps de regarder dans le détail.

Pour charger une DLL (plus communément appelée Assembly dans l'environnement .NET) on utilise la méthode suivante:

[code:1]
[reflection.assembly]::LoadFile(\"c:\dev\monassembly.dll\"«»)
[/code:1]
Janel

Mephisto écrit:
Tout le monde effectue parfois des opérations répréhensible par la loi
[/quote]
\"Afin d’encadrer et de limiter un usage excessif de l’Internet sur le lieu de travail, l’employeur dispose au titre de son pouvoir de direction d’un droit de contrôle et de surveillance sur ses salariés
1. Mais ce pouvoir reconnu à l’employeur ne
doit pas méconnaître les principes du droit à la vie privée et du secret des correspondances.\"
Merci pour le document, il est trés intéressant et même à publiciter, je vais le lire dans le détail.
Mephisto écrit:

Est ce que Powershell peut gérer les pointeurs ?

Bonne question, je crois que les pointeurs sous .NET sont gérés au travers d'une classe spécialisée. Son usage, est schématiquement, d'informer le GC que le zone mémoire pointé n'est pas sujette à modifications.
Je n'ai jamais eu le besoin d'en utiliser jusqu'au maintenant, mais je sais que pour manipuler certaines des API de bas niveau cela est inévitable.
Mephisto écrit:
Autrement je pensais compiler une dll avec une fonction qui prendrait le handle du process et le privilege.
[/quote]
Oui c'est une bonne approche, il n'y a rien de mieux qu'un langage de haut niveaux compilé pour gérer ce type de problème. Je pense qu'il vaut mieux réduire ce pb à des questions d'interface entre une DLL Win32 et PowerShell que de manipuler + couches.
Enfin sous réserve de faisabilité, mais pour s'en assurer tu peux réaliser une dll qui ne renvoi que le résultat attendu.
Mephisto écrit:
Une cmdlet serait encore plus propre
[/quote]
Ce n'est pas qu'une cmdlette serait plus propre c'est qu'un langage codant du Win32 natif est plus adapté. Il faut reconnaitre que là on est au bout du bout de PowerShell et encore s'il arrive au bout
Mephisto écrit:

Merci pour le premier lien, il a l'air vraiment très sympa.

Tu parles de celui sur MSDN ou celui sur le share ?
Mephisto écrit:

Je n'ai jamais essayé le C# et par conséquent de créer des cmdlettes.

Le C# n'est pas complexe par rapport au C++, c'est à dire qu'il contient beaucoup moins de piéges, mais encore quelques un.
Mephisto écrit:

Si oui, est ce que l'on peut se créer des classes perso dans une cmdlette ?

Oui, tu géres un assembly dans un espace de nom donc pas de pb, tu peux créer autant de classes, d'interfaces, d'enumérations ou de structs que tu veux, et avec la portée que tu veux.
Mephisto écrit:

Le langage d'une cmdlette est-il bien C# ?
..
Donc formuler autrement, est ce qu'il y a des limitations du code dans une cmdlette ou tout est possible ?

Pour le 1er point, il n'y a pas de limitation quand au langage .NET supporté. C'est ici qu'on comprend que PowerShell est un Framework technique avant d'être un shell.
Tous langage disponible sous .NET peut servir à créer des cmdlets, à moins de limitations d'implémentation ou technique voir de bug.
Mais le C# est le langage de prédilection de la plateforme .NET.
Ensuite je ne sais pas s'il existe des limitations technique du à la plateforme et au langage utilisé avec le framework technique PowerShell.
Vu de ma fenêtre s'il existe des limitations elles sont du coté de .NET, mais comme autant on peut coupler + langages .NET autant on peut coupler du code Win32/Assembleur avec .NET.
Mais cela ne nécessite pas les mêmes compétences.
Pour toi le problème se situe en amont de PS et de .NET, de mon coté je pense que la programmation de la sécurité est un sujet déjà aride sous Win32 alors sous .NET !
Perso j'atteint mon point de rupture

Concernant l'usage de langages .NET possibles avec le framework technique, voici une ébauche de cmdlet sous Delphi-Prism (version Beta) :
[code:1]
namespace CmdletSequence;

interface

uses System.Management.Automation,
System.ComponentModel;
type

[RunInstaller(true)]
TCreateSequenceSnapIn = public class (PSSnapIn)
private
//Renvoi le nom du snapin(CreateSequenceSnapIn)
// son nom n'est pas celui de la classe
method GetName:«»string;
method GetVendor:«»string;
method GetVendorResource:«»string;
method GetDescription: string;
method GetDescriptionResource: string;

public
property Name:«»string read GetName;override;
property Vendor:«»string read GetVendor;override;
property VendorResource:«»string read GetVendorResource;override;
property Description: string read GetDescription;override;
property DescriptionResource: string read GetDescriptionResource;override;
end;
[Cmdlet('Create','Sequence', SupportsShouldProcess:=true)]
[Description(\"Crée une séquence paramètrable similaire à une séquence Oracle.\"«»)]
TCreateSequence = public class(PSCmdlet)
private
fSequenceName : string;
fComment : string;
fIncrement_By : integer;
fMaxValue : integer;
fMinValue : integer;
fStartWith : integer;
fCycle : SwitchParameter;
fCurrval : integer;
protected
/// <summary>
/// Dérivation nécessaire des méthodes de la classe System.Management.Automation.Cmdlet
/// </summary>
method BeginProcessing;override;
method ProcessRecord;override;
method EndProcessing;override;
method StopProcessing;override;

public
[Parameter(Position:= 0, Mandatory:=true)]
[ValidateNotNullOrEmpty]
property SequenceName : string read fSequenceName;

[Parameter()]
[ValidateNotNullOrEmpty]
property Comment : string read fComment write fComment;

//Test min-1 et max+1 ??
[Parameter(HelpMessage:= \"Spécifie le pas d'incrément.\"«»),
DefaultValue(1)]
[ValidateRange(Int32.MinValue, Int32.MaxValue)]
property Increment_By : integer read fIncrement_By;

//Test min-1 et max+1 ??
[Parameter(HelpMessage:= \"Spécifie la valeur maximum de la séquence.\"«»)]
[ValidateRange(Int32.MinValue, Int32.MaxValue)]
property MaxValue : integer read fMaxValue;

//Test min-1 et max+1 ??
[Parameter(HelpMessage:= \"Spécifie la valeur minimum de la séquence.\"«»)]
[ValidateRange(Int32.MinValue, Int32.MaxValue)]
property MinValue : integer read fMinValue;
//Test min-1 et max+1 ??
[Parameter(HelpMessage:= \"Spécifie la valeur de début de la séquence.\"«»)]
[ValidateRange(Int32.MinValue, Int32.MaxValue)]
property StartWith : integer read fStartWith;

[Parameter(HelpMessage:= \"Spécifie une séquence cyclique. Une fois MaxValue atteint la séquence recommence à la valeur de MinValue.\"«»),
DefaultValue(false)]
property Cycle : SwitchParameter read fCycle;

constructor;
end;


implementation

// TCreateSequence

method TCreateSequence.BeginProcessing;
begin
inherited;
WriteVerbose('TCreateSequence BeginProcessing.');
end;

constructor TCreateSequence;
begin
inherited constructor;
end;

method TCreateSequence.EndProcessing;
begin
inherited;
WriteVerbose('TCreateSequence EndProcessing.');
end;

method TCreateSequence.ProcessRecord;
begin
inherited;
WriteVerbose('TCreateSequence ProcessRecord.');
end;

method TCreateSequence.StopProcessing;
begin
inherited;

end;

{ TCreateSequenceSnapIn }

method TCreateSequenceSnapIn.GetDescription: string;
begin
Result:='Snap-in PowerShell incluant le cmdlet Create-Sequence.';
end;

method TCreateSequenceSnapIn.GetDescriptionResource: string;
begin
Result:='CreateSequenceSnapIn,Snap-in PowerShell incluant le cmdlet Create-Sequence.';
end;

method TCreateSequenceSnapIn.GetName: string;
begin
Result:='CreateSequenceSnapIn';
end;

method TCreateSequenceSnapIn.GetVendor: string;
begin
Result:='Laurent Dardenne.';
end;

method TCreateSequenceSnapIn.GetVendorResource: string;
begin
Result:='CreateSequenceSnapIn,Laurent Dardenne.';
end;

end.
[/code:1]
N'essayez pas avec Delphi 2007 car, et c'est dommage, un bug du compilo .NET 2.0 ne permet pas de créer de snapin, voir QualityCentral pour le détail.
Ce qui prouve qu'il n'y pas, en téhorie, de limitation quand au langage pour générer des cmdlettes. En passant Delphi Prism autorise la programmation par contrat, prochainemant la progammation par aspect.
Faudrait voir si Eiffel ou F# permet de créer des cmdlets, bon j'arrête là

Tout ça est fort juste mais horriblement complexe pour un besoin à la base relativement simple (en tout cas à formuler).

Et contrairement à ce qu'affirme Laurent, je dirais que PowerShell est avant tout un shell. La preuve, c'est qu'il te permet d'utiliser et d'intégrer ensemble tous types d'outils développés pour Windows. Tu n'as pas absolument besoin d'avoir toutes les fonctionnalités disponibles dans le Framework .NET, à partir du moment où un exécutable peut les offrir (et si possible en ligne de commande ), PowerShell peut y accéder.

Donc, si tu connais un outil en ligne de commande qui peut modifier les privilèges d'un jeton utilisateur, tu as déjà résolu 90% du problème. Ensuite, il te suffit de traiter les entrées et les sorties avec cet outil pour que ton script puisse marcher comme prévu. Là, PowerShell se révèle généralement plus souple et plus performant que le bon vieux shell CMD.EXE.

Janel