Exemplo n.º 1
0
 internal ObjectDirectoryInformation(NtDirectory root, string base_path, string name, string typename)
 {
     _root      = root;
     Name       = name;
     NtTypeName = typename;
     FullPath   = String.Format(@"{0}\{1}", base_path, Name);
 }
 internal ObjectDirectoryInformation(NtDirectory root, string base_path, string name, string typename)
 {
     _root      = root;
     Name       = name;
     NtTypeName = typename;
     FullPath   = $@"{base_path}\{Name}";
 }
Exemplo n.º 3
0
        /// <summary>
        /// Open an NT object with a specified type.
        /// </summary>
        /// <param name="typename">The name of the type to open (e.g. Event). If null the method will try and lookup the appropriate type.</param>
        /// <param name="path">The path to the object to open.</param>
        /// <param name="root">A root directory to open from.</param>
        /// <param name="access">Generic access rights to the object.</param>
        /// <param name="attributes">Attributes to open the object.</param>
        /// <param name="security_quality_of_service">Security quality of service.</param>
        /// <param name="throw_on_error">True to throw on error.</param>
        /// <returns>The opened object.</returns>
        /// <exception cref="NtException">Thrown if an error occurred opening the object.</exception>
        public static NtResult <NtObject> OpenWithType(string typename, string path, NtObject root,
                                                       AttributeFlags attributes, AccessMask access, SecurityQualityOfService security_quality_of_service, bool throw_on_error)
        {
            using (var obj_attr = new ObjectAttributes(path, attributes, root, security_quality_of_service, null)) {
                if (typename == null)
                {
                    typename = NtDirectory.GetDirectoryEntryType(path, root);
                }

                // Brute force the open.
                if (typename == null)
                {
                    foreach (var nttype in NtType.GetTypes().Where(t => t.CanOpen))
                    {
                        var result = nttype.Open(obj_attr, access, false);
                        if (result.IsSuccess)
                        {
                            return(result);
                        }
                    }

                    return(NtStatus.STATUS_OBJECT_TYPE_MISMATCH.CreateResultFromError <NtObject>(true));
                }

                NtType type = NtType.GetTypeByName(typename, false);
                if (type != null && type.CanOpen)
                {
                    return(type.Open(obj_attr, access, throw_on_error));
                }
                else
                {
                    return(NtStatus.STATUS_OBJECT_TYPE_MISMATCH.CreateResultFromError <NtObject>(true));
                }
            }
        }
Exemplo n.º 4
0
 /// <summary>
 /// Open an NT object with a specified type.
 /// </summary>
 /// <param name="typename">The name of the type to open (e.g. Event). If null the method will try and lookup the appropriate type.</param>
 /// <param name="path">The path to the object to open.</param>
 /// <param name="root">A root directory to open from.</param>
 /// <param name="access">Generic access rights to the object.</param>
 /// <param name="attributes">Attributes to open the object.</param>
 /// <param name="security_quality_of_service">Security quality of service.</param>
 /// <param name="throw_on_error">True to throw on error.</param>
 /// <returns>The opened object.</returns>
 /// <exception cref="NtException">Thrown if an error occurred opening the object.</exception>
 public static NtResult <NtObject> OpenWithType(string typename, string path, NtObject root,
                                                AttributeFlags attributes, AccessMask access, SecurityQualityOfService security_quality_of_service, bool throw_on_error)
 {
     using (var obj_attr = new ObjectAttributes(path, attributes, root, security_quality_of_service, null))
     {
         NtType type = NtType.GetTypeByName(typename ?? NtDirectory.GetDirectoryEntryType(path, root), false);
         return(OpenWithType(type, obj_attr, access, throw_on_error));
     }
 }
        /// <summary>
        /// Create and initialize a Server Silo,
        /// </summary>
        /// <param name="root_dir_flags">Flags for root directory.</param>
        /// <param name="throw_on_error">True to throw on error.</param>
        /// <param name="system_root">Path to the system root.</param>
        /// <param name="delete_event">Event to signal when silo deleted.</param>
        /// <param name="downlevel_container">True if a downlevel container.</param>
        /// <returns>The Job object.</returns>
        public static NtResult <NtJob> CreateServerSilo(SiloObjectRootDirectoryControlFlags root_dir_flags, string system_root, NtEvent delete_event, bool downlevel_container, bool throw_on_error)
        {
            using (var job = CreateSilo(root_dir_flags, throw_on_error))
            {
                if (!job.IsSuccess)
                {
                    return(job);
                }

                NtStatus status = job.Result.SetSiloSystemRoot(system_root, throw_on_error);
                if (!status.IsSuccess())
                {
                    return(status.CreateResultFromError <NtJob>(throw_on_error));
                }

                var silo_dir = job.Result.QuerySiloRootDirectory(throw_on_error);
                if (!silo_dir.IsSuccess)
                {
                    return(silo_dir.Cast <NtJob>());
                }

                string device_path = $@"{silo_dir.Result}\Device";

                using (var device_dir = NtDirectory.Open(@"\Device", null, DirectoryAccessRights.MaximumAllowed, throw_on_error))
                {
                    if (!device_dir.IsSuccess)
                    {
                        return(device_dir.Cast <NtJob>());
                    }
                    using (var obja = new ObjectAttributes(device_path, AttributeFlags.CaseInsensitive | AttributeFlags.Permanent | AttributeFlags.OpenIf))
                    {
                        using (var dir = NtDirectory.Create(obja, DirectoryAccessRights.MaximumAllowed, device_dir.Result, throw_on_error))
                        {
                            if (!dir.IsSuccess)
                            {
                                return(dir.Cast <NtJob>());
                            }
                        }
                    }
                }

                status = job.Result.InitializeServerSilo(delete_event, downlevel_container, throw_on_error);
                if (!status.IsSuccess())
                {
                    return(status.CreateResultFromError <NtJob>(throw_on_error));
                }
                return(job.Result.Duplicate().CreateResult());
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Open an NT object with a specified type.
        /// </summary>
        /// <param name="typename">The name of the type to open (e.g. Event). If null the method will try and lookup the appropriate type.</param>
        /// <param name="path">The path to the object to open.</param>
        /// <param name="root">A root directory to open from.</param>
        /// <param name="access">Generic access rights to the object.</param>
        /// <returns>The opened object.</returns>
        /// <exception cref="NtException">Thrown if an error occurred opening the object.</exception>
        /// <exception cref="ArgumentException">Thrown if type of resource couldn't be found.</exception>
        public static NtObject OpenWithType(string typename, string path, NtObject root, GenericAccessRights access)
        {
            if (typename == null)
            {
                typename = NtDirectory.GetDirectoryEntryType(path, root);
                if (typename == null)
                {
                    throw new ArgumentException(String.Format("Can't find type for path {0}", path));
                }
            }

            switch (typename.ToLower())
            {
            case "device":
                return(NtFile.Open(path, root, (FileAccessRights)access, FileShareMode.None, FileOpenOptions.None));

            case "file":
                return(NtFile.Open(path, root, (FileAccessRights)access, FileShareMode.Read | FileShareMode.Write | FileShareMode.Delete, FileOpenOptions.None));

            case "event":
                return(NtEvent.Open(path, root, (EventAccessRights)access));

            case "directory":
                return(NtDirectory.Open(path, root, (DirectoryAccessRights)access));

            case "symboliclink":
                return(NtSymbolicLink.Open(path, root, (SymbolicLinkAccessRights)access));

            case "mutant":
                return(NtMutant.Open(path, root, (MutantAccessRights)access));

            case "semaphore":
                return(NtSemaphore.Open(path, root, (SemaphoreAccessRights)access));

            case "section":
                return(NtSection.Open(path, root, (SectionAccessRights)access));

            case "job":
                return(NtJob.Open(path, root, (JobAccessRights)access));

            case "key":
                return(NtKey.Open(path, root, (KeyAccessRights)access));

            default:
                throw new ArgumentException(String.Format("Can't open type {0}", typename));
            }
        }
        /// <summary>
        /// Open an NT object with a specified type.
        /// </summary>
        /// <param name="typename">The name of the type to open (e.g. Event). If null the method will try and lookup the appropriate type.</param>
        /// <param name="path">The path to the object to open.</param>
        /// <param name="root">A root directory to open from.</param>
        /// <param name="access">Generic access rights to the object.</param>
        /// <returns>The opened object.</returns>
        /// <exception cref="NtException">Thrown if an error occurred opening the object.</exception>
        /// <exception cref="ArgumentException">Thrown if type of resource couldn't be found.</exception>
        public static NtObject OpenWithType(string typename, string path, NtObject root, AccessMask access)
        {
            if (typename == null)
            {
                typename = NtDirectory.GetDirectoryEntryType(path, root);
                if (typename == null)
                {
                    throw new ArgumentException(String.Format("Can't find type for path {0}", path));
                }
            }

            NtType type = NtType.GetTypeByName(typename, false);

            if (type != null && type.CanOpen)
            {
                return(type.Open(path, root, access));
            }
            else
            {
                throw new ArgumentException(String.Format("Can't open type {0}", typename));
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Get the NT type from a path.
        /// </summary>
        /// <param name="path">The object manager path.</param>
        /// <param name="root">Optional root object.</param>
        /// <returns>The NT type. Returns null if not available or unknown.</returns>
        public static NtType GetTypeFromPath(string path, NtObject root)
        {
            NtType type = root?.NtType;

            // If a file or a key root then that's what the target must end up being.
            switch (type?.Name)
            {
            case "File":
            case "Key":
                return(type);
            }

            string type_name = NtDirectory.GetDirectoryEntryType(path, root);

            if (type_name != null)
            {
                return(GetTypeByName(type_name, true));
            }
            string full_path = path;

            if (root != null)
            {
                string root_path = root.FullPath;
                full_path = $@"{(root_path == @"\" ? string.Empty : root_path)}\{full_path}";
            }
            if (full_path.Equals(@"\REGISTRY", StringComparison.OrdinalIgnoreCase) ||
                full_path.StartsWith(@"\REGISTRY\", StringComparison.OrdinalIgnoreCase))
            {
                return(GetTypeByType <NtKey>());
            }
            if (full_path.StartsWith(@"\??\") ||
                full_path.StartsWith(@"\GLOBAL??\", StringComparison.OrdinalIgnoreCase) ||
                full_path.StartsWith(@"\Device\", StringComparison.OrdinalIgnoreCase))
            {
                return(GetTypeByType <NtFile>());
            }
            return(null);
        }
 internal ObjectDirectoryInformation(NtDirectory root, string base_path, OBJECT_DIRECTORY_INFORMATION info)
     : this(root, base_path, info.Name.ToString(), info.TypeName.ToString())
 {
 }
Exemplo n.º 10
0
 protected override sealed NtResult <NtDirectory> OpenInternal(ObjectAttributes obj_attributes,
                                                               DirectoryAccessRights desired_access, bool throw_on_error)
 {
     return(NtDirectory.Open(obj_attributes, desired_access, throw_on_error));
 }
 public ObjectDirectoryInformation(NtDirectory root, string name, string typename)
 {
     _root    = root;
     Name     = name;
     TypeName = typename;
 }