Added some more non-throwing apis.

Author: James Forshaw

NtApiDotNet/NtThread.cs

@@ -42,7 +42,12 @@ private static NtResult<NtThread> Open(NtThreadInformation thread_info, ThreadAc
 
         private ThreadBasicInformation QueryBasicInformation()
         {
-            return Query<ThreadBasicInformation>(ThreadInformationClass.ThreadBasicInformation);
+            return QueryBasicInformation(true).Result;
+        }
+
+        private NtResult<ThreadBasicInformation> QueryBasicInformation(bool throw_on_error)
+        {
+            return Query(ThreadInformationClass.ThreadBasicInformation, new ThreadBasicInformation(), throw_on_error);
         }
 
         private NtResult<IContext> GetX86Context(ContextFlags flags, bool throw_on_error)
@@ -823,6 +828,30 @@ public ThreadAlpcServerInformation GetAlpcServerInformation()
             return GetAlpcServerInformation(true).Result;
         }
 
+        /// <summary>
+        /// Get the process ID associated with the thread.
+        /// </summary>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The process ID.</returns>
+        public NtResult<int> GetProcessId(bool throw_on_error)
+        {
+            if (_pid.HasValue)
+                return _pid.Value.CreateResult();
+            return QueryBasicInformation(throw_on_error).Map(i => i.ClientId.UniqueProcess.ToInt32());
+        }
+
+        /// <summary>
+        /// Get the thread ID.
+        /// </summary>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The thread ID.</returns>
+        public NtResult<int> GeThreadId(bool throw_on_error)
+        {
+            if (_tid.HasValue)
+                return _tid.Value.CreateResult();
+            return QueryBasicInformation(throw_on_error).Map(i => i.ClientId.UniqueProcess.ToInt32());
+        }
+
         /// <summary>
         /// Method to query information for this object type.
         /// </summary>

NtApiDotNet/NtToken.cs

@@ -172,13 +172,24 @@ public NtToken DuplicateToken(TokenType type, SecurityImpersonationLevel level,
         }
 
         /// <summary>
-        /// Duplicate the token as a primary token
+        /// Duplicate the token as the same token type.
         /// </summary>
-        /// <returns>The new token</returns>
+        /// <returns>The new token.</returns>
         /// <exception cref="NtException">Thrown on error</exception>
         public NtToken DuplicateToken()
         {
-            return DuplicateToken(TokenType.Primary, SecurityImpersonationLevel.Anonymous, TokenAccessRights.MaximumAllowed);
+            return DuplicateToken(true).Result;
+        }
+
+        /// <summary>
+        /// Duplicate the token as the same token type.
+        /// </summary>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The new token.</returns>
+        /// <exception cref="NtException">Thrown on error</exception>
+        public NtResult<NtToken> DuplicateToken(bool throw_on_error)
+        {
+            return DuplicateToken(TokenType, ImpersonationLevel, TokenAccessRights.MaximumAllowed, throw_on_error);
         }
 
         /// <summary>
@@ -887,6 +898,21 @@ public UserGroup[] QueryGroups(QueryGroupType group_type)
             return QueryGroups(group_type, true).Result;
         }
 
+        /// <summary>
+        /// Get the user from the token.
+        /// </summary>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The user group information.</returns>
+        public NtResult<UserGroup> GetUser(bool throw_on_error)
+        {
+            using (var user = QueryBuffer(TokenInformationClass.TokenUser, new TokenUser(), throw_on_error))
+            {
+                if (!user.IsSuccess)
+                    return user.Cast<UserGroup>();
+                return user.Result.Result.User.ToUserGroup().CreateResult();
+            }
+        }
+
         /// <summary>
         /// Method to query information for this object type.
         /// </summary>
@@ -1854,15 +1880,27 @@ public static NtToken OpenProcessToken(NtProcess process, bool duplicate)
         /// <exception cref="NtException">Thrown if cannot open token</exception>
         public static NtToken OpenProcessToken(NtProcess process, bool duplicate, TokenAccessRights desired_access)
         {
-            var ret = OpenProcessToken(process, desired_access, true).Result;
-            if (duplicate)
+            return OpenProcessToken(process, duplicate, desired_access, true).Result;
+        }
+
+        /// <summary>
+        /// Open the process token of another process
+        /// </summary>
+        /// <param name="process">The process to open the token for</param>
+        /// <param name="duplicate">True to duplicate the token before returning</param>
+        /// <param name="desired_access">The desired access for the token</param>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The opened token</returns>
+        /// <exception cref="NtException">Thrown if cannot open token</exception>
+        public static NtResult<NtToken> OpenProcessToken(NtProcess process, bool duplicate, TokenAccessRights desired_access, bool throw_on_error)
+        {
+            var ret = OpenProcessToken(process, desired_access, throw_on_error);
+            if (!ret.IsSuccess || !duplicate)
+                return ret;
+            using (ret)
             {
-                using (ret)
-                {
-                    return ret.DuplicateToken();
-                }
+                return ret.Result.DuplicateToken(throw_on_error);
             }
-            return ret;
         }
 
         /// <summary>
@@ -1937,6 +1975,25 @@ public static NtToken OpenProcessToken(int pid, bool duplicate, TokenAccessRight
             }
         }
 
+        /// <summary>
+        /// Open the process token of another process
+        /// </summary>
+        /// <param name="pid">The id of the process to open the token for</param>
+        /// <param name="duplicate">True to duplicate the token before returning</param>
+        /// <param name="desired_access">The desired access for the token</param>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The opened token</returns>
+        /// <exception cref="NtException">Thrown if cannot open token</exception>
+        public static NtResult<NtToken> OpenProcessToken(int pid, bool duplicate, TokenAccessRights desired_access, bool throw_on_error)
+        {
+            using (var process = NtProcess.Open(pid, ProcessAccessRights.QueryLimitedInformation, throw_on_error))
+            {
+                if (!process.IsSuccess)
+                    return process.Cast<NtToken>();
+                return OpenProcessToken(process.Result, duplicate, desired_access, throw_on_error);
+            }
+        }
+
         /// <summary>
         /// Open the process token of another process
         /// </summary>
@@ -1968,24 +2025,37 @@ public static NtResult<NtToken> OpenThreadToken(NtThread thread, bool open_as_se
         /// </summary>
         /// <param name="thread">The thread to open the token for</param>
         /// <param name="open_as_self">Open the token as the current identify rather than the impersonated one</param>
-        /// <param name="duplicate">True to duplicate the token before returning</param>
+        /// <param name="duplicate">True to duplicate the token before returning.</param>
         /// <param name="desired_access">The desired access for the token</param>
+        /// <param name="throw_on_error">True to throw on error.</param>
         /// <returns>The opened token, if no token return null</returns>
         /// <exception cref="NtException">Thrown if cannot open token</exception>
-        public static NtToken OpenThreadToken(NtThread thread, bool open_as_self, bool duplicate, TokenAccessRights desired_access)
+        public static NtResult<NtToken> OpenThreadToken(NtThread thread, bool open_as_self, 
+            bool duplicate, TokenAccessRights desired_access, bool throw_on_error)
         {
             var result = OpenThreadToken(thread, open_as_self, desired_access, false);
             if (result.Status == NtStatus.STATUS_NO_TOKEN)
-                return null;
-            NtToken ret = result.GetResultOrThrow();
-            if (duplicate)
+                return new NtResult<NtToken>();
+            if (!duplicate)
+                return result;
+            using (result)
             {
-                using (ret)
-                {
-                    return ret.DuplicateToken();
-                }
+                return result.Result.DuplicateToken(throw_on_error);
             }
-            return ret;
+        }
+
+        /// <summary>
+        /// Open the thread token
+        /// </summary>
+        /// <param name="thread">The thread to open the token for</param>
+        /// <param name="open_as_self">Open the token as the current identify rather than the impersonated one</param>
+        /// <param name="duplicate">True to duplicate the token before returning</param>
+        /// <param name="desired_access">The desired access for the token</param>
+        /// <returns>The opened token, if no token return null</returns>
+        /// <exception cref="NtException">Thrown if cannot open token</exception>
+        public static NtToken OpenThreadToken(NtThread thread, bool open_as_self, bool duplicate, TokenAccessRights desired_access)
+        {
+            return OpenThreadToken(thread, open_as_self, duplicate, desired_access, true).Result;
         }
 
         /// <summary>
@@ -2050,6 +2120,27 @@ public static NtToken OpenThreadToken()
             return OpenThreadToken(false);
         }
 
+        /// <summary>
+        /// Open the effective token, thread if available or process
+        /// </summary>
+        /// <param name="thread">The thread to open the token for</param>
+        /// <param name="duplicate">True to duplicate the token before returning</param>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The opened token</returns>
+        /// <exception cref="NtException">Thrown if cannot open token</exception>
+        public static NtResult<NtToken> OpenEffectiveToken(NtThread thread, bool duplicate, bool throw_on_error)
+        {
+            var token = OpenThreadToken(thread, true, duplicate, TokenAccessRights.MaximumAllowed, throw_on_error);
+            if (!token.IsSuccess || token.Result != null)
+                return token;
+
+            var pid = thread.GetProcessId(throw_on_error);
+            if (!pid.IsSuccess)
+                return pid.Cast<NtToken>();
+
+            return OpenProcessToken(pid.Result, duplicate, TokenAccessRights.MaximumAllowed, throw_on_error);
+        }
+
         /// <summary>
         /// Open the effective token, thread if available or process
         /// </summary>
@@ -2078,7 +2169,18 @@ public static NtToken OpenEffectiveToken(NtThread thread, bool duplicate)
         /// <exception cref="NtException">Thrown if cannot open token</exception>
         public static NtToken OpenEffectiveToken()
         {
-            return OpenEffectiveToken(NtThread.Current, false);
+            return OpenEffectiveToken(true).Result;
+        }
+
+        /// <summary>
+        /// Open the current effective token, thread if available or process
+        /// </summary>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The opened token</returns>
+        /// <exception cref="NtException">Thrown if cannot open token</exception>
+        public static NtResult<NtToken> OpenEffectiveToken(bool throw_on_error)
+        {
+            return OpenEffectiveToken(NtThread.Current, false, throw_on_error);
         }
 
         /// <summary>
@@ -2227,6 +2329,23 @@ public static ThreadImpersonationContext Impersonate(int pid, SecurityImpersonat
             }
         }
 
+        /// <summary>
+        /// Get the current user.
+        /// </summary>
+        /// <param name="throw_on_error">True to throw on error.</param>
+        /// <returns>The current user.</returns>
+        public static NtResult<UserGroup> GetCurrentUser(bool throw_on_error)
+        {
+            using (var token = OpenEffectiveToken(throw_on_error))
+            {
+                if (!token.IsSuccess)
+                {
+                    return token.Cast<UserGroup>();
+                }
+                return token.Result.GetUser(throw_on_error);
+            }
+        }
+
         #endregion
 
         #region Static Properties