sspicli.c

 
#include <winpr/config.h>
 
#include <winpr/assert.h>
#include <winpr/sspicli.h>
 
#ifndef _WIN32
 
#include <winpr/crt.h>
 
#ifdef WINPR_HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#if defined(WINPR_HAVE_GETPWUID_R)
#include <sys/types.h>
#endif
 
#include <pthread.h>
 
#include <pwd.h>
#include <grp.h>
 
#include "../handle/handle.h"
 
#include "../security/security.h"
 
static BOOL LogonUserCloseHandle(HANDLE handle);
 
static BOOL LogonUserIsHandled(HANDLE handle)
{
  return WINPR_HANDLE_IS_HANDLED(handle, HANDLE_TYPE_ACCESS_TOKEN, FALSE);
}
 
static int LogonUserGetFd(HANDLE handle)
{
  WINPR_ACCESS_TOKEN* pLogonUser = (WINPR_ACCESS_TOKEN*)handle;
 
  if (!LogonUserIsHandled(handle))
    return -1;
 
  /* TODO: File fd not supported */
  (void)pLogonUser;
  return -1;
}
 
BOOL LogonUserCloseHandle(HANDLE handle)
{
  WINPR_ACCESS_TOKEN* token = (WINPR_ACCESS_TOKEN*)handle;
 
  if (!handle || !LogonUserIsHandled(handle))
    return FALSE;
 
  free(token->Username);
  token->Username = nullptr;
  free(token->Domain);
  token->Domain = nullptr;
  return TRUE;
}
 
static HANDLE_OPS ops = { LogonUserIsHandled,
                        LogonUserCloseHandle,
                        LogonUserGetFd,
                        nullptr, /* CleanupHandle */
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr,
                        nullptr };
 
BOOL LogonUserA(LPCSTR lpszUsername, LPCSTR lpszDomain, WINPR_ATTR_UNUSED LPCSTR lpszPassword,
                WINPR_ATTR_UNUSED DWORD dwLogonType, WINPR_ATTR_UNUSED DWORD dwLogonProvider,
                PHANDLE phToken)
{
  if (!lpszUsername)
    return FALSE;
 
  WINPR_ACCESS_TOKEN* token = (WINPR_ACCESS_TOKEN*)calloc(1, sizeof(WINPR_ACCESS_TOKEN));
 
  if (!token)
    return FALSE;
 
  WINPR_HANDLE_SET_TYPE_AND_MODE(token, HANDLE_TYPE_ACCESS_TOKEN, WINPR_FD_READ);
  token->common.ops = &ops;
  token->Username = _strdup(lpszUsername);
 
  if (!token->Username)
    goto fail;
 
  if (lpszDomain)
  {
    token->Domain = _strdup(lpszDomain);
 
    if (!token->Domain)
      goto fail;
  }
 
  {
    long buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
    if (buflen < 0)
      buflen = 8196;
 
    {
      const size_t s = 1ULL + (size_t)buflen;
      char* buf = (char*)calloc(s, sizeof(char));
      if (!buf)
        goto fail;
 
      {
        struct passwd pwd = WINPR_C_ARRAY_INIT;
        struct passwd* pw = nullptr;
        const int rc = getpwnam_r(lpszUsername, &pwd, buf,
                                  WINPR_ASSERTING_INT_CAST(size_t, buflen), &pw);
        free(buf);
        if ((rc == 0) && pw)
        {
          token->UserId = (DWORD)pw->pw_uid;
          token->GroupId = (DWORD)pw->pw_gid;
        }
 
        *((ULONG_PTR*)phToken) = (ULONG_PTR)token;
        return TRUE;
      }
    }
  }
fail:
  free(token->Username);
  free(token->Domain);
  free(token);
  return FALSE;
}
 
BOOL LogonUserW(WINPR_ATTR_UNUSED LPCWSTR lpszUsername, WINPR_ATTR_UNUSED LPCWSTR lpszDomain,
                WINPR_ATTR_UNUSED LPCWSTR lpszPassword, WINPR_ATTR_UNUSED DWORD dwLogonType,
                WINPR_ATTR_UNUSED DWORD dwLogonProvider, WINPR_ATTR_UNUSED PHANDLE phToken)
{
  WLog_ERR("TODO", "TODO: implement");
  return TRUE;
}
 
BOOL LogonUserExA(WINPR_ATTR_UNUSED LPCSTR lpszUsername, WINPR_ATTR_UNUSED LPCSTR lpszDomain,
                  WINPR_ATTR_UNUSED LPCSTR lpszPassword, WINPR_ATTR_UNUSED DWORD dwLogonType,
                  WINPR_ATTR_UNUSED DWORD dwLogonProvider, WINPR_ATTR_UNUSED PHANDLE phToken,
                  WINPR_ATTR_UNUSED PSID* ppLogonSid, WINPR_ATTR_UNUSED PVOID* ppProfileBuffer,
                  WINPR_ATTR_UNUSED LPDWORD pdwProfileLength,
                  WINPR_ATTR_UNUSED PQUOTA_LIMITS pQuotaLimits)
{
  WLog_ERR("TODO", "TODO: implement");
  return TRUE;
}
 
BOOL LogonUserExW(WINPR_ATTR_UNUSED LPCWSTR lpszUsername, WINPR_ATTR_UNUSED LPCWSTR lpszDomain,
                  WINPR_ATTR_UNUSED LPCWSTR lpszPassword, WINPR_ATTR_UNUSED DWORD dwLogonType,
                  WINPR_ATTR_UNUSED DWORD dwLogonProvider, WINPR_ATTR_UNUSED PHANDLE phToken,
                  WINPR_ATTR_UNUSED PSID* ppLogonSid, WINPR_ATTR_UNUSED PVOID* ppProfileBuffer,
                  WINPR_ATTR_UNUSED LPDWORD pdwProfileLength,
                  WINPR_ATTR_UNUSED PQUOTA_LIMITS pQuotaLimits)
{
  WLog_ERR("TODO", "TODO: implement");
  return TRUE;
}
 
BOOL GetUserNameExA(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
{
  WINPR_ASSERT(lpNameBuffer);
  WINPR_ASSERT(nSize);
 
  switch (NameFormat)
  {
    case NameSamCompatible:
#if defined(WINPR_HAVE_GETPWUID_R)
    {
      int rc = 0;
      struct passwd pwd = WINPR_C_ARRAY_INIT;
      struct passwd* result = nullptr;
      uid_t uid = getuid();
 
      rc = getpwuid_r(uid, &pwd, lpNameBuffer, *nSize, &result);
      if (rc != 0)
        return FALSE;
      if (result == nullptr)
        return FALSE;
    }
#elif defined(WINPR_HAVE_GETLOGIN_R)
      if (getlogin_r(lpNameBuffer, *nSize) != 0)
        return FALSE;
#else
    {
      const char* name = getlogin();
      if (!name)
        return FALSE;
      strncpy(lpNameBuffer, name, strnlen(name, *nSize));
    }
#endif
      {
        const size_t len = strnlen(lpNameBuffer, *nSize);
        if (len > UINT32_MAX)
          return FALSE;
        *nSize = (ULONG)len;
      }
      return TRUE;
 
    case NameFullyQualifiedDN:
    case NameDisplay:
    case NameUniqueId:
    case NameCanonical:
    case NameUserPrincipal:
    case NameCanonicalEx:
    case NameServicePrincipal:
    case NameDnsDomain:
      break;
 
    default:
      break;
  }
 
  return FALSE;
}
 
BOOL GetUserNameExW(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
{
  BOOL rc = FALSE;
  char* name = nullptr;
 
  WINPR_ASSERT(nSize);
  WINPR_ASSERT(lpNameBuffer);
 
  name = calloc(1, *nSize + 1);
  if (!name)
    goto fail;
 
  if (!GetUserNameExA(NameFormat, name, nSize))
    goto fail;
 
  {
    const SSIZE_T res = ConvertUtf8ToWChar(name, lpNameBuffer, *nSize);
    if ((res < 0) || (res >= UINT32_MAX))
      goto fail;
 
    *nSize = (UINT32)res + 1;
  }
  rc = TRUE;
fail:
  free(name);
  return rc;
}
 
#endif