GuardedFabricTools

1.1.0

CertificateManagement/CertificateManagement.psm1

# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.

function Test-Nano
{
    $EditionId = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' -Name 'EditionID').EditionId

    return (($EditionId -eq "ServerStandardNano") -or
            ($EditionId -eq "ServerDataCenterNano") -or
            ($EditionId -eq "NanoServer") -or
            ($EditionId -eq "ServerTuva"))
}


$ncryptDll = "ncrypt.dll"
$crypt32Dll = "crypt32.dll"

if (-not (Test-Nano))
{
    Write-Verbose "Not running on Nano, using default Win32 binaries."
    $securityDll = "advapi32.dll"
    $capiDll = "advapi32.dll"
    $references = @()
    $PrepareConstrainedRegions = "RuntimeHelpers.PrepareConstrainedRegions();"
}
else
{
    Write-Verbose "Running on Nano, using API sets."
    $securityDll = "api-ms-win-security-base-l1-2-0"
    $capiDll = "api-ms-win-security-cryptoapi-l1-1-0"
    $PrepareConstrainedRegions = "";
    $references =   "System.Security.Cryptography.X509Certificates.dll", `
                    "System.Security.Cryptography.Cng.dll", `
                    "System.IO.FileSystem.AccessControl.dll", `
                    "System.Runtime.Handles.dll", `
                    "System.Security.AccessControl.dll", `
                    "Microsoft.Win32.Primitives.dll" | % { Join-Path "C:\Windows\system32\DotNetCore\v1.0\" $_ }
}

$source = @"
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.AccessControl;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Win32.SafeHandles;
 
namespace Contoso
{
    public static class CryptoTriage
    {
        private const string NCRYPT = "$ncryptDll";
        private const string CRYPT32 = "$crypt32Dll";
        private const string APIMSWINSECURITYBASE = "$securityDll";
        private const string APIMSWINSECURITYCRYPTOAPI = "$capiDll";
 
        internal const string NCRYPT_SECURITY_DESCR_PROPERTY = "Security Descr";
 
        [Flags]
        public enum SECURITY_INFORMATION : uint
        {
            OWNER_SECURITY_INFORMATION = 0x00000001,
            GROUP_SECURITY_INFORMATION = 0x00000002,
            DACL_SECURITY_INFORMATION = 0x00000004,
            SACL_SECURITY_INFORMATION = 0x00000008,
            UNPROTECTED_SACL_SECURITY_INFORMATION = 0x10000000,
            UNPROTECTED_DACL_SECURITY_INFORMATION = 0x20000000,
            PROTECTED_SACL_SECURITY_INFORMATION = 0x40000000,
            PROTECTED_DACL_SECURITY_INFORMATION = 0x80000000
        }
 
        [Flags]
        private enum CryptAcquireKeyFlagControl : uint
        {
            CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG = 0x00010000,
            CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG = 0x00020000,
            CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG = 0x00040000,
        }
 
        [Flags]
        public enum CryptAcquireKeyFlags : uint
        {
            CRYPT_ACQUIRE_CACHE_FLAG = 0x00000001,
            CRYPT_ACQUIRE_USE_PROV_INFO_FLAG = 0x00000002,
            CRYPT_ACQUIRE_COMPARE_KEY_FLAG = 0x00000004,
            CRYPT_ACQUIRE_NO_HEALING = 0x00000008,
            CRYPT_ACQUIRE_SILENT_FLAG = 0x00000040,
        }
 
        [Flags]
        public enum CryptAcquireNCryptKeyFlags : uint
        {
            CRYPT_ACQUIRE_CACHE_FLAG = CryptAcquireKeyFlags.CRYPT_ACQUIRE_CACHE_FLAG | CryptAcquireKeyFlagControl.CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG,
            CRYPT_ACQUIRE_USE_PROV_INFO_FLAG = CryptAcquireKeyFlags.CRYPT_ACQUIRE_USE_PROV_INFO_FLAG | CryptAcquireKeyFlagControl.CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG,
            CRYPT_ACQUIRE_COMPARE_KEY_FLAG = CryptAcquireKeyFlags.CRYPT_ACQUIRE_COMPARE_KEY_FLAG | CryptAcquireKeyFlagControl.CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG,
            CRYPT_ACQUIRE_NO_HEALING = CryptAcquireKeyFlags.CRYPT_ACQUIRE_NO_HEALING | CryptAcquireKeyFlagControl.CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG,
            CRYPT_ACQUIRE_SILENT_FLAG = CryptAcquireKeyFlags.CRYPT_ACQUIRE_SILENT_FLAG | CryptAcquireKeyFlagControl.CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG,
        }
 
        public enum ErrorCode
        {
            Success = 0, // ERROR_SUCCESS
            BadSignature = unchecked((int)0x80090006), // NTE_BAD_SIGNATURE
            NotFound = unchecked((int)0x80090011), // NTE_NOT_FOUND
            KeyDoesNotExist = unchecked((int)0x80090016), // NTE_BAD_KEYSET
            BufferTooSmall = unchecked((int)0x80090028), // NTE_BUFFER_TOO_SMALL
            NoMoreItems = unchecked((int)0x8009002a), // NTE_NO_MORE_ITEMS
            NotSupported = unchecked((int)0x80090029) // NTE_NOT_SUPPORTED
        }
 
        public enum KeySpec : uint
        {
            NONE = 0x0,
            AT_KEYEXCHANGE = 0x1,
            AT_SIGNATURE = 2,
            CERT_NCRYPT_KEY_SPEC = 0xFFFFFFFF
        }
 
        public enum ProvParam : uint
        {
            PP_ENUMALGS = 1,
            PP_ENUMCONTAINERS = 2,
            PP_IMPTYPE = 3,
            PP_NAME = 4,
            PP_VERSION = 5,
            PP_CONTAINER = 6,
            PP_CHANGE_PASSWORD = 7,
            PP_KEYSET_SEC_DESCR = 8, // get/set security descriptor of keyset
            PP_CERTCHAIN = 9, // for retrieving certificates from tokens
            PP_KEY_TYPE_SUBTYPE = 10,
            PP_PROVTYPE = 16,
            PP_KEYSTORAGE = 17,
            PP_APPLI_CERT = 18,
            PP_SYM_KEYSIZE = 19,
            PP_SESSION_KEYSIZE = 20,
            PP_UI_PROMPT = 21,
            PP_ENUMALGS_EX = 22,
            PP_ENUMMANDROOTS = 25,
            PP_ENUMELECTROOTS = 26,
            PP_KEYSET_TYPE = 27,
            PP_ADMIN_PIN = 31,
            PP_KEYEXCHANGE_PIN = 32,
            PP_SIGNATURE_PIN = 33,
            PP_SIG_KEYSIZE_INC = 34,
            PP_KEYX_KEYSIZE_INC = 35,
            PP_UNIQUE_CONTAINER = 36,
            PP_SGC_INFO = 37,
            PP_USE_HARDWARE_RNG = 38,
            PP_KEYSPEC = 39,
            PP_ENUMEX_SIGNING_PROT = 40,
            PP_CRYPT_COUNT_KEY_USE = 41,
        }
 
        [DllImport(APIMSWINSECURITYBASE, CharSet = CharSet.Unicode, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool GetSecurityDescriptorDacl(
            IntPtr pSecurityDescriptor,
            [MarshalAs(UnmanagedType.Bool)] out bool bDaclPresent,
            ref IntPtr pDacl,
            [MarshalAs(UnmanagedType.Bool)] out bool bDaclDefaulted);
 
        [DllImport(NCRYPT, CharSet = CharSet.Unicode, SetLastError = true)]
        public static extern ErrorCode NCryptGetProperty(
            SafeHandle hObject,
            [MarshalAs(UnmanagedType.LPWStr)] string pszProperty,
            SafeSecurityDescriptorPtr pbOutput,
            uint cbOutput,
            ref uint pcbResult,
            SECURITY_INFORMATION dwFlags);
 
        [DllImport(NCRYPT, CharSet = CharSet.Unicode, SetLastError = true)]
        public static extern ErrorCode NCryptSetProperty(
            SafeHandle hObject,
            [MarshalAs(UnmanagedType.LPWStr)] string pszProperty,
            [MarshalAs(UnmanagedType.LPArray)] byte[] pbInput,
            uint cbInput,
            SECURITY_INFORMATION dwFlags);
 
        [DllImport(CRYPT32, CharSet = CharSet.Unicode, SetLastError = true)]
        public static extern bool CryptAcquireCertificatePrivateKey(
            IntPtr pCert,
            CryptAcquireKeyFlags dwFlags,
            IntPtr pvParameters,
            out SafeCryptProviderHandle phCryptProvOrNCryptKey,
            out KeySpec pdwKeySpec,
            out bool pfCallerFreeProvOrNCryptKey);
 
        [DllImport(CRYPT32, CharSet = CharSet.Unicode, SetLastError = true)]
        public static extern bool CryptAcquireCertificatePrivateKey(
            IntPtr pCert,
            CryptAcquireNCryptKeyFlags dwFlags,
            IntPtr pvParameters,
            out SafeNCryptKeyHandle phCryptProvOrNCryptKey,
            out KeySpec pdwKeySpec,
            out bool pfCallerFreeProvOrNCryptKey);
 
        [DllImport(APIMSWINSECURITYCRYPTOAPI, CharSet = CharSet.Unicode, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CryptContextAddRef(
            SafeCryptProviderHandle hProv,
            IntPtr pdwReserved,
            uint dwFlags);
 
        [DllImport(APIMSWINSECURITYCRYPTOAPI, CharSet = CharSet.Unicode, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CryptReleaseContext(
            IntPtr hProv,
            uint dwFlags);
 
        [DllImport(APIMSWINSECURITYCRYPTOAPI, CharSet = CharSet.Unicode, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CryptGetProvParam(
            SafeHandle hProv,
            ProvParam dwParam,
            SafeSecurityDescriptorPtr pbData,
            ref uint pdwDataLen,
            SECURITY_INFORMATION dwFlags);
 
        [DllImport(APIMSWINSECURITYCRYPTOAPI, CharSet = CharSet.Unicode, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CryptSetProvParam(
            SafeHandle hProv,
            ProvParam dwParam,
            [MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
            SECURITY_INFORMATION dwFlags);
 
        public static TriageHandle TriageAcquireKeyHandle(X509Certificate2 certificate)
        {
            SafeNCryptKeyHandle ncryptKeyHandle = null;
            SafeCryptProviderHandle cspHandle = null;
            KeySpec keySpec;
            bool ownHandle = true;
 
            if (!CryptAcquireCertificatePrivateKey(
                    certificate.Handle,
                    CryptAcquireKeyFlags.CRYPT_ACQUIRE_SILENT_FLAG,
                    IntPtr.Zero,
                    out cspHandle,
                    out keySpec,
                    out ownHandle))
            {
                Win32Exception cspException = new Win32Exception(Marshal.GetLastWin32Error());
 
                if (!CryptAcquireCertificatePrivateKey(
                        certificate.Handle,
                        CryptAcquireNCryptKeyFlags.CRYPT_ACQUIRE_SILENT_FLAG,
                        IntPtr.Zero,
                        out ncryptKeyHandle,
                        out keySpec,
                        out ownHandle))
                {
                    throw new AggregateException(
                        new Win32Exception(Marshal.GetLastWin32Error()),
                        cspException);
                }
            }
 
            if (!ownHandle)
            {
                throw new NotSupportedException("Must be able to take ownership of the certificate private key handle.");
            }
 
            if (ncryptKeyHandle != null)
            {
                return new CngTriageHandle(ncryptKeyHandle);
            }
            else if (cspHandle != null)
            {
                if (keySpec != KeySpec.AT_KEYEXCHANGE && keySpec != KeySpec.AT_SIGNATURE)
                {
                    throw new NotSupportedException("Only exchange or signature key pairs are supported.");
                }
 
                return new CapiTriageHandle(cspHandle);
            }
            else
            {
                throw new NotSupportedException("The certificate private key cannot be accessed.");
            }
        }
 
        public static void AssertSuccess(this ErrorCode code)
        {
            if (code != ErrorCode.Success)
            {
                throw new Win32Exception((int)code);
            }
        }
 
        public class SafeCryptProviderHandle : SafeHandleZeroOrMinusOneIsInvalid
        {
            private static SafeCryptProviderHandle nullHandle = new SafeCryptProviderHandle();
 
            public SafeCryptProviderHandle()
                : base(true)
            {
            }
 
            public SafeCryptProviderHandle(IntPtr handle)
                : base(true)
            {
                this.SetHandle(handle);
            }
 
            public static SafeCryptProviderHandle Null
            {
                get
                {
                    return nullHandle;
                }
            }
 
            internal SafeCryptProviderHandle Duplicate()
            {
                if (this.IsInvalid || this.IsClosed)
                {
                    throw new InvalidOperationException();
                }
 
                // in the window between the call to CryptContextAddRef and when the raw handle value is assigned
                // into the new safe handle, there's a second reference to the original safe handle that the CLR does
                // not know about, so we need to bump the reference count around this entire operation to ensure
                // that we don't have the original handle closed underneath us.
                bool acquired = false;
                try
                {
                    this.DangerousAddRef(ref acquired);
                    IntPtr underlyingHandle = this.DangerousGetHandle();
                    SafeCryptProviderHandle duplicate = new SafeCryptProviderHandle();
                    int lastError = 0;
 
                    // atomically add reference and set handle on the duplicate
                    $PrepareConstrainedRegions
                    try
                    {
                    }
                    finally
                    {
                        if (!CryptContextAddRef(this, IntPtr.Zero, 0))
                        {
                            lastError = Marshal.GetLastWin32Error();
                        }
                        else
                        {
                            duplicate.SetHandle(underlyingHandle);
                        }
                    }
 
                    if (lastError != 0)
                    {
                        duplicate.Dispose();
                        throw new Win32Exception(lastError);
                    }
 
                    return duplicate;
                }
                finally
                {
                    if (acquired)
                    {
                        this.DangerousRelease();
                    }
                }
            }
 
            protected override bool ReleaseHandle()
            {
                return CryptReleaseContext(this.handle, 0);
            }
        }
 
        public class SafeSecurityDescriptorPtr : SafeHandleZeroOrMinusOneIsInvalid
        {
            private static SafeSecurityDescriptorPtr nullHandle = new SafeSecurityDescriptorPtr();
 
            private int size = -1;
 
            public SafeSecurityDescriptorPtr()
                : base(true)
            {
            }
 
            public SafeSecurityDescriptorPtr(uint size)
                : base(true)
            {
                this.size = (int)size;
                this.SetHandle(Marshal.AllocHGlobal(this.size));
            }
 
            public SafeSecurityDescriptorPtr(IntPtr handle)
                : base(true)
            {
                this.SetHandle(handle);
            }
 
            public static SafeSecurityDescriptorPtr Null
            {
                get
                {
                    return nullHandle;
                }
            }
 
            public IntPtr GetDacl()
            {
                IntPtr pDacl = IntPtr.Zero;
                bool daclPresent = false;
                bool daclDefaulted = false;
 
                if (!GetSecurityDescriptorDacl(
                        this.handle,
                        out daclPresent,
                        ref pDacl,
                        out daclDefaulted))
                {
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }
 
                if (!daclPresent)
                {
                    return IntPtr.Zero;
                }
                else
                {
                    return pDacl;
                }
            }
 
            public byte[] GetBinaryForm()
            {
                if (size < 0)
                {
                    throw new NotSupportedException();
                }
 
                byte[] buffer = new byte[size];
                Marshal.Copy(this.handle, buffer, 0, buffer.Length);
 
                return buffer;
            }
 
            protected override bool ReleaseHandle()
            {
                try
                {
                    Marshal.FreeHGlobal(this.handle);
                    return true;
                }
                catch
                {
                    // semantics of this function are to never throw an exception so we must eat the underlying error and
                    // return false.
                    return false;
                }
            }
        }
 
        public abstract class TriageHandle : IDisposable
        {
            public TriageHandle()
            {
            }
 
            public abstract FileSecurity Acl
            {
                get;
                set;
            }
 
            public abstract bool IsValid
            {
                get;
            }
 
            public abstract void Dispose();
        }
 
        public class CapiTriageHandle : TriageHandle
        {
            public CapiTriageHandle(SafeCryptProviderHandle handle) : base()
            {
                this.Handle = handle;
            }
 
            public override bool IsValid
            {
                get
                {
                    return this.Handle != null && !this.Handle.IsInvalid && !this.Handle.IsClosed;
                }
            }
 
            public override FileSecurity Acl
            {
                get
                {
                    uint securityDescriptorSize = 0;
                    if (!CryptGetProvParam(
                            this.Handle,
                            ProvParam.PP_KEYSET_SEC_DESCR,
                            SafeSecurityDescriptorPtr.Null,
                            ref securityDescriptorSize,
                            SECURITY_INFORMATION.DACL_SECURITY_INFORMATION))
                    {
                        throw new Win32Exception(Marshal.GetLastWin32Error());
                    }
 
                    SafeSecurityDescriptorPtr securityDescriptorBuffer = new SafeSecurityDescriptorPtr(securityDescriptorSize);
 
                    if (!CryptGetProvParam(
                            this.Handle,
                            ProvParam.PP_KEYSET_SEC_DESCR,
                            securityDescriptorBuffer,
                            ref securityDescriptorSize,
                            SECURITY_INFORMATION.DACL_SECURITY_INFORMATION))
                    {
                        throw new Win32Exception(Marshal.GetLastWin32Error());
                    }
 
                    using (securityDescriptorBuffer)
                    {
                        FileSecurity acl = new FileSecurity();
                        acl.SetSecurityDescriptorBinaryForm(securityDescriptorBuffer.GetBinaryForm());
                        return acl;
                    }
                }
 
                set
                {
                    if (!CryptSetProvParam(
                        this.Handle,
                        ProvParam.PP_KEYSET_SEC_DESCR,
                        value.GetSecurityDescriptorBinaryForm(),
                        SECURITY_INFORMATION.DACL_SECURITY_INFORMATION))
                    {
                        throw new Win32Exception(Marshal.GetLastWin32Error());
                    }
                }
            }
 
            protected SafeCryptProviderHandle Handle
            {
                get;
                set;
            }
 
            public override void Dispose()
            {
                this.Handle.Dispose();
            }
        }
 
        public class CngTriageHandle : TriageHandle
        {
            public CngTriageHandle(SafeNCryptHandle handle) : base()
            {
                this.Handle = handle;
            }
 
            public override bool IsValid
            {
                get
                {
                    return this.Handle != null && !this.Handle.IsInvalid && !this.Handle.IsClosed;
                }
            }
 
            public override FileSecurity Acl
            {
                get
                {
                    uint securityDescriptorSize = 0;
                    NCryptGetProperty(
                        this.Handle,
                        NCRYPT_SECURITY_DESCR_PROPERTY,
                        SafeSecurityDescriptorPtr.Null,
                        0,
                        ref securityDescriptorSize,
                        SECURITY_INFORMATION.DACL_SECURITY_INFORMATION).AssertSuccess();
 
                    SafeSecurityDescriptorPtr securityDescriptorBuffer = new SafeSecurityDescriptorPtr(securityDescriptorSize);
 
                    NCryptGetProperty(
                        this.Handle,
                        NCRYPT_SECURITY_DESCR_PROPERTY,
                        securityDescriptorBuffer,
                        securityDescriptorSize,
                        ref securityDescriptorSize,
                        SECURITY_INFORMATION.DACL_SECURITY_INFORMATION).AssertSuccess();
 
                    using (securityDescriptorBuffer)
                    {
                        FileSecurity acl = new FileSecurity();
                        acl.SetSecurityDescriptorBinaryForm(securityDescriptorBuffer.GetBinaryForm());
                        return acl;
                    }
                }
 
                set
                {
                    byte[] sd = value.GetSecurityDescriptorBinaryForm();
                    NCryptSetProperty(
                        this.Handle,
                        NCRYPT_SECURITY_DESCR_PROPERTY,
                        sd,
                        (uint)sd.Length,
                        SECURITY_INFORMATION.DACL_SECURITY_INFORMATION).AssertSuccess();
                }
            }
 
            protected SafeNCryptHandle Handle
            {
                get;
                set;
            }
 
            public override void Dispose()
            {
                this.Handle.Dispose();
            }
        }
    }
}
"@

if (-not $global:ContosoCertificateManagementCompiled)
{
    Write-Verbose "Loading certificate management p/invoke shim."
    Add-Type -TypeDefinition $source -Language CSharp -ReferencedAssemblies $references -ErrorAction Stop
    $global:ContosoCertificateManagementCompiled = $true
}
else
{
    Write-Warning "Certificate management class was already loaded. If you made any changes, you will need to close and re-open PowerShell to successfully import the new module."
}


function Add-AccessRule
{
    <#
    .SYNOPSIS
    Adds a file access rule to a file security descriptor.
 
    .DESCRIPTION
    Accepts a file access rule or constructs a new access rule from the provided parameters and appends it to an existing file security descriptor. Leaves the original security descriptor intact and returns an updated copy.
 
    .PARAMETER SD
    An existing file security descriptor. Can be retrieved from certificates by accessing the Acl property.
 
    .PARAMETER UserAccount
    A string identifying a user or group principal that will be controled by this access rule.
 
    .PARAMETER FileSystemRights
    The rights to be granted to the UserAccount by this access rule.
 
    .PARAMETER AccessControlType
    Whether this is an allow or deny access rule.
 
    .PARAMETER Rule
    A pre-created file system access rule.
 
    .EXAMPLE
    $certificate.Acl = $certificate.Acl | Add-AccessRule "Administrator" FullControl Allow
 
    Adds a rule granting the local administrator full control of the $certificate's private key.
 
    .EXAMPLE
    $sd = Add-AccessRule -UserAccount "Everyone" -FileSystemRights Read -AccessControlType Deny -SD $sd
 
    Appends a rule to an existing security descriptor ($sd) that denys all users read access.
    #>
    
    [CmdletBinding()]
    Param(
        [Parameter(ValueFromPipeline=$true,Position=3,Mandatory=$true)]
        [ValidateNotNull()]
        [System.Security.AccessControl.FileSecurity] $SD,

        [Parameter(Position=0,Mandatory=$true,ParameterSetName="ctor")]
        [ValidateNotNullOrEmpty()]
        [string] $UserAccount,

        [Parameter(Position=1,Mandatory=$true,ParameterSetName="ctor")]
        [ValidateNotNullOrEmpty()]
        [System.Security.AccessControl.FileSystemRights] $FileSystemRights,

        [Parameter(Position=2,Mandatory=$true,ParameterSetName="ctor")]
        [ValidateNotNullOrEmpty()]
        [System.Security.AccessControl.AccessControlType] $AccessControlType,

        [Parameter(Mandatory=$true,ParameterSetName="obj")]
        [ValidateNotNullOrEmpty()]
        [System.Security.AccessControl.FileSystemAccessRule] $Rule
    )

    if (-not $Rule)
    {
        $Rule = New-Object System.Security.AccessControl.FileSystemAccessRule $UserAccount,$FileSystemRights,$AccessControlType -ErrorAction Stop
    }

    # perform a deep clone of the input SD to prevent side effects
    $newSD = New-Object System.Security.AccessControl.FileSecurity
    $newSD.SetSecurityDescriptorBinaryForm($SD.GetSecurityDescriptorBinaryForm())

    # add the new rule
    $newSD.AddAccessRule($Rule)
    Write-Output $newSD
}
# SIG # Begin signature block
# MIIkegYJKoZIhvcNAQcCoIIkazCCJGcCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCAtdWNn3Ti48bp8
# OJrDVMrTRYrqlEwfwdqpvuxdnTjb4aCCDYEwggX/MIID56ADAgECAhMzAAABA14l
# HJkfox64AAAAAAEDMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD
# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p
# bmcgUENBIDIwMTEwHhcNMTgwNzEyMjAwODQ4WhcNMTkwNzI2MjAwODQ4WjB0MQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
# AQDRlHY25oarNv5p+UZ8i4hQy5Bwf7BVqSQdfjnnBZ8PrHuXss5zCvvUmyRcFrU5
# 3Rt+M2wR/Dsm85iqXVNrqsPsE7jS789Xf8xly69NLjKxVitONAeJ/mkhvT5E+94S
# nYW/fHaGfXKxdpth5opkTEbOttU6jHeTd2chnLZaBl5HhvU80QnKDT3NsumhUHjR
# hIjiATwi/K+WCMxdmcDt66VamJL1yEBOanOv3uN0etNfRpe84mcod5mswQ4xFo8A
# DwH+S15UD8rEZT8K46NG2/YsAzoZvmgFFpzmfzS/p4eNZTkmyWPU78XdvSX+/Sj0
# NIZ5rCrVXzCRO+QUauuxygQjAgMBAAGjggF+MIIBejAfBgNVHSUEGDAWBgorBgEE
# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUR77Ay+GmP/1l1jjyA123r3f3QP8w
# UAYDVR0RBEkwR6RFMEMxKTAnBgNVBAsTIE1pY3Jvc29mdCBPcGVyYXRpb25zIFB1
# ZXJ0byBSaWNvMRYwFAYDVQQFEw0yMzAwMTIrNDM3OTY1MB8GA1UdIwQYMBaAFEhu
# ZOVQBdOCqhc3NyK1bajKdQKVMFQGA1UdHwRNMEswSaBHoEWGQ2h0dHA6Ly93d3cu
# bWljcm9zb2Z0LmNvbS9wa2lvcHMvY3JsL01pY0NvZFNpZ1BDQTIwMTFfMjAxMS0w
# Ny0wOC5jcmwwYQYIKwYBBQUHAQEEVTBTMFEGCCsGAQUFBzAChkVodHRwOi8vd3d3
# Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NlcnRzL01pY0NvZFNpZ1BDQTIwMTFfMjAx
# MS0wNy0wOC5jcnQwDAYDVR0TAQH/BAIwADANBgkqhkiG9w0BAQsFAAOCAgEAn/XJ
# Uw0/DSbsokTYDdGfY5YGSz8eXMUzo6TDbK8fwAG662XsnjMQD6esW9S9kGEX5zHn
# wya0rPUn00iThoj+EjWRZCLRay07qCwVlCnSN5bmNf8MzsgGFhaeJLHiOfluDnjY
# DBu2KWAndjQkm925l3XLATutghIWIoCJFYS7mFAgsBcmhkmvzn1FFUM0ls+BXBgs
# 1JPyZ6vic8g9o838Mh5gHOmwGzD7LLsHLpaEk0UoVFzNlv2g24HYtjDKQ7HzSMCy
# RhxdXnYqWJ/U7vL0+khMtWGLsIxB6aq4nZD0/2pCD7k+6Q7slPyNgLt44yOneFuy
# bR/5WcF9ttE5yXnggxxgCto9sNHtNr9FB+kbNm7lPTsFA6fUpyUSj+Z2oxOzRVpD
# MYLa2ISuubAfdfX2HX1RETcn6LU1hHH3V6qu+olxyZjSnlpkdr6Mw30VapHxFPTy
# 2TUxuNty+rR1yIibar+YRcdmstf/zpKQdeTr5obSyBvbJ8BblW9Jb1hdaSreU0v4
# 6Mp79mwV+QMZDxGFqk+av6pX3WDG9XEg9FGomsrp0es0Rz11+iLsVT9qGTlrEOla
# P470I3gwsvKmOMs1jaqYWSRAuDpnpAdfoP7YO0kT+wzh7Qttg1DO8H8+4NkI6Iwh
# SkHC3uuOW+4Dwx1ubuZUNWZncnwa6lL2IsRyP64wggd6MIIFYqADAgECAgphDpDS
# AAAAAAADMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMK
# V2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0
# IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0
# ZSBBdXRob3JpdHkgMjAxMTAeFw0xMTA3MDgyMDU5MDlaFw0yNjA3MDgyMTA5MDla
# MH4xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS
# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMT
# H01pY3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTEwggIiMA0GCSqGSIb3DQEB
# AQUAA4ICDwAwggIKAoICAQCr8PpyEBwurdhuqoIQTTS68rZYIZ9CGypr6VpQqrgG
# OBoESbp/wwwe3TdrxhLYC/A4wpkGsMg51QEUMULTiQ15ZId+lGAkbK+eSZzpaF7S
# 35tTsgosw6/ZqSuuegmv15ZZymAaBelmdugyUiYSL+erCFDPs0S3XdjELgN1q2jz
# y23zOlyhFvRGuuA4ZKxuZDV4pqBjDy3TQJP4494HDdVceaVJKecNvqATd76UPe/7
# 4ytaEB9NViiienLgEjq3SV7Y7e1DkYPZe7J7hhvZPrGMXeiJT4Qa8qEvWeSQOy2u
# M1jFtz7+MtOzAz2xsq+SOH7SnYAs9U5WkSE1JcM5bmR/U7qcD60ZI4TL9LoDho33
# X/DQUr+MlIe8wCF0JV8YKLbMJyg4JZg5SjbPfLGSrhwjp6lm7GEfauEoSZ1fiOIl
# XdMhSz5SxLVXPyQD8NF6Wy/VI+NwXQ9RRnez+ADhvKwCgl/bwBWzvRvUVUvnOaEP
# 6SNJvBi4RHxF5MHDcnrgcuck379GmcXvwhxX24ON7E1JMKerjt/sW5+v/N2wZuLB
# l4F77dbtS+dJKacTKKanfWeA5opieF+yL4TXV5xcv3coKPHtbcMojyyPQDdPweGF
# RInECUzF1KVDL3SV9274eCBYLBNdYJWaPk8zhNqwiBfenk70lrC8RqBsmNLg1oiM
# CwIDAQABo4IB7TCCAekwEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFEhuZOVQ
# BdOCqhc3NyK1bajKdQKVMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1Ud
# DwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFHItOgIxkEO5FAVO
# 4eqnxzHRI4k0MFoGA1UdHwRTMFEwT6BNoEuGSWh0dHA6Ly9jcmwubWljcm9zb2Z0
# LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y
# Mi5jcmwwXgYIKwYBBQUHAQEEUjBQME4GCCsGAQUFBzAChkJodHRwOi8vd3d3Lm1p
# Y3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y
# Mi5jcnQwgZ8GA1UdIASBlzCBlDCBkQYJKwYBBAGCNy4DMIGDMD8GCCsGAQUFBwIB
# FjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2RvY3MvcHJpbWFyeWNw
# cy5odG0wQAYIKwYBBQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AcABvAGwAaQBjAHkA
# XwBzAHQAYQB0AGUAbQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAGfyhqWY
# 4FR5Gi7T2HRnIpsLlhHhY5KZQpZ90nkMkMFlXy4sPvjDctFtg/6+P+gKyju/R6mj
# 82nbY78iNaWXXWWEkH2LRlBV2AySfNIaSxzzPEKLUtCw/WvjPgcuKZvmPRul1LUd
# d5Q54ulkyUQ9eHoj8xN9ppB0g430yyYCRirCihC7pKkFDJvtaPpoLpWgKj8qa1hJ
# Yx8JaW5amJbkg/TAj/NGK978O9C9Ne9uJa7lryft0N3zDq+ZKJeYTQ49C/IIidYf
# wzIY4vDFLc5bnrRJOQrGCsLGra7lstnbFYhRRVg4MnEnGn+x9Cf43iw6IGmYslmJ
# aG5vp7d0w0AFBqYBKig+gj8TTWYLwLNN9eGPfxxvFX1Fp3blQCplo8NdUmKGwx1j
# NpeG39rz+PIWoZon4c2ll9DuXWNB41sHnIc+BncG0QaxdR8UvmFhtfDcxhsEvt9B
# xw4o7t5lL+yX9qFcltgA1qFGvVnzl6UJS0gQmYAf0AApxbGbpT9Fdx41xtKiop96
# eiL6SJUfq/tHI4D1nvi/a7dLl+LrdXga7Oo3mXkYS//WsyNodeav+vyL6wuA6mk7
# r/ww7QRMjt/fdW1jkT3RnVZOT7+AVyKheBEyIXrvQQqxP/uozKRdwaGIm1dxVk5I
# RcBCyZt2WwqASGv9eZ/BvW1taslScxMNelDNMYIWTzCCFksCAQEwgZUwfjELMAkG
# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx
# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEoMCYGA1UEAxMfTWljcm9z
# b2Z0IENvZGUgU2lnbmluZyBQQ0EgMjAxMQITMwAAAQNeJRyZH6MeuAAAAAABAzAN
# BglghkgBZQMEAgEFAKCB0DAZBgkqhkiG9w0BCQMxDAYKKwYBBAGCNwIBBDAcBgor
# BgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAvBgkqhkiG9w0BCQQxIgQgPjj+FZjF
# H4R/yHtXKz4nSWJeaEHkFELAwd94ZjJ/BjYwZAYKKwYBBAGCNwIBDDFWMFSgNIAy
# AEcAdQBhAHIAZABlAGQARgBhAGIAcgBpAGMAVABvAG8AbABzACAAdgAxACAAMQAg
# ADChHIAaaHR0cHM6Ly93d3cubWljcm9zb2Z0LmNvbSAwDQYJKoZIhvcNAQEBBQAE
# ggEAHIlfc2Qo/hk8kfdUDTW8CM06Gsf03sJQcOXG8NxAo157aLeZbcWckVpu5YM5
# uaQgs13pyiPcmxpCc69QZTTwljLpRH1qZMRvdMg+5Hj6XMD68SWG1kC+oLB5+kwa
# omfDpEj3yfBEIo7U50TX/xu08+mYbvGbKZcgsiJYm27/iEfaPkzyTXyAMIFWwlOG
# sgso5mARTB/1how3TY8qjio2B971pHyEFGx8kyP4EdwCRuU14l4bivGkR0lJ5Gbr
# kBrKe9h4eFlac9azUn3Qa50ZStD7jLyi+z8TYqVoHwTzvxsTJ7CaZBTLIWLA2fMk
# elJ1FoCftalV3Yn8VpUzenurYqGCE7cwghOzBgorBgEEAYI3AwMBMYITozCCE58G
# CSqGSIb3DQEHAqCCE5AwghOMAgEDMQ8wDQYJYIZIAWUDBAIBBQAwggFYBgsqhkiG
# 9w0BCRABBKCCAUcEggFDMIIBPwIBAQYKKwYBBAGEWQoDATAxMA0GCWCGSAFlAwQC
# AQUABCB0eIPLyfcArRbAZOcD6BCJ3oAR1leJrff2g81QL6dp5AIGXJQP3jcgGBMy
# MDE5MDMyNjAwMTE1Ny4xMDhaMAcCAQGAAgH0oIHUpIHRMIHOMQswCQYDVQQGEwJV
# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE
# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQLEyBNaWNyb3NvZnQgT3Bl
# cmF0aW9ucyBQdWVydG8gUmljbzEmMCQGA1UECxMdVGhhbGVzIFRTUyBFU046QjhF
# Qy0zMEE0LTcxNDQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1wIFNlcnZp
# Y2Wggg8fMIIGcTCCBFmgAwIBAgIKYQmBKgAAAAAAAjANBgkqhkiG9w0BAQsFADCB
# iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1Jl
# ZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMp
# TWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMTAw
# NzAxMjEzNjU1WhcNMjUwNzAxMjE0NjU1WjB8MQswCQYDVQQGEwJVUzETMBEGA1UE
# CBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9z
# b2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQ
# Q0EgMjAxMDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKkdDbx3EYo6
# IOz8E5f1+n9plGt0VBDVpQoAgoX77XxoSyxfxcPlYcJ2tz5mK1vwFVMnBDEfQRsa
# lR3OCROOfGEwWbEwRA/xYIiEVEMM1024OAizQt2TrNZzMFcmgqNFDdDq9UeBzb8k
# YDJYYEbyWEeGMoQedGFnkV+BVLHPk0ySwcSmXdFhE24oxhr5hoC732H8RsEnHSRn
# EnIaIYqvS2SJUGKxXf13Hz3wV3WsvYpCTUBR0Q+cBj5nf/VmwAOWRH7v0Ev9buWa
# yrGo8noqCjHw2k4GkbaICDXoeByw6ZnNPOcvRLqn9NxkvaQBwSAJk3jN/LzAyURd
# XhacAQVPIk0CAwEAAaOCAeYwggHiMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQW
# BBTVYzpcijGQ80N7fEYbxTNoWoVtVTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMA
# QTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBTV9lbL
# j+iiXGJo0T2UkFvXzpoYxDBWBgNVHR8ETzBNMEugSaBHhkVodHRwOi8vY3JsLm1p
# Y3Jvc29mdC5jb20vcGtpL2NybC9wcm9kdWN0cy9NaWNSb29DZXJBdXRfMjAxMC0w
# Ni0yMy5jcmwwWgYIKwYBBQUHAQEETjBMMEoGCCsGAQUFBzAChj5odHRwOi8vd3d3
# Lm1pY3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIz
# LmNydDCBoAYDVR0gAQH/BIGVMIGSMIGPBgkrBgEEAYI3LgMwgYEwPQYIKwYBBQUH
# AgEWMWh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9QS0kvZG9jcy9DUFMvZGVmYXVs
# dC5odG0wQAYIKwYBBQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AUABvAGwAaQBjAHkA
# XwBTAHQAYQB0AGUAbQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAAfmiFEN
# 4sbgmD+BcQM9naOhIW+z66bM9TG+zwXiqf76V20ZMLPCxWbJat/15/B4vceoniXj
# +bzta1RXCCtRgkQS+7lTjMz0YBKKdsxAQEGb3FwX/1z5Xhc1mCRWS3TvQhDIr79/
# xn/yN31aPxzymXlKkVIArzgPF/UveYFl2am1a+THzvbKegBvSzBEJCI8z+0DpZaP
# WSm8tv0E4XCfMkon/VWvL/625Y4zu2JfmttXQOnxzplmkIz/amJ/3cVKC5Em4jns
# GUpxY517IW3DnKOiPPp/fZZqkHimbdLhnPkd/DjYlPTGpQqWhqS9nhquBEKDuLWA
# myI4ILUl5WTs9/S/fmNZJQ96LjlXdqJxqgaKD4kWumGnEcua2A5HmoDF0M2n0O99
# g/DhO3EJ3110mCIIYdqwUB5vvfHhAN/nMQekkzr3ZUd46PioSKv33nJ+YWtvd6mB
# y6cJrDm77MbL2IK0cs0d9LiFAR6A+xuJKlQ5slvayA1VmXqHczsI5pgt6o3gMy4S
# KfXAL1QnIffIrE7aKLixqduWsqdCosnPGUFN4Ib5KpqjEWYw07t0MkvfY3v1mYov
# G8chr1m1rtxEPJdQcdeh0sVV42neV8HR3jDA/czmTfsNv11P6Z0eGTgvvM9YBS7v
# DaBQNdrvCScc1bN+NR4Iuto229Nfj950iEkSMIIE9TCCA92gAwIBAgITMwAAAMw6
# vTtyOBEFugAAAAAAzDANBgkqhkiG9w0BAQsFADB8MQswCQYDVQQGEwJVUzETMBEG
# A1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWlj
# cm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFt
# cCBQQ0EgMjAxMDAeFw0xODA4MjMyMDI2MjVaFw0xOTExMjMyMDI2MjVaMIHOMQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQLEyBNaWNy
# b3NvZnQgT3BlcmF0aW9ucyBQdWVydG8gUmljbzEmMCQGA1UECxMdVGhhbGVzIFRT
# UyBFU046QjhFQy0zMEE0LTcxNDQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0
# YW1wIFNlcnZpY2UwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDH0FWl
# iiYVaxXd8HeYu7X5zFNLBnExJxJk6j0vI/p5USi1aLW63x1b07oLgwpViHNfpZ7M
# OoJ8/poCU+WOlcyBqcGkWEzHt3CfV//1zmQWu8bl7vQOOh4jtk+a6CQZCfZSLduv
# L6Er15oxkAPddzdZ1obHOlBOFbjrD+eoh7rYh0rSdgIDGKw66SRASNilFZP1whG6
# YiGmchJ+fbIe4jASJNTiadyEo0F7fgGI8YEqFmqs0rzf6I9UVrvr9IBXi0QZXaxY
# oRTvT72dx6kierO3LZjmZGJ35jYzsIXlZnR490J7nm23mNITgxbVV2Jb0FOw8Nkg
# UOlxHJ5esWBy5SKLAgMBAAGjggEbMIIBFzAdBgNVHQ4EFgQUralNpkrCZRBP1+t7
# HiGaMTNI66kwHwYDVR0jBBgwFoAU1WM6XIoxkPNDe3xGG8UzaFqFbVUwVgYDVR0f
# BE8wTTBLoEmgR4ZFaHR0cDovL2NybC5taWNyb3NvZnQuY29tL3BraS9jcmwvcHJv
# ZHVjdHMvTWljVGltU3RhUENBXzIwMTAtMDctMDEuY3JsMFoGCCsGAQUFBwEBBE4w
# TDBKBggrBgEFBQcwAoY+aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0
# cy9NaWNUaW1TdGFQQ0FfMjAxMC0wNy0wMS5jcnQwDAYDVR0TAQH/BAIwADATBgNV
# HSUEDDAKBggrBgEFBQcDCDANBgkqhkiG9w0BAQsFAAOCAQEAPV1daoLp4mVRNVLD
# yRy/4BFgVhCnmHLmQ7p4IQjBs6twKdtJPKrEYyhMJi6cI0CuBKx4YGS7o2AgkZMa
# QHB3KlK83wUJeoTGy6icCTUZhbv+x+DCQHJJfuJSJjlLCUQI4oXh5eu36uVfovCz
# AYPC2DTysuJAqE1L0v6oFITq1Z0AqrRDSUwzMY5jnnszvZL6j7byMe+g0nSrYPj1
# 6BP1IF3N8S+kQXjYse+jHVPJSzqoOEtRrPQeSssWb/E7X39ck1PxNpDMDn/EJ81p
# 6uTX2g2dfE1M5cmnC+Oxh1tyud01nVsrfsX4WBq5NClXB4qc9afdgHtQXuV+6Uoi
# ay7Y36GCA60wggKVAgEBMIH+oYHUpIHRMIHOMQswCQYDVQQGEwJVUzETMBEGA1UE
# CBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9z
# b2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQLEyBNaWNyb3NvZnQgT3BlcmF0aW9ucyBQ
# dWVydG8gUmljbzEmMCQGA1UECxMdVGhhbGVzIFRTUyBFU046QjhFQy0zMEE0LTcx
# NDQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1wIFNlcnZpY2WiJQoBATAJ
# BgUrDgMCGgUAAxUAc9qHMf0u+zxorOfoRpRzRIe/lk2ggd4wgdukgdgwgdUxCzAJ
# BgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25k
# MR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKTAnBgNVBAsTIE1pY3Jv
# c29mdCBPcGVyYXRpb25zIFB1ZXJ0byBSaWNvMScwJQYDVQQLEx5uQ2lwaGVyIE5U
# UyBFU046NERFOS0wQzVFLTNFMDkxKzApBgNVBAMTIk1pY3Jvc29mdCBUaW1lIFNv
# dXJjZSBNYXN0ZXIgQ2xvY2swDQYJKoZIhvcNAQEFBQACBQDgQ02DMCIYDzIwMTkw
# MzI1MTI1MjE5WhgPMjAxOTAzMjYxMjUyMTlaMHQwOgYKKwYBBAGEWQoEATEsMCow
# CgIFAOBDTYMCAQAwBwIBAAICGUEwBwIBAAICGpwwCgIFAOBEnwMCAQAwNgYKKwYB
# BAGEWQoEAjEoMCYwDAYKKwYBBAGEWQoDAaAKMAgCAQACAxbjYKEKMAgCAQACAweh
# IDANBgkqhkiG9w0BAQUFAAOCAQEAMFm5cEAgaBG5J3Q+INOqWlKx9h3qJWPdp51j
# B26hNmOAnYuq6GPNu4Srla3bVriLL9QrZHQr7280CUraId4fJv8rWpYSA9lxWbGg
# YRuX9Ptv7wnjjz6XtcQjmaotnSMGwmWX0SsyWaBT4/Xqqemg+AQidZfOJ6Naxhgp
# rkMPbuvBrv3D3WVyb6iA7LFUH3VQ99O8TlOrM/uPpa4ntsUAGiYXMBj4tWBBmjcB
# eOGjtjFHttupQFAVOAABjdu5yDbI4BzrpKcE1wdPtHsAmLlzxge2SQFipxD20q5C
# cA8cFgz8Zgaj3ayxZ1KYdrUx+SD9rrsBMFeGeoY9uS31eJzurzGCAvUwggLxAgEB
# MIGTMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQH
# EwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJjAkBgNV
# BAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwAhMzAAAAzDq9O3I4EQW6
# AAAAAADMMA0GCWCGSAFlAwQCAQUAoIIBMjAaBgkqhkiG9w0BCQMxDQYLKoZIhvcN
# AQkQAQQwLwYJKoZIhvcNAQkEMSIEIOjvBjHaSVZHWUj9ZvTxIpXJXcsenSQ7YKpB
# DG3E1/sSMIHiBgsqhkiG9w0BCRACDDGB0jCBzzCBzDCBsQQUc9qHMf0u+zxorOfo
# RpRzRIe/lk0wgZgwgYCkfjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu
# Z3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv
# cmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMAIT
# MwAAAMw6vTtyOBEFugAAAAAAzDAWBBQ80fa/XVuZBJHYY1GpiXEu5OtX+DANBgkq
# hkiG9w0BAQsFAASCAQAfpMwi1rUfrTqsqskCku66d79UIBO6XVafdDqp3SKvZjbH
# e8KDAdEcWjkRfzPK3L+nQkUkvsqfc/4s48QLrGqZRgBMzHxvCrS4JhxvMpRoBFV8
# vlptk+NU2pWlB2IiapBjzDKBnIWC3yh3M8xW0S716S4WKM+oJ3aBXTydqHVme8kA
# EIMyBW7xftVhF2l50C+bEzseRmDDucCvcko192OfHQhLxqA/wIZBkRVvK0BgUYOL
# 4CBmwYfcfX5ldZ73PxYVi3uFvQNREIY7dalShz98RJ8H823EYRqEJ6yxyuCcpOYm
# eX3B6ZJDxBKsu+mIqHO/ffYcRYbwgWFkEpPH8xRJ
# SIG # End signature block