gio/gwin32sid.c

/* GIO - GLib Input, Output and Streaming Library
 *
 * Copyright (C) 2018 Руслан Ижбулатов
 * Copyright (C) 2022 Red Hat, Inc.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Руслан Ижбулатов <lrn1986@gmail.com>
 */

#include "config.h"

#include "gwin32sid.h"
#include "gioerror.h"

#include <sddl.h>

/**
 * _g_win32_sid_replace: (skip)
 * @dest: A pointer to a SID storage
 * @src: Existing SID
 * @error: return location for a #GError, or %NULL
 *
 * Creates a copy of the @src SID and puts that into @dest, after freeing
 * existing SID in @dest (if any).
 *
 * The @src SID must be valid (use IsValidSid() to ensure that).
 *
 * Returns: TRUE on success, FALSE otherwise
 */
static gboolean
_g_win32_sid_replace (SID **dest,
                      SID  *src,
                      GError **error)
{
  DWORD sid_len;
  SID *new_sid;

  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
  g_return_val_if_fail (src != NULL, FALSE);
  g_return_val_if_fail (dest && *dest == NULL, FALSE);

  sid_len = GetLengthSid (src);
  new_sid = g_malloc (sid_len);

  if (!CopySid (sid_len, new_sid, src))
    {
      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (GetLastError ()),
                           "Failed to copy SID");

      g_free (new_sid);
      return FALSE;
    }
  else
    {
      g_free (*dest);
      *dest = g_steal_pointer (&new_sid);

      return TRUE;
    }
}

/**
 * _g_win32_token_get_sid: (skip)
 * @token: A handle of an access token
 * @error: return location for a #GError, or %NULL
 *
 * Gets user SID of the @token and returns a copy of that SID.
 *
 * Returns: A newly-allocated SID, or NULL in case of an error.
 *          Free the returned SID with g_free().
 */
static SID *
_g_win32_token_get_sid (HANDLE token,
                        GError **error)
{
  TOKEN_USER *token_user = NULL;
  DWORD n;
  PSID psid;
  SID *result = NULL;

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  if (!GetTokenInformation (token, TokenUser, NULL, 0, &n)
      && GetLastError () != ERROR_INSUFFICIENT_BUFFER)
    {
      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (GetLastError ()),
                           "Failed to GetTokenInformation");

      return NULL;
    }

  token_user = g_alloca (n);

  if (!GetTokenInformation (token, TokenUser, token_user, n, &n))
    {
      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (GetLastError ()),
                           "Failed to GetTokenInformation");

      return NULL;
    }

  psid = token_user->User.Sid;

  if (!IsValidSid (psid))
    {
      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (GetLastError ()),
                           "Invalid SID token");

      return NULL;
    }

  _g_win32_sid_replace (&result, psid, error);

  return result;
}

/**
 * _g_win32_process_get_access_token_sid: (skip)
 * @process_id: Identifier of a process to get an access token of
 *              (use 0 to get a token of the current process)
 * @error: return location for a #GError, or %NULL
 *
 * Opens the process identified by @process_id and opens its token,
 * then retrieves SID of the token user and returns a copy of that SID.
 *
 * Returns: A newly-allocated SID, or NULL in case of an error.
 *          Free the returned SID with g_free().
 */
SID *
_g_win32_process_get_access_token_sid (DWORD process_id,
                                       GError **error)
{
  HANDLE process_handle;
  HANDLE process_token;
  SID *result = NULL;

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  if (process_id == 0)
    process_handle = GetCurrentProcess ();
  else
    process_handle = OpenProcess (PROCESS_QUERY_LIMITED_INFORMATION, FALSE, process_id);

  if (process_handle == NULL)
    {
      g_set_error (error, G_IO_ERROR, g_io_error_from_errno (GetLastError ()),
                   "%s failed", process_id == 0 ? "GetCurrentProcess" : "OpenProcess");

      return NULL;
    }

  if (!OpenProcessToken (process_handle, TOKEN_QUERY, &process_token))
    {
      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (GetLastError ()),
                           "OpenProcessToken failed");

      CloseHandle (process_handle);
      return NULL;
    }

  result = _g_win32_token_get_sid (process_token, error);

  CloseHandle (process_token);
  CloseHandle (process_handle);

  return result;
}

/**
 * _g_win32_sid_to_string: (skip)
 * @sid: a SID.
 * @error: return location for a #GError, or %NULL
 *
 * Convert a SID to its string form.
 *
 * Returns: A newly-allocated string, or NULL in case of an error.
 */
gchar *
_g_win32_sid_to_string (SID *sid, GError **error)
{
  wchar_t *tmp = NULL;
  char *ret;

  g_return_val_if_fail (sid != NULL, NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  if (!ConvertSidToStringSid (sid, &tmp))
    {
      g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (GetLastError ()),
                           "Failed to ConvertSidToString");
      return NULL;
    }

  ret = g_utf16_to_utf8 (tmp, -1, NULL, NULL, NULL);
  LocalFree (tmp);
  return ret;
}

/**
 * _g_win32_current_process_sid_string: (skip)
 * @error: return location for a #GError, or %NULL
 *
 * Get the current process SID, as a string.
 *
 * Returns: A newly-allocated string, or NULL in case of an error.
 */
gchar *
_g_win32_current_process_sid_string (GError **error)
{
  SID *sid;
  gchar *ret;

  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  sid = _g_win32_process_get_access_token_sid (0, error);
  if (!sid)
    return NULL;

  ret = _g_win32_sid_to_string (sid, error);
  g_free (sid);
  return ret;
}