File: system\security\policy\pefileevidencefactory.cs
Project: ndp\clr\src\bcl\mscorlib.csproj (mscorlib)
// ==++==
// 
//   Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// ==--==
// <OWNER>Microsoft</OWNER>
// 
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security;
using System.Security.Cryptography.X509Certificates;
using System.Security.Policy;
using System.Security.Permissions;
using Microsoft.Win32.SafeHandles;
 
namespace System.Security.Policy
{
    /// <summary>
    ///     Arguments to the ETW evidence generation event.  This enumeration should be kept in sync with
    ///     the VM enumeration EvidenceType in SecurityPolicy.h.
    /// </summary>
    internal enum EvidenceTypeGenerated
    {
        AssemblySupplied,
        Gac,
        Hash,
        PermissionRequest,
        Publisher,
        Site,
        StrongName,
        Url,
        Zone
    }
 
    /// <summary>
    ///     Factory class which can create evidence on demand for a VM PEFile
    /// </summary>
    internal sealed class PEFileEvidenceFactory : IRuntimeEvidenceFactory
    {
        [System.Security.SecurityCritical] // auto-generated
        private SafePEFileHandle m_peFile;
 
        private List<EvidenceBase> m_assemblyProvidedEvidence;
 
        // Since all three of these evidence objects are generated from the same source data, we'll generate
        // all three when we're asked for any one of them and save them around in case we're asked for the
        // others.
        bool m_generatedLocationEvidence;
        private Site m_siteEvidence;
        private Url m_urlEvidence;
        private Zone m_zoneEvidence;
 
        [SecurityCritical]
        private PEFileEvidenceFactory(SafePEFileHandle peFile)
        {
            Contract.Assert(peFile != null &&
                            !peFile.IsClosed &&
                            !peFile.IsInvalid);
            m_peFile = peFile;
        }
 
        /// <summary>
        ///     PEFile * that we generate evidence for
        /// </summary>
        internal SafePEFileHandle PEFile
        {
            [SecurityCritical]
            get { return m_peFile; }
        }
 
        /// <summary>
        ///     Object the supplied evidence is for
        /// </summary>
        public IEvidenceFactory Target
        {
            // Since the CLR does not have a PEFile abstraction and this PEFile may not have an associated
            // assembly if we're early in runtime startup, there is no valid target object to return here.
            get { return null; }
        }
 
        /// <summary>
        ///     Generate an evidence collection the PE file.  This is called from the the VM in
        ///     SecurityDescriptor::GetEvidenceForPEFile. 
        /// </summary>
        [SecurityCritical]
        private static Evidence CreateSecurityIdentity(SafePEFileHandle peFile,
                                                       Evidence hostProvidedEvidence)
        {
 
            PEFileEvidenceFactory evidenceFactory = new PEFileEvidenceFactory(peFile);
            Evidence evidence = new Evidence(evidenceFactory);
 
            // If the host (caller of Assembly.Load) provided evidence, merge it with the evidence we've just
            // created. The host evidence takes priority.
            if (hostProvidedEvidence != null)
            {
                evidence.MergeWithNoDuplicates(hostProvidedEvidence);
            }
 
            return evidence;
        }
 
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SecurityCritical]
        [SuppressUnmanagedCodeSecurity]
        private static extern void FireEvidenceGeneratedEvent(SafePEFileHandle peFile,
                                                              EvidenceTypeGenerated type);
 
        /// <summary>
        ///     Fire an ETW event indicating that a piece of evidence has been generated.  Evidence that is
        ///     generated in the VM fires this event without a seperate call to this method, however
        ///     evidence types generated in the BCL, such as GacInstalled, need to call this directly.
        /// </summary>
        [SecuritySafeCritical]
        internal void FireEvidenceGeneratedEvent(EvidenceTypeGenerated type)
        {
            FireEvidenceGeneratedEvent(m_peFile, type);
        }
 
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SecurityCritical]
        [SuppressUnmanagedCodeSecurity]
        private static extern void GetAssemblySuppliedEvidence(SafePEFileHandle peFile,
                                                               ObjectHandleOnStack retSerializedEvidence);
 
        /// <summary>
        ///     Get any evidence that was serialized into the PE File
        /// </summary>
        [SecuritySafeCritical]
        public IEnumerable<EvidenceBase> GetFactorySuppliedEvidence()
        {
            if (m_assemblyProvidedEvidence == null)
            {
                byte[] serializedEvidence = null;
                GetAssemblySuppliedEvidence(m_peFile, JitHelpers.GetObjectHandleOnStack(ref serializedEvidence));
 
                m_assemblyProvidedEvidence = new List<EvidenceBase>();
                if (serializedEvidence != null)
                {
                    Evidence deserializedEvidence = new Evidence();
 
                    // Partial trust assemblies can provide their own evidence, so make sure that we have
                    // permission to deserialize it
                    new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
 
                    try
                    {
                        BinaryFormatter formatter = new BinaryFormatter();
                        using (MemoryStream ms = new MemoryStream(serializedEvidence))
                        {
                            deserializedEvidence = (Evidence)formatter.Deserialize(ms);
                        }
                    }
                    catch { /* Ignore any errors deserializing */ }
 
                    CodeAccessPermission.RevertAssert();
 
                    // Enumerate the assembly evidence, ignoring any host evidence supplied.  Since we
                    // could be loading a Whidbey assembly, we need to use the old GetAssemblyEnumerator
                    // API and deal with objects instead of EvidenceBases.
                    if (deserializedEvidence != null)
                    {
                        IEnumerator enumerator = deserializedEvidence.GetAssemblyEnumerator();
 
                        while (enumerator.MoveNext())
                        {
                            if (enumerator.Current != null)
                            {
                                // If this is a legacy evidence object, we need to wrap it before
                                // returning it.
                                EvidenceBase currentEvidence = enumerator.Current as EvidenceBase;
                                if (currentEvidence == null)
                                {
                                    currentEvidence = new LegacyEvidenceWrapper(enumerator.Current);
                                }
 
                                m_assemblyProvidedEvidence.Add(currentEvidence);
                            }
                        }
                    }
                }
            }
 
            return m_assemblyProvidedEvidence;
        }
 
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SecurityCritical]
        [SuppressUnmanagedCodeSecurity]
        private static extern void GetLocationEvidence(SafePEFileHandle peFile,
                                                       [Out] out SecurityZone zone,
                                                       StringHandleOnStack retUrl);
 
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SecurityCritical]
        [SuppressUnmanagedCodeSecurity]
        private static extern void GetPublisherCertificate(SafePEFileHandle peFile,
                                                           ObjectHandleOnStack retCertificate);
 
        /// <summary>
        ///     Called to generate different types of evidence on demand
        /// </summary>
        public EvidenceBase GenerateEvidence(Type evidenceType)
        {
            if (evidenceType == typeof(Site))
            {
                return GenerateSiteEvidence();
            }
            else if (evidenceType == typeof(Url))
            {
                return GenerateUrlEvidence();
            }
            else if (evidenceType == typeof(Zone))
            {
                return GenerateZoneEvidence();
            }
            else if (evidenceType == typeof(Publisher))
            {
                return GeneratePublisherEvidence();
            }
 
            return null;
        }
 
        /// <summary>
        ///     Generate Site, Url, and Zone evidence for this file.
        /// </summary>
        [SecuritySafeCritical]
        private void GenerateLocationEvidence()
        {
            if (!m_generatedLocationEvidence)
            {
                SecurityZone securityZone = SecurityZone.NoZone;
                string url = null;
                GetLocationEvidence(m_peFile, out securityZone, JitHelpers.GetStringHandleOnStack(ref url));
 
                if (securityZone != SecurityZone.NoZone)
                {
                    m_zoneEvidence = new Zone(securityZone);
                }
 
                if (!String.IsNullOrEmpty(url))
                {
                    m_urlEvidence = new Url(url, true);
 
                    // We only create site evidence if the URL does not with file:
                    if (!url.StartsWith("file:", StringComparison.OrdinalIgnoreCase))
                    {
                        m_siteEvidence = Site.CreateFromUrl(url);
                    }
                }
 
                m_generatedLocationEvidence = true;
            }
        }
 
        /// <summary>
        ///     Generate evidence for the file's Authenticode signature
        /// </summary>
        [SecuritySafeCritical]
        private Publisher GeneratePublisherEvidence()
        {
            byte[] certificate = null;
            GetPublisherCertificate(m_peFile, JitHelpers.GetObjectHandleOnStack(ref certificate));
 
            if (certificate == null)
            {
                return null;
            }
 
            return new Publisher(new X509Certificate(certificate));
        }
 
        /// <summary>
        ///     Generate evidence for the site this file was loaded from
        /// </summary>
        private Site GenerateSiteEvidence()
        {
            if (m_siteEvidence == null)
            {
                GenerateLocationEvidence();
            }
 
            return m_siteEvidence;
        }
 
        /// <summary>
        ///     Generate evidence for the URL this file was loaded from
        /// </summary>
        private Url GenerateUrlEvidence()
        {
            if (m_urlEvidence == null)
            {
                GenerateLocationEvidence();
            }
 
            return m_urlEvidence;
        }
 
        /// <summary>
        ///     Generate evidence for the zone this file was loaded from
        /// </summary>
        private Zone GenerateZoneEvidence()
        {
            if (m_zoneEvidence == null)
            {
                GenerateLocationEvidence();
            }
 
            return m_zoneEvidence;
        }
    }
}