mcs/class/corlib/Test/System.Security/SecurityExceptionCas.cs

   1 //
   2 // SecurityExceptionCas.cs - CAS unit tests for
   3 //      System.Security.SecurityException
   4 //
   5 // Author:
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using NUnit.Framework;
  31
  32 using System;
  33 using System.Reflection;
  34 using System.Runtime.Serialization;
  35 using System.Security;
  36 using System.Security.Permissions;
  37
  38 namespace MonoCasTests.System.Security {
  39
  40         [TestFixture]
  41         [Category ("CAS")]
  42         public class SecurityExceptionCas {
  43
  44                 private SecurityException se;
  45
  46                 [SetUp]
  47                 public void SetUp ()
  48                 {
  49                         if (!SecurityManager.SecurityEnabled)
  50                                 Assert.Ignore ("SecurityManager.SecurityEnabled is OFF");
  51
  52                         se = new SecurityException ();
  53                 }
  54
  55
  56 #if NET_2_0
  57                 [Test]
  58                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
  59                 public void GetAction ()
  60                 {
  61                         SecurityAction sa = se.Action;
  62                 }
  63
  64                 [Test]
  65                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
  66                 public void SetAction ()
  67                 {
  68                         se.Action = SecurityAction.RequestRefuse;
  69                 }
  70
  71                 [Test]
  72                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
  73                 public void GetDemanded_Pass ()
  74                 {
  75                         object o = se.Demanded;
  76                 }
  77
  78                 [Test]
  79                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
  80                 [ExpectedException (typeof (SecurityException))]
  81                 public void GetDemanded_Fail_ControlEvidence ()
  82                 {
  83                         object o = se.Demanded;
  84                 }
  85
  86                 [Test]
  87                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
  88                 [ExpectedException (typeof (SecurityException))]
  89                 public void GetDemanded_Fail_ControlPolicy ()
  90                 {
  91                         object o = se.Demanded;
  92                 }
  93
  94                 [Test]
  95                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
  96                 public void SetDemanded ()
  97                 {
  98                         se.Demanded = new PermissionSet (PermissionState.None);
  99                 }
 100
 101                 [Test]
 102                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 103                 public void GetDenySetInstance_Pass ()
 104                 {
 105                         object o = se.DenySetInstance;
 106                 }
 107
 108                 [Test]
 109                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 110                 [ExpectedException (typeof (SecurityException))]
 111                 public void GetDenySetInstance_Fail_ControlEvidence ()
 112                 {
 113                         object o = se.DenySetInstance;
 114                 }
 115
 116                 [Test]
 117                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 118                 [ExpectedException (typeof (SecurityException))]
 119                 public void GetDenySetInstance_Fail_ControlPolicy ()
 120                 {
 121                         object o = se.DenySetInstance;
 122                 }
 123
 124                 [Test]
 125                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 126                 public void SetDenySetInstance ()
 127                 {
 128                         se.DenySetInstance = new PermissionSet (PermissionState.None);
 129                 }
 130
 131                 [Test]
 132                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 133                 public void GetFailedAssemblyInfo_Pass ()
 134                 {
 135                         AssemblyName an = se.FailedAssemblyInfo;
 136                 }
 137
 138                 [Test]
 139                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 140                 [ExpectedException (typeof (SecurityException))]
 141                 public void GetFailedAssemblyInfo_Fail_ControlEvidence ()
 142                 {
 143                         AssemblyName an = se.FailedAssemblyInfo;
 144                 }
 145
 146                 [Test]
 147                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 148                 [ExpectedException (typeof (SecurityException))]
 149                 public void GetFailedAssemblyInfo_Fail_ControlPolicy ()
 150                 {
 151                         AssemblyName an = se.FailedAssemblyInfo;
 152                 }
 153
 154                 [Test]
 155                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 156                 public void SetFailedAssemblyInfo ()
 157                 {
 158                         se.FailedAssemblyInfo = null;
 159                 }
 160
 161                 [Test]
 162                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 163                 public void GetFirstPermissionThatFailed_Pass ()
 164                 {
 165                         IPermission p = se.FirstPermissionThatFailed;
 166                 }
 167
 168                 [Test]
 169                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 170                 [ExpectedException (typeof (SecurityException))]
 171                 public void GetFirstPermissionThatFailed_Fail_ControlEvidence ()
 172                 {
 173                         IPermission p = se.FirstPermissionThatFailed;
 174                 }
 175
 176                 [Test]
 177                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 178                 [ExpectedException (typeof (SecurityException))]
 179                 public void GetFirstPermissionThatFailed_Fail_ControlPolicy ()
 180                 {
 181                         IPermission p = se.FirstPermissionThatFailed;
 182                 }
 183
 184                 [Test]
 185                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 186                 public void SetFirstPermissionThatFailed ()
 187                 {
 188                         se.FirstPermissionThatFailed = null;
 189                 }
 190 #endif
 191                 [Test]
 192                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 193                 public void GetGrantedSet_Pass ()
 194                 {
 195                         string s = se.GrantedSet;
 196                 }
 197
 198                 [Test]
 199                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 200                 [ExpectedException (typeof (SecurityException))]
 201                 public void GetGrantedSet_Fail_ControlEvidence ()
 202                 {
 203                         string s = se.GrantedSet;
 204                 }
 205
 206                 [Test]
 207                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 208                 [ExpectedException (typeof (SecurityException))]
 209                 public void GetGrantedSet_Fail_ControlPolicy ()
 210                 {
 211                         string s = se.GrantedSet;
 212                 }
 213 #if NET_2_0
 214                 [Test]
 215                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 216                 public void SetGrantedSet ()
 217                 {
 218                         se.GrantedSet = String.Empty;
 219                 }
 220
 221                 [Test]
 222                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 223                 public void GetMethod_Pass ()
 224                 {
 225                         MethodInfo mi = se.Method;
 226                 }
 227
 228                 [Test]
 229                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 230                 [ExpectedException (typeof (SecurityException))]
 231                 public void GetMethod_Fail_ControlEvidence ()
 232                 {
 233                         MethodInfo mi = se.Method;
 234                 }
 235
 236                 [Test]
 237                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 238                 [ExpectedException (typeof (SecurityException))]
 239                 public void GetMethod_Fail_ControlPolicy ()
 240                 {
 241                         MethodInfo mi = se.Method;
 242                 }
 243
 244                 [Test]
 245                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 246                 public void SetMethod ()
 247                 {
 248                         se.Method = null;
 249                 }
 250 #endif
 251                 [Test]
 252                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 253                 public void GetPermissionState_Pass ()
 254                 {
 255                         string s = se.PermissionState;
 256                 }
 257
 258                 [Test]
 259                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 260                 [ExpectedException (typeof (SecurityException))]
 261                 public void GetPermissionState_Fail_ControlEvidence ()
 262                 {
 263                         string s = se.PermissionState;
 264                 }
 265
 266                 [Test]
 267                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 268                 [ExpectedException (typeof (SecurityException))]
 269                 public void GetPermissionState_Fail_ControlPolicy ()
 270                 {
 271                         string s = se.PermissionState;
 272                 }
 273 #if NET_2_0
 274                 [Test]
 275                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 276                 public void SetPermissionState ()
 277                 {
 278                         se.PermissionState = String.Empty;
 279                 }
 280
 281                 [Test]
 282                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 283                 public void GetPermitOnlySetInstance_Pass ()
 284                 {
 285                         object s = se.PermitOnlySetInstance;
 286                 }
 287
 288                 [Test]
 289                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 290                 [ExpectedException (typeof (SecurityException))]
 291                 public void GetPermitOnlySetInstance_Fail_ControlEvidence ()
 292                 {
 293                         object s = se.PermitOnlySetInstance;
 294                 }
 295
 296                 [Test]
 297                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 298                 [ExpectedException (typeof (SecurityException))]
 299                 public void GetPermitOnlySetInstance_Fail_ControlPolicy ()
 300                 {
 301                         object s = se.PermitOnlySetInstance;
 302                 }
 303
 304                 [Test]
 305                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 306                 public void SetPermitOnlySetInstance ()
 307                 {
 308                         se.PermitOnlySetInstance = null;
 309                 }
 310 #endif
 311                 [Test]
 312                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 313                 public void GetRefusedSet_Pass ()
 314                 {
 315                         string s = se.RefusedSet;
 316                 }
 317
 318                 [Test]
 319                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 320                 [ExpectedException (typeof (SecurityException))]
 321                 public void GetRefusedSet_Fail_ControlEvidence ()
 322                 {
 323                         string s = se.RefusedSet;
 324                 }
 325
 326                 [Test]
 327                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 328                 [ExpectedException (typeof (SecurityException))]
 329                 public void GetRefusedSet_Fail_ControlPolicy ()
 330                 {
 331                         string s = se.RefusedSet;
 332                 }
 333 #if NET_2_0
 334                 [Test]
 335                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 336                 public void SetRefusedSet ()
 337                 {
 338                         se.RefusedSet = String.Empty;
 339                 }
 340
 341                 [Test]
 342                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 343                 public void GetUrl_Pass ()
 344                 {
 345                         string s = se.Url;
 346                 }
 347
 348                 [Test]
 349                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 350                 [ExpectedException (typeof (SecurityException))]
 351                 public void GetUrl_Fail_ControlEvidence ()
 352                 {
 353                         string s = se.Url;
 354                 }
 355
 356                 [Test]
 357                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 358                 [ExpectedException (typeof (SecurityException))]
 359                 public void GetUrl_Fail_ControlPolicy ()
 360                 {
 361                         string s = se.Url;
 362                 }
 363
 364                 [Test]
 365                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 366                 public void SetUrl ()
 367                 {
 368                         se.Url = "http://www.mono-project.com/";
 369                 }
 370
 371                 [Test]
 372                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 373                 public void GetZone ()
 374                 {
 375                         SecurityZone sz = se.Zone;
 376                 }
 377
 378                 [Test]
 379                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 380                 public void SetZone ()
 381                 {
 382                         se.Zone = SecurityZone.Untrusted;
 383                 }
 384 #endif
 385                 [Test]
 386                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 387                 public void ToString_Empty ()
 388                 {
 389                         string s = se.ToString ();
 390                 }
 391
 392                 [Test]
 393                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 394                 public void ToString_WithSuppliedSensitiveInformation1 ()
 395                 {
 396                         // here we supply something *sensitive* as the state
 397                         string sensitive = "*SENSITIVE*";
 398                         SecurityException se = new SecurityException ("message", typeof (Object), sensitive);
 399                         // and we don't expect it to be shown in the output
 400                         Assert.IsTrue (se.ToString ().IndexOf (sensitive) == -1, sensitive);
 401                 }
 402
 403                 [Test]
 404                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 405                 public void ToString_WithSuppliedSensitiveInformation2 ()
 406                 {
 407                         // here we supply something *sensitive* as the state
 408                         string sensitive = "*SENSITIVE*";
 409                         SecurityException se = new SecurityException ("message", typeof (Object), sensitive);
 410                         // and we EXPECT it to be shown in the output
 411                         // as we pass the security checks for PermissionState property
 412                         Assert.IsFalse (se.ToString ().IndexOf (sensitive) == -1, sensitive);
 413                 }
 414
 415                 [Test]
 416                 public void GetObjectData ()
 417                 {
 418                         SecurityException se = new SecurityException ("message", typeof (string), "state");
 419                         SerializationInfo info = new SerializationInfo (typeof (SecurityException), new FormatterConverter ());
 420                         se.GetObjectData (info, new StreamingContext (StreamingContextStates.All));
 421                         Assert.AreEqual ("state", info.GetValue ("PermissionState", typeof (string)), "PermissionState");
 422                 }
 423
 424                 [Test]
 425                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 426                 [ExpectedException (typeof (SerializationException))]
 427                 public void GetObjectData_Deny_Unrestricted ()
 428                 {
 429                         SecurityException se = new SecurityException ("message", typeof (string), "state");
 430                         SerializationInfo info = new SerializationInfo (typeof (SecurityException), new FormatterConverter ());
 431                         se.GetObjectData (info, new StreamingContext (StreamingContextStates.All));
 432                         // "PermissionState" hasn't been serialized because it's access was restricted
 433                         info.GetValue ("PermissionState", typeof (string));
 434                 }
 435         }
 436 }