mono/metadata/mono-security.c

   1 /*
   2  * security.c:  Security internal calls
   3  *
   4  * Author:
   5  *      Sebastien Pouliot  <sebastien@ximian.com>
   6  *
   7  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
   8  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   9  */
  10
  11 #ifdef HAVE_CONFIG_H
  12 #include <config.h>
  13 #endif
  14
  15 #include <mono/metadata/assembly.h>
  16 #include <mono/metadata/appdomain.h>
  17 #include <mono/metadata/image.h>
  18 #include <mono/metadata/exception.h>
  19 #include <mono/metadata/object-internals.h>
  20 #include <mono/metadata/metadata-internals.h>
  21 #include <mono/metadata/security.h>
  22 #include <mono/io-layer/io-layer.h>
  23 #include <mono/utils/strenc.h>
  24
  25 #ifdef HOST_WIN32
  26
  27 #include <aclapi.h>
  28 #include <accctrl.h>
  29
  30 #ifndef PROTECTED_DACL_SECURITY_INFORMATION
  31 #define PROTECTED_DACL_SECURITY_INFORMATION     0x80000000L
  32 #endif
  33
  34 #else
  35
  36 #include <config.h>
  37 #ifdef HAVE_GRP_H
  38 #include <grp.h>
  39 #endif
  40 #ifdef HAVE_PWD_H
  41 #include <pwd.h>
  42 #endif
  43 #include <string.h>
  44 #include <sys/stat.h>
  45 #include <sys/types.h>
  46 #include <unistd.h>
  47
  48 /* Disclaimers */
  49
  50 #if defined(__GNUC__)
  51
  52 #ifndef HAVE_GETGRGID_R
  53         #warning Non-thread safe getgrgid being used!
  54 #endif
  55 #ifndef HAVE_GETGRNAM_R
  56         #warning Non-thread safe getgrnam being used!
  57 #endif
  58 #ifndef HAVE_GETPWNAM_R
  59         #warning Non-thread safe getpwnam being used!
  60 #endif
  61 #ifndef HAVE_GETPWUID_R
  62         #warning Non-thread safe getpwuid being used!
  63 #endif
  64
  65 #endif /* defined(__GNUC__) */
  66
  67 #endif /* not HOST_WIN32 */
  68
  69
  70 /* internal functions - reuse driven */
  71
  72 #ifdef HOST_WIN32
  73
  74 /* ask a server to translate a SID into a textual representation */
  75 static gunichar2*
  76 GetSidName (gunichar2 *server, PSID sid, gint32 *size)
  77 {
  78         gunichar2 *uniname = NULL;
  79         DWORD cchName = 0;
  80         DWORD cchDomain = 0;
  81         SID_NAME_USE peUse; /* out */
  82
  83         LookupAccountSid (server, sid, NULL, &cchName, NULL,
  84                 &cchDomain, &peUse);
  85
  86         if ((cchName > 0) && (cchDomain > 0)) {
  87                 gunichar2 *user = g_malloc0 ((cchName + 1) * 2);
  88                 gunichar2 *domain = g_malloc0 ((cchDomain + 1) * 2);
  89
  90                 LookupAccountSid (server, sid, user, &cchName, domain,
  91                         &cchDomain, &peUse);
  92
  93                 if (cchName > 0) {
  94                         if (cchDomain > 0) {
  95                                 /* domain/machine name included (+ sepearator) */
  96                                 *size = cchName + cchDomain + 1;
  97                                 uniname = g_malloc0 ((*size + 1) * 2);
  98                                 memcpy (uniname, domain, cchDomain * 2);
  99                                 *(uniname + cchDomain) = '\\';
 100                                 memcpy (uniname + cchDomain + 1, user, cchName * 2);
 101                                 g_free (user);
 102                         }
 103                         else {
 104                                 /* no domain / machine */
 105                                 *size = cchName;
 106                                 uniname = user;
 107                         }
 108                 }
 109                 else {
 110                         /* nothing -> return NULL */
 111                         g_free (user);
 112                 }
 113
 114                 g_free (domain);
 115         }
 116
 117         return uniname;
 118 }
 119
 120
 121 #else /* not HOST_WIN32 */
 122
 123 #define MONO_SYSCONF_DEFAULT_SIZE       ((size_t) 1024)
 124
 125 /*
 126  * Ensure we always get a valid (usable) value from sysconf.
 127  * In case of error, we return the default value.
 128  */
 129 static size_t mono_sysconf (int name)
 130 {
 131         size_t size = (size_t) sysconf (name);
 132         /* default value */
 133         return (size == -1) ? MONO_SYSCONF_DEFAULT_SIZE : size;
 134 }
 135
 136
 137 static gchar*
 138 GetTokenName (uid_t uid)
 139 {
 140         gchar *uname = NULL;
 141
 142 #ifdef HAVE_GETPWUID_R
 143         struct passwd pwd;
 144         size_t fbufsize;
 145         gchar *fbuf;
 146         gint32 retval;
 147 #endif
 148         struct passwd *p = NULL;
 149         gboolean result;
 150
 151 #ifdef HAVE_GETPWUID_R
 152 #ifdef _SC_GETPW_R_SIZE_MAX
 153         fbufsize = mono_sysconf (_SC_GETPW_R_SIZE_MAX);
 154 #else
 155         fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
 156 #endif
 157         fbuf = (gchar *)g_malloc0 (fbufsize);
 158         retval = getpwuid_r (uid, &pwd, fbuf, fbufsize, &p);
 159         result = ((retval == 0) && (p == &pwd));
 160 #else
 161         /* default to non thread-safe but posix compliant function */
 162         p = getpwuid (uid);
 163         result = (p != NULL);
 164 #endif
 165
 166         if (result) {
 167                 uname = g_strdup (p->pw_name);
 168         }
 169
 170 #ifdef HAVE_GETPWUID_R
 171         g_free (fbuf);
 172 #endif
 173
 174         return uname;
 175 }
 176
 177
 178 static gboolean
 179 IsMemberInList (uid_t user, struct group *g)
 180 {
 181         gboolean result = FALSE;
 182         gchar *utf8_username = GetTokenName (user);
 183
 184         if (!utf8_username)
 185                 return FALSE;
 186
 187         if (g) {
 188                 gchar **users = g->gr_mem;
 189
 190                 while (*users) {
 191                         gchar *u = *(users);
 192                         if (strcmp (utf8_username, u) == 0) {
 193                                 result = TRUE;
 194                                 break;
 195                         }
 196                         users++;
 197                 }
 198         }
 199
 200         g_free (utf8_username);
 201         return result;
 202 }
 203
 204
 205 static gboolean
 206 IsDefaultGroup (uid_t user, gid_t group)
 207 {
 208 #ifdef HAVE_GETPWUID_R
 209         struct passwd pwd;
 210         size_t fbufsize;
 211         gchar *fbuf;
 212         gint32 retval;
 213 #endif
 214         struct passwd *p = NULL;
 215         gboolean result;
 216
 217 #ifdef HAVE_GETPWUID_R
 218 #ifdef _SC_GETPW_R_SIZE_MAX
 219         fbufsize = mono_sysconf (_SC_GETPW_R_SIZE_MAX);
 220 #else
 221         fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
 222 #endif
 223
 224         fbuf = (gchar *)g_malloc0 (fbufsize);
 225         retval = getpwuid_r (user, &pwd, fbuf, fbufsize, &p);
 226         result = ((retval == 0) && (p == &pwd));
 227 #else
 228         /* default to non thread-safe but posix compliant function */
 229         p = getpwuid (user);
 230         result = (p != NULL);
 231 #endif
 232
 233         if (result) {
 234                 result = (p->pw_gid == group);
 235         }
 236
 237 #ifdef HAVE_GETPWUID_R
 238         g_free (fbuf);
 239 #endif
 240
 241         return result;
 242 }
 243
 244
 245 static gboolean
 246 IsMemberOf (gid_t user, struct group *g)
 247 {
 248         if (!g)
 249                 return FALSE;
 250
 251         /* is it the user default group */
 252         if (IsDefaultGroup (user, g->gr_gid))
 253                 return TRUE;
 254
 255         /* is the user in the group list */
 256         return IsMemberInList (user, g);
 257 }
 258
 259 #endif
 260
 261
 262 /* ICALLS */
 263
 264
 265 /* System.Security.Principal.WindowsIdentity */
 266
 267
 268 gpointer
 269 ves_icall_System_Security_Principal_WindowsIdentity_GetCurrentToken (void)
 270 {
 271         gpointer token = NULL;
 272
 273 #ifdef HOST_WIN32
 274         /* Note: This isn't a copy of the Token - we must not close it!!!
 275          * http://www.develop.com/kbrown/book/html/whatis_windowsprincipal.html
 276          */
 277
 278         /* thread may be impersonating somebody */
 279         if (OpenThreadToken (GetCurrentThread (), TOKEN_QUERY, 1, &token) == 0) {
 280                 /* if not take the process identity */
 281                 OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &token);
 282         }
 283 #else
 284         token = GINT_TO_POINTER (geteuid ());
 285 #endif
 286         return token;
 287 }
 288
 289
 290 MonoString*
 291 ves_icall_System_Security_Principal_WindowsIdentity_GetTokenName (gpointer token)
 292 {
 293         MonoError error;
 294         MonoString *result = NULL;
 295         gunichar2 *uniname = NULL;
 296         gint32 size = 0;
 297
 298         mono_error_init (&error);
 299 #ifdef HOST_WIN32
 300         GetTokenInformation (token, TokenUser, NULL, size, (PDWORD)&size);
 301         if (size > 0) {
 302                 TOKEN_USER *tu = g_malloc0 (size);
 303                 if (GetTokenInformation (token, TokenUser, tu, size, (PDWORD)&size)) {
 304                         uniname = GetSidName (NULL, tu->User.Sid, &size);
 305                 }
 306                 g_free (tu);
 307         }
 308 #else
 309         gchar *uname = GetTokenName ((uid_t) GPOINTER_TO_INT (token));
 310
 311         if (uname) {
 312                 size = strlen (uname);
 313                 uniname = g_utf8_to_utf16 (uname, size, NULL, NULL, NULL);
 314                 g_free (uname);
 315         }
 316 #endif /* HOST_WIN32 */
 317
 318         if (size > 0) {
 319                 result = mono_string_new_utf16_checked (mono_domain_get (), uniname, size, &error);
 320         }
 321         else
 322                 result = mono_string_new (mono_domain_get (), "");
 323
 324         if (uniname)
 325                 g_free (uniname);
 326
 327         mono_error_set_pending_exception (&error);
 328         return result;
 329 }
 330
 331
 332 gpointer
 333 ves_icall_System_Security_Principal_WindowsIdentity_GetUserToken (MonoString *username)
 334 {
 335 #ifdef HOST_WIN32
 336         gpointer token = NULL;
 337
 338         /* TODO: MS has something like this working in Windows 2003 (client and
 339          * server) but works only for domain accounts (so it's quite limiting).
 340          * http://www.develop.com/kbrown/book/html/howto_logonuser.html
 341          */
 342         g_warning ("Unsupported on Win32 (anyway requires W2K3 minimum)");
 343
 344 #else /* HOST_WIN32*/
 345
 346 #ifdef HAVE_GETPWNAM_R
 347         struct passwd pwd;
 348         size_t fbufsize;
 349         gchar *fbuf;
 350         gint32 retval;
 351 #endif
 352         gpointer token = (gpointer) -2;
 353         struct passwd *p;
 354         gchar *utf8_name;
 355         gboolean result;
 356
 357         utf8_name = mono_unicode_to_external (mono_string_chars (username));
 358
 359 #ifdef HAVE_GETPWNAM_R
 360 #ifdef _SC_GETPW_R_SIZE_MAX
 361         fbufsize = mono_sysconf (_SC_GETPW_R_SIZE_MAX);
 362 #else
 363         fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
 364 #endif
 365
 366         fbuf = (gchar *)g_malloc0 (fbufsize);
 367         retval = getpwnam_r (utf8_name, &pwd, fbuf, fbufsize, &p);
 368         result = ((retval == 0) && (p == &pwd));
 369 #else
 370         /* default to non thread-safe but posix compliant function */
 371         p = getpwnam (utf8_name);
 372         result = (p != NULL);
 373 #endif
 374
 375         if (result) {
 376                 token = GINT_TO_POINTER (p->pw_uid);
 377         }
 378
 379 #ifdef HAVE_GETPWNAM_R
 380         g_free (fbuf);
 381 #endif
 382         g_free (utf8_name);
 383 #endif
 384         return token;
 385 }
 386
 387
 388 /* http://www.dotnet247.com/247reference/msgs/39/195403.aspx
 389 // internal static string[] WindowsIdentity._GetRoles (IntPtr token)
 390 */
 391 MonoArray*
 392 ves_icall_System_Security_Principal_WindowsIdentity_GetRoles (gpointer token)
 393 {
 394         MonoArray *array = NULL;
 395         MonoDomain *domain = mono_domain_get ();
 396 #ifdef HOST_WIN32
 397         MonoError error;
 398         gint32 size = 0;
 399
 400         GetTokenInformation (token, TokenGroups, NULL, size, (PDWORD)&size);
 401         if (size > 0) {
 402                 TOKEN_GROUPS *tg = g_malloc0 (size);
 403                 if (GetTokenInformation (token, TokenGroups, tg, size, (PDWORD)&size)) {
 404                         int i=0;
 405                         int num = tg->GroupCount;
 406
 407                         array = mono_array_new (domain, mono_get_string_class (), num);
 408
 409                         for (i=0; i < num; i++) {
 410                                 gint32 size = 0;
 411                                 gunichar2 *uniname = GetSidName (NULL, tg->Groups [i].Sid, &size);
 412
 413                                 if (uniname) {
 414                                         MonoString *str = mono_string_new_utf16_checked (domain, uniname, size, &error);
 415                                         if (!is_ok (&error)) {
 416                                                 g_free (uniname);
 417                                                 g_free (tg);
 418                                                 mono_error_set_pending_exception (&error);
 419                                                 return NULL;
 420                                         }
 421                                         mono_array_setref (array, i, str);
 422                                         g_free (uniname);
 423                                 }
 424                         }
 425                 }
 426                 g_free (tg);
 427         }
 428 #else
 429         /* POSIX-compliant systems should use IsMemberOfGroupId or IsMemberOfGroupName */
 430         g_warning ("WindowsIdentity._GetRoles should never be called on POSIX");
 431 #endif
 432         if (!array) {
 433                 /* return empty array of string, i.e. string [0] */
 434                 array = mono_array_new (domain, mono_get_string_class (), 0);
 435         }
 436         return array;
 437 }
 438
 439
 440 /* System.Security.Principal.WindowsImpersonationContext */
 441
 442
 443 gboolean
 444 ves_icall_System_Security_Principal_WindowsImpersonationContext_CloseToken (gpointer token)
 445 {
 446         gboolean result = TRUE;
 447
 448 #ifdef HOST_WIN32
 449         result = (CloseHandle (token) != 0);
 450 #endif
 451         return result;
 452 }
 453
 454
 455 gpointer
 456 ves_icall_System_Security_Principal_WindowsImpersonationContext_DuplicateToken (gpointer token)
 457 {
 458         gpointer dupe = NULL;
 459
 460 #ifdef HOST_WIN32
 461         if (DuplicateToken (token, SecurityImpersonation, &dupe) == 0) {
 462                 dupe = NULL;
 463         }
 464 #else
 465         dupe = token;
 466 #endif
 467         return dupe;
 468 }
 469
 470
 471 gboolean
 472 ves_icall_System_Security_Principal_WindowsImpersonationContext_SetCurrentToken (gpointer token)
 473 {
 474         /* Posix version implemented in /mono/mono/io-layer/security.c */
 475         return (ImpersonateLoggedOnUser (token) != 0);
 476 }
 477
 478
 479 gboolean
 480 ves_icall_System_Security_Principal_WindowsImpersonationContext_RevertToSelf (void)
 481 {
 482         /* Posix version implemented in /mono/mono/io-layer/security.c */
 483         return (RevertToSelf () != 0);
 484 }
 485
 486
 487 /* System.Security.Principal.WindowsPrincipal */
 488
 489 gboolean
 490 ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupId (gpointer user, gpointer group)
 491 {
 492         gboolean result = FALSE;
 493
 494 #ifdef HOST_WIN32
 495         /* The convertion from an ID to a string is done in managed code for Windows */
 496         g_warning ("IsMemberOfGroupId should never be called on Win32");
 497
 498 #else /* HOST_WIN32 */
 499
 500 #ifdef HAVE_GETGRGID_R
 501         struct group grp;
 502         size_t fbufsize;
 503         gchar *fbuf;
 504         gint32 retval;
 505 #endif
 506         struct group *g = NULL;
 507
 508 #ifdef HAVE_GETGRGID_R
 509 #ifdef _SC_GETGR_R_SIZE_MAX
 510         fbufsize = mono_sysconf (_SC_GETGR_R_SIZE_MAX);
 511 #else
 512         fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
 513 #endif
 514         fbuf = (gchar *)g_malloc0 (fbufsize);
 515         retval = getgrgid_r ((gid_t) GPOINTER_TO_INT (group), &grp, fbuf, fbufsize, &g);
 516         result = ((retval == 0) && (g == &grp));
 517 #else
 518         /* default to non thread-safe but posix compliant function */
 519         g = getgrgid ((gid_t) GPOINTER_TO_INT (group));
 520         result = (g != NULL);
 521 #endif
 522
 523         if (result) {
 524                 result = IsMemberOf ((uid_t) GPOINTER_TO_INT (user), g);
 525         }
 526
 527 #ifdef HAVE_GETGRGID_R
 528         g_free (fbuf);
 529 #endif
 530
 531 #endif /* HOST_WIN32 */
 532
 533         return result;
 534 }
 535
 536
 537 gboolean
 538 ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupName (gpointer user, MonoString *group)
 539 {
 540         gboolean result = FALSE;
 541
 542 #ifdef HOST_WIN32
 543         /* Windows version use a cache built using WindowsIdentity._GetRoles */
 544         g_warning ("IsMemberOfGroupName should never be called on Win32");
 545
 546 #else /* HOST_WIN32 */
 547         gchar *utf8_groupname;
 548
 549         utf8_groupname = mono_unicode_to_external (mono_string_chars (group));
 550         if (utf8_groupname) {
 551                 struct group *g = NULL;
 552 #ifdef HAVE_GETGRNAM_R
 553                 struct group grp;
 554                 gchar *fbuf;
 555                 gint32 retval;
 556 #ifdef _SC_GETGR_R_SIZE_MAX
 557                 size_t fbufsize = mono_sysconf (_SC_GETGR_R_SIZE_MAX);
 558 #else
 559                 size_t fbufsize = MONO_SYSCONF_DEFAULT_SIZE;
 560 #endif
 561                 fbuf = (gchar *)g_malloc0 (fbufsize);
 562                 retval = getgrnam_r (utf8_groupname, &grp, fbuf, fbufsize, &g);
 563                 result = ((retval == 0) && (g == &grp));
 564 #else
 565                 /* default to non thread-safe but posix compliant function */
 566                 g = getgrnam (utf8_groupname);
 567                 result = (g != NULL);
 568 #endif
 569
 570                 if (result) {
 571                         result = IsMemberOf ((uid_t) GPOINTER_TO_INT (user), g);
 572                 }
 573
 574 #ifdef HAVE_GETGRNAM_R
 575                 g_free (fbuf);
 576 #endif
 577                 g_free (utf8_groupname);
 578         }
 579 #endif /* HOST_WIN32 */
 580
 581         return result;
 582 }
 583
 584
 585 /* Mono.Security.Cryptography IO related internal calls */
 586
 587 #ifdef HOST_WIN32
 588
 589 static PSID
 590 GetAdministratorsSid (void)
 591 {
 592         SID_IDENTIFIER_AUTHORITY admins = SECURITY_NT_AUTHORITY;
 593         PSID pSid = NULL;
 594         if (!AllocateAndInitializeSid (&admins, 2, SECURITY_BUILTIN_DOMAIN_RID,
 595                 DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &pSid))
 596                 return NULL;
 597         /* Note: this SID must be freed with FreeSid () */
 598         return pSid;
 599 }
 600
 601
 602 static PSID
 603 GetEveryoneSid (void)
 604 {
 605         SID_IDENTIFIER_AUTHORITY everyone = SECURITY_WORLD_SID_AUTHORITY;
 606         PSID pSid = NULL;
 607         if (!AllocateAndInitializeSid (&everyone, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pSid))
 608                 return NULL;
 609         /* Note: this SID must be freed with FreeSid () */
 610         return pSid;
 611 }
 612
 613
 614 static PSID
 615 GetCurrentUserSid (void)
 616 {
 617         PSID sid = NULL;
 618         guint32 size = 0;
 619         gpointer token = ves_icall_System_Security_Principal_WindowsIdentity_GetCurrentToken ();
 620
 621         GetTokenInformation (token, TokenUser, NULL, size, (PDWORD)&size);
 622         if (size > 0) {
 623                 TOKEN_USER *tu = g_malloc0 (size);
 624                 if (GetTokenInformation (token, TokenUser, tu, size, (PDWORD)&size)) {
 625                         DWORD length = GetLengthSid (tu->User.Sid);
 626                         sid = (PSID) g_malloc0 (length);
 627                         if (!CopySid (length, sid, tu->User.Sid)) {
 628                                 g_free (sid);
 629                                 sid = NULL;
 630                         }
 631                 }
 632                 g_free (tu);
 633         }
 634         /* Note: this SID must be freed with g_free () */
 635         return sid;
 636 }
 637
 638
 639 static ACCESS_MASK
 640 GetRightsFromSid (PSID sid, PACL acl)
 641 {
 642         ACCESS_MASK rights = 0;
 643         TRUSTEE trustee;
 644
 645         BuildTrusteeWithSidW (&trustee, sid);
 646         if (GetEffectiveRightsFromAcl (acl, &trustee, &rights) != ERROR_SUCCESS)
 647                 return 0;
 648
 649         return rights;
 650 }
 651
 652
 653 static gboolean
 654 IsMachineProtected (gunichar2 *path)
 655 {
 656         gboolean success = FALSE;
 657         PACL pDACL = NULL;
 658         PSID pEveryoneSid = NULL;
 659
 660         DWORD dwRes = GetNamedSecurityInfoW (path, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, &pDACL, NULL, NULL);
 661         if (dwRes != ERROR_SUCCESS)
 662                 return FALSE;
 663
 664         /* We check that Everyone is still limited to READ-ONLY -
 665         but not if new entries have been added by an Administrator */
 666
 667         pEveryoneSid = GetEveryoneSid ();
 668         if (pEveryoneSid) {
 669                 ACCESS_MASK rights = GetRightsFromSid (pEveryoneSid, pDACL);
 670                 /* http://msdn.microsoft.com/library/en-us/security/security/generic_access_rights.asp?frame=true */
 671                 success = (rights == (READ_CONTROL | SYNCHRONIZE | FILE_READ_DATA | FILE_READ_EA | FILE_READ_ATTRIBUTES));
 672                 FreeSid (pEveryoneSid);
 673         }
 674         /* Note: we don't need to check our own access -
 675         we'll know soon enough when reading the file */
 676
 677         if (pDACL)
 678                 LocalFree (pDACL);
 679
 680         return success;
 681 }
 682
 683
 684 static gboolean
 685 IsUserProtected (gunichar2 *path)
 686 {
 687         gboolean success = FALSE;
 688         PACL pDACL = NULL;
 689         PSID pEveryoneSid = NULL;
 690         PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
 691
 692         DWORD dwRes = GetNamedSecurityInfoW (path, SE_FILE_OBJECT,
 693                 DACL_SECURITY_INFORMATION, NULL, NULL, &pDACL, NULL, &pSecurityDescriptor);
 694         if (dwRes != ERROR_SUCCESS)
 695                 return FALSE;
 696
 697         /* We check that our original entries in the ACL are in place -
 698         but not if new entries have been added by the user */
 699
 700         /* Everyone should be denied */
 701         pEveryoneSid = GetEveryoneSid ();
 702         if (pEveryoneSid) {
 703                 ACCESS_MASK rights = GetRightsFromSid (pEveryoneSid, pDACL);
 704                 success = (rights == 0);
 705                 FreeSid (pEveryoneSid);
 706         }
 707         /* Note: we don't need to check our own access -
 708         we'll know soon enough when reading the file */
 709
 710         if (pSecurityDescriptor)
 711                 LocalFree (pSecurityDescriptor);
 712
 713         return success;
 714 }
 715
 716
 717 static gboolean
 718 ProtectMachine (gunichar2 *path)
 719 {
 720         PSID pEveryoneSid = GetEveryoneSid ();
 721         PSID pAdminsSid = GetAdministratorsSid ();
 722         DWORD retval = -1;
 723
 724         if (pEveryoneSid && pAdminsSid) {
 725                 PACL pDACL = NULL;
 726                 EXPLICIT_ACCESS ea [2];
 727                 ZeroMemory (&ea, 2 * sizeof (EXPLICIT_ACCESS));
 728
 729                 /* grant all access to the BUILTIN\Administrators group */
 730                 BuildTrusteeWithSidW (&ea [0].Trustee, pAdminsSid);
 731                 ea [0].grfAccessPermissions = GENERIC_ALL;
 732                 ea [0].grfAccessMode = SET_ACCESS;
 733                 ea [0].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
 734                 ea [0].Trustee.TrusteeForm = TRUSTEE_IS_SID;
 735                 ea [0].Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
 736
 737                 /* read-only access everyone */
 738                 BuildTrusteeWithSidW (&ea [1].Trustee, pEveryoneSid);
 739                 ea [1].grfAccessPermissions = GENERIC_READ;
 740                 ea [1].grfAccessMode = SET_ACCESS;
 741                 ea [1].grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
 742                 ea [1].Trustee.TrusteeForm = TRUSTEE_IS_SID;
 743                 ea [1].Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
 744
 745                 retval = SetEntriesInAcl (2, ea, NULL, &pDACL);
 746                 if (retval == ERROR_SUCCESS) {
 747                         /* with PROTECTED_DACL_SECURITY_INFORMATION we */
 748                         /* remove any existing ACL (like inherited ones) */
 749                         retval = SetNamedSecurityInfo (path, SE_FILE_OBJECT,
 750                                 DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,
 751                                 NULL, NULL, pDACL, NULL);
 752                 }
 753                 if (pDACL)
 754                         LocalFree (pDACL);
 755         }
 756
 757         if (pEveryoneSid)
 758                 FreeSid (pEveryoneSid);
 759         if (pAdminsSid)
 760                 FreeSid (pAdminsSid);
 761         return (retval == ERROR_SUCCESS);
 762 }
 763
 764
 765 static gboolean
 766 ProtectUser (gunichar2 *path)
 767 {
 768         DWORD retval = -1;
 769
 770         PSID pCurrentSid = GetCurrentUserSid ();
 771         if (pCurrentSid) {
 772                 PACL pDACL = NULL;
 773                 EXPLICIT_ACCESS ea;
 774                 ZeroMemory (&ea, sizeof (EXPLICIT_ACCESS));
 775
 776                 /* grant exclusive access to the current user */
 777                 BuildTrusteeWithSidW (&ea.Trustee, pCurrentSid);
 778                 ea.grfAccessPermissions = GENERIC_ALL;
 779                 ea.grfAccessMode = SET_ACCESS;
 780                 ea.grfInheritance = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
 781                 ea.Trustee.TrusteeForm = TRUSTEE_IS_SID;
 782                 ea.Trustee.TrusteeType = TRUSTEE_IS_USER;
 783
 784                 retval = SetEntriesInAcl (1, &ea, NULL, &pDACL);
 785                 if (retval == ERROR_SUCCESS) {
 786                         /* with PROTECTED_DACL_SECURITY_INFORMATION we
 787                            remove any existing ACL (like inherited ones) */
 788                         retval = SetNamedSecurityInfo (path, SE_FILE_OBJECT,
 789                                 DACL_SECURITY_INFORMATION | PROTECTED_DACL_SECURITY_INFORMATION,
 790                                 NULL, NULL, pDACL, NULL);
 791                 }
 792
 793                 if (pDACL)
 794                         LocalFree (pDACL);
 795                 g_free (pCurrentSid); /* g_malloc0 */
 796         }
 797
 798         return (retval == ERROR_SUCCESS);
 799 }
 800
 801 #else
 802
 803 static gboolean
 804 IsProtected (MonoString *path, gint32 protection)
 805 {
 806         gboolean result = FALSE;
 807         gchar *utf8_name = mono_unicode_to_external (mono_string_chars (path));
 808         if (utf8_name) {
 809                 struct stat st;
 810                 if (stat (utf8_name, &st) == 0) {
 811                         result = (((st.st_mode & 0777) & protection) == 0);
 812                 }
 813                 g_free (utf8_name);
 814         }
 815         return result;
 816 }
 817
 818
 819 static gboolean
 820 Protect (MonoString *path, gint32 file_mode, gint32 add_dir_mode)
 821 {
 822         gboolean result = FALSE;
 823         gchar *utf8_name = mono_unicode_to_external (mono_string_chars (path));
 824         if (utf8_name) {
 825                 struct stat st;
 826                 if (stat (utf8_name, &st) == 0) {
 827                         int mode = file_mode;
 828                         if (st.st_mode & S_IFDIR)
 829                                 mode |= add_dir_mode;
 830                         result = (chmod (utf8_name, mode) == 0);
 831                 }
 832                 g_free (utf8_name);
 833         }
 834         return result;
 835 }
 836
 837 #endif /* not HOST_WIN32 */
 838
 839
 840 MonoBoolean
 841 ves_icall_Mono_Security_Cryptography_KeyPairPersistence_CanSecure (MonoString *root)
 842 {
 843 #if HOST_WIN32
 844         gint32 flags;
 845
 846         /* ACL are nice... unless you have FAT or other uncivilized filesystem */
 847         if (!GetVolumeInformation (mono_string_chars (root), NULL, 0, NULL, NULL, (LPDWORD)&flags, NULL, 0))
 848                 return FALSE;
 849         return ((flags & FS_PERSISTENT_ACLS) == FS_PERSISTENT_ACLS);
 850 #else
 851         /* we assume some kind of security is applicable outside Windows */
 852         return TRUE;
 853 #endif
 854 }
 855
 856
 857 MonoBoolean
 858 ves_icall_Mono_Security_Cryptography_KeyPairPersistence_IsMachineProtected (MonoString *path)
 859 {
 860         gboolean ret = FALSE;
 861
 862         /* no one, but the owner, should have write access to the directory */
 863 #ifdef HOST_WIN32
 864         ret = IsMachineProtected (mono_string_chars (path));
 865 #else
 866         ret = IsProtected (path, (S_IWGRP | S_IWOTH));
 867 #endif
 868         return ret;
 869 }
 870
 871
 872 MonoBoolean
 873 ves_icall_Mono_Security_Cryptography_KeyPairPersistence_IsUserProtected (MonoString *path)
 874 {
 875         gboolean ret = FALSE;
 876
 877         /* no one, but the user, should have access to the directory */
 878 #ifdef HOST_WIN32
 879         ret = IsUserProtected (mono_string_chars (path));
 880 #else
 881         ret = IsProtected (path, (S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH));
 882 #endif
 883         return ret;
 884 }
 885
 886
 887 MonoBoolean
 888 ves_icall_Mono_Security_Cryptography_KeyPairPersistence_ProtectMachine (MonoString *path)
 889 {
 890         gboolean ret = FALSE;
 891
 892         /* read/write to owner, read to everyone else */
 893 #ifdef HOST_WIN32
 894         ret = ProtectMachine (mono_string_chars (path));
 895 #else
 896         ret = Protect (path, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH), (S_IXUSR | S_IXGRP | S_IXOTH));
 897 #endif
 898         return ret;
 899 }
 900
 901
 902 MonoBoolean
 903 ves_icall_Mono_Security_Cryptography_KeyPairPersistence_ProtectUser (MonoString *path)
 904 {
 905         gboolean ret = FALSE;
 906
 907         /* read/write to user, no access to everyone else */
 908 #ifdef HOST_WIN32
 909         ret = ProtectUser (mono_string_chars (path));
 910 #else
 911         ret = Protect (path, (S_IRUSR | S_IWUSR), S_IXUSR);
 912 #endif
 913         return ret;
 914 }
 915
 916
 917 /*
 918  * Returns TRUE if there is "something" where the Authenticode signature is
 919  * normally located. Returns FALSE is data directory is empty.
 920  *
 921  * Note: Neither the structure nor the signature is verified by this function.
 922  */
 923 MonoBoolean
 924 ves_icall_System_Security_Policy_Evidence_IsAuthenticodePresent (MonoReflectionAssembly *refass)
 925 {
 926         if (refass && refass->assembly && refass->assembly->image) {
 927                 return mono_image_has_authenticode_entry (refass->assembly->image);
 928         }
 929         return FALSE;
 930 }
 931
 932
 933 /* System.Security.SecureString related internal calls */
 934
 935 static MonoImage *system_security_assembly = NULL;
 936
 937 void
 938 ves_icall_System_Security_SecureString_DecryptInternal (MonoArray *data, MonoObject *scope)
 939 {
 940         MonoError error;
 941         invoke_protected_memory_method (data, scope, FALSE, &error);
 942         mono_error_set_pending_exception (&error);
 943 }
 944 void
 945 ves_icall_System_Security_SecureString_EncryptInternal (MonoArray* data, MonoObject *scope)
 946 {
 947         MonoError error;
 948         invoke_protected_memory_method (data, scope, TRUE, &error);
 949         mono_error_set_pending_exception (&error);
 950 }
 951
 952 void invoke_protected_memory_method (MonoArray *data, MonoObject *scope, gboolean encrypt, MonoError *error)
 953 {
 954         MonoClass *klass;
 955         MonoMethod *method;
 956         void *params [2];
 957
 958         mono_error_init (error);
 959
 960         if (system_security_assembly == NULL) {
 961                 system_security_assembly = mono_image_loaded ("System.Security");
 962                 if (!system_security_assembly) {
 963                         MonoAssembly *sa = mono_assembly_open ("System.Security.dll", NULL);
 964                         if (!sa)
 965                                 g_assert_not_reached ();
 966                         system_security_assembly = mono_assembly_get_image (sa);
 967                 }
 968         }
 969
 970         klass = mono_class_load_from_name (system_security_assembly,
 971                                                                   "System.Security.Cryptography", "ProtectedMemory");
 972         method = mono_class_get_method_from_name (klass, encrypt ? "Protect" : "Unprotect", 2);
 973         params [0] = data;
 974         params [1] = scope; /* MemoryProtectionScope.SameProcess */
 975
 976         mono_runtime_invoke_checked (method, NULL, params, error);
 977 }