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