Una forma confiable de determinar si se heredaron los permisos ntfs

Question

Tengo una pregunta un tanto oscura aquí.

Lo que necesito:Para determinar si se heredaron los permisos (o, estrictamente hablando, una ACE específica de una DACL) de un archivo/carpeta.

Cómo intenté resolver esto:usando enlaces winapi para python (módulo win32security, para ser precisos).Aquí está la versión simplificada, que hace precisamente eso: simplemente toma una ruta a un archivo como argumento e imprime las ACE una por una, indicando qué indicadores están configurados.

#!/usr/bin/env python
from win32security import *
import sys

def decode_flags(flags):
    _flags = {
        SE_DACL_PROTECTED:"SE_DACL_PROTECTED",
        SE_DACL_AUTO_INHERITED:"SE_DACL_AUTO_INHERITED",
        OBJECT_INHERIT_ACE:"OBJECT_INHERIT_ACE",
        CONTAINER_INHERIT_ACE:"CONTAINER_INHERIT_ACE",
        INHERIT_ONLY_ACE:"INHERIT_ONLY_ACE",
        NO_INHERITANCE:"NO_INHERITANCE",
        NO_PROPAGATE_INHERIT_ACE:"NO_PROPAGATE_INHERIT_ACE",
        INHERITED_ACE:"INHERITED_ACE"
    }
    for key in _flags.keys():
        if (flags & key):
            print '\t','\t',_flags[key],"is set!"


def main(argv):
    target = argv[0]
    print target

    security_descriptor = GetFileSecurity(target,DACL_SECURITY_INFORMATION)

    dacl = security_descriptor.GetSecurityDescriptorDacl()

    for ace_index in range(dacl.GetAceCount()):
        (ace_type,ace_flags),access_mask,sid = dacl.GetAce(ace_index)
        name,domain,account_type = LookupAccountSid(None,sid)
        print '\t',domain+'\\'+name,hex(ace_flags)
        decode_flags(ace_flags)


if __name__ == '__main__':
    main(sys.argv[1:])

Bastante simple: obtenga un descriptor de seguridad, obtenga una DACL y luego repita las ACE en la DACL.Lo realmente importante aquí es el indicador de acceso INHERITED_ACE.Debe establecerse cuando se hereda la ACE y no establecerse explícitamente.

Cuando crea una carpeta/archivo, su ACL se completa con ACE de acuerdo con las ACE del objeto principal (carpeta), que están configuradas para propagarse a los secundarios.Sin embargo, a menos que realice algún cambio en la lista de acceso, ¡NO se establecerá el indicador INHERITED_ACE!Pero los permisos heredados están ahí y SÍ funcionan.

Si realiza algún pequeño cambio (por ejemplo, agrega una entrada a la lista de acceso, aplica cambios y la elimina), la bandera aparece mágicamente (¡sin embargo, el comportamiento no cambia de ninguna manera, funcionó antes y funciona después)!Lo que quiero es encontrar la fuente de este comportamiento del indicador INHERITED_ACE y tal vez encontrar otro confiable forma de determinar si la ACE se heredó o no.

Cómo reproducirse:

1. Crear un objeto (archivo o carpeta)
2. Verifique los permisos en el Explorador de Windows, vea que se hayan propagado desde el objeto principal (usando, por ejemplo, la pestaña de seguridad del cuadro de diálogo de propiedades del archivo del Explorador de Windows).
3. Verifique las banderas usando, por ejemplo, el script que estaba usando (INHERITED_ACE NO se configurará en ninguna ACE).
4. Cambiar los permisos de un objeto (aplicar cambios), incluso volver a cambiarlos.
5. Verifique las banderas (INHERITED_ACE voluntad estar ahí)
6. ..mueve la cabeza con incredulidad (lo sé)

Perdón por una publicación un tanto larga, espero que esto tenga al menos un poco de sentido.

Answer 1

no parece

En mi Win XP Home Edition que este código funcione en absoluto: -)

Me sale este seguimiento de la pila:

  

Rastreo (llamada más reciente pasado):
  Archivo "C: \ 1.py", línea 37, en       principal (sys.argv [1:])
  Archivo "C: \ 1.py", línea 29, en el principal       para ace_index en el rango (dacl.GetAceCount ()):

     

AttributeError: objeto 'NoneType' no tiene atributo 'GetAceCount'

Puede usted acaba de tratar de "empujar" la DACL para ser llenado? Es decir, si usted sabe que va a trabajar después de realizar un ligero cambio en ella ... hacer un ligero cambio mediante programación, añadir un trozo de la ECA y retirarla. ¿Puede usted?

Actualizar. Hice un experimento con un programa en C # en mi máquina de trabajo (con Win XP Prof) y debo decir que la forma en .NET de conseguir esta información de seguridad realmente funciona. Por lo tanto, cuando se crea un nuevo archivo, mi programa C # detecta que las ACE fueron heredados, mientras que el código Python no lo hace.

Aquí está el ejemplo del resultado de mis carreras:

  

C:> csharp_tricks.exe 2.txt

     

FullControl -> IsInherited: True

     

FullControl -> IsInherited: True

     

ReadAndExecute, Sincronizar -> IsInherited: True

     

---

     

C:> 1.py 2.txt

     

2.txt

     

BUILTIN \ Administradores 0x0

     

NT AUTORIDAD \ SISTEMA 0x0

     

BUILTIN \ Usuarios 0x0

Mi clase C #:

public class InheritedAce
{
    public static string GetDACLReport(string path)
    {
        StringBuilder result = new StringBuilder();
        FileSecurity fs = new FileSecurity(path, AccessControlSections.Access);
        foreach (var rule in fs.GetAccessRules(true, true, typeof(SecurityIdentifier)).OfType<FileSystemAccessRule>())
        {
            result.AppendFormat("{0}  -->  IsInherited:  {1}", rule.FileSystemRights, rule.IsInherited);
            result.AppendLine();
        }

        return result.ToString();
    }
}

Por lo tanto, parece ser un error en la biblioteca de seguridad pywin32 pitón. Tal vez ellos no están haciendo todo el sistema es necesario llama ...

Answer 2

Puede utilizar el marco .Net

System.Security.AccessControl

Esto cubre ACL y DACL y SACL.

Answer 3

Creo que el cartel original se detalla en el comportamiento de ver

Este grupo de noticias

Tenga en cuenta que los indicadores de control establecidos en el envase pueden cambiar simplemente desmarcando y volver a marcar la casilla de la herencia en la interfaz gráfica de usuario.

nota además que la simple adición de un ACE a la DACL usando las herramientas de Microsoft también va a cambiar los indicadores de control.

nota además de que la GUI, cacls y icacls no se puede confiar en lo que se refiere a la herencia debido a muchos errores sutiles como se discutió en el grupo de noticias.

Parece que la "vieja" de controlar la herencia era utilizar los indicadores de control en el envase en combinación con las banderas de la ECA relacionados con la herencia.

La forma "nueva" no utiliza los indicadores de control en el envase y en su lugar utiliza ACE duplicados; una para controlar el acceso en el objeto y un segundo para controlar lo que se hereda por los objetos secundarios.

Pero, parece que las herramientas existentes de Microsoft (por ejemplo Vista) no pueden trabajar en la forma "nueva", sin embargo, por lo que cuando se realiza un cambio sencillo utilizando las herramientas, se recurre a la vieja manera de utilizar los indicadores de control en el envase .

Si crea una nueva partición en Vista, a continuación, crear una nueva carpeta, y luego mirar las banderas y las ACE, que se verá algo como esto

ControlFlags : 0x8004
Owner : BUILTIN\Administrators
Group : WS1\None
S-1-5-32-544 : BUILTIN\Administrators : 0x0 : 0x0 : 0x1F01FF
S-1-5-32-544 : BUILTIN\Administrators : 0x0 : 0xB : 0x10000000
S-1-5-18 : NT AUTHORITY\SYSTEM : 0x0 : 0x0 : 0x1F01FF
S-1-5-18 : NT AUTHORITY\SYSTEM : 0x0 : 0xB : 0x10000000
S-1-5-11 : NT AUTHORITY\Authenticated Users : 0x0 : 0x0 : 0x1301BF
S-1-5-11 : NT AUTHORITY\Authenticated Users : 0x0 : 0xB : 0xE0010000
S-1-5-32-545 : BUILTIN\Users : 0x0 : 0x0 : 0x1200A9
S-1-5-32-545 : BUILTIN\Users : 0x0 : 0xB : 0xA0000000

Tenga en cuenta las ControlFlags y las ACE duplicadas.