받아 들여진 대답은 너무 설득력이있어서 이것이 버그가 아니라고 거의 믿었습니다. 그러나 몇 가지 실험을 한 후에는 Level2 보안이 완전히 엉망이라고 말할 수 있습니다. 적어도 뭔가 정말 비린내입니다.

며칠 전에 도서관에서 같은 문제에 부딪 혔습니다. 빠르게 단위 테스트를 만들었습니다. 그러나 .NET Fiddle에서 경험 한 문제를 재현 할 수 없었고, 동일한 코드가 “성공적으로”콘솔 앱에서 예외를 던졌습니다. 결국 나는 문제를 극복하는 두 가지 이상한 방법을 발견했습니다.

요약 : 소비자 프로젝트에서 사용 된 라이브러리의 내부 유형을 사용하면 부분적으로 신뢰할 수있는 코드가 예상대로 작동합니다. ISerializable구현 을 인스턴스화 할 수 있습니다 (보안에 중요한 코드는 직접 호출 할 수 없습니다. 그러나 아래 참조). 또는 훨씬 더 우스꽝 스럽지만 처음으로 작동하지 않았다면 샌드 박스를 다시 만들 수 있습니다.

하지만 몇 가지 코드를 살펴 보겠습니다.

ClassLibrary.dll :

두 가지 경우를 분리 해 보겠습니다. 하나는 보안에 중요한 내용이있는 일반 클래스 용이고 다른 하나는 ISerializable구현입니다.

public class CriticalClass
{
    public void SafeCode() { }

    [SecurityCritical]
    public void CriticalCode() { }

    [SecuritySafeCritical]
    public void SafeEntryForCriticalCode() => CriticalCode();
}

[Serializable]
public class SerializableCriticalClass : CriticalClass, ISerializable
{
    public SerializableCriticalClass() { }

    private SerializableCriticalClass(SerializationInfo info, StreamingContext context) { }

    [SecurityCritical]
    public void GetObjectData(SerializationInfo info, StreamingContext context) { }
}

문제를 극복하는 한 가지 방법은 소비자 어셈블리의 내부 유형을 사용하는 것입니다. 어떤 유형이든 할 수 있습니다. 이제 속성을 정의합니다.

[AttributeUsage(AttributeTargets.All)]
internal class InternalTypeReferenceAttribute : Attribute
{
    public InternalTypeReferenceAttribute() { }
}

어셈블리에 적용된 관련 특성 :

[assembly: InternalsVisibleTo("UnitTest, PublicKey=<your public key>")]
[assembly: AllowPartiallyTrustedCallers]
[assembly: SecurityRules(SecurityRuleSet.Level2, SkipVerificationInFullTrust = true)]

어셈블리에 서명하고 InternalsVisibleTo속성에 키를 적용하고 테스트 프로젝트를 준비합니다.

UnitTest.dll (NUnit 및 ClassLibrary 사용) :

내부 트릭을 사용하려면 테스트 어셈블리도 서명해야합니다. 어셈블리 속성 :

// Just to make the tests security transparent by default. This helps to test the full trust behavior.
[assembly: AllowPartiallyTrustedCallers]

// !!! Comment this line out and the partial trust test cases may fail for the fist time !!!
[assembly: InternalTypeReference]

참고 : 속성은 어디에나 적용 할 수 있습니다. 제 경우에는 무작위 테스트 클래스의 메소드에 있었는데 찾아내는 데 며칠이 걸렸습니다.

참고 2 : 모든 테스트 메서드를 함께 실행하면 테스트가 통과 될 수 있습니다.

테스트 클래스의 골격 :

[TestFixture]
public class SecurityCriticalAccessTest
{
    private partial class Sandbox : MarshalByRefObject
    {
    }

    private static AppDomain CreateSandboxDomain(params IPermission[] permissions)
    {
        var evidence = new Evidence(AppDomain.CurrentDomain.Evidence);
        var permissionSet = GetPermissionSet(permissions);
        var setup = new AppDomainSetup
        {
            ApplicationBase = AppDomain.CurrentDomain.BaseDirectory,
        };

        var assemblies = AppDomain.CurrentDomain.GetAssemblies();
        var strongNames = new List<StrongName>();
        foreach (Assembly asm in assemblies)
        {
            AssemblyName asmName = asm.GetName();
            strongNames.Add(new StrongName(new StrongNamePublicKeyBlob(asmName.GetPublicKey()), asmName.Name, asmName.Version));
        }

        return AppDomain.CreateDomain("SandboxDomain", evidence, setup, permissionSet, strongNames.ToArray());
    }

    private static PermissionSet GetPermissionSet(IPermission[] permissions)
    {
        var evidence = new Evidence();
        evidence.AddHostEvidence(new Zone(SecurityZone.Internet));
        var result = SecurityManager.GetStandardSandbox(evidence);
        foreach (var permission in permissions)
            result.AddPermission(permission);
        return result;
    }
}

그리고 테스트 케이스를 하나씩 보자

사례 1 : ISerializable 구현

질문에서와 같은 문제입니다. 테스트는 다음과 같은 경우 통과합니다.

• InternalTypeReferenceAttribute 은 적용되다
• 샌드 박스를 여러 번 만들려고합니다 (코드 참조).
• 또는 모든 테스트 케이스가 한 번에 실행되고 이것이 첫 번째가 아닌 경우

그렇지 않으면 Inheritance security rules violated while overriding member...인스턴스화 할 때 완전히 부적절한 예외가 발생합니다 SerializableCriticalClass.

[Test]
[SecuritySafeCritical] // for Activator.CreateInstance
public void SerializableCriticalClass_PartialTrustAccess()
{
    var domain = CreateSandboxDomain(
        new SecurityPermission(SecurityPermissionFlag.SerializationFormatter), // BinaryFormatter
        new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)); // Assert.IsFalse
    var handle = Activator.CreateInstance(domain, Assembly.GetExecutingAssembly().FullName, typeof(Sandbox).FullName);
    var sandbox = (Sandbox)handle.Unwrap();
    try
    {
        sandbox.TestSerializableCriticalClass();
        return;
    }
    catch (Exception e)
    {
        // without [InternalTypeReference] it may fail for the first time
        Console.WriteLine($"1st try failed: {e.Message}");
    }

    domain = CreateSandboxDomain(
        new SecurityPermission(SecurityPermissionFlag.SerializationFormatter), // BinaryFormatter
        new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)); // Assert.IsFalse
    handle = Activator.CreateInstance(domain, Assembly.GetExecutingAssembly().FullName, typeof(Sandbox).FullName);
    sandbox = (Sandbox)handle.Unwrap();
    sandbox.TestSerializableCriticalClass();

    Assert.Inconclusive("Meh... succeeded only for the 2nd try");
}

private partial class Sandbox
{
    public void TestSerializableCriticalClass()
    {
        Assert.IsFalse(AppDomain.CurrentDomain.IsFullyTrusted);

        // ISerializable implementer can be created.
        // !!! May fail for the first try if the test does not use any internal type of the library. !!!
        var critical = new SerializableCriticalClass();

        // Critical method can be called via a safe method
        critical.SafeEntryForCriticalCode();

        // Critical method cannot be called directly by a transparent method
        Assert.Throws<MethodAccessException>(() => critical.CriticalCode());
        Assert.Throws<MethodAccessException>(() => critical.GetObjectData(null, new StreamingContext()));

        // BinaryFormatter calls the critical method via a safe route (SerializationFormatter permission is required, though)
        new BinaryFormatter().Serialize(new MemoryStream(), critical);
    }

}

사례 2 : 보안에 중요한 구성원이있는 정규 클래스

테스트는 첫 번째 테스트와 동일한 조건에서 통과됩니다. 그러나 여기서 문제는 완전히 다릅니다. 부분적으로 신뢰할 수있는 코드가 보안에 중요한 구성원에 직접 액세스 할 수 있습니다 .

[Test]
[SecuritySafeCritical] // for Activator.CreateInstance
public void CriticalClass_PartialTrustAccess()
{
    var domain = CreateSandboxDomain(
        new ReflectionPermission(ReflectionPermissionFlag.MemberAccess), // Assert.IsFalse
        new EnvironmentPermission(PermissionState.Unrestricted)); // Assert.Throws (if fails)
    var handle = Activator.CreateInstance(domain, Assembly.GetExecutingAssembly().FullName, typeof(Sandbox).FullName);
    var sandbox = (Sandbox)handle.Unwrap();
    try
    {
        sandbox.TestCriticalClass();
        return;
    }
    catch (Exception e)
    {
        // without [InternalTypeReference] it may fail for the first time
        Console.WriteLine($"1st try failed: {e.Message}");
    }

    domain = CreateSandboxDomain(
        new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)); // Assert.IsFalse
    handle = Activator.CreateInstance(domain, Assembly.GetExecutingAssembly().FullName, typeof(Sandbox).FullName);
    sandbox = (Sandbox)handle.Unwrap();
    sandbox.TestCriticalClass();

    Assert.Inconclusive("Meh... succeeded only for the 2nd try");
}

private partial class Sandbox
{
    public void TestCriticalClass()
    {
        Assert.IsFalse(AppDomain.CurrentDomain.IsFullyTrusted);

        // A type containing critical methods can be created
        var critical = new CriticalClass();

        // Critical method can be called via a safe method
        critical.SafeEntryForCriticalCode();

        // Critical method cannot be called directly by a transparent method
        // !!! May fail for the first time if the test does not use any internal type of the library. !!!
        // !!! Meaning, a partially trusted code has more right than a fully trusted one and is       !!!
        // !!! able to call security critical method directly.                                        !!!
        Assert.Throws<MethodAccessException>(() => critical.CriticalCode());
    }
}

사례 3-4 : 사례 1-2의 완전 신뢰 버전

완전성을 위해 여기에는 완전히 신뢰할 수있는 도메인에서 실행 된 위와 동일한 경우가 있습니다. [assembly: AllowPartiallyTrustedCallers]테스트 를 제거 하면 중요한 코드에 직접 액세스 할 수 있기 때문에 실패합니다 (메소드는 더 이상 기본적으로 투명하지 않기 때문입니다).

[Test]
public void CriticalClass_FullTrustAccess()
{
    Assert.IsTrue(AppDomain.CurrentDomain.IsFullyTrusted);

    // A type containing critical methods can be created
    var critical = new CriticalClass();

    // Critical method cannot be called directly by a transparent method
    Assert.Throws<MethodAccessException>(() => critical.CriticalCode());

    // Critical method can be called via a safe method
    critical.SafeEntryForCriticalCode();
}

[Test]
public void SerializableCriticalClass_FullTrustAccess()
{
    Assert.IsTrue(AppDomain.CurrentDomain.IsFullyTrusted);

    // ISerializable implementer can be created
    var critical = new SerializableCriticalClass();

    // Critical method cannot be called directly by a transparent method (see also AllowPartiallyTrustedCallersAttribute)
    Assert.Throws<MethodAccessException>(() => critical.CriticalCode());
    Assert.Throws<MethodAccessException>(() => critical.GetObjectData(null, default(StreamingContext)));

    // Critical method can be called via a safe method
    critical.SafeEntryForCriticalCode();

    // BinaryFormatter calls the critical method via a safe route
    new BinaryFormatter().Serialize(new MemoryStream(), critical);
}

발문:

물론 이것은 .NET Fiddle의 문제를 해결하지 못합니다. 하지만 지금은 그것이 프레임 워크의 버그가 아니었다면 매우 놀랄 것입니다.

지금 저에게 가장 큰 질문은 받아 들여지는 답변에서 인용 된 부분입니다. 이 말도 안되는 소리로 어떻게 나왔습니까? 이것은 ISafeSerializationData분명히 어떤 것에 대한 해결책이 아닙니다. 기본 Exception클래스 에서만 독점적으로 사용 되며 SerializeObjectState이벤트 를 구독하면 (무시할 수있는 메서드가 아닌 이유는 무엇입니까?) 결국 상태도 소비됩니다 Exception.GetObjectData.

AllowPartiallyTrustedCallers/ SecurityCritical/ SecuritySafeCritical속성의 삼인조는 위 정확히 사용을 위해 설계되었습니다. 부분적으로 신뢰할 수있는 코드는 보안에 중요한 멤버를 사용하는 시도에 관계없이 유형을 인스턴스화 할 수 없다는 것은 나에게 완전히 말도 안되는 것 같습니다. 그러나 부분적으로 신뢰할 수있는 코드가 보안에 중요한 방법에 직접 액세스 할 수 있다는 것은 (실제로 보안 구멍 ) 더 큰 말도 안되는 일입니다 ( 사례 2 참조 ). 반면 완전히 신뢰할 수있는 도메인에서도 투명한 방법에 대해 금지되어 있습니다.

따라서 소비자 프로젝트가 테스트이거나 다른 잘 알려진 어셈블리 인 경우 내부 트릭을 완벽하게 사용할 수 있습니다. .NET Fiddle 및 기타 실제 샌드 박스 환경의 경우 유일한 솔루션은 SecurityRuleSet.Level1Microsoft에서이 문제 를 해결할 때까지 되 돌리는 것 입니다.

업데이트 : 문제에 대한 개발자 커뮤니티 티켓 이 생성되었습니다.

답변

using System;
using System.Security.Permissions;
using System.Runtime.Serialization;

namespace Samples2
{
    [Serializable]
    public class Book : ISerializable
    {
        private readonly string _Title;

        public Book(string title)
        {
            if (title == null)
                throw new ArgumentNullException("title");

            _Title = title;
        }

        protected Book(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
                throw new ArgumentNullException("info");

            _Title = info.GetString("Title");
        }

        public string Title
        {
            get { return _Title; }
        }

        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
        protected virtual void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("Title", _Title);
        }

        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
                throw new ArgumentNullException("info");

            GetObjectData(info, context);
        }
    }

    [Serializable]
    public class LibraryBook : Book
    {
        private readonly DateTime _CheckedOut;

        public LibraryBook(string title, DateTime checkedOut)
            : base(title)
        {
            _CheckedOut = checkedOut;
        }

        protected LibraryBook(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            _CheckedOut = info.GetDateTime("CheckedOut");
        }

        public DateTime CheckedOut
        {
            get { return _CheckedOut; }
        }

        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
        protected override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            base.GetObjectData(info, context);

            info.AddValue("CheckedOut", _CheckedOut);
        }
    }
}