Delete dead strongname-related code (#24709)

5 files changed, 6 insertions, 376 deletions

diff --git a/src/strongname/api/cryptapis.h b/src/strongname/api/cryptapis.h
deleted file mode 100644
index fbfbab752f..0000000000
--- a/src/strongname/api/cryptapis.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-// ===========================================================================
-// File: CryptApis.h
-// 
-// CryptoAPI entry points used for StrongName implementation. This file is
-// included multiple times with different definitions of the DEFINE_IMPORT
-// macro in order handle dynamically finding these entry points.
-// ===========================================================================
-
-#ifndef DEFINE_IMPORT
-#error Must define DEFINE_IMPORT macro before including this file
-#endif
-
-// DEFINE_IMPORT parameters are:
-//  1)  Function name (remember to add A to functions that take strings, don't
-//      use W versions since they're unsupported on Win9X).
-//  2)  Paranthesised argument types (return type is always assumed to be
-//      BOOLEAN).
-//  3)  TRUE if function is required, FALSE if it is optional (calls will not
-//      fail because the function can't be found).
-
-DEFINE_IMPORT(CryptAcquireContextA,     (HCRYPTPROV*, LPCSTR, LPCSTR, DWORD, DWORD),                TRUE)
-DEFINE_IMPORT(CryptAcquireContextW,     (HCRYPTPROV*, LPCWSTR, LPCWSTR, DWORD, DWORD),                TRUE)
-DEFINE_IMPORT(CryptReleaseContext,      (HCRYPTPROV, DWORD),                                        TRUE)
-DEFINE_IMPORT(CryptCreateHash,          (HCRYPTPROV, ALG_ID, HCRYPTKEY, DWORD, HCRYPTHASH*),        TRUE)
-DEFINE_IMPORT(CryptDestroyHash,         (HCRYPTHASH),                                               TRUE)
-DEFINE_IMPORT(CryptHashData,            (HCRYPTHASH, CONST BYTE*, DWORD, DWORD),                    TRUE)
-DEFINE_IMPORT(CryptGetHashParam,        (HCRYPTHASH, DWORD, BYTE*, DWORD*, DWORD),                  TRUE)
-DEFINE_IMPORT(CryptImportKey,           (HCRYPTPROV, CONST BYTE*, DWORD, HCRYPTKEY, DWORD, HCRYPTKEY*), TRUE)
-DEFINE_IMPORT(CryptExportKey,           (HCRYPTKEY, HCRYPTKEY, DWORD, DWORD, BYTE*, DWORD*),        TRUE)
-DEFINE_IMPORT(CryptGenKey,              (HCRYPTPROV, ALG_ID, DWORD, HCRYPTKEY*),                    TRUE)
-DEFINE_IMPORT(CryptGetKeyParam,         (HCRYPTKEY, DWORD, BYTE*, DWORD*, DWORD),                   TRUE)
-DEFINE_IMPORT(CryptDestroyKey,          (HCRYPTKEY),                                                TRUE)
-DEFINE_IMPORT(CryptVerifySignatureA,    (HCRYPTHASH, CONST BYTE*, DWORD, HCRYPTKEY, LPCSTR, DWORD), TRUE)
-DEFINE_IMPORT(CryptVerifySignatureW,    (HCRYPTHASH, CONST BYTE*, DWORD, HCRYPTKEY, LPCWSTR, DWORD), TRUE)
-DEFINE_IMPORT(CryptSignHashA,           (HCRYPTHASH, DWORD, LPCSTR, DWORD, BYTE*, DWORD*),          TRUE)
-DEFINE_IMPORT(CryptSignHashW,           (HCRYPTHASH, DWORD, LPCWSTR, DWORD, BYTE*, DWORD*),          TRUE)
-
-DEFINE_IMPORT(CryptGetProvParam,        (HCRYPTPROV, DWORD, BYTE*, DWORD*, DWORD),                  TRUE)
-DEFINE_IMPORT(CryptGetUserKey,          (HCRYPTPROV, DWORD, HCRYPTKEY*),                            TRUE)
-DEFINE_IMPORT(CryptEnumProvidersA,      (DWORD, DWORD*, DWORD, DWORD*, LPSTR, DWORD*),              FALSE)
-DEFINE_IMPORT(CryptEnumProvidersW,      (DWORD, DWORD*, DWORD, DWORD*, LPWSTR, DWORD*),              FALSE)
-
-#undef DEFINE_IMPORT
diff --git a/src/strongname/api/strongname.cpp b/src/strongname/api/strongname.cpp
index 4f69b3682f..263789d213 100644
--- a/src/strongname/api/strongname.cpp
+++ b/src/strongname/api/strongname.cpp
@@ -101,13 +101,6 @@ void Log(__in_z const WCHAR *wszFormat, ...)
 // Size in bytes of strong name token.
 #define SN_SIZEOF_TOKEN     8
 
-enum StrongNameCachedCsp {
-    None = -1,
-    Sha1CachedCsp = 0,
-    Sha2CachedCsp = Sha1CachedCsp + 1,
-    CachedCspCount = Sha2CachedCsp + 1
-};
-
 // We cache a couple of things on a per thread basis: the last error encountered
 // and (potentially) CSP contexts. The following structure tracks these and is
 // allocated lazily as needed.
@@ -119,12 +112,6 @@ struct SN_THREAD_CTX {
 
 // Macro containing common code used at the start of most APIs.
 #define SN_COMMON_PROLOG() do {                             \
-    HRESULT __hr = InitStrongName();                        \
-    if (FAILED(__hr)) {                                     \
-        SetStrongNameErrorInfo(__hr);                       \
-        retVal = FALSE;                                     \
-        goto Exit;                                          \
-    }                                                       \
     SetStrongNameErrorInfo(S_OK);                           \
 } while (0)
 
@@ -178,23 +165,6 @@ struct SN_THREAD_CTX {
 
 #define SN_THE_SILVERLIGHT_KEYTOKEN() ((PublicKeyBlob*)g_rbTheSilverlightKeyToken)
 
-#ifdef FEATURE_WINDOWSPHONE
-// Microsoft.Phone.* key
-#define SN_THE_MICROSOFT_PHONE_KEYTOKEN() ((PublicKeyBlob*)g_rbTheMicrosoftPhoneKeyToken)
-
-#define SN_IS_THE_MICROSOFT_PHONE_KEY(_pk) (SN_SIZEOF_KEY((PublicKeyBlob*)(_pk)) == sizeof(g_rbTheMicrosoftPhoneKey) && \
-                                memcmp((_pk), g_rbTheMicrosoftPhoneKey, sizeof(g_rbTheMicrosoftPhoneKey)) == 0)
-
-// Microsoft.Xna.* key
-#define SN_THE_MICROSOFT_XNA_KEYTOKEN() ((PublicKeyBlob*)g_rbTheMicrosoftXNAKeyToken)
-
-#define SN_IS_THE_MICROSOFT_XNA_KEY(_pk) (SN_SIZEOF_KEY((PublicKeyBlob*)(_pk)) == sizeof(g_rbTheMicrosoftXNAKey) && \
-                                memcmp((_pk), g_rbTheMicrosoftXNAKey, sizeof(g_rbTheMicrosoftXNAKey)) == 0)
-
-#endif // FEATURE_WINDOWSPHONE
-
-#define InitStrongName() S_OK
-
 
 // Free buffer allocated by routines below.
 SNAPI_(VOID) StrongNameFreeBuffer(BYTE *pbMemory)            // [in] address of memory to free
@@ -294,7 +264,7 @@ SNAPI StrongNameTokenFromPublicKey(BYTE    *pbPublicKeyBlob,        // [in] publ
 
     if (pbPublicKeyBlob == NULL)
         SN_ERROR(E_POINTER);
-    if (!StrongNameIsValidPublicKey(pbPublicKeyBlob, cbPublicKeyBlob, false))
+    if (!StrongNameIsValidPublicKey(pbPublicKeyBlob, cbPublicKeyBlob))
         SN_ERROR(CORSEC_E_INVALID_PUBLICKEY);
     if (ppbStrongNameToken == NULL)
         SN_ERROR(E_POINTER);
@@ -336,24 +306,6 @@ SNAPI StrongNameTokenFromPublicKey(BYTE    *pbPublicKeyBlob,        // [in] publ
         goto Exit;
     }
 
-#ifdef FEATURE_WINDOWSPHONE
-
-    if (SN_IS_THE_MICROSOFT_PHONE_KEY(pbPublicKeyBlob))
-    {
-        memcpy_s(*ppbStrongNameToken, *pcbStrongNameToken, SN_THE_MICROSOFT_PHONE_KEYTOKEN(), SN_SIZEOF_TOKEN);
-        retVal = TRUE;
-        goto Exit;
-    }
-
-    if (SN_IS_THE_MICROSOFT_XNA_KEY(pbPublicKeyBlob))
-    {
-        memcpy_s(*ppbStrongNameToken, *pcbStrongNameToken, SN_THE_MICROSOFT_XNA_KEYTOKEN(), SN_SIZEOF_TOKEN);
-        retVal = TRUE;
-        goto Exit;
-    }
-
-#endif //FEATURE_WINDOWSPHONE
-
     // To compute the correct public key token, we need to make sure the public key blob
     // was not padded with extra bytes that CAPI CryptImportKey would've ignored.
     // Without this round trip, we would blindly compute the hash over the padded bytes
diff --git a/src/strongname/api/strongnameinternal.cpp b/src/strongname/api/strongnameinternal.cpp
index 56b1c0e031..208573742e 100644
--- a/src/strongname/api/strongnameinternal.cpp
+++ b/src/strongname/api/strongnameinternal.cpp
@@ -62,90 +62,14 @@ bool StrongNameIsEcmaKey(const PublicKeyBlob &keyPublicKey)
 
 //---------------------------------------------------------------------------------------
 //
-// Check to see if a public key blob is the TheKey public key blob
-//
-// Arguments:
-//   pbKey - public key blob to check
-//   cbKey - size in bytes of pbKey
-//
-bool StrongNameIsTheKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    // The key should be the same size as the TheKey key
-    if (cbKey != sizeof(g_rbTheKey))
-    {
-        return false;
-    }
-
-    return (memcmp(pbKey, g_rbTheKey, sizeof(g_rbTheKey)) == 0);
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Check to see if a public key blob is the Silverlight Platform public key blob
-//
-// Arguments:
-//   pbKey - public key blob to check
-//   cbKey - size in bytes of pbKey
-//
-
-bool StrongNameIsSilverlightPlatformKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    // The key should be the same size as the ECMA key
-    if (cbKey != sizeof(g_rbTheSilverlightPlatformKey))
-    {
-        return false;
-    }
-
-    const PublicKeyBlob *pKeyBlob = reinterpret_cast<const PublicKeyBlob *>(pbKey);
-    return StrongNameIsSilverlightPlatformKey(*pKeyBlob);
-}
-
-//---------------------------------------------------------------------------------------
-//
-// Check to see if a public key blob is the Silverlight Platform public key blob
-//
-// Arguments:
-//   keyPublicKey - Key to check to see if it matches the ECMA key
-//
-
-bool StrongNameIsSilverlightPlatformKey(const PublicKeyBlob &keyPublicKey)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return StrongNameSizeOfPublicKey(keyPublicKey) == sizeof(g_rbTheSilverlightPlatformKey) &&
-           memcmp(reinterpret_cast<const BYTE *>(&keyPublicKey), g_rbTheSilverlightPlatformKey, sizeof(g_rbTheSilverlightPlatformKey)) == 0;
-}
-
-//---------------------------------------------------------------------------------------
-//
 // Verify that a public key blob looks like a reasonable public key
 //
 // Arguments:
 //   pbBuffer     - buffer to verify the format of
 //   cbBuffer     - size of pbBuffer
-//   fImportKeys  - do a more extensive check by attempting to import the keys
 //
 
-bool StrongNameIsValidPublicKey(__in_ecount(cbBuffer) const BYTE *pbBuffer, DWORD cbBuffer, bool fImportKeys)
+bool StrongNameIsValidPublicKey(__in_ecount(cbBuffer) const BYTE *pbBuffer, DWORD cbBuffer)
 {
     CONTRACTL
     {
@@ -169,7 +93,7 @@ bool StrongNameIsValidPublicKey(__in_ecount(cbBuffer) const BYTE *pbBuffer, DWOR
     }
 
     // The buffer itself looks reasonable, but the public key structure needs to be validated as well
-    return StrongNameIsValidPublicKey(*pkeyPublicKey, fImportKeys);
+    return StrongNameIsValidPublicKey(*pkeyPublicKey);
 }
 
 //---------------------------------------------------------------------------------------
@@ -178,13 +102,12 @@ bool StrongNameIsValidPublicKey(__in_ecount(cbBuffer) const BYTE *pbBuffer, DWOR
 // 
 // Arguments:
 //   keyPublicKey - key blob to verify 
-//   fImportKeys  - do a more extensive check by verifying that the key data imports into CAPI
 // 
 // Notes:
 //    This can be a very expensive operation, since it involves importing keys.  
 //
 
-bool StrongNameIsValidPublicKey(const PublicKeyBlob &keyPublicKey, bool fImportKeys)
+bool StrongNameIsValidPublicKey(const PublicKeyBlob &keyPublicKey)
 {
     CONTRACTL
     {
@@ -221,26 +144,6 @@ bool StrongNameIsValidPublicKey(const PublicKeyBlob &keyPublicKey, bool fImportK
         return false;
     }
 
-#if (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
-    // Make sure the public key blob imports properly
-    if (fImportKeys)
-    {
-        CapiProviderHolder hProv;
-        if (!StrongNameCryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
-        {
-            return false;
-        }
-
-        CapiKeyHolder hKey;
-        if (!CryptImportKey(hProv, keyPublicKey.PublicKey, GET_UNALIGNED_VAL32(&keyPublicKey.cbPublicKey), NULL, 0, &hKey))
-        {
-            return false;
-        }
-    }
-#else // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
-    _ASSERTE(!fImportKeys);
-#endif // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
-
     return true;
 }
 
@@ -265,105 +168,3 @@ DWORD StrongNameSizeOfPublicKey(const PublicKeyBlob &keyPublicKey)
     return offsetof(PublicKeyBlob, PublicKey) +     // Size of the blob header plus
            GET_UNALIGNED_VAL32(&keyPublicKey.cbPublicKey);  // the number of bytes in the key
 }
-
-#if (defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX))
-
-//---------------------------------------------------------------------------------------
-//
-// Check to see if the value held in a buffer is a full strong name key pair
-//
-// Arguments:
-//    pbBuffer - Blob to check
-//    cbBuffer - Size of the buffer in bytes
-//
-// Return Value:
-//    true if the buffer represents a full strong name key pair, false otherwise
-//
-
-bool StrongNameIsValidKeyPair(__in_ecount(cbKeyPair) const BYTE *pbKeyPair, DWORD cbKeyPair)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-        PRECONDITION(CheckPointer(pbKeyPair));
-    }
-    CONTRACTL_END;
-
-    // Key pairs are just CAPI PRIVATEKEYBLOBs, so see if CAPI can import the blob
-    CapiProviderHolder hProv;
-    if (!StrongNameCryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
-    {
-        return false;
-    }
-
-    CapiKeyHolder hKey;
-    if (!CryptImportKey(hProv, pbKeyPair, cbKeyPair, NULL, 0, &hKey))
-    {
-        return false;
-    }
-
-    return true;
-}
-
-
-BYTE HexToByteA (char c) {
-    LIMITED_METHOD_CONTRACT;
-
-    if (!isxdigit(c)) return (BYTE) 0xff;
-    if (isdigit(c)) return (BYTE) (c - '0');
-    if (isupper(c)) return (BYTE) (c - 'A' + 10);
-    return (BYTE) (c - 'a' + 10);
-}
-    
-// Read the hex string into a buffer
-// Caller owns the buffer. 
-// Returns NULL if the string contains non-hex characters, or doesn't contain a multiple of 2 characters.
-bool GetBytesFromHex(LPCUTF8 szHexString, ULONG cchHexString, BYTE** buffer, ULONG *cbBufferSize) {
-    LIMITED_METHOD_CONTRACT;
-
-    ULONG cchHex = cchHexString;
-    if (cchHex % 2 != 0)
-        return false;
-    *cbBufferSize = cchHex / 2;
-    NewArrayHolder<BYTE> tempBuffer(new (nothrow) BYTE[*cbBufferSize]);
-    if (tempBuffer == NULL)
-        return false;
-
-    for (ULONG i = 0; i < *cbBufferSize; i++) {
-        BYTE msn = HexToByteA(*szHexString);
-        BYTE lsn = HexToByteA(*(szHexString + 1));
-        if(msn == 0xFF || lsn == 0xFF)
-        {
-            return false;
-        }
-
-        tempBuffer[i] = (BYTE) ( (msn << 4) | lsn );
-        szHexString += 2;
-    }
-
-    *buffer = tempBuffer.Extract();
-    return true;
-}
-
-// Helper method to call CryptAcquireContext, making sure we have a valid set of flags
-bool StrongNameCryptAcquireContext(HCRYPTPROV *phProv, LPCWSTR pwszContainer, LPCWSTR pwszProvider, DWORD dwProvType, DWORD dwFlags)
-{
-    LIMITED_METHOD_CONTRACT;
-
-#if defined(CRYPT_VERIFYCONTEXT) && defined(CRYPT_MACHINE_KEYSET)
-    // Specifying both verify context (for an ephemeral key) and machine keyset (for a persisted machine key)
-    // does not make sense.  Additionally, Widows is beginning to lock down against uses of MACHINE_KEYSET
-    // (for instance in the app container), even if verify context is present.   Therefore, if we're using
-    // an ephemeral key, strip out MACHINE_KEYSET from the flags.
-    if ((dwFlags & CRYPT_VERIFYCONTEXT) && (dwFlags & CRYPT_MACHINE_KEYSET))
-    {
-        dwFlags &= ~CRYPT_MACHINE_KEYSET;
-    }
-#endif // defined(CRYPT_VERIFYCONTEXT) && defined(CRYPT_MACHINE_KEYSET)
-
-    return !!WszCryptAcquireContext(phProv, pwszContainer, pwszProvider, dwProvType, dwFlags);
-}
-
-#endif // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
-
diff --git a/src/strongname/inc/strongnameinternal.h b/src/strongname/inc/strongnameinternal.h
index 7cbf5d87a8..c3fd25658d 100644
--- a/src/strongname/inc/strongnameinternal.h
+++ b/src/strongname/inc/strongnameinternal.h
@@ -10,42 +10,14 @@
 
 #include <strongname.h>
 
-#include <wincrypt.h>
-
-// NTDDI_VERSION is currently defined as XP SP2.
-// Strongname api's that use this are supported on XP SP3 and later, so we can use them.
-#ifndef ALG_SID_SHA_256 
-#define ALG_SID_SHA_256                 12
-#define ALG_SID_SHA_384                 13
-#define ALG_SID_SHA_512                 14
-#define CALG_SHA_256            (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_256)
-#define CALG_SHA_384            (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_384)
-#define CALG_SHA_512            (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_512)
-#endif //ALG_SID_SHA_256
-
 // Determine the number of bytes in a public key
 DWORD StrongNameSizeOfPublicKey(const PublicKeyBlob &keyPublicKey);
 
-bool StrongNameIsValidPublicKey(__in_ecount(cbPublicKeyBlob) const BYTE *pbPublicKeyBlob, DWORD cbPublicKeyBlob, bool fImporKey);
-bool StrongNameIsValidPublicKey(const PublicKeyBlob &keyPublicKey, bool fImportKey);
+bool StrongNameIsValidPublicKey(__in_ecount(cbPublicKeyBlob) const BYTE *pbPublicKeyBlob, DWORD cbPublicKeyBlob);
+bool StrongNameIsValidPublicKey(const PublicKeyBlob &keyPublicKey);
 
 // Determine if a public key is the ECMA key
 bool StrongNameIsEcmaKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey);
 bool StrongNameIsEcmaKey(const PublicKeyBlob &keyPublicKey);
 
-bool StrongNameIsTheKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey);
-
-#if defined(CROSSGEN_COMPILE) && !defined(PLATFORM_UNIX)
-
-// Verify the format of a public key blob
-bool StrongNameIsValidKeyPair(__in_ecount(cbKeyPair) const BYTE *pbKeyPair, DWORD cbKeyPair);
-
-bool GetBytesFromHex(LPCUTF8 szHexString, ULONG cchHexString, BYTE** buffer, ULONG *cbBufferSize);
-
-bool StrongNameCryptAcquireContext(HCRYPTPROV *phProv, LPCWSTR pwszContainer, LPCWSTR pwszProvider, DWORD dwProvType, DWORD dwFlags);
-#endif // (CROSSGEN_COMPILE && !PLATFORM_UNIX)
-
-bool StrongNameIsSilverlightPlatformKey(__in_ecount(cbKey) const BYTE *pbKey, DWORD cbKey);
-bool StrongNameIsSilverlightPlatformKey(const PublicKeyBlob &keyPublicKey);
-
 #endif // !_STRONGNAME_INTERNAL_H
diff --git a/src/strongname/inc/thekey.h b/src/strongname/inc/thekey.h
index 7a53f4713b..9286c77971 100644
--- a/src/strongname/inc/thekey.h
+++ b/src/strongname/inc/thekey.h
@@ -52,51 +52,3 @@ static const BYTE g_rbTheSilverlightKey[] =
 };
 
 static const BYTE g_rbTheSilverlightKeyToken[] = {0x31,0xBF,0x38,0x56,0xAD,0x36,0x4E,0x35};
-
-#ifdef FEATURE_WINDOWSPHONE
-
-static const BYTE g_rbTheMicrosoftPhoneKey[] = 
-{
-0x00,0x24,0x00,0x00,0x04,0x80,0x00,0x00,0x14,0x01,0x00,0x00,0x06,0x02,0x00,0x00,
-0x00,0x24,0x00,0x00,0x52,0x53,0x41,0x31,0x00,0x08,0x00,0x00,0x01,0x00,0x01,0x00,
-0xCB,0x8F,0x76,0xDA,0xE0,0x5D,0x35,0x2C,0x11,0x7A,0x84,0x67,0xEF,0x32,0x60,0xE0,
-0x02,0x10,0x8A,0xA9,0xE7,0x09,0x56,0xE7,0x05,0xF6,0x43,0x0F,0x6C,0xBC,0xFE,0x35,
-0x9D,0x02,0x11,0x75,0x63,0x40,0x00,0x17,0xD1,0x00,0x4D,0x68,0xD1,0x3F,0xE5,0x74,
-0xA2,0x56,0x49,0x58,0x0E,0xD1,0xEE,0x22,0x5A,0xA4,0xBB,0xC0,0x93,0x06,0x2D,0xA0,
-0xB1,0x68,0xBB,0xEA,0x3F,0x57,0x95,0x50,0x8F,0xCB,0xD7,0x53,0x13,0x74,0xC7,0x45,
-0xCE,0x63,0x27,0xA9,0x1A,0xC7,0x24,0x35,0x71,0xF2,0xB4,0xE8,0xE4,0xFC,0x24,0x8C,
-0xA1,0xA2,0xF3,0xC8,0x73,0xE1,0x49,0xB3,0x43,0x0B,0x37,0xBD,0x51,0xA6,0xA3,0xAD,
-0xC9,0x5F,0x68,0x5C,0x91,0x74,0x57,0x69,0x13,0x0F,0xA1,0x0F,0xBF,0xC7,0xB2,0x28,
-0x2F,0x25,0xDF,0xFD,0x4B,0xA2,0xC0,0xBD,0x7C,0x82,0x88,0xCD,0xE4,0x80,0x6C,0x8B,
-0xDC,0x81,0x7D,0x12,0x6C,0x7E,0x54,0x36,0x10,0xD3,0x47,0x6A,0x63,0x17,0xB5,0xD5,
-0x48,0x76,0xA0,0xE3,0xB3,0xAD,0x42,0xB1,0x2C,0x51,0x38,0xDB,0x2F,0xFB,0x66,0x9F,
-0x1B,0xE6,0x31,0x4B,0xC9,0x58,0x7A,0xC1,0xAC,0xE4,0x75,0x1D,0x6C,0x58,0x84,0xDB,
-0x04,0x81,0x15,0x90,0x7C,0x09,0x0D,0xBB,0xDF,0x98,0xC6,0x5E,0xD4,0xC0,0x42,0xC3,
-0x77,0x5A,0xCA,0xA7,0xD6,0x04,0x23,0x07,0xFA,0xE2,0xAA,0xFA,0xE7,0x12,0x8E,0x17,
-0x65,0x81,0x92,0x44,0x6C,0x07,0x40,0x0D,0x22,0xC5,0xBA,0x43,0xF3,0xA1,0xE7,0xA3,
-0xE5,0xAF,0x81,0xBE,0x0E,0x65,0xA5,0x01,0x6C,0x5F,0x0C,0x62,0xA3,0xC0,0xDE,0xB3 
-};
-
-static const BYTE g_rbTheMicrosoftPhoneKeyToken[] = {0x24,0xEE,0xC0,0xD8,0xC8,0x6C,0xDA,0x1E};
-
-
-static const BYTE g_rbTheMicrosoftXNAKey[] =
-{
-0x00,0x24,0x00,0x00,0x04,0x80,0x00,0x00,0x94,0x00,0x00,0x00,0x06,0x02,0x00,0x00,
-0x00,0x24,0x00,0x00,0x52,0x53,0x41,0x31,0x00,0x04,0x00,0x00,0x01,0x00,0x01,0x00,
-0x0F,0xC5,0x99,0x3E,0x0F,0x51,0x1A,0xD5,0xE1,0x6E,0x8B,0x22,0x65,0x53,0x49,0x3E,
-0x09,0x06,0x7A,0xFC,0x41,0x03,0x9F,0x70,0xDA,0xEB,0x94,0xA9,0x68,0xD6,0x64,0xF4,
-0x0E,0x69,0xA4,0x6B,0x61,0x7D,0x15,0xD3,0xD5,0x32,0x8B,0xE7,0xDB,0xED,0xD0,0x59,
-0xEB,0x98,0x49,0x5A,0x3B,0x03,0xCB,0x4E,0xA4,0xBA,0x12,0x74,0x44,0x67,0x1C,0x3C,
-0x84,0xCB,0xC1,0xFD,0xC3,0x93,0xD7,0xE1,0x0B,0x5E,0xE3,0xF3,0x1F,0x5A,0x29,0xF0,
-0x05,0xE5,0xEE,0xD7,0xE3,0xC9,0xC8,0xAF,0x74,0xF4,0x13,0xF0,0x00,0x4F,0x0C,0x2C,
-0xAB,0xB2,0x2F,0x9D,0xD4,0xF7,0x5A,0x6F,0x59,0x97,0x84,0xE1,0xBA,0xB7,0x09,0x85,
-0xEF,0x81,0x74,0xCA,0x6C,0x68,0x42,0x78,0xBE,0x82,0xCE,0x05,0x5A,0x03,0xEB,0xAF
-};
-
-static const BYTE g_rbTheMicrosoftXNAKeyToken[] = {0xCC,0xAC,0x92,0xED,0x87,0x3B,0x18,0x5C};
-
-#endif
-// for FEATURE_WINDOWSPHONE, we can add the Microsoft.Phone key and the Xna key to the list of blessed keys...
-
-