mono/metadata/security-manager.c

   1 /*
   2  * security-manager.c:  Security Manager (Unmanaged side)
   3  *
   4  * Author:
   5  *      Sebastien Pouliot  <sebastien@ximian.com>
   6  *
   7  * Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
   8  */
   9
  10 #include "security-manager.h"
  11
  12
  13 /* Internal stuff */
  14
  15 static MonoSecurityManager secman;
  16 static MonoBoolean mono_security_manager_activated = FALSE;
  17 static MonoBoolean mono_security_manager_enabled = TRUE;
  18 static MonoBoolean mono_security_manager_execution = TRUE;
  19
  20
  21 /* Public stuff */
  22
  23 MonoSecurityManager*
  24 mono_security_manager_get_methods (void)
  25 {
  26         /* Already initialized ? */
  27         if (secman.securitymanager)
  28                 return &secman;
  29
  30         /* Initialize */
  31         secman.securitymanager = mono_class_from_name (mono_defaults.corlib,
  32                 "System.Security", "SecurityManager");
  33         g_assert (secman.securitymanager);
  34         if (!secman.securitymanager->inited)
  35                 mono_class_init (secman.securitymanager);
  36
  37         secman.demand = mono_class_get_method_from_name (secman.securitymanager,
  38                 "InternalDemand", 2);
  39         g_assert (secman.demand);
  40
  41         secman.inheritancedemand = mono_class_get_method_from_name (secman.securitymanager,
  42                 "InheritanceDemand", 2);
  43         g_assert (secman.inheritancedemand);
  44
  45         secman.inheritsecurityexception = mono_class_get_method_from_name (secman.securitymanager,
  46                 "InheritanceDemandSecurityException", 4);
  47         g_assert (secman.inheritsecurityexception);
  48
  49         secman.linkdemand = mono_class_get_method_from_name (secman.securitymanager,
  50                 "LinkDemand", 3);
  51         g_assert (secman.linkdemand);
  52
  53         secman.linkdemandunmanaged = mono_class_get_method_from_name (secman.securitymanager,
  54                 "LinkDemandUnmanaged", 1);
  55         g_assert (secman.linkdemandunmanaged);
  56
  57         secman.linkdemandfulltrust = mono_class_get_method_from_name (secman.securitymanager,
  58                 "LinkDemandFullTrust", 1);
  59         g_assert (secman.linkdemandfulltrust);
  60
  61         secman.linkdemandsecurityexception = mono_class_get_method_from_name (secman.securitymanager,
  62                 "LinkDemandSecurityException", 3);
  63         g_assert (secman.linkdemandsecurityexception);
  64
  65         secman.aptc = mono_class_from_name (mono_defaults.corlib, "System.Security",
  66                 "AllowPartiallyTrustedCallersAttribute");
  67         g_assert (secman.aptc);
  68
  69         return &secman;
  70 }
  71
  72 static gboolean
  73 mono_secman_inheritance_check (MonoClass *klass, MonoDeclSecurityActions *demands)
  74 {
  75         MonoSecurityManager* secman = mono_security_manager_get_methods ();
  76         MonoDomain *domain = mono_domain_get ();
  77         MonoAssembly *assembly = mono_image_get_assembly (klass->image);
  78         MonoReflectionAssembly *refass = mono_assembly_get_object (domain, assembly);
  79         MonoObject *res;
  80         gpointer args [2];
  81
  82         args [0] = refass;
  83         args [1] = demands;
  84
  85         res = mono_runtime_invoke (secman->inheritancedemand, NULL, args, NULL);
  86         return (*(MonoBoolean *) mono_object_unbox (res));
  87 }
  88
  89 void
  90 mono_secman_inheritancedemand_class (MonoClass *klass, MonoClass *parent)
  91 {
  92         MonoDeclSecurityActions demands;
  93
  94         /* don't hide previous results -and- don't calc everything for nothing */
  95         if (klass->exception_type != 0)
  96                 return;
  97
  98         /* Check if there are an InheritanceDemand on the parent class */
  99         if (mono_declsec_get_inheritdemands_class (parent, &demands)) {
 100                 /* If so check the demands on the klass (inheritor) */
 101                 if (!mono_secman_inheritance_check (klass, &demands)) {
 102                         /* Keep flags in MonoClass to be able to throw a SecurityException later (if required) */
 103                         klass->exception_type = MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND;
 104                         klass->exception_data = NULL;
 105                 }
 106         }
 107 }
 108
 109 void
 110 mono_secman_inheritancedemand_method (MonoMethod *override, MonoMethod *base)
 111 {
 112         MonoDeclSecurityActions demands;
 113
 114         /* don't hide previous results -and- don't calc everything for nothing */
 115         if (override->klass->exception_type != 0)
 116                 return;
 117
 118         /* Check if there are an InheritanceDemand on the base (virtual) method */
 119         if (mono_declsec_get_inheritdemands_method (base, &demands)) {
 120                 /* If so check the demands on the overriding method */
 121                 if (!mono_secman_inheritance_check (override->klass, &demands)) {
 122                         /* Keep flags in MonoClass to be able to throw a SecurityException later (if required) */
 123                         override->klass->exception_type = MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND;
 124                         override->klass->exception_data = base;
 125                 }
 126         }
 127 }
 128
 129
 130 /*
 131  * Note: The security manager is activate once when executing the Mono. This
 132  * is not meant to be a turn on/off runtime switch.
 133  */
 134 void
 135 mono_activate_security_manager (void)
 136 {
 137         mono_security_manager_activated = TRUE;
 138 }
 139
 140 gboolean
 141 mono_is_security_manager_active (void)
 142 {
 143         return mono_security_manager_activated;
 144 }
 145
 146 /*
 147  * @publickey   An encoded (with header) public key
 148  * @size        The length of the public key
 149  *
 150  * returns TRUE if the public key is the ECMA "key", FALSE otherwise
 151  *
 152  * ECMA key isn't a real public key - it's simply an empty (but valid) header
 153  * so it's length (16) and value (00000000000000000400000000000000) are
 154  * constants.
 155  */
 156 gboolean
 157 mono_is_ecma_key (const char *publickey, int size)
 158 {
 159         int i;
 160         if ((publickey == NULL) || (size != MONO_ECMA_KEY_LENGTH) || (publickey [8] != 0x04))
 161                 return FALSE;
 162
 163         for (i=0; i < size; i++) {
 164                 if ((publickey [i] != 0x00) && (i != 8))
 165                         return FALSE;
 166         }
 167         return TRUE;
 168 }
 169
 170 MonoBoolean
 171 ves_icall_System_Security_SecurityManager_get_SecurityEnabled (void)
 172 {
 173         if (!mono_security_manager_activated)
 174                 return FALSE;
 175         return mono_security_manager_enabled;
 176 }
 177
 178 void
 179 ves_icall_System_Security_SecurityManager_set_SecurityEnabled (MonoBoolean value)
 180 {
 181         /* value can be changed only if the security manager is activated */
 182         if (mono_security_manager_activated) {
 183                 mono_security_manager_enabled = value;
 184         }
 185 }
 186
 187 MonoBoolean
 188 ves_icall_System_Security_SecurityManager_get_CheckExecutionRights (void)
 189 {
 190         if (!mono_security_manager_activated)
 191                 return FALSE;
 192         return mono_security_manager_execution;
 193 }
 194
 195 void
 196 ves_icall_System_Security_SecurityManager_set_CheckExecutionRights (MonoBoolean value)
 197 {
 198         /* value can be changed only id the security manager is activated */
 199         if (mono_security_manager_activated) {
 200                 mono_security_manager_execution = value;
 201         }
 202 }