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                 [Test]
  57                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
  58                 public void GetAction ()
  59                 {
  60                         SecurityAction sa = se.Action;
  61                 }
  62
  63                 [Test]
  64                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
  65                 public void SetAction ()
  66                 {
  67                         se.Action = SecurityAction.RequestRefuse;
  68                 }
  69
  70                 [Test]
  71                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
  72                 public void GetDemanded_Pass ()
  73                 {
  74                         object o = se.Demanded;
  75                 }
  76
  77                 [Test]
  78                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
  79                 [ExpectedException (typeof (SecurityException))]
  80                 public void GetDemanded_Fail_ControlEvidence ()
  81                 {
  82                         object o = se.Demanded;
  83                 }
  84
  85                 [Test]
  86                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
  87                 [ExpectedException (typeof (SecurityException))]
  88                 public void GetDemanded_Fail_ControlPolicy ()
  89                 {
  90                         object o = se.Demanded;
  91                 }
  92
  93                 [Test]
  94                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
  95                 public void SetDemanded ()
  96                 {
  97                         se.Demanded = new PermissionSet (PermissionState.None);
  98                 }
  99
 100                 [Test]
 101                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 102                 public void GetDenySetInstance_Pass ()
 103                 {
 104                         object o = se.DenySetInstance;
 105                 }
 106
 107                 [Test]
 108                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 109                 [ExpectedException (typeof (SecurityException))]
 110                 public void GetDenySetInstance_Fail_ControlEvidence ()
 111                 {
 112                         object o = se.DenySetInstance;
 113                 }
 114
 115                 [Test]
 116                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 117                 [ExpectedException (typeof (SecurityException))]
 118                 public void GetDenySetInstance_Fail_ControlPolicy ()
 119                 {
 120                         object o = se.DenySetInstance;
 121                 }
 122
 123                 [Test]
 124                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 125                 public void SetDenySetInstance ()
 126                 {
 127                         se.DenySetInstance = new PermissionSet (PermissionState.None);
 128                 }
 129
 130                 [Test]
 131                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 132                 public void GetFailedAssemblyInfo_Pass ()
 133                 {
 134                         AssemblyName an = se.FailedAssemblyInfo;
 135                 }
 136
 137                 [Test]
 138                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 139                 [ExpectedException (typeof (SecurityException))]
 140                 public void GetFailedAssemblyInfo_Fail_ControlEvidence ()
 141                 {
 142                         AssemblyName an = se.FailedAssemblyInfo;
 143                 }
 144
 145                 [Test]
 146                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 147                 [ExpectedException (typeof (SecurityException))]
 148                 public void GetFailedAssemblyInfo_Fail_ControlPolicy ()
 149                 {
 150                         AssemblyName an = se.FailedAssemblyInfo;
 151                 }
 152
 153                 [Test]
 154                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 155                 public void SetFailedAssemblyInfo ()
 156                 {
 157                         se.FailedAssemblyInfo = null;
 158                 }
 159
 160                 [Test]
 161                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 162                 public void GetFirstPermissionThatFailed_Pass ()
 163                 {
 164                         IPermission p = se.FirstPermissionThatFailed;
 165                 }
 166
 167                 [Test]
 168                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 169                 [ExpectedException (typeof (SecurityException))]
 170                 public void GetFirstPermissionThatFailed_Fail_ControlEvidence ()
 171                 {
 172                         IPermission p = se.FirstPermissionThatFailed;
 173                 }
 174
 175                 [Test]
 176                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 177                 [ExpectedException (typeof (SecurityException))]
 178                 public void GetFirstPermissionThatFailed_Fail_ControlPolicy ()
 179                 {
 180                         IPermission p = se.FirstPermissionThatFailed;
 181                 }
 182
 183                 [Test]
 184                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 185                 public void SetFirstPermissionThatFailed ()
 186                 {
 187                         se.FirstPermissionThatFailed = null;
 188                 }
 189                 [Test]
 190                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 191                 public void GetGrantedSet_Pass ()
 192                 {
 193                         string s = se.GrantedSet;
 194                 }
 195
 196                 [Test]
 197                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 198                 [ExpectedException (typeof (SecurityException))]
 199                 public void GetGrantedSet_Fail_ControlEvidence ()
 200                 {
 201                         string s = se.GrantedSet;
 202                 }
 203
 204                 [Test]
 205                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 206                 [ExpectedException (typeof (SecurityException))]
 207                 public void GetGrantedSet_Fail_ControlPolicy ()
 208                 {
 209                         string s = se.GrantedSet;
 210                 }
 211                 [Test]
 212                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 213                 public void SetGrantedSet ()
 214                 {
 215                         se.GrantedSet = String.Empty;
 216                 }
 217
 218                 [Test]
 219                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 220                 public void GetMethod_Pass ()
 221                 {
 222                         MethodInfo mi = se.Method;
 223                 }
 224
 225                 [Test]
 226                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 227                 [ExpectedException (typeof (SecurityException))]
 228                 public void GetMethod_Fail_ControlEvidence ()
 229                 {
 230                         MethodInfo mi = se.Method;
 231                 }
 232
 233                 [Test]
 234                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 235                 [ExpectedException (typeof (SecurityException))]
 236                 public void GetMethod_Fail_ControlPolicy ()
 237                 {
 238                         MethodInfo mi = se.Method;
 239                 }
 240
 241                 [Test]
 242                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 243                 public void SetMethod ()
 244                 {
 245                         se.Method = null;
 246                 }
 247                 [Test]
 248                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 249                 public void GetPermissionState_Pass ()
 250                 {
 251                         string s = se.PermissionState;
 252                 }
 253
 254                 [Test]
 255                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 256                 [ExpectedException (typeof (SecurityException))]
 257                 public void GetPermissionState_Fail_ControlEvidence ()
 258                 {
 259                         string s = se.PermissionState;
 260                 }
 261
 262                 [Test]
 263                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 264                 [ExpectedException (typeof (SecurityException))]
 265                 public void GetPermissionState_Fail_ControlPolicy ()
 266                 {
 267                         string s = se.PermissionState;
 268                 }
 269                 [Test]
 270                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 271                 public void SetPermissionState ()
 272                 {
 273                         se.PermissionState = String.Empty;
 274                 }
 275
 276                 [Test]
 277                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 278                 public void GetPermitOnlySetInstance_Pass ()
 279                 {
 280                         object s = se.PermitOnlySetInstance;
 281                 }
 282
 283                 [Test]
 284                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 285                 [ExpectedException (typeof (SecurityException))]
 286                 public void GetPermitOnlySetInstance_Fail_ControlEvidence ()
 287                 {
 288                         object s = se.PermitOnlySetInstance;
 289                 }
 290
 291                 [Test]
 292                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 293                 [ExpectedException (typeof (SecurityException))]
 294                 public void GetPermitOnlySetInstance_Fail_ControlPolicy ()
 295                 {
 296                         object s = se.PermitOnlySetInstance;
 297                 }
 298
 299                 [Test]
 300                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 301                 public void SetPermitOnlySetInstance ()
 302                 {
 303                         se.PermitOnlySetInstance = null;
 304                 }
 305                 [Test]
 306                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 307                 public void GetRefusedSet_Pass ()
 308                 {
 309                         string s = se.RefusedSet;
 310                 }
 311
 312                 [Test]
 313                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 314                 [ExpectedException (typeof (SecurityException))]
 315                 public void GetRefusedSet_Fail_ControlEvidence ()
 316                 {
 317                         string s = se.RefusedSet;
 318                 }
 319
 320                 [Test]
 321                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 322                 [ExpectedException (typeof (SecurityException))]
 323                 public void GetRefusedSet_Fail_ControlPolicy ()
 324                 {
 325                         string s = se.RefusedSet;
 326                 }
 327                 [Test]
 328                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 329                 public void SetRefusedSet ()
 330                 {
 331                         se.RefusedSet = String.Empty;
 332                 }
 333
 334                 [Test]
 335                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 336                 public void GetUrl_Pass ()
 337                 {
 338                         string s = se.Url;
 339                 }
 340
 341                 [Test]
 342                 [SecurityPermission (SecurityAction.Deny, ControlEvidence = true)]
 343                 [ExpectedException (typeof (SecurityException))]
 344                 public void GetUrl_Fail_ControlEvidence ()
 345                 {
 346                         string s = se.Url;
 347                 }
 348
 349                 [Test]
 350                 [SecurityPermission (SecurityAction.Deny, ControlPolicy = true)]
 351                 [ExpectedException (typeof (SecurityException))]
 352                 public void GetUrl_Fail_ControlPolicy ()
 353                 {
 354                         string s = se.Url;
 355                 }
 356
 357                 [Test]
 358                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 359                 public void SetUrl ()
 360                 {
 361                         se.Url = "http://www.example.com/";
 362                 }
 363
 364                 [Test]
 365                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 366                 public void GetZone ()
 367                 {
 368                         SecurityZone sz = se.Zone;
 369                 }
 370
 371                 [Test]
 372                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 373                 public void SetZone ()
 374                 {
 375                         se.Zone = SecurityZone.Untrusted;
 376                 }
 377                 [Test]
 378                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 379                 public void ToString_Empty ()
 380                 {
 381                         string s = se.ToString ();
 382                 }
 383
 384                 [Test]
 385                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 386                 public void ToString_WithSuppliedSensitiveInformation1 ()
 387                 {
 388                         // here we supply something *sensitive* as the state
 389                         string sensitive = "*SENSITIVE*";
 390                         SecurityException se = new SecurityException ("message", typeof (Object), sensitive);
 391                         // and we don't expect it to be shown in the output
 392                         Assert.IsTrue (se.ToString ().IndexOf (sensitive) == -1, sensitive);
 393                 }
 394
 395                 [Test]
 396                 [SecurityPermission (SecurityAction.PermitOnly, ControlEvidence = true, ControlPolicy = true)]
 397                 public void ToString_WithSuppliedSensitiveInformation2 ()
 398                 {
 399                         // here we supply something *sensitive* as the state
 400                         string sensitive = "*SENSITIVE*";
 401                         SecurityException se = new SecurityException ("message", typeof (Object), sensitive);
 402                         // and we EXPECT it to be shown in the output
 403                         // as we pass the security checks for PermissionState property
 404                         Assert.IsFalse (se.ToString ().IndexOf (sensitive) == -1, sensitive);
 405                 }
 406
 407                 [Test]
 408                 public void GetObjectData ()
 409                 {
 410                         SecurityException se = new SecurityException ("message", typeof (string), "state");
 411                         SerializationInfo info = new SerializationInfo (typeof (SecurityException), new FormatterConverter ());
 412                         se.GetObjectData (info, new StreamingContext (StreamingContextStates.All));
 413                         Assert.AreEqual ("state", info.GetValue ("PermissionState", typeof (string)), "PermissionState");
 414                 }
 415
 416                 [Test]
 417                 [PermissionSet (SecurityAction.Deny, Unrestricted = true)]
 418                 [ExpectedException (typeof (SerializationException))]
 419                 public void GetObjectData_Deny_Unrestricted ()
 420                 {
 421                         SecurityException se = new SecurityException ("message", typeof (string), "state");
 422                         SerializationInfo info = new SerializationInfo (typeof (SecurityException), new FormatterConverter ());
 423                         se.GetObjectData (info, new StreamingContext (StreamingContextStates.All));
 424                         // "PermissionState" hasn't been serialized because it's access was restricted
 425                         info.GetValue ("PermissionState", typeof (string));
 426                 }
 427         }
 428 }