nucleus/library/security/nt_security.cpp

   1
   2
   3
   4 /*****************************************************************************\
   5 *                                                                             *
   6 *  Name   : nt_security                                                       *
   7 *  Author : Sue Richeson                                                      *
   8 *  Author : Chris Koeritz                                                     *
   9 *                                                                             *
  10 *******************************************************************************
  11 * Copyright (c) 1999-$now By Author.  This program is free software; you can  *
  12 * redistribute it and/or modify it under the terms of the GNU General Public  *
  13 * License as published by the Free Software Foundation; either version 2 of   *
  14 * the License or (at your option) any later version.  This is online at:      *
  15 *     http://www.fsf.org/copyleft/gpl.html                                    *
  16 * Please send any updates to: fred@gruntose.com                               *
  17 \*****************************************************************************/
  18
  19 #ifdef __WIN32__
  20
  21 #include "nt_security.h"
  22 #include "win32_security.h"
  23
  24 #include <basis/astring.h>
  25
  26 #include <lm.h>
  27
  28 // LSA success status value.
  29 #ifndef STATUS_SUCCESS
  30   #define STATUS_SUCCESS  ((NTSTATUS)0x00000000L)
  31 #endif
  32
  33 nt_security::nt_security()
  34 : m_sDirServiceProvider(NULL_POINTER)
  35 {
  36   // Eventually, construction of nt_security should determine if WinNT://
  37   // or LDAP://, etc is the service provider and set a private member variable
  38   // with the appropriate distinguished name qualifier.
  39   m_sDirServiceProvider = new astring("WinNT://");
  40 }
  41 //---------------------------------------------------------------------------
  42
  43
  44 nt_security::~nt_security()
  45 {
  46   if (m_sDirServiceProvider)
  47     delete m_sDirServiceProvider;
  48 }
  49
  50
  51 //---------------------------------------------------------------------------
  52
  53 bool nt_security::iequalsUsername(astring name1, astring name2)
  54 {
  55     return normalizeUsername(name1) == normalizeUsername(name2);
  56 }
  57
  58 const astring &nt_security::normalizeUsername(astring &username)
  59 {
  60     username.replace_all('/', '\\');
  61     username.replace_all('|', ':');
  62     username.to_lower();
  63     return username;
  64 }
  65
  66   //---------------------------------------------------------------------------
  67
  68 astring nt_security::DomainBinding(const astring &domain)
  69 {
  70   astring tempstring = *m_sDirServiceProvider + domain;
  71   return (tempstring);
  72 }
  73 //---------------------------------------------------------------------------
  74
  75
  76 astring nt_security::DomainUserBinding(const astring &domain, const astring &user_name)
  77 {
  78   astring tempstring = *m_sDirServiceProvider + domain + astring("/") + user_name;
  79   return (tempstring);
  80 }
  81 //---------------------------------------------------------------------------
  82
  83 // This piece of code is borrowed from the following July 1999 MSDN article
  84 //     HOWTO: Look Up Current User Name and Domain Name
  85 //     ID: Q155698
  86 //NOTE: It has been modified for inclusion in this class and it is NT-specific.
  87
  88 bool nt_security::GetUserAndDomainName(astring &UserName, astring &DomainName)
  89 {
  90   return win32_security::GetUserAndDomainName(UserName, DomainName);
  91 }
  92
  93
  94 //---------------------------------------------------------------------------
  95 // The following routines were taken from the lsapriv sample application by
  96 // Scott Field on the MSDN January 2001.
  97 //---------------------------------------------------------------------------
  98
  99 /*---------------------------------------------------------------------------
 100 This function attempts to obtain a SID representing the supplied
 101 account on the supplied system.
 102
 103 If the function succeeds, the return value is the SID. A buffer is
 104 allocated which contains the SID representing the supplied account.
 105 This buffer should be freed when it is no longer needed by calling
 106 HeapFree(GetProcessHeap(), 0, buffer)
 107
 108 If the function fails, the return SID is NULL.
 109
 110 Scott Field (sfield)    12-Jul-95
 111 Sue Richeson   27-FEB-2001  Mods for use in LightLink.
 112 Chris Koeritz  02-JAN-2008  changed some more for use within hoople.
 113 ---------------------------------------------------------------------------*/
 114
 115 PSID nt_security::GetUserSID(const astring &user_name)
 116 {
 117     PSID psid = NULL;
 118     char * ReferencedDomain = NULL;
 119     DWORD cbSid = 128;    // initial allocation attempt
 120     DWORD cchReferencedDomain = 16; // initial allocation size
 121     SID_NAME_USE peUse;
 122     bool bSuccess = false;
 123
 124     try
 125     {   //
 126         // initial memory allocations
 127         //
 128         psid = (PSID)HeapAlloc(GetProcessHeap(), 0, cbSid);
 129         if (psid != NULL)
 130         {
 131             ReferencedDomain = (char *)HeapAlloc(GetProcessHeap(), 0, cchReferencedDomain * sizeof(TCHAR));
 132             if (ReferencedDomain != NULL)
 133             {
 134                 // Obtain the SID of the specified account on the specified system.
 135                 //
 136                 bSuccess = true;
 137                 while (!LookupAccountName(NULL, // machine to lookup account on
 138                     to_unicode_temp(user_name),  // account to lookup
 139                     psid,               // SID of interest
 140                     &cbSid,             // size of SID
 141                     to_unicode_temp(ReferencedDomain),  // domain where found.
 142                     &cchReferencedDomain,
 143                     &peUse))
 144                 {
 145                     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 146                     {
 147                         // reallocate memory
 148                         //
 149                         psid = (PSID)HeapReAlloc(GetProcessHeap(), 0, psid, cbSid);
 150                         if(psid != NULL)
 151                         {
 152                             ReferencedDomain = (char *)HeapReAlloc(GetProcessHeap(), 0,
 153                                                                    ReferencedDomain,
 154                                                                    cchReferencedDomain * sizeof(TCHAR));
 155                             if (ReferencedDomain == NULL)
 156                             {
 157                                 break;
 158                                 bSuccess = false;
 159                             }
 160                         }
 161                         else
 162                         {
 163                             break;
 164                             bSuccess = false;
 165                         }
 166                     }
 167                     else
 168                     {
 169                         break;
 170                         bSuccess = false;
 171                     }
 172                 } // end while
 173             } // if ReferencedDomain
 174         } // if psid
 175     }
 176     catch(...)
 177     {
 178         bSuccess = false;
 179     }
 180
 181     // Cleanup and indicate failure, if appropriate.
 182     //
 183     if (ReferencedDomain != NULL)
 184         HeapFree(GetProcessHeap(), 0, ReferencedDomain);
 185
 186     if (!bSuccess)
 187     {
 188         if (psid != NULL)
 189         {
 190             HeapFree(GetProcessHeap(), 0, psid);
 191             psid = NULL;
 192         }
 193     }
 194
 195     return psid;
 196 }
 197 //---------------------------------------------------------------------------
 198
 199
 200 DWORD nt_security::OpenPolicy(const astring &serverName, DWORD DesiredAccess, PLSA_HANDLE pPolicyHandle)
 201 {
 202     LSA_OBJECT_ATTRIBUTES ObjectAttributes;
 203     NTSTATUS Status;
 204     DWORD winerror = 0;
 205
 206     // Always initialize the object attributes to all zeroes.
 207     //
 208     ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
 209
 210     transcode_to_utf16 temp_server(serverName);
 211     LSA_UNICODE_STRING server;
 212     server.Buffer = (PWSTR)(UTF16 *)temp_server;
 213     server.Length = serverName.length() * (int)sizeof(UTF16);
 214     server.MaximumLength = (serverName.length() +1) * (int)sizeof(UTF16);
 215
 216     // Attempt to open the policy.
 217     Status = LsaOpenPolicy(&server, &ObjectAttributes, DesiredAccess, pPolicyHandle);
 218     if (STATUS_SUCCESS != Status)
 219     {
 220         winerror = LsaNtStatusToWinError(Status);
 221         ClosePolicy(pPolicyHandle);
 222         return winerror;
 223     }
 224     else
 225         return winerror;
 226 }
 227 //---------------------------------------------------------------------------
 228
 229
 230 void nt_security::ClosePolicy(PLSA_HANDLE policyHandle)
 231 {
 232     if (policyHandle != NULL)
 233         LsaClose(policyHandle);
 234 }
 235 //---------------------------------------------------------------------------
 236
 237
 238 /*
 239 void nt_security::InitLsaString(LPWSTR inString, PLSA_UNICODE_STRING LsaString)
 240 {
 241     DWORD StringLength;
 242
 243     if (inString == NULL)
 244     {
 245         LsaString->Buffer = NULL;
 246         LsaString->Length = 0;
 247         LsaString->MaximumLength = 0;
 248         return;
 249     }
 250
 251     StringLength = wcslen(inString);
 252     LsaString->Buffer = inString;
 253     LsaString->Length = (USHORT) StringLength * sizeof(WCHAR);
 254     LsaString->MaximumLength=(USHORT)(StringLength+1) * sizeof(WCHAR);
 255 }
 256 */
 257 //---------------------------------------------------------------------------
 258
 259
 260 DWORD nt_security::SetPrivilegeOnAccount(LSA_HANDLE PolicyHandle,       // open policy handle
 261                                             PSID AccountSid,               // SID to grant privilege to
 262                                             const astring &PrivilegeName,  // privilege to grant (Unicode)
 263                                             bool bEnable)                  // enable or disable
 264 {
 265     NTSTATUS Status;
 266     DWORD winerror = 0;
 267
 268     // Create a LSA_UNICODE_STRING for the privilege name.
 269     //
 270     transcode_to_utf16 temp_priv(PrivilegeName);
 271     LSA_UNICODE_STRING privs;
 272     privs.Buffer = (PWSTR)(UTF16 *)temp_priv;
 273     privs.Length = PrivilegeName.length() * (int)sizeof(UTF16);
 274     privs.MaximumLength = (PrivilegeName.length() +1) * (int)sizeof(UTF16);
 275
 276     // grant or revoke the privilege, accordingly
 277     //
 278     if (bEnable)
 279     {
 280         Status = LsaAddAccountRights(PolicyHandle,       // open policy handle
 281                                      AccountSid,         // target SID
 282                                      &privs,   // privileges
 283                                      1);                 // privilege count
 284     }
 285     else
 286     {
 287         Status = LsaRemoveAccountRights(PolicyHandle,       // open policy handle
 288                                         AccountSid,         // target SID
 289                                         FALSE,              // do not disable all rights
 290                                         &privs,   // privileges
 291                                         1);                 // privilege count
 292     }
 293
 294     if (Status == STATUS_SUCCESS)
 295         return winerror;
 296     else
 297     {
 298         winerror = LsaNtStatusToWinError(Status);
 299         return winerror;
 300     }
 301 }
 302 //---------------------------------------------------------------------------
 303
 304
 305 DWORD nt_security::SetPrivilegeOnUser(const astring &domain,
 306                                          const astring &user,
 307                                          const astring &privilege,
 308                                          bool bEnable)
 309 {
 310     LSA_HANDLE policyHandle;
 311     PSID psid = NULL;
 312     DWORD winerror = 0;
 313
 314     // Open the policy on the target machine.
 315     //
 316     winerror = OpenPolicy(domain, (POLICY_CREATE_ACCOUNT | POLICY_LOOKUP_NAMES), &policyHandle);
 317     if (winerror != 0)
 318         return winerror;
 319
 320     // Obtain the SID of the user/group.
 321     // Note that we could target a specific machine, but we don't.
 322     // Specifying NULL for target machine searches for the SID in the
 323     // following order: well-known, Built-in and local, primary domain,
 324     // trusted domains.
 325     //
 326     psid = GetUserSID(user);
 327     if (psid == NULL)
 328     {
 329         ClosePolicy(&policyHandle);
 330         return ERROR_NO_SUCH_USER;
 331     }
 332
 333     // Grant the SeServiceLogonRight to users represented by psid.
 334     //
 335     winerror = SetPrivilegeOnAccount(policyHandle, psid, privilege, bEnable);
 336
 337     // Close the policy handle.
 338     //
 339     ClosePolicy(&policyHandle);
 340
 341     //
 342     // Free memory allocated for SID.
 343     //
 344     if (psid != NULL)
 345         HeapFree(GetProcessHeap(), 0, psid);
 346
 347     return winerror;
 348 }
 349
 350 DWORD nt_security::AddUserToGroup(const astring &user_name, const astring &group_name)
 351 {
 352    LOCALGROUP_MEMBERS_INFO_3 lgmi3;
 353    DWORD dwLevel = 3;
 354    DWORD totalEntries = 1;
 355    NET_API_STATUS nStatus;
 356
 357 // fwprintf(stderr, L"Usage: %s ServerName GroupName MemberAccountName-(DomainName\\AccountName)\n", argv[0]);
 358
 359    // Set up the LOCALGROUP_MEMBERS_INFO_3 structure.
 360    // Assign the member account name in form of DomainName\AccountName
 361    transcode_to_utf16 temp_user(user_name);
 362    lgmi3.lgrmi3_domainandname = (LPWSTR)(UTF16 *)temp_user;
 363
 364    // Call the NetLocalGroupAddMembers() function, specifying level 3.
 365    // Level 0 can use SID
 366    transcode_to_utf16 temp_group(group_name);
 367    nStatus = NetLocalGroupAddMembers(L"", (LPWSTR)(UTF16 *)temp_group, dwLevel,
 368        (LPBYTE)&lgmi3, totalEntries);
 369
 370 //printf("got error code %d\n" , nStatus);
 371
 372    if (nStatus == ERROR_MEMBER_IN_ALIAS) nStatus = 0;  // not an error.
 373
 374    return nStatus;
 375 }
 376
 377 #endif  //win32
 378
 379
 380