IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Scripts/Batch Discussion :

Permissions NTFS de répertoires [PowerShell]


Sujet :

Scripts/Batch

  1. #21
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par arnaudperfect Voir le message
    Oui, j'ai vu ça, mais c'est pas très claire pour moi...
    Essaie qq chose comme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories('C:\temp','*.*','AllDirectories')
    Ceci dit attention à la remarque suivante :
    This method may consume a lot of memory if a large tree of files, directories and subdirectories are searched. Consider using FileSystemEntryEnumerator instead if possible.
    Vérifie déjà si tu peux lire un chemin ayant plus de 250 caractères.

  2. #22
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Pour info les drives créés par New-PsDrive sont soumis à la m^me restriction de longueur du path, mais pas ceux crées avec Subst.

    Un début de solution :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    Function RecursePath([string]$RootPath, [string]$SourcePath){
            
       #renvoi un chemin commencant par \\.?\ 
       #voir http://aspadvice.com/blogs/davidwalker/archive/2007/01/22/PathTooLongException-work-around.aspx
      $RootPath = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($RootPath)
            
        # for each subdirectory in the current directory..       
            [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
                $ShortDirectory = $_
                $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
    
                Write-Host "Read directory $LongDirectory" -fore cyan
                $dir = new-object Alphaleonis.Win32.Filesystem.DirectoryInfo($LongDirectory)
                $dirACL = $dir.GetAccessControl("Access")
                $accessRules = $dirACL.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
                $accessRules
                # For each file in the current directory..                                              
                [Alphaleonis.Win32.Filesystem.Directory]::GetFiles($LongDirectory) | % {
    
                    $ShortFile = $_
                    $LongFile = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortFile)
                    
                    Write-Host "Read file to $LongFile" -fore green
                     #todo ACL fichier
            }
        # Loop.
        RecursePath $SourcePath $LongDirectory #$ShortDirectory
        }
    }
    RecursePath 'C:\temp\98264hjngmndvbtuiygo\' 'C:\temp\98264hjngmndvbtuiygo\'
    Un extrait du résultat:
    FileSystemRights : -536805376
    AccessControlType : Allow
    IdentityReference : S-1-5-11
    IsInherited : True
    InheritanceFlags : ContainerInherit, ObjectInherit
    PropagationFlags : InheritOnly

    Read file to \\?\C:\temp\98264hjngmndvbtuiygo\oiruwhg\auhfguitvgniugysliesd\iuatjhsbgvldsjyurugdfbnlsiughyjb\p98utyndb\s
    iuhg\uofyg\iushg\resd\g\apiughnv;shign\osfyukjutyetsb\wiuyqiortoiut\uy\tru\dyuj\dyyj\yt\tyi\cgj\op\yuio\uio\wer\yti\ch\j
    kl\uyt\fhkj\iop\12345\12\abcdefghijklmnopqrst\1234567890\theLast.txt
    La longueur du chemin du dernier fichier est de 292 caractères et les ACLs appartiennent au dernier répertoire dont la longueur du chemin est de 280 caractères.

    J'ai un doute sur la fonction récursive, car sous PS la profondeur max est de 100.

    Cette DLL peut résoudre ton pb, sous réserve de la tester sérieusement et qu'elle soit maintenue, ce qui pour le moment est le cas. En revanche pour les performances, à vérifier si c'est viable.
    La création d'un module Wrapper me semble préférable (réutilisation et maintenance).

    C'est le moment de se mettre à Pester

  3. #23
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Une dernière pour la route.
    Ce module utilise une dll 'expérimental' de Microsoft, a vérifier si la gestion des ACLs est possible à partir des objets reçus.
    Voir aussi ce Wiki.

  4. #24
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Citation Envoyé par Laurent Dardenne Voir le message
    Essaie qq chose comme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories('C:\temp','*.*','AllDirectories')
    Ceci dit attention à la remarque suivante :

    Vérifie déjà si tu peux lire un chemin ayant plus de 250 caractères.
    Alors pour vérifier un chemin de plus de 250 caractères, c'est assez difficile, car en labo, je ne peux produire un tel chemin car Windows me dit que je ne peux dépasser une telle longueur. Sur mon serveur de fichier, j'ai trop de répertoire pour trouver un chemin aussi long, mais visiblement, il y en a.

    Après, j'ai essayé la commande proposé. Sur certaines arborescence, elle paresse toutes l'arbo récursivement, sur d'autres arbo, non. Bizarre.

  5. #25
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Citation Envoyé par Laurent Dardenne Voir le message
    Pour info les drives créés par New-PsDrive sont soumis à la m^me restriction de longueur du path, mais pas ceux crées avec Subst.
    Je ne comprend pas trop (Je ne suis pas développeur, donc cela n'est pas évident pour moi)

    Citation Envoyé par Laurent Dardenne Voir le message
    Un début de solution :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    Function RecursePath([string]$RootPath, [string]$SourcePath){
            
       #renvoi un chemin commencant par \\.?\ 
       #voir http://aspadvice.com/blogs/davidwalker/archive/2007/01/22/PathTooLongException-work-around.aspx
      $RootPath = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($RootPath)
            
        # for each subdirectory in the current directory..       
            [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
                $ShortDirectory = $_
                $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
    
                Write-Host "Read directory $LongDirectory" -fore cyan
                $dir = new-object Alphaleonis.Win32.Filesystem.DirectoryInfo($LongDirectory)
                $dirACL = $dir.GetAccessControl("Access")
                $accessRules = $dirACL.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
                $accessRules
                # For each file in the current directory..                                              
                [Alphaleonis.Win32.Filesystem.Directory]::GetFiles($LongDirectory) | % {
    
                    $ShortFile = $_
                    $LongFile = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortFile)
                    
                    Write-Host "Read file to $LongFile" -fore green
                     #todo ACL fichier
            }
        # Loop.
        RecursePath $SourcePath $LongDirectory #$ShortDirectory
        }
    }
    RecursePath 'C:\temp\98264hjngmndvbtuiygo\' 'C:\temp\98264hjngmndvbtuiygo\'
    Alors, je viens de regarder ta proposition. Je ne les pas encore testé.

    Cependant, j'ai quelques questions :

    Q1. Pourquoi il faut un $RootPath, $SourcePath dans la fonction ?
    Q2. A quoi sert "le chemin commençant par \\.?\" ? J'ai lu l'article, mais je ne suis pas sûr de tout comprendre. De plus, la variable $RootPath = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($RootPath) n'est plus utilisé par la suite du script. Est-elle vraiment utile ?

  6. #26
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par arnaudperfect Voir le message
    Alors pour vérifier un chemin de plus de 250 caractères, c'est assez difficile, car en labo,
    je ne peux produire un tel chemin car Windows me dit que je ne peux dépasser une telle longueur.
    Essaie ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    $path= 'C:\temp\98264hjngmndvbtuiygo\oiruwhg\auhfguitvgniugysliesd\iuatjhsbgvldsjyurugdfbnlsiughyjb\p98utyndb\siuhg\uofyg\iushg\resd\g\apiughnv;shign\osfyukjutyetsb\wiuyqiortoiut\uy\tru\dyuj\dyyj\yt\tyi\cgj\op\yuio\uio\wer\yti\ch\jkl\uyt\fhkj\iop\12345\12'
    md $Path  
    "test" > 12345678.txt
    cd $path
     #crée un lecteur substitué, c'est un lecteur du système
    Subst x: "$pwd"
    #crée un lecteur Powershell pointant sur le lecteur substitué
    #Le nom du drive PS n'est pas lié au nom d'unité du système
    new-psdrive -Name X -Root X:\ -PSProvider FileSystem
    
    Md 'x:\abcdefghijklmnopqrst\1234567890'
    cd 'x:\abcdefghijklmnopqrst\1234567890' 
    "test" > Dernier.txt
    
    #En fin de Test
    #
    #cd x:\
    #del -path X:\ -Recurse Force
    #del -path X:\ -Recurse Force
    #cd 'C:\temp\98264hjngmndvbtuiygo''
    #del -path 'C:\temp\98264hjngmndvbtuiygo' -Recurse Force
    # Remove-PSDrive x
    # Subst X: /D
    Citation Envoyé par arnaudperfect Voir le message
    Bizarre.
    D'où la création d'un jeux de tests. C'est du code adapté, pour valider le principe, je ne l'est pas testé plus que ça.
    Car mine de rien, cela demande pas mal de temps.

    Citation Envoyé par arnaudperfect Voir le message
    Je ne comprend pas trop (Je ne suis pas développeur, donc cela n'est pas évident pour moi)
    Tu es mal tombé avec ton traitement...
    Je ne connais pas cette librairie, il faut un peu temps pour lire la doc et comprendre commnent l'utiliser.


    Citation Envoyé par arnaudperfect Voir le message
    Q2. A quoi sert "le chemin commençant par \\.?\" ?
    Cela force le code de l'API à outrepasser la limite de longueur, voir aussi Maximum Path Length Limitation.
    Pour les autres points, j'ai adapté rapido cette fonction, c'est du code de test, il y a donc un reliquat de l'ancien code qui pour moi n'a pas de sens ici.
    Si le nombre d'appel récursif dépasse 100 (à vérifier), cette fonction ne servira à rien, pas la peine de passer trop de temps à comprendre le code.

  7. #27
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Alors j'ai simplifier le code que tu m'as proposé :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    clear
    # Import AlphaFS .NET module - http://alphafs.codeplex.com/
    Import-Module C:\Users\xxxxxxxxxxxxxxxx\Desktop\AlphaFS-1.5-BinAndDocs\Release\AlphaFS.dll
    
    Function RecursePath([string]$SourcePath){      
    	# for each subdirectory in the current directory.. 	
    	[Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
    		$ShortDirectory = $_
    		$LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
    		Write-Host $LongDirectory -fore cyan
    		# Loop.
    		RecursePath $LongDirectory
    	}
    }
    RecursePath 'H:\groupe\xxx'
    Puis j'ai fais quelques tests sur plusieurs arborescence de mon serveur de fichier. Le test le plus gros que j'ai fais, c'est 6013 répertoires parcourus. Nombre nombre d'appel récursif : aucune idée, il faudrait compter.

    J'arrive à avoir le bon nombre de répertoire parcouru en comparant avec les propriétés Windows.
    Niveau vitesse de traitement, cela est assez rapide par rapport à la fonction

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    # Paresser les répertoires et sous répertoires #
    $Folders = @(Get-Item $RootPath) + (dir $RootPath -recurse | where {$_.psiscontainer -eq $true})

  8. #28
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par arnaudperfect Voir le message
    Nombre nombre d'appel récursif : aucune idée, il faudrait compter.
    Avec un compteur :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    $global:i=0
    Function RecursePath([string]$SourcePath){      
        $global:i++ 
        # for each subdirectory in the current directory..     
        [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
            $ShortDirectory = $_
            $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
            Write-Host $LongDirectory -fore cyan
            Write-host "Loop:  $global:i"
            RecursePath $LongDirectory
        }
    }
    Citation Envoyé par arnaudperfect Voir le message
    Niveau vitesse de traitement, cela est assez rapide par rapport à la fonction
    Il manque la lecture des ACLs et la création d'un objet personnalisé...

    Création d'un jeux de test :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    $SourcePath='C:\temp\'
    cd $SourcePath
    try {
    foreach ($i in 1..110)
    {
      $path='{0:000}' -F $i
      try {
         md $path -ea Stop > $null
      } catch {
       Subst x: "$pwd"
       new-psdrive -Name X -Root X:\ -PSProvider FileSystem
       set-location x:\
       md $path -ea Stop > -null
      }
      set-location $path
      Write-host "$i $pwd"
    }
    } finally {
      set-location $SourcePath
      Remove-PSDrive x
      Subst X: /D
    }
    L'appel suivant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    RecursePath 'c:\temp\001' 'c:\temp\001'
    effectue 109 récursions, la limite de 100 concerne PS v1.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    $s='c:\temp\001\002\003\004\005\006\007\008\009\010\011\012\013\014\015\016\017\018\019\020\021\022\023\024\025\026\027\028\029\030\031\032\033\034\035\036\037\038\039\040\041\042\043\044\045\046\047\048\049\050\051\052\053\054\055\056\057\058\059\060\061\062\063\064\065\066\067\068\069\070\071\072\073\074\075\076\077\078\079\080\081\082\083\084\085\086\087\088\089\090\091\092\093\094\095\096\097\098\099\100\101\102\103\104\105\106\107\108\109\110'
    $s.length
    #447
    447 caractères devraient suffire pour tes tests :-)

    Quel OS et version de powershell utilises-tu ?

  9. #29
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Citation Envoyé par Laurent Dardenne Voir le message
    Avec un compteur :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    $global:i=0
    Function RecursePath([string]$SourcePath){      
        $global:i++ 
        # for each subdirectory in the current directory..     
        [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
            $ShortDirectory = $_
            $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
            Write-Host $LongDirectory -fore cyan
            Write-host "Loop:  $global:i"
            RecursePath $LongDirectory
        }
    }
    J'essayais justement d'en ajouter un !

    J'ai donc refais un test sur mon serveur de fichier. J'ai réalisé 6012 d'appels récursifs.


    Citation Envoyé par Laurent Dardenne Voir le message
    Création d'un jeux de test :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    $SourcePath='C:\temp\'
    cd $SourcePath
    try {
    foreach ($i in 1..110)
    {
      $path='{0:000}' -F $i
      try {
         md $path -ea Stop > $null
      } catch {
       Subst x: "$pwd"
       new-psdrive -Name X -Root X:\ -PSProvider FileSystem
       set-location x:\
       md $path -ea Stop > -null
      }
      set-location $path
      Write-host "$i $pwd"
    }
    } finally {
      set-location $SourcePath
      Remove-PSDrive x
      Subst X: /D
    }
    L'appel suivant :
    [code]
    Je viens de créer le jeu de test avec ton script. J'ai testé le parresseur sur ce jeu.

    Visiblement, aucun problème de longueur de chaine ou de nombre occurrences
    (chaine de 457 caractères, 110 boucles)

    \\?\C:\Temp\001\002\003\004\005\006\007\008\009\010\011\012\013\014\015\016\017\018\019\020\021\022\023\024\025\026\027\
    028\029\030\031\032\033\034\035\036\037\038\039\040\041\042\043\044\045\046\047\048\049\050\051\052\053\054\055\056\057\
    058\059\060\061\062\063\064\065\066\067\068\069\070\071\072\073\074\075\076\077\078\079\080\081\082\083\084\085\086\087\
    088\089\090\091\092\093\094\095\096\097\098\099\100\101\102\103\104\105\106\107\108\109\110
    Je pense qu'on est plutôt bien avec cette DLL.

    Citation Envoyé par Laurent Dardenne Voir le message
    Quel OS et version de powershell utilises-tu ?
    J'utilise PowerShell version 4.0 sur un Windows 2008 R2.

    bon, reste plus qu'à ré implémenté la lecture des ACL... J'espère pouvoir réutiliser ce qu'on à conçu la semaine dernière !

    Tien aussi, si je n'abuse pas trop, y a t-il moyen de géré les erreurs d'accès ? Par exemple, si le script n'arrive pas à ouvrir un répertoire car pas d'autorisation.

  10. #30
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par arnaudperfect Voir le message
    J'ai réalisé 6012 d'appels récursifs.
    Tout de même !
    Citation Envoyé par arnaudperfect Voir le message
    J'ai testé le parresseur sur ce jeu.
    En passant c'est parser ou parseur ou encore analyse.
    Citation Envoyé par arnaudperfect Voir le message
    J'utilise PowerShell version 4.0 sur un Windows 2008 R2
    A moins de tomber sur une régression, c'est à mon avis préférable d'avoir cette version. Surtout que cette DLL ne peut fonctionner avec la V2.
    Citation Envoyé par arnaudperfect Voir le message
    Je pense qu'on est plutôt bien avec cette DLL.
    A priori oui, mais la réalisation de ce projet m'incite à la prudence sur ce type de wrapper.
    Ceci dit l'équipe projet est composée de 5 personnes, ils répondent aux demandes, corrigent les bugs, le code est propre et structuré.

    Le code source actuel contient qq corrections de bugs, mais il n'y a pas les binaires associés.
    De référencer les bugs corrigés et vérifier leur impacts sur ton traitement est à mon avis préférable.

    Enfin cette DLL évoluant, d'automatiser un jeux de test avec Pester ne serait pas du luxe.
    Après, chacun fait comme il le souhaite ;-)

  11. #31
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Je regardais pour implémenter code de la semaine dernière dans le parseur qu'on vient de réaliser.

    Get-ACL, je pense que cette commande ne fonctionnera pas avec des chemins très long...

    J'ai vu que AlphaFS permet aussi la lecture des ACL, comme tu me l'as montré ce matin. Il faut que je regarde pour obtenir les même informations que mon script de la semaine dernière.

    Arpès, mon script va me permet d'auditer les droits NTFS sur des serveurs de fichiers, en vu de faire des croisements de données entre des informations présentent sur mon Active Directory et les rapports d'audits générés. L'idée est de savoir quels groupes de sécurité AD est appliqués sur les répertoires de fichiers.

    Bien casse tête mon truc ! Pour quelque chose qui semble tout bête à 1er vue.

    sinon, j'ai ajouté le code nécessaire à l'obtention des ACL sur les répertoires (inspiré de ton script de ce matin) :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #$global:i=0
    Function RecursePath([string]$SourcePath){      
        #$global:i++ 
        # for each subdirectory in the current directory..     
        [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
            $ShortDirectory = $_
            $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
            Write-Host $LongDirectory -fore cyan
    		
    	$dir = new-object Alphaleonis.Win32.Filesystem.DirectoryInfo($LongDirectory)
            $dirACL = $dir.GetAccessControl("Access")
            $accessRules = $dirACL.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
            foreach($accessRule in $accessRules)
    		{
    			Write-Host $accessRule.FileSystemRights $accessRule.IsInherited $accessRule.IdentityReference  -fore red
    		}
            #Write-host "Loop:  $global:i"
            RecursePath $LongDirectory
        }
    }
    avec ce résultat :

    \\?\C:\Users\xxx\Desktop\NTFS_Permissions_Explorer\Basic Documentation
    FullControl False S-1-5-18
    FullControl False S-1-5-32-544
    FullControl False S-1-5-21-2660795650-4073143688-716774788-5157
    \\?\C:\Users\xxx\Desktop\NTFS_Permissions_Explorer\Basic Documentation\images
    FullControl False S-1-5-18
    FullControl False S-1-5-32-544
    FullControl False S-1-5-21-2660795650-4073143688-716774788-5157
    \\?\C:\Users\xxx\Desktop\NTFS_Permissions_Explorer\DllWithInstructions
    FullControl False S-1-5-18
    FullControl False S-1-5-32-544
    FullControl False S-1-5-21-2660795650-4073143688-716774788-5157
    J'ai presque toutes les informations qu'il me faut : FileSystemRights, IsInherited
    sauf que IdentityReference, il m'indique le SID de l'utilisateur/groupe. Je ne sais pas s'il y a possibilité d'avoir le nom de l'utilisateur/groupe afin que cela soit plus lisible...

  12. #32
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Je me répond à moi même : voici la solution :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    #$global:i=0
    Function RecursePath([string]$SourcePath){      
        #$global:i++ 
        # for each subdirectory in the current directory..     
        [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
            $ShortDirectory = $_
            $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
            Write-Host $LongDirectory -fore cyan
    		
    		$dir = new-object Alphaleonis.Win32.Filesystem.DirectoryInfo($LongDirectory)
    		$dirACL = $dir.GetAccessControl("Access")
            $accessRules = $dirACL.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
            foreach($accessRule in $accessRules)
    		{
    			# convert SID to User/group domain
    			$objSID = New-Object System.Security.Principal.SecurityIdentifier($accessRule.IdentityReference)
    			$objUser = $objSID.Translate([System.Security.Principal.NTAccount])
    			
    			Write-Host $accessRule.FileSystemRights $accessRule.IsInherited $accessRule.IdentityReference $objUser.Value   -fore red
    		}
            #Write-host "Loop:  $global:i"
            RecursePath $LongDirectory
        }
    }

  13. #33
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par arnaudperfect Voir le message
    Get-ACL, je pense que cette commande ne fonctionnera pas avec des chemins très long...
    Exact, sauf si on triche avec un drive substitué
    Citation Envoyé par arnaudperfect Voir le message
    Il faut que je regarde pour obtenir les même informations que mon script de la semaine dernière.
    A priori seul le nom de classe change.
    Citation Envoyé par arnaudperfect Voir le message
    Bien casse tête mon truc ! Pour quelque chose qui semble tout bête à 1er vue.
    Oui, l'énoncé peut être trompeur. Dis autrement, il y a loin de la coupe aux lèvres :-)
    Citation Envoyé par arnaudperfect Voir le message
    avec ce résultat
    Il te faut remplacer le write-host par une création d'objet personnalisé :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    [pscustomobject]@{
        PSTypeName='MonTypePerso';
        Path=$ShortDirectory;
        FileSystemRights=$accessRule.FileSystemRights;
        IsInherited=$accessRule.IsInherited 
        IdentityReference=$accessRule.IdentityReference; #todo convert SID
        User=$objUser.Value
    }
    Ainsi, la fonction émet une collection d'objet à partir de la laquelle tu pourraq construire ton fichier XL.
    Pas la peine de charge XL auparavant
    Citation Envoyé par arnaudperfect Voir le message
    voici la solution :

  14. #34
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Alors, j'ai encore un soucie.

    J'arrive à parser les répertoires, à obtenir les ACL, à les afficher sur le promt, mais pour écrire sur Excel, j'ai certainnes données quine s'écrive pas correctement !

    Voici le script :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    # Parseur de répertoire et sous répertoire
    
    $global:i=0
    Function RecursePath([string]$SourcePath){ 	
        # Compteur de boucle
        $global:i++ 
    	
        # for each subdirectory in the current directory..     
        [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
            $ShortDirectory = $_
            $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
            Write-Host $LongDirectory -fore cyan
    		
    		# Get ACL
    		$dir = new-object Alphaleonis.Win32.Filesystem.DirectoryInfo($LongDirectory)
    		$dirACL = $dir.GetAccessControl("Access")
            $accessRules = $dirACL.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
            foreach($accessRule in $accessRules)
    		{
    			# Convert SID to User/group domain
    			$objSID = New-Object System.Security.Principal.SecurityIdentifier($accessRule.IdentityReference)
    			$objUser = $objSID.Translate([System.Security.Principal.NTAccount])
    			
    			Write-Host "--" $objUser.Value $accessRule.IdentityReference $accessRule.FileSystemRights $accessRule.IsInherited -fore red
    			
    			$Col=1
    			$d.Cells.Item($ligne,$col)= $LongDirectory # Fullname
    			$Col++
    			
    			$d.Cells.Item($ligne,$col)= $objUser.Value # Identity
    			$Col++
    			
    			$d.Cells.Item($ligne,$col)= $accessRule.IdentityReference # SID
    			$Col++
    
    			$d.Cells.Item($ligne,$col)= $accessRule.FileSystemRights # Rights
    			$Col++
    			
    			$d.Cells.Item($ligne,$col)= $accessRule.IsInherited # SID	
    			$ligne++	
    		}
            Write-host "Loop:  $global:i"
            RecursePath $LongDirectory
        }
    }
    La ligne "$d.Cells.Item($ligne,$col)= $accessRule.IdentityReference # SID", me génère cette erreur :

    % : Exception setting "Item": "Exception from HRESULT: 0x800A03EC"
    At C:\Users\ADMROOT_fourquemin\Desktop\test.ps1:39 char:77
    + [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
    + ~~~
    + CategoryInfo : NotSpecified: ( [ForEach-Object], SetValueInvocationException
    + FullyQualifiedErrorId : CatchFromBaseAdapterParameterizedPropertySetValueTI,Microsoft.PowerShell.Commands.ForEac
    hObjectCommand
    Cette ligne "$d.Cells.Item($ligne,$col)= $accessRule.FileSystemRights # Rights", m'écrit cela dans le tableau Excel :

    Fullname Identity SID Rights IsInherited
    \\?\C:\Users\xxxx\Desktop\NTFS_Permissions_Explorer\Basic Documentation NT AUTHORITY\SYSTEM 2032127 FALSE
    Je n'y comprend rien !!

  15. #35
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Citation Envoyé par Laurent Dardenne Voir le message
    Il te faut remplacer le write-host par une création d'objet personnalisé :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    [pscustomobject]@{
        PSTypeName='MonTypePerso';
        Path=$ShortDirectory;
        FileSystemRights=$accessRule.FileSystemRights;
        IsInherited=$accessRule.IsInherited 
        IdentityReference=$accessRule.IdentityReference; #todo convert SID
        User=$objUser.Value
    }
    Ainsi, la fonction émet une collection d'objet à partir de la laquelle tu pourraq construire ton fichier XL.
    Pas la peine de charge XL auparavant
    Je ne connais pas ce genre d'objet. On l'utilise comment après ? Quel est l'avantage ?

    Je l’intègre comme cela dans la fonction ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    $global:i=0
    Function RecursePath([string]$SourcePath){ 	
        # Compteur de boucle
        $global:i++ 
    	
        # for each subdirectory in the current directory..     
        [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
            $ShortDirectory = $_
            $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
            Write-Host $LongDirectory -fore cyan
    		
    		# Get ACL
    		$dir = new-object Alphaleonis.Win32.Filesystem.DirectoryInfo($LongDirectory)
    		$dirACL = $dir.GetAccessControl("Access")
            $accessRules = $dirACL.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
            foreach($accessRule in $accessRules)
    		{
    			# Convert SID to User/group domain
    			$objSID = New-Object System.Security.Principal.SecurityIdentifier($accessRule.IdentityReference)
    			$objUser = $objSID.Translate([System.Security.Principal.NTAccount])
    			
    			[pscustomobject]@{
    				PSTypeName='MonTypePerso';
    				Path=$ShortDirectory;
    				FileSystemRights=$accessRule.FileSystemRights;
    				IsInherited=$accessRule.IsInherited 
    				IdentityReference=$accessRule.IdentityReference; #todo convert SID
    				User=$objUser.Value
    			}
    		}
            Write-host "Loop:  $global:i"
            RecursePath $LongDirectory
        }
    }
    Dans mon MAIN, j'écris comment mon Excel ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    	$Col=1
    	$d.Cells.Item($ligne,$col)= $LongDirectory # Fullname
    	$Col++
    	$d.Cells.Item($ligne,$col)= $objUser.Value # Identity
    	$Col++
    	$d.Cells.Item($ligne,$col)= $accessRule.IdentityReference # SID
    	$Col++
    	$d.Cells.Item($ligne,$col)= $accessRule.FileSystemRights # Rights
    	$Col++
    	$d.Cells.Item($ligne,$col)= $accessRule.IsInherited # SID	
    	$ligne++
    Je suis un peu perdu sur ce point...

  16. #36
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par arnaudperfect Voir le message
    Alors, j'ai encore un souci.
    La route est longue
    Citation Envoyé par arnaudperfect Voir le message
    On l'utilise comment après ?
    Comme n'importe quel objet:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    $Collection=1..5|
                 Foreach {
                  [pscustomobject]@{
                      PSTypeName='MonTypePerso';
                      Path="test $_"
                  }
                 }
    $Collection
    $Collection[0]|gm
    Citation Envoyé par arnaudperfect Voir le message
    Quel est l'avantage ?
    Structurer ton code, faciliter la maintenance et s'éviter entre autres ceci:
    Citation Envoyé par arnaudperfect Voir le message
    Je n'y comprend rien !!
    Dans ton script tout est dans tout, c'est possible mais le debug s'avère laborieux.

    C'est du dev, pas une course . Prend le temps d'apprendre, car de gérer toutes ces nouveautés en même temps va t'embrouiller plus qu'autre chose.

  17. #37
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Ok, j'ai compris ! (je me surprend moi même !)

    J'ai réussi à utilisé ton objet personnel.

    La fonction :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    Function RecursePath([string]$SourcePath){ 	
        # for each subdirectory in the current directory..     
        [Alphaleonis.Win32.Filesystem.Directory]::GetDirectories($SourcePath) | % {
            $ShortDirectory = $_
            $LongDirectory = [Alphaleonis.Win32.Filesystem.Path]::GetLongPath($ShortDirectory)
    		# Get ACL
    		$dir = new-object Alphaleonis.Win32.Filesystem.DirectoryInfo($LongDirectory)
    		$dirACL = $dir.GetAccessControl("Access")
            $accessRules = $dirACL.GetAccessRules($true, $true, [System.Security.Principal.SecurityIdentifier])
            foreach($accessRule in $accessRules)
    		{
    			# Convert SID to User/group domain
    			$objSID = New-Object System.Security.Principal.SecurityIdentifier($accessRule.IdentityReference)
    			$objUser = $objSID.Translate([System.Security.Principal.NTAccount])
    			
    			[pscustomobject]@{
    				Path=$ShortDirectory;
    				FileSystemRights=$accessRule.FileSystemRights;
    				IsInherited=$accessRule.IsInherited 
    				IdentityReference=$accessRule.IdentityReference;
    				User=$objUser.Value
    			}
    		}
            RecursePath $LongDirectory
        }
    }
    L'appel à la fonction avec écriture dans le Excel :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    ...
    
    RecursePath $RootPath
    	
    	$RecursePathACL = RecursePath $RootPath
    	foreach($RecursePath in $RecursePathACL)
    	{
    		$Col=1
    		$d.Cells.Item($ligne,$col)= $RecursePath.Path # Fullname
    		$Col++
    		$d.Cells.Item($ligne,$col)= $RecursePath.User # Identity
    		$Col++
    		$d.Cells.Item($ligne,$col)= $RecursePath.IdentityReference # SID
    		$Col++
    		$d.Cells.Item($ligne,$col)= $RecursePath.FileSystemRights # Rights
    		$Col++
    		$d.Cells.Item($ligne,$col)= $RecursePath.IsInherited # IsInherited	
    		$ligne++
    	}
    
    ...
    Les champs "Fullname" et "Identity" sont bien écrit dans le Excel.

    Le champs "SID" me fait une erreur :

    Invoke-Command : Exception setting "Item": "Exception from HRESULT: 0x800A03EC"
    At C:\Users\ADMROOT_fourquemin\Desktop\test.ps1:16 char:5
    + Invoke-Command $script
    + ~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo : NotSpecified: (:) [Invoke-Command], SetValueInvocationException
    + FullyQualifiedErrorId : CatchFromBaseAdapterParameterizedPropertySetValueTI,Microsoft.PowerShell.Commands.Invoke
    CommandCommand
    Le champ "Right" m'écrit des chiffre dans l'Excel, alors que dans le promt PowerShell, j'ai bien les droits écrit en clair.

    Le champ "IsInherited" est écrit dans excel correctement.

    On y est presque !!! :aie:

  18. #38
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par arnaudperfect Voir le message
    Ok, j'ai compris ! (je me surprend moi même !)
    Il n'y a rien de complexe ici
    Citation Envoyé par arnaudperfect Voir le message
    J'ai réussi à utilisé ton objet personnel.
    Une fonction dédiée est préférable :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    #Requires -version 3
    Function New-AlphaleonisACL{
    param(
             [Parameter(Mandatory=$True,position=0)]
            $Path,
             [Parameter(Mandatory=$True,position=1)]
            $FileSystemRights,
             [Parameter(Mandatory=$True,position=2)]
            $IsInherited,
             [Parameter(Mandatory=$True,position=3)]
            $IdentityReference,
             [Parameter(Mandatory=$True,position=4)]
            $User
    )
    
      [pscustomobject]@{
        PSTypeName='AlphaleonisACL';
        Path=$Path;
        FileSystemRights=$FileSystemRights;
        IsInherited=$IsInherited;
        IdentityReference=$IdentityReference;
        User=$User;
       }
    }# New-AlphaleonisACL
    Je te laisse modifier la fonction RecursePath.
    Citation Envoyé par arnaudperfect Voir le message
    Le champ "Right" m'écrit des chiffre dans l'Excel, alors que dans le promt PowerShell, j'ai bien les droits écrit en clair.
    Il ne faut pas confondre l'affichage des objets par la console et le type de l'objet.
    Pour le moment je te conseille de laisser tomber XL et de construire un fichier CSV :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    $RecursePathACL = RecursePath $RootPath
    $RecursePathACL | Export-csv c:\temp\ACLDatas.csv
    Travaille le formatage/conversion des données avant d'aller plus loin. XL gère par défaut des chaînes de caractères.
    Citation Envoyé par arnaudperfect Voir le message
    On y est presque !!!
    Je n'en suis pas certains, mais que tu aies envie que cela se termine je peux le comprendre.

  19. #39
    Rédacteur


    Profil pro
    Inscrit en
    Janvier 2003
    Messages
    7 171
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2003
    Messages : 7 171
    Points : 15 060
    Points
    15 060
    Billets dans le blog
    1
    Par défaut
    Pour l'ajout dans les cellules XL, il faut transformer l'objet ou utiliser la propriété value pour IdentityReference et User.
    Le code suivant affiche les objets différemment :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    foreach($RecursePath in $RecursePathACL)
    {
     Write-host "`r`nPath $('-'* 40)"
     $RecursePath.Path.GetType()
     $RecursePath.Path
     $RecursePath.Path.Tostring()
     
     Write-host "`r`nUser $('-'* 40)"
     $RecursePath.User.GetType()
     $RecursePath.User
     $RecursePath.User.Tostring()
     
     Write-host "`r`nIdentityReference $('-'* 40)"
     $RecursePath.IdentityReference.GetType()
     $RecursePath.IdentityReference
     $RecursePath.IdentityReference.Tostring()
     
     Write-host "`r`nFileSystemRights $('-'* 40)"
     $RecursePath.FileSystemRights.GetType()
     $RecursePath.FileSystemRights
     $RecursePath.FileSystemRights.Tostring()
     
     Write-host "`r`nIsInherited  $('-'* 40)"
     $RecursePath.IsInherited.GetType()
     $RecursePath.IsInherited
     $RecursePath.IsInherited.Tostring()
             
    break
    }
    La construction d'un fichier CSV n'a pas ce problème, car la méthode Tostring() est appelée sur chaque propriété de chaque objet.
    La correction étant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
      $d.Cells.Item($ligne,$col)= $RecursePath.User.Value # Identity
      $Col++
      $d.Cells.Item($ligne,$col)= $RecursePath.IdentityReference.Value # SID
    A noter que la création d'un fichier CSV en lieu et place d'un XLS serait plus rapide.

  20. #40
    Membre actif
    Homme Profil pro
    Ingénieur systèmes et réseaux
    Inscrit en
    Décembre 2006
    Messages
    1 080
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur systèmes et réseaux

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 080
    Points : 287
    Points
    287
    Par défaut
    Citation Envoyé par Laurent Dardenne Voir le message
    Une fonction dédiée est préférable :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    #Requires -version 3
    Function New-AlphaleonisACL{
    param(
             [Parameter(Mandatory=$True,position=0)]
            $Path,
             [Parameter(Mandatory=$True,position=1)]
            $FileSystemRights,
             [Parameter(Mandatory=$True,position=2)]
            $IsInherited,
             [Parameter(Mandatory=$True,position=3)]
            $IdentityReference,
             [Parameter(Mandatory=$True,position=4)]
            $User
    )
    
      [pscustomobject]@{
        PSTypeName='AlphaleonisACL';
        Path=$Path;
        FileSystemRights=$FileSystemRights;
        IsInherited=$IsInherited;
        IdentityReference=$IdentityReference;
        User=$User;
       }
    }# New-AlphaleonisACL
    Je te laisse modifier la fonction RecursePath.
    Euh, la tu m'as largué... A quoi cela sert ? Comment l’implémenté ?


    Citation Envoyé par Laurent Dardenne Voir le message
    Pour le moment je te conseille de laisser tomber XL et de construire un fichier CSV :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    $RecursePathACL = RecursePath $RootPath
    $RecursePathACL | Export-csv c:\temp\ACLDatas.csv
    Travaille le formatage/conversion des données avant d'aller plus loin. XL gère par défaut des chaînes de caractères.
    Je vais rester en CSV, car l'écriture dans Excel est trop longue à programmer et j'ai pas des jours et des jours à consacrer à ce script. On va faire simple et fonctionnelle.

    Aussi, même problème que la semaine derrière, ma fonction n’inclue pas la racine dans l'analyse. Comment faire ?

+ Répondre à la discussion
Cette discussion est résolue.
Page 2 sur 4 PremièrePremière 1234 DernièreDernière

Discussions similaires

  1. [Infomaniak] Quelles permissions sur fichiers/répertoires ?
    Par Sayrus dans le forum Hébergement
    Réponses: 0
    Dernier message: 22/10/2009, 16h32
  2. Delphi et Permission NTFS (cacls inside)
    Par Raspoutitsa dans le forum Débuter
    Réponses: 0
    Dernier message: 19/08/2009, 17h37
  3. [WD11] Permissions NTFS
    Par WDKyle dans le forum WinDev
    Réponses: 7
    Dernier message: 06/07/2009, 10h29
  4. Modifier les permissions d'un répertoire
    Par zan001 dans le forum Général Java
    Réponses: 0
    Dernier message: 30/04/2009, 19h57
  5. Permissions NTFS avec XP Home
    Par Loceka dans le forum Sécurité
    Réponses: 2
    Dernier message: 10/09/2006, 12h32

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo