441 lines
12 KiB
C#
441 lines
12 KiB
C#
//
|
|
// System.Security.Permissions.RegistryPermission.cs
|
|
//
|
|
// Author
|
|
// Sebastien Pouliot <sebastien@ximian.com>
|
|
//
|
|
// Copyright (C) 2003 Motus Technologies. http://www.motus.com
|
|
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System.Collections;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
|
|
using System.Runtime.InteropServices;
|
|
using System.Security.AccessControl;
|
|
|
|
namespace System.Security.Permissions {
|
|
|
|
[Serializable]
|
|
[ComVisible (true)]
|
|
public sealed class RegistryPermission
|
|
: CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission {
|
|
|
|
private const int version = 1;
|
|
|
|
private PermissionState _state;
|
|
// private RegistryPermissionAccess _access;
|
|
private ArrayList createList;
|
|
private ArrayList readList;
|
|
private ArrayList writeList;
|
|
// private AccessControlActions _control;
|
|
// Constructors
|
|
|
|
public RegistryPermission (PermissionState state)
|
|
{
|
|
_state = CheckPermissionState (state, true);
|
|
createList = new ArrayList ();
|
|
readList = new ArrayList ();
|
|
writeList = new ArrayList ();
|
|
}
|
|
|
|
public RegistryPermission (RegistryPermissionAccess access, string pathList)
|
|
{
|
|
_state = PermissionState.None;
|
|
createList = new ArrayList ();
|
|
readList = new ArrayList ();
|
|
writeList = new ArrayList ();
|
|
AddPathList (access, pathList);
|
|
}
|
|
public RegistryPermission (RegistryPermissionAccess access, AccessControlActions control, string pathList)
|
|
{
|
|
if (!Enum.IsDefined (typeof (AccessControlActions), control)) {
|
|
string msg = String.Format (Locale.GetText ("Invalid enum {0}"), control);
|
|
throw new ArgumentException (msg, "AccessControlActions");
|
|
}
|
|
_state = PermissionState.None;
|
|
AddPathList (access, control, pathList);
|
|
}
|
|
|
|
// Properties
|
|
|
|
// Methods
|
|
|
|
public void AddPathList (RegistryPermissionAccess access, string pathList)
|
|
{
|
|
if (pathList == null)
|
|
throw new ArgumentNullException ("pathList");
|
|
|
|
switch (access) {
|
|
case RegistryPermissionAccess.AllAccess:
|
|
AddWithUnionKey (createList, pathList);
|
|
AddWithUnionKey (readList, pathList);
|
|
AddWithUnionKey (writeList, pathList);
|
|
break;
|
|
case RegistryPermissionAccess.NoAccess:
|
|
// ??? unit tests doesn't show removal using NoAccess ???
|
|
break;
|
|
case RegistryPermissionAccess.Create:
|
|
AddWithUnionKey (createList, pathList);
|
|
break;
|
|
case RegistryPermissionAccess.Read:
|
|
AddWithUnionKey (readList, pathList);
|
|
break;
|
|
case RegistryPermissionAccess.Write:
|
|
AddWithUnionKey (writeList, pathList);
|
|
break;
|
|
default:
|
|
ThrowInvalidFlag (access, false);
|
|
break;
|
|
}
|
|
}
|
|
[MonoTODO ("(2.0) Access Control isn't implemented")]
|
|
public void AddPathList (RegistryPermissionAccess access, AccessControlActions control, string pathList)
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
public string GetPathList (RegistryPermissionAccess access)
|
|
{
|
|
switch (access) {
|
|
case RegistryPermissionAccess.AllAccess:
|
|
case RegistryPermissionAccess.NoAccess:
|
|
ThrowInvalidFlag (access, true);
|
|
break;
|
|
case RegistryPermissionAccess.Create:
|
|
return GetPathList (createList);
|
|
case RegistryPermissionAccess.Read:
|
|
return GetPathList (readList);
|
|
case RegistryPermissionAccess.Write:
|
|
return GetPathList (writeList);
|
|
default:
|
|
ThrowInvalidFlag (access, false);
|
|
break;
|
|
}
|
|
return null; // never reached
|
|
}
|
|
|
|
public void SetPathList (RegistryPermissionAccess access, string pathList)
|
|
{
|
|
if (pathList == null)
|
|
throw new ArgumentNullException ("pathList");
|
|
|
|
string[] paths;
|
|
switch (access) {
|
|
case RegistryPermissionAccess.AllAccess:
|
|
createList.Clear ();
|
|
readList.Clear ();
|
|
writeList.Clear ();
|
|
paths = pathList.Split (';');
|
|
foreach (string path in paths) {
|
|
createList.Add (path);
|
|
readList.Add (path);
|
|
writeList.Add (path);
|
|
}
|
|
break;
|
|
case RegistryPermissionAccess.NoAccess:
|
|
// ??? unit tests doesn't show removal using NoAccess ???
|
|
break;
|
|
case RegistryPermissionAccess.Create:
|
|
createList.Clear ();
|
|
paths = pathList.Split (';');
|
|
foreach (string path in paths) {
|
|
createList.Add (path);
|
|
}
|
|
break;
|
|
case RegistryPermissionAccess.Read:
|
|
readList.Clear ();
|
|
paths = pathList.Split (';');
|
|
foreach (string path in paths) {
|
|
readList.Add (path);
|
|
}
|
|
break;
|
|
case RegistryPermissionAccess.Write:
|
|
writeList.Clear ();
|
|
paths = pathList.Split (';');
|
|
foreach (string path in paths) {
|
|
writeList.Add (path);
|
|
}
|
|
break;
|
|
default:
|
|
ThrowInvalidFlag (access, false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public override IPermission Copy ()
|
|
{
|
|
RegistryPermission rp = new RegistryPermission (_state);
|
|
|
|
string path = GetPathList (RegistryPermissionAccess.Create);
|
|
if (path != null)
|
|
rp.SetPathList (RegistryPermissionAccess.Create, path);
|
|
|
|
path = GetPathList (RegistryPermissionAccess.Read);
|
|
if (path != null)
|
|
rp.SetPathList (RegistryPermissionAccess.Read, path);
|
|
|
|
path = GetPathList (RegistryPermissionAccess.Write);
|
|
if (path != null)
|
|
rp.SetPathList (RegistryPermissionAccess.Write, path);
|
|
return rp;
|
|
}
|
|
|
|
public override void FromXml (SecurityElement esd)
|
|
{
|
|
// General validation in CodeAccessPermission
|
|
CheckSecurityElement (esd, "esd", version, version);
|
|
// Note: we do not (yet) care about the return value
|
|
// as we only accept version 1 (min/max values)
|
|
|
|
// General validation in CodeAccessPermission
|
|
CheckSecurityElement (esd, "esd", version, version);
|
|
// Note: we do not (yet) care about the return value
|
|
// as we only accept version 1 (min/max values)
|
|
|
|
if (IsUnrestricted (esd))
|
|
_state = PermissionState.Unrestricted;
|
|
|
|
string create = esd.Attribute ("Create");
|
|
if ((create != null) && (create.Length > 0))
|
|
SetPathList (RegistryPermissionAccess.Create, create);
|
|
|
|
string read = esd.Attribute ("Read");
|
|
if ((read != null) && (read.Length > 0))
|
|
SetPathList (RegistryPermissionAccess.Read, read);
|
|
|
|
string write = esd.Attribute ("Write");
|
|
if ((write != null) && (write.Length > 0))
|
|
SetPathList (RegistryPermissionAccess.Write, write);
|
|
}
|
|
|
|
public override IPermission Intersect (IPermission target)
|
|
{
|
|
RegistryPermission rp = Cast (target);
|
|
if (rp == null)
|
|
return null;
|
|
|
|
if (IsUnrestricted ())
|
|
return rp.Copy ();
|
|
if (rp.IsUnrestricted ())
|
|
return Copy ();
|
|
|
|
RegistryPermission result = new RegistryPermission (PermissionState.None);
|
|
|
|
IntersectKeys (createList, rp.createList, result.createList);
|
|
IntersectKeys (readList, rp.readList, result.readList);
|
|
IntersectKeys (writeList, rp.writeList, result.writeList);
|
|
|
|
return (result.IsEmpty () ? null : result);
|
|
}
|
|
|
|
public override bool IsSubsetOf (IPermission target)
|
|
{
|
|
RegistryPermission rp = Cast (target);
|
|
if (rp == null)
|
|
return false;
|
|
if (rp.IsEmpty ())
|
|
return IsEmpty ();
|
|
|
|
if (IsUnrestricted ())
|
|
return rp.IsUnrestricted ();
|
|
else if (rp.IsUnrestricted ())
|
|
return true;
|
|
|
|
if (!KeyIsSubsetOf (createList, rp.createList))
|
|
return false;
|
|
if (!KeyIsSubsetOf (readList, rp.readList))
|
|
return false;
|
|
if (!KeyIsSubsetOf (writeList, rp.writeList))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool IsUnrestricted ()
|
|
{
|
|
return (_state == PermissionState.Unrestricted);
|
|
}
|
|
|
|
public override SecurityElement ToXml ()
|
|
{
|
|
SecurityElement se = Element (version);
|
|
|
|
if (_state == PermissionState.Unrestricted) {
|
|
se.AddAttribute ("Unrestricted", "true");
|
|
}
|
|
else {
|
|
string path = GetPathList (RegistryPermissionAccess.Create);
|
|
if (path != null)
|
|
se.AddAttribute ("Create", path);
|
|
path = GetPathList (RegistryPermissionAccess.Read);
|
|
if (path != null)
|
|
se.AddAttribute ("Read", path);
|
|
path = GetPathList (RegistryPermissionAccess.Write);
|
|
if (path != null)
|
|
se.AddAttribute ("Write", path);
|
|
}
|
|
return se;
|
|
}
|
|
|
|
public override IPermission Union (IPermission other)
|
|
{
|
|
RegistryPermission rp = Cast (other);
|
|
if (rp == null)
|
|
return Copy ();
|
|
|
|
if (IsUnrestricted () || rp.IsUnrestricted ())
|
|
return new RegistryPermission (PermissionState.Unrestricted);
|
|
|
|
if (IsEmpty () && rp.IsEmpty ())
|
|
return null;
|
|
|
|
RegistryPermission result = (RegistryPermission) Copy ();
|
|
string path = rp.GetPathList (RegistryPermissionAccess.Create);
|
|
if (path != null)
|
|
result.AddPathList (RegistryPermissionAccess.Create, path);
|
|
path = rp.GetPathList (RegistryPermissionAccess.Read);
|
|
if (path != null)
|
|
result.AddPathList (RegistryPermissionAccess.Read, path);
|
|
path = rp.GetPathList (RegistryPermissionAccess.Write);
|
|
if (path != null)
|
|
result.AddPathList (RegistryPermissionAccess.Write, path);
|
|
return result;
|
|
}
|
|
|
|
// IBuiltInPermission
|
|
int IBuiltInPermission.GetTokenIndex ()
|
|
{
|
|
return (int) BuiltInToken.Registry;
|
|
}
|
|
|
|
// helpers
|
|
|
|
private bool IsEmpty ()
|
|
{
|
|
return ((_state == PermissionState.None) && (createList.Count == 0) &&
|
|
(readList.Count == 0) && (writeList.Count == 0));
|
|
}
|
|
|
|
private RegistryPermission Cast (IPermission target)
|
|
{
|
|
if (target == null)
|
|
return null;
|
|
|
|
RegistryPermission rp = (target as RegistryPermission);
|
|
if (rp == null) {
|
|
ThrowInvalidPermission (target, typeof (RegistryPermission));
|
|
}
|
|
|
|
return rp;
|
|
}
|
|
|
|
internal void ThrowInvalidFlag (RegistryPermissionAccess flag, bool context)
|
|
{
|
|
string msg = null;
|
|
if (context)
|
|
msg = Locale.GetText ("Unknown flag '{0}'.");
|
|
else
|
|
msg = Locale.GetText ("Invalid flag '{0}' in this context.");
|
|
throw new ArgumentException (String.Format (msg, flag), "flag");
|
|
}
|
|
|
|
private string GetPathList (ArrayList list)
|
|
{
|
|
if (IsUnrestricted ())
|
|
return String.Empty;
|
|
if (list.Count == 0)
|
|
return String.Empty;
|
|
StringBuilder sb = new StringBuilder ();
|
|
foreach (string path in list) {
|
|
sb.Append (path);
|
|
sb.Append (";");
|
|
}
|
|
|
|
string result = sb.ToString ();
|
|
// remove last ';'
|
|
int n = result.Length;
|
|
if (n > 0)
|
|
return result.Substring (0, n - 1);
|
|
return String.Empty;
|
|
}
|
|
|
|
internal bool KeyIsSubsetOf (IList local, IList target)
|
|
{
|
|
bool result = false;
|
|
foreach (string l in local) {
|
|
foreach (string t in target) {
|
|
if (l.StartsWith (t)) {
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!result)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal void AddWithUnionKey (IList list, string pathList)
|
|
{
|
|
string[] paths = pathList.Split (';');
|
|
foreach (string path in paths) {
|
|
int len = list.Count;
|
|
if (len == 0) {
|
|
list.Add (path);
|
|
}
|
|
else {
|
|
for (int i=0; i < len; i++) {
|
|
string s = (string) list [i];
|
|
if (s.StartsWith (path)) {
|
|
// replace (with reduced version)
|
|
list [i] = path;
|
|
}
|
|
else if (path.StartsWith (s)) {
|
|
// no need to add
|
|
}
|
|
else {
|
|
list.Add (path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void IntersectKeys (IList local, IList target, IList result)
|
|
{
|
|
foreach (string l in local) {
|
|
foreach (string t in target) {
|
|
if (t.Length > l.Length) {
|
|
if (t.StartsWith (l))
|
|
result.Add (t);
|
|
}
|
|
else {
|
|
if (l.StartsWith (t))
|
|
result.Add (l);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|