/// <summary> /// Duplicate an instance from a process /// </summary> /// <param name="process">The process (with DupHandle access)</param> /// <param name="handle">The handle value to duplicate</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public static NtResult <O> DuplicateFrom(NtProcess process, IntPtr handle, A access, DuplicateObjectOptions options, bool throw_on_error) { return(NtObject.DuplicateHandle(process, new SafeKernelObjectHandle(handle, false), NtProcess.Current, ToGenericAccess(access), AttributeFlags.None, options, throw_on_error).Map(h => FromHandle(h))); }
private DuplicateObjectOptions GetOptions() { DuplicateObjectOptions options = DuplicateObjectOptions.None; if (!DesiredAccess.HasValue && !DesiredAccessMask.HasValue) { options |= DuplicateObjectOptions.SameAccess; } if (!ObjectAttributes.HasValue) { options |= DuplicateObjectOptions.SameAttributes; } if (CloseSource) { options |= DuplicateObjectOptions.CloseSource; } if (NoRightsUpgrade) { options |= DuplicateObjectOptions.NoRightsUpgrade; } return(options); }
/// <summary> /// Duplicate an instance from a process to an other process /// </summary> /// <param name="src_process">The source process (with DupHandle access)</param> /// <param name="handle">The handle value to duplicate</param> /// <param name="dst_process">The destination process (with DupHandle access)</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public static NtResult <IntPtr> DuplicateTo(NtProcess src_process, IntPtr handle, NtProcess dst_process, A access, DuplicateObjectOptions options, bool throw_on_error) { return(NtObject.DuplicateHandle(src_process, handle, dst_process, ToGenericAccess(access), AttributeFlags.None, options, throw_on_error)); }
/// <summary> /// Duplicate an instance from current process to an other process /// </summary> /// <param name="process">The destination process (with DupHandle access)</param> /// <param name="handle">The handle value to duplicate</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public static NtResult <IntPtr> DuplicateTo(NtProcess process, SafeKernelObjectHandle handle, A access, DuplicateObjectOptions options, bool throw_on_error) { return(DuplicateHandle(NtProcess.Current, handle.DangerousGetHandle(), process, ToGenericAccess(access), AttributeFlags.None, options, throw_on_error)); }
/// <summary> /// Duplicate the internal handle to a new handle. /// </summary> /// <param name="src_handle">The source handle to duplicate</param> /// <param name="dest_process">The desination process for the handle</param> /// <param name="options">Duplicate handle options</param> /// <param name="access_rights">The access rights for the new handle</param> /// <returns>The duplicated handle.</returns> internal static SafeKernelObjectHandle DuplicateHandle( SafeKernelObjectHandle src_handle, NtProcess dest_process, AccessMask access_rights, DuplicateObjectOptions options) { return(DuplicateHandle(NtProcess.Current, src_handle, dest_process, access_rights, AttributeFlags.None, options, true).Result); }
public static extern NtStatus NtDuplicateObject( SafeHandle SourceProcessHandle, IntPtr SourceHandle, IntPtr TargetProcessHandle, IntPtr TargetHandle, AccessMask DesiredAccess, AttributeFlags HandleAttributes, DuplicateObjectOptions Options );
public static extern NtStatus NtDuplicateObject( SafeHandle SourceProcessHandle, SafeHandle SourceHandle, SafeHandle TargetProcessHandle, out SafeKernelObjectHandle TargetHandle, GenericAccessRights DesiredAccess, AttributeFlags HandleAttributes, DuplicateObjectOptions Options );
/// <summary> /// Duplicate a handle to a new handle, potentially in a different process. /// </summary> /// <param name="flags">Attribute flags for new handle</param> /// <param name="src_handle">The source handle to duplicate</param> /// <param name="src_process">The source process to duplicate from</param> /// <param name="dest_process">The desination process for the handle</param> /// <param name="options">Duplicate handle options</param> /// <param name="access_rights">The access rights for the new handle</param> /// <returns>The NT status code and object result.</returns> public static IntPtr DuplicateHandle( NtProcess src_process, IntPtr src_handle, NtProcess dest_process, AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options) { return(DuplicateHandle(src_process, src_handle, dest_process, access_rights, flags, options, true).Result); }
/// <summary> /// Duplicate the internal handle to a new handle. /// </summary> /// <param name="flags">Attribute flags for new handle</param> /// <param name="src_handle">The source handle to duplicate</param> /// <param name="src_process">The source process to duplicate from</param> /// <param name="dest_process">The desination process for the handle</param> /// <param name="options">Duplicate handle options</param> /// <param name="access_rights">The access rights for the new handle</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> internal static NtResult <SafeKernelObjectHandle> DuplicateHandle( NtProcess src_process, SafeKernelObjectHandle src_handle, NtProcess dest_process, AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options, bool throw_on_error) { return(DuplicateHandle(src_process, src_handle.DangerousGetHandle(), dest_process, access_rights, flags, options, throw_on_error).Map(h => new SafeKernelObjectHandle(h, true))); }
/// <summary> /// Duplicate a handle to a new handle, potentially in a different process. /// </summary> /// <param name="flags">Attribute flags for new handle</param> /// <param name="src_handle">The source handle to duplicate</param> /// <param name="src_process">The source process to duplicate from</param> /// <param name="dest_process">The desination process for the handle</param> /// <param name="options">Duplicate handle options</param> /// <param name="access_rights">The access rights for the new handle</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public static NtResult <IntPtr> DuplicateHandle( NtProcess src_process, IntPtr src_handle, NtProcess dest_process, AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options, bool throw_on_error) { return(NtSystemCalls.NtDuplicateObject(src_process.Handle, src_handle, dest_process.Handle, out IntPtr external_handle, access_rights, flags, options).CreateResult(throw_on_error, () => external_handle)); }
/// <summary> /// Duplicate the internal handle to a new handle. /// </summary> /// <param name="flags">Attribute flags for new handle</param> /// <param name="src_handle">The source handle to duplicate</param> /// <param name="src_process">The source process to duplicate from</param> /// <param name="dest_process">The desination process for the handle</param> /// <param name="options">Duplicate handle options</param> /// <param name="access_rights">The access rights for the new handle</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> internal static NtResult <SafeKernelObjectHandle> DuplicateHandle( NtProcess src_process, SafeKernelObjectHandle src_handle, NtProcess dest_process, AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options, bool throw_on_error) { SafeKernelObjectHandle new_handle; return(NtSystemCalls.NtDuplicateObject(src_process.Handle, src_handle, dest_process.Handle, out new_handle, access_rights, flags, options).CreateResult(throw_on_error, () => new_handle)); }
/// <summary> /// Duplicate an instance from current process to an other process /// </summary> /// <param name="pid">The destination process ID</param> /// <param name="handle">The handle value to duplicate</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public static NtResult <IntPtr> DuplicateTo(int pid, SafeKernelObjectHandle handle, A access, DuplicateObjectOptions options, bool throw_on_error) { using (var process = NtProcess.Open(pid, ProcessAccessRights.DupHandle, throw_on_error)) { if (!process.IsSuccess) { return(new NtResult <IntPtr>(process.Status, IntPtr.Zero)); } return(DuplicateTo(process.Result, handle, access, options, throw_on_error)); } }
/// <summary> /// Duplicate an instance from a process /// </summary> /// <param name="pid">The process ID</param> /// <param name="handle">The handle value to duplicate</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public static NtResult <O> DuplicateFrom(int pid, IntPtr handle, A access, DuplicateObjectOptions options, bool throw_on_error) { using (var process = NtProcess.Open(pid, ProcessAccessRights.DupHandle, throw_on_error)) { if (!process.IsSuccess) { return(new NtResult <O>(process.Status, default(O))); } return(DuplicateFrom(process.Result, handle, access, options, throw_on_error)); } }
/// <summary> /// Duplicate an instance from a process to an other process /// </summary> /// <param name="src_pid">The source process ID</param> /// <param name="handle">The handle value to duplicate</param> /// <param name="dst_pid">The destination process ID</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public static NtResult <IntPtr> DuplicateTo(int src_pid, IntPtr handle, int dst_pid, A access, DuplicateObjectOptions options, bool throw_on_error) { using (var src_process = NtProcess.Open(src_pid, ProcessAccessRights.DupHandle, throw_on_error)) { if (!src_process.IsSuccess) { return(new NtResult <IntPtr>(src_process.Status, IntPtr.Zero)); } using (var dst_process = NtProcess.Open(dst_pid, ProcessAccessRights.DupHandle, throw_on_error)) { if (!dst_process.IsSuccess) { return(new NtResult <IntPtr>(dst_process.Status, IntPtr.Zero)); } return(DuplicateTo(src_process.Result, handle, dst_process.Result, access, options, throw_on_error)); } } }
/// <summary> /// Duplicate an instance from a process /// </summary> /// <param name="process">The process (with DupHandle access)</param> /// <param name="handle">The handle value to duplicate</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="attributes">The attribute flags for the new object.</param> /// <returns>The NT status code and object result.</returns> public static O DuplicateFrom(NtProcess process, IntPtr handle, A access, AttributeFlags attributes, DuplicateObjectOptions options) { return(DuplicateFrom(process, handle, access, attributes, options, true).Result); }
/// <summary> /// Duplicate object. /// </summary> /// <param name="access_rights">Access rights to duplicate with.</param> /// <param name="flags">Attribute flags.</param> /// <param name="options">Duplicate options</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The duplicated object.</returns> public sealed override NtResult <NtObject> DuplicateObject(AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options, bool throw_on_error) { return(Duplicate(access_rights.ToSpecificAccess <A>(), flags, options, throw_on_error).Cast <NtObject>()); }
/// <summary> /// Duplicate object. /// </summary> /// <param name="access_rights">Access rights to duplicate with.</param> /// <param name="flags">Attribute flags.</param> /// <param name="options">Duplicate options</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The duplicated object.</returns> public abstract NtResult <NtObject> DuplicateObject(AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options, bool throw_on_error);
/// <summary> /// Duplicate an instance from current process to an other process /// </summary> /// <param name="process">The destination process (with DupHandle access)</param> /// <param name="access">The access rights to duplicate with</param> /// <param name="options">The options for duplication.</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The NT status code and object result.</returns> public NtResult <IntPtr> DuplicateTo(NtProcess process, A access, DuplicateObjectOptions options, bool throw_on_error) { return(DuplicateTo(process, Handle, access, options, throw_on_error)); }
static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, IntPtr hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, DuplicateObjectOptions dwOptions);
/// <summary> /// Duplicate the internal handle to a new handle. /// </summary> /// <param name="source_process">The source process for the handle</param> /// <param name="dest_process">The desination process for the handle</param> /// <param name="handle">The handle in the source process to duplicate</param> /// <param name="options">Duplicate handle options</param> /// <param name="access_rights">The access rights for the new handle</param> /// <returns>The new duplicated handle.</returns> public static SafeKernelObjectHandle DuplicateHandle(NtProcess source_process, SafeHandle handle, NtProcess dest_process, GenericAccessRights access_rights, DuplicateObjectOptions options) { SafeKernelObjectHandle new_handle; NtSystemCalls.NtDuplicateObject(source_process.Handle, handle, dest_process.Handle, out new_handle, GenericAccessRights.None, AttributeFlags.None, DuplicateObjectOptions.SameAccess).ToNtException(); return(new_handle); }
/// <summary> /// Duplicate the internal handle to a new handle. /// </summary> /// <param name="dest_process">The desination process for the handle</param> /// <param name="options">Duplicate handle options</param> /// <param name="access_rights">The access rights for the new handle</param> /// <returns>The new duplicated handle.</returns> public SafeKernelObjectHandle DuplicateHandle(NtProcess dest_process, uint access_rights, DuplicateObjectOptions options) { SafeKernelObjectHandle new_handle; NtSystemCalls.NtDuplicateObject(NtProcess.Current.Handle, Handle, dest_process.Handle, out new_handle, (GenericAccessRights)access_rights, AttributeFlags.None, options).ToNtException(); return(new_handle); }
/// <summary> /// Duplicate object. /// </summary> /// <param name="access_rights">Access rights to duplicate with.</param> /// <param name="flags">Attribute flags.</param> /// <param name="options">Duplicate options</param> /// <param name="throw_on_error">True to throw an exception on error.</param> /// <returns>The duplicated object.</returns> public NtResult <O> Duplicate(A access_rights, AttributeFlags flags, DuplicateObjectOptions options, bool throw_on_error) { return(DuplicateHandle(NtProcess.Current, Handle, NtProcess.Current, ToGenericAccess(access_rights), flags, options, throw_on_error).Map(h => ShallowClone(h, true))); }
/// <summary> /// Duplicate object. /// </summary> /// <param name="access_rights">Access rights to duplicate with.</param> /// <param name="flags">Attribute flags.</param> /// <param name="options">Duplicate options</param> /// <returns>The duplicated object.</returns> public O Duplicate(A access_rights, AttributeFlags flags, DuplicateObjectOptions options) { return(Duplicate(access_rights, flags, options, true).Result); }
/// <summary> /// Duplicate object. /// </summary> /// <param name="access_rights">Access rights to duplicate with.</param> /// <param name="flags">Attribute flags.</param> /// <param name="options">Duplicate options</param> /// <returns>The duplicated object.</returns> public NtObject DuplicateObject(AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options) { return(DuplicateObject(access_rights, flags, options, true).Result); }