PSSwaggerUtility

0.2.0

PSSwaggerNetUtilities.Unsafe.Code.ps1

                                // Copyright (c) Microsoft Corporation. All rights reserved.



// Licensed under the MIT license.



// PSSwaggerUtility Module

namespace Microsoft.PowerShell.Commands.PSSwagger

{

    using Microsoft.Rest;

    using System;

    using System.Net.Http;

    using System.Net.Http.Headers;

    using System.Runtime.CompilerServices;

    using System.Runtime.InteropServices;

    using System.Security;

    using System.Text;

    using System.Threading;

    using System.Threading.Tasks;

    

    public class PSBasicAuthenticationEx : ServiceClientCredentials

    {

        public string UserName { get; set; }

        public SecureString Password { get; set; }

        public PSBasicAuthenticationEx(string userName, SecureString password)

        {

            this.UserName = userName;

            this.Password = password;

        }



        public override async Task ProcessHttpRequestAsync(HttpRequestMessage request, CancellationToken cancellationToken)

        {

            await Task.Run(() => ProcessHttpRequest(request), cancellationToken);

        }



        private void ProcessHttpRequest(HttpRequestMessage request)

        {

            int passwordLength = this.Password.Length;

            int userNameLength = this.UserName.Length;

            int totalCredsLength = passwordLength + userNameLength + 1;

            int base64size = Base64Encoder.PredictSize(totalCredsLength);

            byte[] userNameBytes = Encoding.UTF8.GetBytes(this.UserName);

            // This array ensures we clean up the string concatenation of "username:password"

            byte[] clientCredsArr = new byte[totalCredsLength];

            // And here we need to clean up the base64 encoded string

            // 3 bytes == 4 characters, + padding

            // totalCredsLength is the number of bytes we'll eventually encode
            char[] base64string = new char[base64size];
            GCHandle byteHandle = new GCHandle();
            GCHandle strHandle = new GCHandle();
            // Ensure the insecure client cred string and the GC handle are cleaned up
            RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(delegate
            {
                // This block pins the insecure client cred string, converts the SecureString to the insecure password, frees the unpinned string, then generates the basic auth headers
                RuntimeHelpers.PrepareConstrainedRegions();
                try { }
                finally
                {
                    byteHandle = GCHandle.Alloc(clientCredsArr, GCHandleType.Pinned);
                    strHandle = GCHandle.Alloc(base64string, GCHandleType.Pinned);
                }

                
                IntPtr pBstr = IntPtr.Zero;
                // Ensure bBstr is properly cleaned up
                RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(delegate
                    {
                        RuntimeHelpers.PrepareConstrainedRegions();
                        try { }
                        finally
                        {
                            pBstr = Marshal.SecureStringToBSTR(this.Password);
                        }

                        unsafe
                        {
                            char* pTempPassword = (char*)pBstr;
                            byte* pClientCreds = (byte*)byteHandle.AddrOfPinnedObject();
                            Encoding.UTF8.GetBytes(pTempPassword, passwordLength, pClientCreds + userNameLength + 1, passwordLength);
                            for (int i = 0; i < userNameLength; i++)
                            {
                                pClientCreds[i] = userNameBytes[i];
                            }
                            pClientCreds[userNameLength] = (byte)':';
                            Base64Encoder.Encode(clientCredsArr, base64string);
                        }
                    },
                    delegate
                    {
                        if (pBstr != IntPtr.Zero)
                        {
                            Marshal.ZeroFreeBSTR(pBstr);
                        }
                    }, null);

                // Not using BasicAuthenticationCredentials here because: 1) async, 2) need to have the handle to the pinned base64 encoded string
                // NOTE: URL safe encoding?
                request.Headers.Authorization = new AuthenticationHeaderValue("Basic", new string(base64string));
            }, delegate
            {
                if (byteHandle.IsAllocated)
                {
                    unsafe
                    {
                        byte* pClientCreds = (byte*)byteHandle.AddrOfPinnedObject();
                        for (int i = 0; i < totalCredsLength; i++)
                        {
                            pClientCreds[i] = 0;
                        }

                        byteHandle.Free();

                        char* pBase64String = (char*)strHandle.AddrOfPinnedObject();
                        for (int i = 0; i < base64size; i++)
                        {
                            pBase64String[i] = '\0';
                        }

                        strHandle.Free();
                    }
                }
            }, null);
        }
    }

     public static class Base64Encoder
    {
        private const byte ls6mask = 0x3F;
        private const byte ls4mask = 0x0F;
        private const byte ls2mask = 0x03;
        private const byte ms6mask = 0xFC;
        private const byte ms4mask = 0xF0;
        private const byte ms2mask = 0xC0;
        private static char[] base64encoding = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
                                                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
                                                 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
        private static Func<byte?, byte?, byte>[] base64encoder =
        {
            (b1, b2) =>
            {
                // MS6 of b2
                return (byte)((b2 & ms6mask) >> 2);
            },
            (b1, b2) =>
            {
                // LS2 of b1 + MS4 of b2
                return (byte)((byte)((b1 & ls2mask) << 4) | (byte)((b2 & ms4mask) >> 4));
            },
            (b1, b2) =>
            {
                // LS4 of b1 + MS2 of b2
                return (byte)((byte)((b1 & ls4mask) << 2) | (byte)((b2 & ms2mask) >> 6));
            },
            (b1, b2) =>
            {
                // LS6 of b1
                return (byte)(b1 & ls6mask);
            }
        };

        public static void Encode(byte[] bytesToEncode, char[] charsToCopyOut)
        {
            int charOutIndex = 0;
            byte[] currentEncodingBuffer = new byte[2];
            int indexToAddByte;
            if (BitConverter.IsLittleEndian)
            {
                currentEncodingBuffer[1] = 0;
                indexToAddByte = 0;
            }
            else
            {
                currentEncodingBuffer[0] = 0;
                indexToAddByte = 1;
            }

            int encodingActionIndex = 0;
            byte? lastByte = null;
            for (int i = 0; i < bytesToEncode.Length; i++)
            {
                if (charOutIndex >= charsToCopyOut.Length)
                {
                    throw new Exception("Out char buffer is not big enough for base64 encoded string.");
                }

                charsToCopyOut[charOutIndex++] = GetChar(base64encoder[encodingActionIndex](lastByte, bytesToEncode[i]),
                    currentEncodingBuffer, indexToAddByte);
                if (encodingActionIndex == bytesToEncode.Length - 1)
                {
                    // Last step resets the next lastByte to null
                    lastByte = null;
                }
                else
                {
                    lastByte = bytesToEncode[i];
                }

                encodingActionIndex = (encodingActionIndex + 1) % base64encoder.Length;

                // If the next action is the last one, run it now and reset lastByte
                if (encodingActionIndex == base64encoder.Length - 1)
                {
                    if (charOutIndex >= charsToCopyOut.Length)
                    {
                        throw new Exception("Out char buffer is not big enough for base64 encoded string.");
                    }

                    charsToCopyOut[charOutIndex++] = GetChar(base64encoder[encodingActionIndex](bytesToEncode[i], null),
                        currentEncodingBuffer, indexToAddByte);
                    encodingActionIndex = (encodingActionIndex + 1) % base64encoder.Length;
                    lastByte = null;
                }
                else
                {
                    lastByte = bytesToEncode[i];
                }
            }

            // One more phase to run on the last byte
            if (encodingActionIndex != 0)
            {
                if (charOutIndex >= charsToCopyOut.Length)
                {
                    throw new Exception("Out char buffer is not big enough for base64 encoded string.");
                }

                charsToCopyOut[charOutIndex++] = GetChar(base64encoder[encodingActionIndex](lastByte, 0),
                    currentEncodingBuffer, indexToAddByte);
            }

            int charsLeft = charOutIndex % 4;
            if (charsLeft != 0)
            {
                int padding = 4 - charsLeft;
                while (padding-- > 0)
                {
                    charsToCopyOut[charOutIndex++] = '=';
                }
            }
        }

        public static int PredictSize(int numberOfBytes)
        {
            return (int)(4 * Math.Ceiling((double)numberOfBytes / 3));
        }

        private static char GetChar(byte b, byte[] buffer, int index)
        {
            buffer[index] = b;
            return base64encoding[BitConverter.ToInt16(buffer, 0)];
        }
    }
}

# SIG # Begin signature block
# MIIasAYJKoZIhvcNAQcCoIIaoTCCGp0CAQExCzAJBgUrDgMCGgUAMGkGCisGAQQB
# gjcCAQSgWzBZMDQGCisGAQQBgjcCAR4wJgIDAQAABBAfzDtgWUsITrck0sYpfvNR
# AgEAAgEAAgEAAgEAAgEAMCEwCQYFKw4DAhoFAAQUZKvdLkkcQHVwIz7Pg2YS4EZd
# J9agghWDMIIEwzCCA6ugAwIBAgITMwAAAMzLuBPrXXItRQAAAAAAzDANBgkqhkiG
# 9w0BAQUFADB3MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4G
# A1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSEw
# HwYDVQQDExhNaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EwHhcNMTYwOTA3MTc1ODU2
# WhcNMTgwOTA3MTc1ODU2WjCBszELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hp
# bmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jw
# b3JhdGlvbjENMAsGA1UECxMETU9QUjEnMCUGA1UECxMebkNpcGhlciBEU0UgRVNO
# OjE0OEMtQzRCOS0yMDY2MSUwIwYDVQQDExxNaWNyb3NvZnQgVGltZS1TdGFtcCBT
# ZXJ2aWNlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwe5bp0PH7Nar
# LeUDfq1E+Jd4WNpGm2kgEVzLGmOAjML+w5RXEzQOQuqTl8SfMUcrg1+to2Ihbu3h
# fPFFRQJq0cPH/i14X1w0cWP6jRqyAqv/T3lSM4O3dDSNZK+QUsUq0yXeF+FmvW0i
# gBHUpOpXEyxHha0QNzbJm9iyCXSu/WaUstgcq8wHA2gvuLdvSA6pDt+AgAUf0o/f
# 2Nwl25HtlDNRiI1PgfSRdw+W0gnSalk3xycrDVFDlVLavPccwXNc0YsNrKFr9T17
# baz3xYPTb/+90NtpUoBgSdpV2Rr7ev7l806lz4mlxEEqFv/xwk7Yws4BowtU9pE1
# zaPyNiV2GQIDAQABo4IBCTCCAQUwHQYDVR0OBBYEFPWhmmbVkedPZa+s2RQAnZdC
# m8+qMB8GA1UdIwQYMBaAFCM0+NlSRnAK7UD7dvuzK7DDNbMPMFQGA1UdHwRNMEsw
# SaBHoEWGQ2h0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3Rz
# L01pY3Jvc29mdFRpbWVTdGFtcFBDQS5jcmwwWAYIKwYBBQUHAQEETDBKMEgGCCsG
# AQUFBzAChjxodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY3Jv
# c29mdFRpbWVTdGFtcFBDQS5jcnQwEwYDVR0lBAwwCgYIKwYBBQUHAwgwDQYJKoZI
# hvcNAQEFBQADggEBAJaBLYob96ccjvtcRqUl/51+iQ6TX4WoJCYb+jf3sMtgQLd4
# kLPpCB/2f8uuZePf9wSdjCu2SPFt1Px6vJysXk2B7rReYR3A8G0SsoUv/nCdFjp3
# dtr3lm2xkMU2wv5Ox4BO4Jf+0vT9+s3PbLnPZK/GjUJ1idWSG0sKpXgq7mpSw9SV
# 7jIjjdM0bupBd2xLCKfocxjYir5UYJWiC8C0kb//6F8/JL/n1Gr1Ty7mZdiFjW4F
# BEIxTU3r0EnAqtOv/O0cApLuC9AV1pFixlGgQRqlA/xRQLLaui3j5qGKeJeijYSz
# RJgTY5L21IbbuV6arIrZhpJkL059QogKBFgjmiIwggTtMIID1aADAgECAhMzAAAB
# QJap7nBW/swHAAEAAAFAMA0GCSqGSIb3DQEBBQUAMHkxCzAJBgNVBAYTAlVTMRMw
# EQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVN
# aWNyb3NvZnQgQ29ycG9yYXRpb24xIzAhBgNVBAMTGk1pY3Jvc29mdCBDb2RlIFNp
# Z25pbmcgUENBMB4XDTE2MDgxODIwMTcxN1oXDTE3MTEwMjIwMTcxN1owgYMxCzAJ
# BgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25k
# MR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xDTALBgNVBAsTBE1PUFIx
# HjAcBgNVBAMTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjCCASIwDQYJKoZIhvcNAQEB
# BQADggEPADCCAQoCggEBANtLi+kDal/IG10KBTnk1Q6S0MThi+ikDQUZWMA81ynd
# ibdobkuffryavVSGOanxODUW5h2s+65r3Akw77ge32z4SppVl0jII4mzWSc0vZUx
# R5wPzkA1Mjf+6fNPpBqks3m8gJs/JJjE0W/Vf+dDjeTc8tLmrmbtBDohlKZX3APb
# LMYb/ys5qF2/Vf7dSd9UBZSrM9+kfTGmTb1WzxYxaD+Eaxxt8+7VMIruZRuetwgc
# KX6TvfJ9QnY4ItR7fPS4uXGew5T0goY1gqZ0vQIz+lSGhaMlvqqJXuI5XyZBmBre
# ueZGhXi7UTICR+zk+R+9BFF15hKbduuFlxQiCqET92ECAwEAAaOCAWEwggFdMBMG
# A1UdJQQMMAoGCCsGAQUFBwMDMB0GA1UdDgQWBBSc5ehtgleuNyTe6l6pxF+QHc7Z
# ezBSBgNVHREESzBJpEcwRTENMAsGA1UECxMETU9QUjE0MDIGA1UEBRMrMjI5ODAz
# K2Y3ODViMWMwLTVkOWYtNDMxNi04ZDZhLTc0YWU2NDJkZGUxYzAfBgNVHSMEGDAW
# gBTLEejK0rQWWAHJNy4zFha5TJoKHzBWBgNVHR8ETzBNMEugSaBHhkVodHRwOi8v
# Y3JsLm1pY3Jvc29mdC5jb20vcGtpL2NybC9wcm9kdWN0cy9NaWNDb2RTaWdQQ0Ff
# MDgtMzEtMjAxMC5jcmwwWgYIKwYBBQUHAQEETjBMMEoGCCsGAQUFBzAChj5odHRw
# Oi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY0NvZFNpZ1BDQV8wOC0z
# MS0yMDEwLmNydDANBgkqhkiG9w0BAQUFAAOCAQEAa+RW49cTHSBA+W3p3k7bXR7G
# bCaj9+UJgAz/V+G01Nn5XEjhBn/CpFS4lnr1jcmDEwxxv/j8uy7MFXPzAGtOJar0
# xApylFKfd00pkygIMRbZ3250q8ToThWxmQVEThpJSSysee6/hU+EbkfvvtjSi0lp
# DimD9aW9oxshraKlPpAgnPWfEj16WXVk79qjhYQyEgICamR3AaY5mLPuoihJbKwk
# Mig+qItmLPsC2IMvI5KR91dl/6TV6VEIlPbW/cDVwCBF/UNJT3nuZBl/YE7ixMpT
# Th/7WpENW80kg3xz6MlCdxJfMSbJsM5TimFU98KNcpnxxbYdfqqQhAQ6l3mtYDCC
# BbwwggOkoAMCAQICCmEzJhoAAAAAADEwDQYJKoZIhvcNAQEFBQAwXzETMBEGCgmS
# JomT8ixkARkWA2NvbTEZMBcGCgmSJomT8ixkARkWCW1pY3Jvc29mdDEtMCsGA1UE
# AxMkTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MB4XDTEwMDgz
# MTIyMTkzMloXDTIwMDgzMTIyMjkzMloweTELMAkGA1UEBhMCVVMxEzARBgNVBAgT
# Cldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29m
# dCBDb3Jwb3JhdGlvbjEjMCEGA1UEAxMaTWljcm9zb2Z0IENvZGUgU2lnbmluZyBQ
# Q0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCycllcGTBkvx2aYCAg
# Qpl2U2w+G9ZvzMvx6mv+lxYQ4N86dIMaty+gMuz/3sJCTiPVcgDbNVcKicquIEn0
# 8GisTUuNpb15S3GbRwfa/SXfnXWIz6pzRH/XgdvzvfI2pMlcRdyvrT3gKGiXGqel
# cnNW8ReU5P01lHKg1nZfHndFg4U4FtBzWwW6Z1KNpbJpL9oZC/6SdCnidi9U3RQw
# WfjSjWL9y8lfRjFQuScT5EAwz3IpECgixzdOPaAyPZDNoTgGhVxOVoIoKgUyt0vX
# T2Pn0i1i8UU956wIAPZGoZ7RW4wmU+h6qkryRs83PDietHdcpReejcsRj1Y8wawJ
# XwPTAgMBAAGjggFeMIIBWjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTLEejK
# 0rQWWAHJNy4zFha5TJoKHzALBgNVHQ8EBAMCAYYwEgYJKwYBBAGCNxUBBAUCAwEA
# ATAjBgkrBgEEAYI3FQIEFgQU/dExTtMmipXhmGA7qDFvpjy82C0wGQYJKwYBBAGC
# NxQCBAweCgBTAHUAYgBDAEEwHwYDVR0jBBgwFoAUDqyCYEBWJ5flJRP8KuEKU5VZ
# 5KQwUAYDVR0fBEkwRzBFoEOgQYY/aHR0cDovL2NybC5taWNyb3NvZnQuY29tL3Br
# aS9jcmwvcHJvZHVjdHMvbWljcm9zb2Z0cm9vdGNlcnQuY3JsMFQGCCsGAQUFBwEB
# BEgwRjBEBggrBgEFBQcwAoY4aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraS9j
# ZXJ0cy9NaWNyb3NvZnRSb290Q2VydC5jcnQwDQYJKoZIhvcNAQEFBQADggIBAFk5
# Pn8mRq/rb0CxMrVq6w4vbqhJ9+tfde1MOy3XQ60L/svpLTGjI8x8UJiAIV2sPS9M
# uqKoVpzjcLu4tPh5tUly9z7qQX/K4QwXaculnCAt+gtQxFbNLeNK0rxw56gNogOl
# VuC4iktX8pVCnPHz7+7jhh80PLhWmvBTI4UqpIIck+KUBx3y4k74jKHK6BOlkU7I
# G9KPcpUqcW2bGvgc8FPWZ8wi/1wdzaKMvSeyeWNWRKJRzfnpo1hW3ZsCRUQvX/Ta
# rtSCMm78pJUT5Otp56miLL7IKxAOZY6Z2/Wi+hImCWU4lPF6H0q70eFW6NB4lhhc
# yTUWX92THUmOLb6tNEQc7hAVGgBd3TVbIc6YxwnuhQ6MT20OE049fClInHLR82zK
# wexwo1eSV32UjaAbSANa98+jZwp0pTbtLS8XyOZyNxL0b7E8Z4L5UrKNMxZlHg6K
# 3RDeZPRvzkbU0xfpecQEtNP7LN8fip6sCvsTJ0Ct5PnhqX9GuwdgR2VgQE6wQuxO
# 7bN2edgKNAltHIAxH+IOVN3lofvlRxCtZJj/UBYufL8FIXrilUEnacOTj5XJjdib
# Ia4NXJzwoq6GaIMMai27dmsAHZat8hZ79haDJLmIz2qoRzEvmtzjcT3XAH5iR9HO
# iMm4GPoOco3Boz2vAkBq/2mbluIQqBC0N1AI1sM9MIIGBzCCA++gAwIBAgIKYRZo
# NAAAAAAAHDANBgkqhkiG9w0BAQUFADBfMRMwEQYKCZImiZPyLGQBGRYDY29tMRkw
# FwYKCZImiZPyLGQBGRYJbWljcm9zb2Z0MS0wKwYDVQQDEyRNaWNyb3NvZnQgUm9v
# dCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDcwNDAzMTI1MzA5WhcNMjEwNDAz
# MTMwMzA5WjB3MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4G
# A1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSEw
# HwYDVQQDExhNaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EwggEiMA0GCSqGSIb3DQEB
# AQUAA4IBDwAwggEKAoIBAQCfoWyx39tIkip8ay4Z4b3i48WZUSNQrc7dGE4kD+7R
# p9FMrXQwIBHrB9VUlRVJlBtCkq6YXDAm2gBr6Hu97IkHD/cOBJjwicwfyzMkh53y
# 9GccLPx754gd6udOo6HBI1PKjfpFzwnQXq/QsEIEovmmbJNn1yjcRlOwhtDlKEYu
# J6yGT1VSDOQDLPtqkJAwbofzWTCd+n7Wl7PoIZd++NIT8wi3U21StEWQn0gASkdm
# EScpZqiX5NMGgUqi+YSnEUcUCYKfhO1VeP4Bmh1QCIUAEDBG7bfeI0a7xC1Un68e
# eEExd8yb3zuDk6FhArUdDbH895uyAc4iS1T/+QXDwiALAgMBAAGjggGrMIIBpzAP
# BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQjNPjZUkZwCu1A+3b7syuwwzWzDzAL
# BgNVHQ8EBAMCAYYwEAYJKwYBBAGCNxUBBAMCAQAwgZgGA1UdIwSBkDCBjYAUDqyC
# YEBWJ5flJRP8KuEKU5VZ5KShY6RhMF8xEzARBgoJkiaJk/IsZAEZFgNjb20xGTAX
# BgoJkiaJk/IsZAEZFgltaWNyb3NvZnQxLTArBgNVBAMTJE1pY3Jvc29mdCBSb290
# IENlcnRpZmljYXRlIEF1dGhvcml0eYIQea0WoUqgpa1Mc1j0BxMuZTBQBgNVHR8E
# STBHMEWgQ6BBhj9odHRwOi8vY3JsLm1pY3Jvc29mdC5jb20vcGtpL2NybC9wcm9k
# dWN0cy9taWNyb3NvZnRyb290Y2VydC5jcmwwVAYIKwYBBQUHAQEESDBGMEQGCCsG
# AQUFBzAChjhodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY3Jv
# c29mdFJvb3RDZXJ0LmNydDATBgNVHSUEDDAKBggrBgEFBQcDCDANBgkqhkiG9w0B
# AQUFAAOCAgEAEJeKw1wDRDbd6bStd9vOeVFNAbEudHFbbQwTq86+e4+4LtQSooxt
# YrhXAstOIBNQmd16QOJXu69YmhzhHQGGrLt48ovQ7DsB7uK+jwoFyI1I4vBTFd1P
# q5Lk541q1YDB5pTyBi+FA+mRKiQicPv2/OR4mS4N9wficLwYTp2OawpylbihOZxn
# LcVRDupiXD8WmIsgP+IHGjL5zDFKdjE9K3ILyOpwPf+FChPfwgphjvDXuBfrTot/
# xTUrXqO/67x9C0J71FNyIe4wyrt4ZVxbARcKFA7S2hSY9Ty5ZlizLS/n+YWGzFFW
# 6J1wlGysOUzU9nm/qhh6YinvopspNAZ3GmLJPR5tH4LwC8csu89Ds+X57H2146So
# dDW4TsVxIxImdgs8UoxxWkZDFLyzs7BNZ8ifQv+AeSGAnhUwZuhCEl4ayJ4iIdBD
# 6Svpu/RIzCzU2DKATCYqSCRfWupW76bemZ3KOm+9gSd0BhHudiG/m4LBJ1S2sWo9
# iaF2YbRuoROmv6pH8BJv/YoybLL+31HIjCPJZr2dHYcSZAI9La9Zj7jkIeW1sMpj
# tHhUBdRBLlCslLCleKuzoJZ1GtmShxN1Ii8yqAhuoFuMJb+g74TKIdbrHk/Jmu5J
# 4PcBZW+JC33Iacjmbuqnl84xKf8OxVtc2E0bodj6L54/LlUWa8kTo/0xggSXMIIE
# kwIBATCBkDB5MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4G
# A1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSMw
# IQYDVQQDExpNaWNyb3NvZnQgQ29kZSBTaWduaW5nIFBDQQITMwAAAUCWqe5wVv7M
# BwABAAABQDAJBgUrDgMCGgUAoIGwMBkGCSqGSIb3DQEJAzEMBgorBgEEAYI3AgEE
# MBwGCisGAQQBgjcCAQsxDjAMBgorBgEEAYI3AgEVMCMGCSqGSIb3DQEJBDEWBBSa
# kBf0udv5EPSlTQz5WK0WwSH8rTBQBgorBgEEAYI3AgEMMUIwQKAWgBQAUABvAHcA
# ZQByAFMAaABlAGwAbKEmgCRodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vUG93ZXJT
# aGVsbCAwDQYJKoZIhvcNAQEBBQAEggEAK0G9LieTN0w8kNTpkrH7jWQCZES4blgV
# mRj/CoExnaXCE2O+i4wFoIytVH4dibQyUf4KEhqmM+QceR7F1r6NWyghlUnOW085
# tIOm7/sdlO900YmflfoihZYws7mOGOfW4DUWVmk8aA58lIBn6yTqQ6ySGR5EVc7S
# jQdXtDyt05iFDWQFFRvBlEoOPISgZjW8m8dwmor85YBYFCu/YRIFcwRCSnIyIE0u
# dWcSHhF/WshS2LTYiaHYsl5IxYNXhS9tbxxw/egREojD2YIBnFutMZmush9JYHRU
# pQhva/IgESadhC48Eei/FJpKluH4HbOiwkWqfQecwUIA0cY0dCM3YqGCAigwggIk
# BgkqhkiG9w0BCQYxggIVMIICEQIBATCBjjB3MQswCQYDVQQGEwJVUzETMBEGA1UE
# CBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9z
# b2Z0IENvcnBvcmF0aW9uMSEwHwYDVQQDExhNaWNyb3NvZnQgVGltZS1TdGFtcCBQ
# Q0ECEzMAAADMy7gT611yLUUAAAAAAMwwCQYFKw4DAhoFAKBdMBgGCSqGSIb3DQEJ
# AzELBgkqhkiG9w0BBwEwHAYJKoZIhvcNAQkFMQ8XDTE3MDgwODE3NDAxNVowIwYJ
# KoZIhvcNAQkEMRYEFKD8McryZA0vY6YTbXwyC9FD/Fg4MA0GCSqGSIb3DQEBBQUA
# BIIBAC03jB3E8rshnCS4BX7rOmO8A/8a2yhOqj9Q45iAFRRQ4+TeXe81lGG1oqZa
# 1PxzcrnlA682oevgo52rS3Xg4Jc9tMjjyBTJveO5rolk6lZvTZ3sEIxByep7C4n1
# 54WfmDKwYZz4Ni14S9o6WQ/m/S/0RLRa+yO4agGkBp4qiVxtFL+q/HyFUqyuxDX5
# kgCr5DS9riMRoewM1ncTvO1JJ/bz5obOaCUd209DuWcmt0bkTu+eG0Z+xExUGow0
# 1GQo7ioJndVBObrKHo6FyUlAymtJEfgyvuHi4TeCOLK9GAFNl3EiCHdYsHbDgDja
# 0VDTIBoewx+B5yJqSKm8OL1nilA=
# SIG # End signature block

                            