// Undefine all of the windows wrappers so you can't use them.
//*****************************************************************************
-// wincrypt.h
-#undef CryptAcquireContext
-#undef CryptSignHash
-#undef CryptVerifySignature
-
// winbase.h
#undef GetBinaryType
#undef GetShortPathName
// to the *W entry points as macros. This way no client code needs a wrapper on NT.
//
-// wincrypt.h
-#define WszCryptAcquireContext CryptAcquireContextW
-#define WszCryptSignHash CryptSignHashW
-#define WszCryptVerifySignature CryptVerifySignatureW
-
// winbase.h
#define WszGetEnvironmentStrings GetEnvironmentStringsW
#define WszFreeEnvironmentStrings FreeEnvironmentStringsW
+++ /dev/null
-// 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
// 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.
// 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)
#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
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);
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
//---------------------------------------------------------------------------------------
//
-// 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
{
}
// The buffer itself looks reasonable, but the public key structure needs to be validated as well
- return StrongNameIsValidPublicKey(*pkeyPublicKey, fImportKeys);
+ return StrongNameIsValidPublicKey(*pkeyPublicKey);
}
//---------------------------------------------------------------------------------------
//
// 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
{
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;
}
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)
-
#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
};
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...
-
-
#ifndef DACCESS_COMPILE
-bool IsPlatformAssembly(LPCSTR szName, DomainAssembly *pDomainAssembly)
-{
- CONTRACTL
- {
- THROWS;
- GC_TRIGGERS;
- MODE_ANY;
- PRECONDITION(CheckPointer(szName));
- PRECONDITION(CheckPointer(pDomainAssembly));
- }
- CONTRACTL_END;
-
- PEAssembly *pPEAssembly = pDomainAssembly->GetFile();
-
- if (strcmp(szName, pPEAssembly->GetSimpleName()) != 0)
- {
- return false;
- }
-
- DWORD cbPublicKey;
- const BYTE *pbPublicKey = static_cast<const BYTE *>(pPEAssembly->GetPublicKey(&cbPublicKey));
- if (pbPublicKey == nullptr)
- {
- return false;
- }
-
- return StrongNameIsSilverlightPlatformKey(pbPublicKey, cbPublicKey);
-}
-
void AppDomain::AddAssembly(DomainAssembly * assem)
{
CONTRACTL
projects / platform / upstream / coreclr.git / commitdiff