X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fmetadata-verify.c;h=cb3f5829f77138708c11354b362c6f0f004572fd;hb=6a6fc5e87e734dabce3f6014e34db58ae06ee09a;hp=6a31e06621b98d21c76fede9ac58479c89b82b83;hpb=802102909829f424382768e82c13bbdd5917f41b;p=mono.git

diff --git a/mono/metadata/metadata-verify.c b/mono/metadata/metadata-verify.c
index 6a31e06621b..cb3f5829f77 100644
--- a/mono/metadata/metadata-verify.c
+++ b/mono/metadata/metadata-verify.c
@@ -97,7 +97,7 @@ const static unsigned char coded_index_desc[] = {
 
 #define HAS_CATTR_DESC (HAS_CONSTANT_DESC + 5)
 	5, /*bits*/
-	19, /*tables*/
+	20, /*tables*/
 	MONO_TABLE_METHOD,
 	MONO_TABLE_FIELD,
 	MONO_TABLE_TYPEREF,
@@ -117,8 +117,9 @@ const static unsigned char coded_index_desc[] = {
 	MONO_TABLE_FILE,
 	MONO_TABLE_EXPORTEDTYPE,
 	MONO_TABLE_MANIFESTRESOURCE,
+	MONO_TABLE_GENERICPARAM,
 
-#define HAS_FIELD_MARSHAL_DESC (HAS_CATTR_DESC + 21)
+#define HAS_FIELD_MARSHAL_DESC (HAS_CATTR_DESC + 22)
 	1, /*bits*/
 	2, /*tables*/
 	MONO_TABLE_FIELD,
@@ -216,12 +217,12 @@ typedef struct {
 
 typedef struct {
 	const char *data;
-	guint32 size;
+	guint32 size, token;
 	GSList *errors;
 	int valid;
-	gboolean is_corlib;
 	MonoImage *image;
 	gboolean report_error;
+	gboolean report_warning;
 	int stage;
 
 	DataDirectory data_directories [16];
@@ -240,6 +241,21 @@ typedef struct {
 		(__ctx)->errors = g_slist_prepend ((__ctx)->errors, vinfo);	\
 	} while (0)
 
+#define ADD_WARNING(__ctx, __msg)	\
+	do {	\
+		if ((__ctx)->report_warning) { \
+			ADD_VERIFY_INFO(__ctx, __msg, MONO_VERIFY_WARNING, MONO_EXCEPTION_INVALID_PROGRAM); \
+			(__ctx)->valid = 0; \
+			return; \
+		} \
+	} while (0)
+
+#define ADD_ERROR_NO_RETURN(__ctx, __msg)	\
+	do {	\
+		if ((__ctx)->report_error) \
+			ADD_VERIFY_INFO(__ctx, __msg, MONO_VERIFY_ERROR, MONO_EXCEPTION_INVALID_PROGRAM); \
+		(__ctx)->valid = 0; \
+	} while (0)
 
 #define ADD_ERROR(__ctx, __msg)	\
 	do {	\
@@ -261,6 +277,28 @@ typedef struct {
 
 #define CHECK_ERROR() do { if (!ctx->valid) return; } while (0)
 
+#define CHECK_ADD4_OVERFLOW_UN(a, b) ((guint32)(0xFFFFFFFFU) - (guint32)(b) < (guint32)(a))
+#define CHECK_ADD8_OVERFLOW_UN(a, b) ((guint64)(0xFFFFFFFFFFFFFFFFUL) - (guint64)(b) < (guint64)(a))
+
+#if SIZEOF_VOID_P == 4
+#define CHECK_ADDP_OVERFLOW_UN(a,b) CHECK_ADD4_OVERFLOW_UN(a, b)
+#else
+#define CHECK_ADDP_OVERFLOW_UN(a,b) CHECK_ADD8_OVERFLOW_UN(a, b)
+#endif
+
+#define ADDP_IS_GREATER_OR_OVF(a, b, c) (((a) + (b) > (c)) || CHECK_ADDP_OVERFLOW_UN (a, b))
+#define ADD_IS_GREATER_OR_OVF(a, b, c) (((a) + (b) > (c)) || CHECK_ADD4_OVERFLOW_UN (a, b))
+
+static const char *
+dword_align (const char *ptr)
+{
+#if SIZEOF_VOID_P == 8
+	return (const char *) (((guint64) (ptr + 3)) & ~3);
+#else
+	return (const char *) (((guint32) (ptr + 3)) & ~3);
+#endif
+}
+
 static guint32
 pe_signature_offset (VerifyContext *ctx)
 {
@@ -565,34 +603,42 @@ verify_import_table (VerifyContext *ctx)
 		ADD_ERROR (ctx, g_strdup_printf ("Import table size %d is smaller than 40", it.size));
 
 	ilt_rva = read32 (ptr);
-	if (!bounds_check_virtual_address (ctx, ilt_rva, 8))
+	if (ilt_rva && !bounds_check_virtual_address (ctx, ilt_rva, 8))
 		ADD_ERROR (ctx, g_strdup_printf ("Invalid Import Lookup Table rva %x", ilt_rva));
 
 	name_rva = read32 (ptr + 12);
-	if (!bounds_check_virtual_address (ctx, name_rva, SIZE_OF_MSCOREE))
+	if (name_rva && !bounds_check_virtual_address (ctx, name_rva, SIZE_OF_MSCOREE))
 		ADD_ERROR (ctx, g_strdup_printf ("Invalid Import Table Name rva %x", name_rva));
 
 	iat_rva = read32 (ptr + 16);
-	if (!bounds_check_virtual_address (ctx, iat_rva, 8))
-		ADD_ERROR (ctx, g_strdup_printf ("Invalid Import Address Table rva %x", iat_rva));
-
-	if (iat_rva != ctx->data_directories [IAT_IDX].rva)
-		ADD_ERROR (ctx, g_strdup_printf ("Import Address Table rva %x different from data directory entry %x", read32 (ptr + 16), ctx->data_directories [IAT_IDX].rva));
+	if (iat_rva) {
+		if (!bounds_check_virtual_address (ctx, iat_rva, 8))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid Import Address Table rva %x", iat_rva));
 
-	name_rva = translate_rva (ctx, name_rva);
-	g_assert (name_rva != INVALID_OFFSET);
-	ptr = ctx->data + name_rva;
+		if (iat_rva != ctx->data_directories [IAT_IDX].rva)
+			ADD_ERROR (ctx, g_strdup_printf ("Import Address Table rva %x different from data directory entry %x", read32 (ptr + 16), ctx->data_directories [IAT_IDX].rva));
+	}
 
-	if (memcmp ("mscoree.dll", ptr, SIZE_OF_MSCOREE)) {
-		char name[SIZE_OF_MSCOREE];
-		memcpy (name, ptr, SIZE_OF_MSCOREE);
-		name [SIZE_OF_MSCOREE - 1] = 0;
-		ADD_ERROR (ctx, g_strdup_printf ("Invalid Import Table Name: '%s'", name));
+	if (name_rva) {
+		name_rva = translate_rva (ctx, name_rva);
+		g_assert (name_rva != INVALID_OFFSET);
+		ptr = ctx->data + name_rva;
+	
+		if (memcmp ("mscoree.dll", ptr, SIZE_OF_MSCOREE)) {
+			char name[SIZE_OF_MSCOREE];
+			memcpy (name, ptr, SIZE_OF_MSCOREE);
+			name [SIZE_OF_MSCOREE - 1] = 0;
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid Import Table Name: '%s'", name));
+		}
 	}
 	
-	verify_hint_name_table (ctx, ilt_rva, "Import Lookup Table");
-	CHECK_ERROR ();
-	verify_hint_name_table (ctx, iat_rva, "Import Address Table");
+	if (ilt_rva) {
+		verify_hint_name_table (ctx, ilt_rva, "Import Lookup Table");
+		CHECK_ERROR ();
+	}
+
+	if (iat_rva)
+		verify_hint_name_table (ctx, iat_rva, "Import Address Table");
 }
 
 static void
@@ -703,7 +749,7 @@ verify_metadata_header (VerifyContext *ctx)
 {
 	int i;
 	DataDirectory it = get_data_dir (ctx, CLI_HEADER_IDX);
-	guint32 offset;
+	guint32 offset, section_count;
 	const char *ptr;
 
 	offset = it.translated_offset;
@@ -733,13 +779,14 @@ verify_metadata_header (VerifyContext *ctx)
 
 	ptr = ctx->data + offset; //move to streams header 
 
-	if (read16 (ptr + 2) < 3)
+	section_count = read16 (ptr + 2);
+	if (section_count < 3)
 		ADD_ERROR (ctx, g_strdup_printf ("Metadata root section must have at least 3 streams (#~, #GUID and #Blob"));
 
 	ptr += 4;
 	offset += 4;
 
-	for (i = 0; i < 5; ++i) {
+	for (i = 0; i < section_count; ++i) {
 		guint32 stream_off, stream_size;
 		int string_size, stream_idx;
 
@@ -775,8 +822,12 @@ verify_metadata_header (VerifyContext *ctx)
 			stream_idx = GUID_STREAM;
 		else if (!strncmp ("#~", ptr, 3))
 			stream_idx = TILDE_STREAM;
-		else
-			ADD_ERROR (ctx, g_strdup_printf ("Metadata stream header %d invalid name %s", i, ptr));
+		else {
+			ADD_WARNING (ctx, g_strdup_printf ("Metadata stream header %d invalid name %s", i, ptr));
+			offset = pad4 (offset);
+			ptr = ctx->data + offset;
+			continue;
+		}
 
 		if (ctx->metadata_streams [stream_idx].offset != 0)
 			ADD_ERROR (ctx, g_strdup_printf ("Duplicated metadata stream header %s", ptr));
@@ -830,7 +881,7 @@ verify_tables_schema (VerifyContext *ctx)
  		  Unused: 0x1E 0x1F 0x2D-0x3F
  		  We don't care about the MS extensions.*/
 		if (i == 0x3 || i == 0x5 || i == 0x7 || i == 0x13 || i == 0x16)
-			ADD_ERROR (ctx, g_strdup_printf ("The metadata verifies doesn't support MS specific table %x", i));
+			ADD_ERROR (ctx, g_strdup_printf ("The metadata verifier doesn't support MS specific table %x", i));
 		if (i == 0x1E || i == 0x1F || i >= 0x2D)
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid table %x", i));
 		++count;
@@ -1021,10 +1072,19 @@ string_cmp (VerifyContext *ctx, const char *str, guint offset)
 	return strcmp (str, get_string_ptr (ctx, offset));
 }
 
+static gboolean
+mono_verifier_is_corlib (MonoImage *image)
+{
+	gboolean trusted_location = (mono_security_get_mode () != MONO_SECURITY_MODE_CORE_CLR) ? 
+			TRUE : mono_security_core_clr_is_platform_image (image);
+
+	return trusted_location && image->module_name && !strcmp ("mscorlib.dll", image->module_name);
+}
+
 static gboolean
 typedef_is_system_object (VerifyContext *ctx, guint32 *data)
 {
-	return ctx->is_corlib && !string_cmp (ctx, "System", data [MONO_TYPEDEF_NAME]) && !string_cmp (ctx, "Object", data [MONO_TYPEDEF_NAMESPACE]);
+	return mono_verifier_is_corlib (ctx->image) && !string_cmp (ctx, "System", data [MONO_TYPEDEF_NAMESPACE]) && !string_cmp (ctx, "Object", data [MONO_TYPEDEF_NAME]);
 }
 
 static gboolean
@@ -1084,22 +1144,22 @@ decode_signature_header (VerifyContext *ctx, guint32 offset, int *size, const ch
 }
 
 static gboolean
-safe_read (const char **_ptr, const char *limit, void *dest, int size)
+safe_read (const char **_ptr, const char *limit, unsigned *dest, int size)
 {
 	const char *ptr = *_ptr;
 	if (ptr + size > limit)
 		return FALSE;
 	switch (size) {
 	case 1:
-		*((guint8*)dest) = *((guint8*)ptr);
+		*dest = *((guint8*)ptr);
 		++ptr;
 		break;
 	case 2:
-		*((guint16*)dest) = read16 (ptr);
+		*dest = read16 (ptr);
 		ptr += 2;
 		break;
 	case 4:
-		*((guint32*)dest) = read32 (ptr);
+		*dest = read32 (ptr);
 		ptr += 4;
 		break;
 	}
@@ -1125,12 +1185,15 @@ safe_read_compressed_int (const char **_ptr, const char *limit, unsigned *dest)
 static gboolean
 parse_type (VerifyContext *ctx, const char **_ptr, const char *end);
 
+static gboolean
+parse_method_signature (VerifyContext *ctx, const char **_ptr, const char *end, gboolean allow_sentinel, gboolean allow_unmanaged);
+
 static gboolean
 parse_custom_mods (VerifyContext *ctx, const char **_ptr, const char *end)
 {
 	const char *ptr = *_ptr;
-	guint type = 0;
-	guint32 token = 0;
+	unsigned type = 0;
+	unsigned token = 0;
 
 	while (TRUE) {
 		if (!safe_read8 (type, ptr, end))
@@ -1156,8 +1219,8 @@ static gboolean
 parse_array_shape (VerifyContext *ctx, const char **_ptr, const char *end)
 {
 	const char *ptr = *_ptr;
-	guint8 val;
-	guint32 size, num, i;
+	unsigned val = 0;
+	unsigned size, num, i;
 
 	if (!safe_read8 (val, ptr, end))
 		FAIL (ctx, g_strdup ("ArrayShape: Not enough room for Rank"));
@@ -1189,8 +1252,8 @@ static gboolean
 parse_generic_inst (VerifyContext *ctx, const char **_ptr, const char *end)
 {
 	const char *ptr = *_ptr;
-	guint8 type;
-	guint32 count, token, i;
+	unsigned type;
+	unsigned count, token, i;
 
 	if (!safe_read8 (type, ptr, end))
 		FAIL (ctx, g_strdup ("GenericInst: Not enough room for kind"));
@@ -1204,6 +1267,12 @@ parse_generic_inst (VerifyContext *ctx, const char **_ptr, const char *end)
 	if (!is_valid_coded_index (ctx, TYPEDEF_OR_REF_DESC, token))
 		FAIL (ctx, g_strdup_printf ("GenericInst: invalid TypeDefOrRef token %x", token));
 
+	if (ctx->token) {
+		if (mono_metadata_token_index (ctx->token) == get_coded_index_token (TYPEDEF_OR_REF_DESC, token) &&
+			mono_metadata_token_table (ctx->token) == get_coded_index_table (TYPEDEF_OR_REF_DESC, token))
+			FAIL (ctx, g_strdup_printf ("Type: Recurside generic instance specification (%x). A type signature can't reference itself", ctx->token));
+	}
+
 	if (!safe_read_cint (count, ptr, end))
 		FAIL (ctx, g_strdup ("GenericInst: Not enough room for argument count"));
 
@@ -1222,8 +1291,8 @@ static gboolean
 parse_type (VerifyContext *ctx, const char **_ptr, const char *end)
 {
 	const char *ptr = *_ptr;
-	guint8 type = 0;
-	guint32 token = 0;
+	unsigned type;
+	unsigned token = 0;
 
 	if (!safe_read8 (type, ptr, end))
 		FAIL (ctx, g_strdup ("Type: Not enough room for the type"));
@@ -1256,6 +1325,11 @@ parse_type (VerifyContext *ctx, const char **_ptr, const char *end)
 	
 		if (!is_valid_coded_index (ctx, TYPEDEF_OR_REF_DESC, token))
 			FAIL (ctx, g_strdup_printf ("Type: invalid TypeDefOrRef token %x", token));
+		if (ctx->token) {
+			if (mono_metadata_token_index (ctx->token) == get_coded_index_token (TYPEDEF_OR_REF_DESC, token) &&
+				mono_metadata_token_table (ctx->token) == get_coded_index_table (TYPEDEF_OR_REF_DESC, token))
+				FAIL (ctx, g_strdup_printf ("Type: Recurside type specification (%x). A type signature can't reference itself", ctx->token));
+		}
 		break;
 
 	case MONO_TYPE_VAR:
@@ -1275,6 +1349,18 @@ parse_type (VerifyContext *ctx, const char **_ptr, const char *end)
 		if (!parse_generic_inst (ctx, &ptr, end))
 			FAIL (ctx, g_strdup ("Type: Could not parse generic inst"));
 		break;
+
+	case MONO_TYPE_FNPTR:
+		if (!parse_method_signature (ctx, &ptr, end, TRUE, TRUE))
+			FAIL (ctx, g_strdup ("Type: Could not parse method pointer signature"));
+		break;
+
+	case MONO_TYPE_SZARRAY:
+		if (!parse_custom_mods (ctx, &ptr, end))
+			FAIL (ctx, g_strdup ("Type: Failed to parse array element custom attr"));
+		if (!parse_type (ctx, &ptr, end))
+			FAIL (ctx, g_strdup ("Type: Could not parse array type"));
+		break;
 	}
 	*_ptr = ptr;
 	return TRUE;
@@ -1284,7 +1370,7 @@ static gboolean
 parse_return_type (VerifyContext *ctx, const char **_ptr, const char *end)
 {
 	const char *ptr;
-	int type = 0;
+	unsigned type = 0;
 
 	if (!parse_custom_mods (ctx, _ptr, end))
 		return FALSE;
@@ -1309,7 +1395,7 @@ static gboolean
 parse_param (VerifyContext *ctx, const char **_ptr, const char *end)
 {
 	const char *ptr;
-	int type = 0;
+	unsigned type = 0;
 
 	if (!parse_custom_mods (ctx, _ptr, end))
 		return FALSE;
@@ -1333,7 +1419,7 @@ parse_param (VerifyContext *ctx, const char **_ptr, const char *end)
 static gboolean
 parse_method_signature (VerifyContext *ctx, const char **_ptr, const char *end, gboolean allow_sentinel, gboolean allow_unmanaged)
 {
-	int cconv = 0;
+	unsigned cconv = 0;
 	unsigned param_count = 0, gparam_count = 0, type = 0, i;
 	const char *ptr = *_ptr;
 	gboolean saw_sentinel = FALSE;
@@ -1426,18 +1512,23 @@ static gboolean
 parse_field (VerifyContext *ctx, const char **_ptr, const char *end)
 {
 	const char *ptr = *_ptr;
-	guint8 signature = 0;
+	unsigned signature = 0;
 
 	if (!safe_read8 (signature, ptr, end))
 		FAIL (ctx, g_strdup ("Field: Not enough room for field signature"));
 
 	if (signature != 0x06)
 		FAIL (ctx, g_strdup_printf ("Field: Invalid signature 0x%x, must be 6", signature));
-	*_ptr = ptr; 
 
-	if (!parse_custom_mods (ctx, _ptr, end))
+	if (!parse_custom_mods (ctx, &ptr, end))
 		return FALSE;
 
+	if (safe_read8 (signature, ptr, end)) {
+		if (signature != MONO_TYPE_BYREF)
+			--ptr;
+	}
+	*_ptr = ptr;
+
 	return parse_type (ctx, _ptr, end);
 }
 
@@ -1457,23 +1548,34 @@ parse_locals_signature (VerifyContext *ctx, const char **_ptr, const char *end)
 	if (!safe_read_cint (locals_count, ptr, end))
 		FAIL (ctx, g_strdup ("LocalsSig: Not enough room for the param count"));
 
+	/* LAMEIMPL: MS sometimes generates empty local signatures and its verifier is ok with.
 	if (locals_count == 0)
 		FAIL (ctx, g_strdup ("LocalsSig: Signature with zero locals"));
+	*/
 
 	for (i = 0; i < locals_count; ++i) {
 		if (!safe_read8 (sig, ptr, end))
 			FAIL (ctx, g_strdup ("LocalsSig: Not enough room for type"));
 
-		if (sig == MONO_TYPE_TYPEDBYREF)
-			continue;
-
 		while (sig == MONO_TYPE_CMOD_REQD || sig == MONO_TYPE_CMOD_OPT || sig == MONO_TYPE_PINNED) {
 			if (sig != MONO_TYPE_PINNED && !parse_custom_mods (ctx, &ptr, end))
 				FAIL (ctx, g_strdup_printf ("LocalsSig: Error parsing local %d", i));
 			if (!safe_read8 (sig, ptr, end))
 				FAIL (ctx, g_strdup ("LocalsSig: Not enough room for type"));
 		}
+
+		if (sig == MONO_TYPE_BYREF) {
+			if (!safe_read8 (sig, ptr, end))
+				FAIL (ctx, g_strdup_printf ("Type: Not enough room for byref type for local %d", i));
+			if (sig == MONO_TYPE_TYPEDBYREF)
+				FAIL (ctx, g_strdup_printf ("Type: Invalid type typedref& for local %d", i));
+		}
+
+		if (sig == MONO_TYPE_TYPEDBYREF)
+			continue;
+
 		--ptr;
+
 		if (!parse_type (ctx, &ptr, end))
 			FAIL (ctx, g_strdup_printf ("LocalsSig: Error parsing local %d", i));
 	}
@@ -1485,7 +1587,8 @@ parse_locals_signature (VerifyContext *ctx, const char **_ptr, const char *end)
 static gboolean
 is_valid_field_signature (VerifyContext *ctx, guint32 offset)
 {
-	int size = 0, signature = 0;
+	int size = 0;
+	unsigned signature = 0;
 	const char *ptr = NULL, *end;
 
 	if (!decode_signature_header (ctx, offset, &size, &ptr))
@@ -1539,9 +1642,24 @@ is_valid_method_or_field_signature (VerifyContext *ctx, guint32 offset)
 static gboolean
 is_vald_cattr_blob (VerifyContext *ctx, guint32 offset)
 {
-	OffsetAndSize blob = get_metadata_stream (ctx, &ctx->image->heap_blob);
-	//TODO do proper verification
-	return blob.size >= 1 && blob.size - 1 >= offset;
+	int size = 0;
+	unsigned prolog = 0;
+	const char *ptr = NULL, *end;
+
+	if (!offset)
+		return TRUE;
+
+	if (!decode_signature_header (ctx, offset, &size, &ptr))
+		FAIL (ctx, g_strdup ("CustomAttribute: Could not decode signature header"));
+	end = ptr + size;
+
+	if (!safe_read16 (prolog, ptr, end))
+		FAIL (ctx, g_strdup ("CustomAttribute: Not enough room for prolog"));
+
+	if (prolog != 1)
+		FAIL (ctx, g_strdup_printf ("CustomAttribute: Prolog is 0x%x, expected 0x1", prolog));
+		
+	return TRUE;
 }
 
 static gboolean
@@ -1596,37 +1714,86 @@ is_valid_property_sig_blob (VerifyContext *ctx, guint32 offset)
 static gboolean
 is_valid_typespec_blob (VerifyContext *ctx, guint32 offset)
 {
-	OffsetAndSize blob = get_metadata_stream (ctx, &ctx->image->heap_blob);
-	//TODO do proper verification
-	return offset > 0 && blob.size >= 1 && blob.size - 1 >= offset;
+	int size = 0;
+	const char *ptr = NULL, *end;
+	unsigned type = 0;
+	
+
+	if (!decode_signature_header (ctx, offset, &size, &ptr))
+		FAIL (ctx, g_strdup ("TypeSpec: Could not decode signature header"));
+	end = ptr + size;
+
+	if (!parse_custom_mods (ctx, &ptr, end))
+		return FALSE;
+
+	if (!safe_read8 (type, ptr, end))
+		FAIL (ctx, g_strdup ("TypeSpec: Not enough room for type"));
+
+	if (type == MONO_TYPE_BYREF) {
+		if (!safe_read8 (type, ptr, end)) 
+			FAIL (ctx, g_strdup ("TypeSpec: Not enough room for byref type"));
+		if (type == MONO_TYPE_TYPEDBYREF)
+			FAIL (ctx, g_strdup ("TypeSpec: Invalid type typedref&"));
+	}
+	
+	if (type == MONO_TYPE_TYPEDBYREF)
+		return TRUE;
+
+	--ptr;
+	return parse_type (ctx, &ptr, end);
 }
 
 static gboolean
-is_valid_methodspec_blog (VerifyContext *ctx, guint32 offset)
+is_valid_methodspec_blob (VerifyContext *ctx, guint32 offset)
 {
-	OffsetAndSize blob = get_metadata_stream (ctx, &ctx->image->heap_blob);
-	//TODO do proper verification
-	return offset > 0 && blob.size >= 1 && blob.size - 1 >= offset;
+	int size = 0;
+	const char *ptr = NULL, *end;
+	unsigned type = 0;
+	unsigned count = 0, i;
+
+	if (!decode_signature_header (ctx, offset, &size, &ptr))
+		FAIL (ctx, g_strdup ("MethodSpec: Could not decode signature header"));
+	end = ptr + size;
+
+	if (!safe_read8 (type, ptr, end))
+		FAIL (ctx, g_strdup ("MethodSpec: Not enough room for call convention"));
+
+	if (type != 0x0A)
+		FAIL (ctx, g_strdup_printf ("MethodSpec: Invalid call convention 0x%x, expected 0x0A", type));
+
+	if (!safe_read_cint (count, ptr, end))
+		FAIL (ctx, g_strdup ("MethodSpec: Not enough room for parameter count"));
+
+	if (!count)
+		FAIL (ctx, g_strdup ("MethodSpec: Zero generic argument count"));
+
+	for (i = 0; i < count; ++i) {
+		if (!parse_type (ctx, &ptr, end))
+			FAIL (ctx, g_strdup_printf ("MethodSpec: Could not parse parameter %d", i + 1));
+	}
+	return TRUE;
 }
 
 static gboolean
-is_valid_blob_object (VerifyContext *ctx, guint32 offset)
+is_valid_blob_object (VerifyContext *ctx, guint32 offset, guint32 minsize)
 {
 	OffsetAndSize blob = get_metadata_stream (ctx, &ctx->image->heap_blob);
 	guint32 entry_size, bytes;
 
-	if (blob.size < offset) {
-		printf ("1\n");
+	if (blob.size < offset)
 		return FALSE;
-	}
 
 	if (!decode_value (ctx->data + offset + blob.offset, blob.size - blob.offset, &entry_size, &bytes))
 		return FALSE;
 
-	if (offset + entry_size + bytes < offset)
+	if (entry_size < minsize)
+		return FALSE;
+
+	if (CHECK_ADD4_OVERFLOW_UN (entry_size, bytes))
 		return FALSE;
+	entry_size += bytes;
 
-	return blob.size >= offset + entry_size + bytes;
+	return !ADD_IS_GREATER_OR_OVF (offset, entry_size, blob.size);
 }
 
 static gboolean
@@ -1635,23 +1802,20 @@ is_valid_constant (VerifyContext *ctx, guint32 type, guint32 offset)
 	OffsetAndSize blob = get_metadata_stream (ctx, &ctx->image->heap_blob);
 	guint32 size, entry_size, bytes;
 
-	if (blob.size < offset) {
-		printf ("1\n");
-		return FALSE;
-	}
-
+	if (blob.size < offset)
+		FAIL (ctx, g_strdup ("ContantValue: invalid offset"));
 	
 	if (!decode_value (ctx->data + offset + blob.offset, blob.size - blob.offset, &entry_size, &bytes))
-		return FALSE;
+		FAIL (ctx, g_strdup ("ContantValue: not enough space to decode size"));
 
 	if (type == MONO_TYPE_STRING) {
-		//String is encoded as: compressed_int:len len *chars
-
+		//String is encoded as: compressed_int:len len *bytes
 		offset += bytes;
-		if (offset > offset + entry_size * 2) //overflow
-			return FALSE;
-		offset += offset + entry_size * 2;
-		return  offset <= blob.size;
+
+		if (ADD_IS_GREATER_OR_OVF (offset, entry_size, blob.size))
+			FAIL (ctx, g_strdup_printf ("ContantValue: not enough space for string, required %d but got %d", entry_size * 2, blob.size - offset));	
+
+		return TRUE;
 	}
 
 	switch (type) {
@@ -1682,25 +1846,136 @@ is_valid_constant (VerifyContext *ctx, guint32 type, guint32 offset)
 	}
 
 	if (size != entry_size)
-		return FALSE;
-	offset += bytes;
+		FAIL (ctx, g_strdup_printf ("ContantValue: Expected size %d but got %d", size, entry_size));
 
-	if(offset > offset + size) //overflow
-		return FALSE;
+	offset += bytes;
 
-	if (offset + size > blob.size)
-		return FALSE;
+	if (ADD_IS_GREATER_OR_OVF (offset, size, blob.size))
+		FAIL (ctx, g_strdup_printf ("ContantValue: Not enough room for constant, required %d but have %d", size, blob.size - offset));
 
-	if (type == MONO_TYPE_CLASS && read32 (ctx->data + offset))
-		return FALSE;
+	if (type == MONO_TYPE_CLASS && read32 (ctx->data + blob.offset + offset))
+		FAIL (ctx, g_strdup_printf ("ContantValue: Type is class but value is not null"));
 	return TRUE;
 }
 
+#define FAT_HEADER_INVALID_FLAGS ~(0x3 | 0x8 | 0x10 | 0xF000)
+//only 0x01, 0x40 and 0x80 are allowed
+#define SECTION_HEADER_INVALID_FLAGS 0x3E
+
 static gboolean
 is_valid_method_header (VerifyContext *ctx, guint32 rva)
 {
-	//TODO do proper method header validation
-	return mono_cli_rva_image_map (ctx->image, rva) != INVALID_ADDRESS;
+	unsigned local_vars_tok, code_size, offset = mono_cli_rva_image_map (ctx->image, rva);
+	unsigned header = 0;
+	unsigned fat_header = 0, size = 0, max_stack;
+	const char *ptr = NULL, *end;
+
+	if (offset == INVALID_ADDRESS)
+		FAIL (ctx, g_strdup ("MethodHeader: Invalid RVA"));
+
+	ptr = ctx->data + offset;
+	end = ctx->data + ctx->size; /*no worries if it spawns multiple sections*/
+
+	if (!safe_read8 (header, ptr, end))
+		FAIL (ctx, g_strdup ("MethodHeader: Not enough room for header"));
+
+	switch (header & 0x3) {
+	case 0:
+	case 1:
+		FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid header type 0x%x", header & 0x3));
+	case 2:
+		header >>= 2;
+		if (ADDP_IS_GREATER_OR_OVF (ptr, header, end)) 
+			FAIL (ctx, g_strdup_printf ("MethodHeader: Not enough room for method body. Required %d, but only %d is available", header, (int)(end - ptr)));
+		return TRUE;
+	}
+	//FAT HEADER
+	--ptr;
+	if (!safe_read16 (fat_header, ptr, end))
+		FAIL (ctx, g_strdup ("MethodHeader: Not enough room for fat header"));
+
+	size = (fat_header >> 12) & 0xF;
+	if (size != 3)
+		FAIL (ctx, g_strdup ("MethodHeader: header size must be 3"));
+
+	if (!safe_read16 (max_stack, ptr, end))
+		FAIL (ctx, g_strdup ("MethodHeader: Not enough room for max stack"));
+
+	if (!safe_read32 (code_size, ptr, end))
+		FAIL (ctx, g_strdup ("MethodHeader: Not enough room for code size"));
+
+	if (!safe_read32 (local_vars_tok, ptr, end))
+		FAIL (ctx, g_strdup ("MethodHeader: Not enough room for local vars tok"));
+
+	if (local_vars_tok) {
+		if (((local_vars_tok >> 24) & 0xFF) != 0x11)
+			FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid local vars signature table 0x%x", ((local_vars_tok >> 24) & 0xFF)));
+		if ((local_vars_tok & 0xFFFFFF) > ctx->image->tables [MONO_TABLE_STANDALONESIG].rows)	
+			FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid local vars signature points to invalid row 0x%x", local_vars_tok & 0xFFFFFF));
+	}
+
+	if (fat_header & FAT_HEADER_INVALID_FLAGS)
+		FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid fat signature flags %x", fat_header & FAT_HEADER_INVALID_FLAGS));
+
+	if (ADDP_IS_GREATER_OR_OVF (ptr, code_size, end))
+		FAIL (ctx, g_strdup_printf ("MethodHeader: Not enough room for code %d", code_size));
+
+	if (!(fat_header & 0x08))
+		return TRUE;
+
+	ptr += code_size;
+
+	do {
+		unsigned section_header = 0, section_size = 0;
+		gboolean is_fat;
+
+		ptr = dword_align (ptr);
+		if (!safe_read32 (section_header, ptr, end))
+			FAIL (ctx, g_strdup ("MethodHeader: Not enough room for data section header"));
+
+		if (section_header & SECTION_HEADER_INVALID_FLAGS)
+			FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid section header flags 0x%x", section_header & SECTION_HEADER_INVALID_FLAGS));
+			
+		is_fat = (section_header & METHOD_HEADER_SECTION_FAT_FORMAT) != 0;
+		section_size = (section_header >> 8) & (is_fat ? 0xFFFFFF : 0xFF);
+
+		if (section_size < 4)
+			FAIL (ctx, g_strdup_printf ("MethodHeader: Section size too small"));
+
+		if (ADDP_IS_GREATER_OR_OVF (ptr, section_size - 4, end)) /*must be section_size -4 as ptr was incremented by safe_read32*/
+			FAIL (ctx, g_strdup_printf ("MethodHeader: Not enough room for section content %d", section_size));
+
+		if (section_header & METHOD_HEADER_SECTION_EHTABLE) {
+			guint32 i, clauses = section_size / (is_fat ? 24 : 12);
+			/*
+				LAMEIMPL: MS emits section_size without accounting for header size.
+				Mono does as the spec says. section_size is header + section
+				MS's peverify happily accepts both. 
+			*/
+			if ((clauses * (is_fat ? 24 : 12) != section_size) && (clauses * (is_fat ? 24 : 12) + 4 != section_size))
+				FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid EH section size %d, it's not of the expected size %d", section_size, clauses * (is_fat ? 24 : 12)));
+
+			/* only verify the class token is verified as the rest is done by the IL verifier*/
+			for (i = 0; i < clauses; ++i) {
+				unsigned flags = *(unsigned char*)ptr;
+				unsigned class_token = 0;
+				ptr += (is_fat ? 20 : 8);
+				if (!safe_read32 (class_token, ptr, end))
+					FAIL (ctx, g_strdup_printf ("MethodHeader: Not enough room for section %d", i));
+				if (flags == MONO_EXCEPTION_CLAUSE_NONE && class_token) {
+					guint table = mono_metadata_token_table (class_token);
+					if (table != MONO_TABLE_TYPEREF && table != MONO_TABLE_TYPEDEF && table != MONO_TABLE_TYPESPEC)
+						FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid section %d class token table %x", i, table));
+					if (mono_metadata_token_index (class_token) > ctx->image->tables [table].rows)
+						FAIL (ctx, g_strdup_printf ("MethodHeader: Invalid section %d class token index %x", i, mono_metadata_token_index (class_token)));
+				}
+			}
+		}
+
+		if (!(section_header & METHOD_HEADER_SECTION_MORE_SECTS))
+			break;
+	} while (1);
+	return TRUE;
 }
 
 static void
@@ -1757,7 +2032,7 @@ verify_typedef_table (VerifyContext *ctx)
 {
 	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_TYPEDEF];
 	guint32 data [MONO_TYPEDEF_SIZE];
-	guint32 fieldlist = 1, methodlist = 1;
+	guint32 fieldlist = 1, methodlist = 1, visibility;
 	int i;
 
 	if (table->rows == 0)
@@ -1777,32 +2052,22 @@ verify_typedef_table (VerifyContext *ctx)
 		if ((data [MONO_TYPEDEF_FLAGS] & 0xC00000) != 0)
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d mono doesn't support custom string format", i));
 
+		if ((data [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_INTERFACE) && (data [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_ABSTRACT) == 0)
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for interface type must be abstract", i));
+
 		if (!data [MONO_TYPEDEF_NAME] || !is_valid_non_empty_string (ctx, data [MONO_TYPEDEF_NAME]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d invalid name token %08x", i, data [MONO_TYPEDEF_NAME]));
 
 		if (data [MONO_TYPEREF_NAMESPACE] && !is_valid_non_empty_string (ctx, data [MONO_TYPEREF_NAMESPACE]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d invalid namespace token %08x", i, data [MONO_TYPEREF_NAMESPACE]));
 
-		if (i == 0) {
-			if (data [MONO_TYPEDEF_EXTENDS] != 0)
-				ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row 0 for the special <module> type must have a null extend field"));
-		} else {
-			if (typedef_is_system_object (ctx, data) && data [MONO_TYPEDEF_EXTENDS] != 0)
-				ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for System.Object must have a null extend field", i));
-	
-			if (data [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_INTERFACE) {
-				if (data [MONO_TYPEDEF_EXTENDS])
-					ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for interface type must have a null extend field", i));
-				if ((data [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_ABSTRACT) == 0)
-					ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for interface type must be abstract", i));
-			} else {
-				if (!is_valid_coded_index (ctx, TYPEDEF_OR_REF_DESC, data [MONO_TYPEDEF_EXTENDS]))
-					ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d extend field coded index 0x%08x", i, data [MONO_TYPEDEF_EXTENDS]));
-	
-				if (!get_coded_index_token (TYPEDEF_OR_REF_DESC, data [MONO_TYPEDEF_EXTENDS])) 
-					ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for non-interface type must have a non-null extend field", i));
-			}
-		}
+		if (data [MONO_TYPEDEF_EXTENDS] && !is_valid_coded_index (ctx, TYPEDEF_OR_REF_DESC, data [MONO_TYPEDEF_EXTENDS]))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d extend field coded index 0x%08x", i, data [MONO_TYPEDEF_EXTENDS]));
+
+		visibility = data [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_VISIBILITY_MASK;
+		if ((visibility >= TYPE_ATTRIBUTE_NESTED_PUBLIC && visibility <= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM) &&
+			search_sorted_table (ctx, MONO_TABLE_NESTEDCLASS, MONO_NESTED_CLASS_NESTED, i + 1) == -1)
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d has nested visibility but no rows in the NestedClass table", i));
 
 		if (data [MONO_TYPEDEF_FIELD_LIST] == 0)
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d FieldList be be >= 1", i));
@@ -1822,12 +2087,49 @@ verify_typedef_table (VerifyContext *ctx)
 		if (data [MONO_TYPEDEF_METHOD_LIST] < methodlist)
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d MethodList rowid 0x%08x can't be smaller than of previous row 0x%08x", i, data [MONO_TYPEDEF_METHOD_LIST], methodlist));
 
-
 		fieldlist = data [MONO_TYPEDEF_FIELD_LIST];
 		methodlist = data [MONO_TYPEDEF_METHOD_LIST];
 	}
 }
 
+static void
+verify_typedef_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_TYPEDEF];
+	guint32 data [MONO_TYPEDEF_SIZE];
+	int i;
+
+	if (table->rows == 0)
+		ADD_ERROR (ctx, g_strdup_printf ("Typedef table must have exactly at least one row"));
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_TYPEDEF_SIZE);
+
+		if (i == 0) {
+			if (data [MONO_TYPEDEF_EXTENDS] != 0)
+				ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row 0 for the special <module> type must have a null extend field"));
+			continue;
+		}
+
+		if (data [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_INTERFACE) {
+			if (data [MONO_TYPEDEF_EXTENDS])
+				ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for interface type must have a null extend field", i));
+		} else {
+			gboolean is_sys_obj = typedef_is_system_object (ctx, data);
+			gboolean has_parent = get_coded_index_token (TYPEDEF_OR_REF_DESC, data [MONO_TYPEDEF_EXTENDS]) != 0;
+
+			if (is_sys_obj) {
+				if (has_parent)
+					ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for System.Object must have a null extend field", i));
+			} else {
+				if (!has_parent) {
+					ADD_ERROR (ctx, g_strdup_printf ("Invalid typedef row %d for non-interface type must have a non-null extend field", i));
+				}
+			}
+		}
+	}
+}
+
 /*bits 3,11,14 */
 #define INVALID_FIELD_FLAG_BITS ((1 << 3) | (1 << 11) | (1 << 14))
 static void
@@ -1881,9 +2183,10 @@ verify_field_table (VerifyContext *ctx)
 		if (!data [MONO_FIELD_NAME] || !is_valid_non_empty_string (ctx, data [MONO_FIELD_NAME]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid field row %d invalid name token %08x", i, data [MONO_FIELD_NAME]));
 
+		if (data [MONO_FIELD_SIGNATURE] && !is_valid_blob_object (ctx, data [MONO_FIELD_SIGNATURE], 1))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid field row %d invalid signature blob token 0x%x", i, data [MONO_FIELD_SIGNATURE]));
+
 		//TODO verify contant flag
-		if (!data [MONO_FIELD_SIGNATURE] || !is_valid_field_signature (ctx, data [MONO_FIELD_SIGNATURE]))
-			ADD_ERROR (ctx, g_strdup_printf ("Invalid field row %d invalid signature token %08x", i, data [MONO_FIELD_SIGNATURE]));
 
 		if (i + 1 < module_field_list) {
 			guint32 access = flags & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK;
@@ -1895,8 +2198,23 @@ verify_field_table (VerifyContext *ctx)
 	}
 }
 
-/*bits 6,8,9,10,11,13,14,15*/
-#define INVALID_METHOD_IMPLFLAG_BITS ((1 << 6) | (1 << 8) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 13) | (1 << 14) | (1 << 15))
+static void
+verify_field_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_FIELD];
+	guint32 data [MONO_FIELD_SIZE];
+	int i;
+	
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_FIELD_SIZE);
+
+		if (!data [MONO_FIELD_SIGNATURE] || !is_valid_field_signature (ctx, data [MONO_FIELD_SIGNATURE]))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid field row %d invalid signature token %08x", i, data [MONO_FIELD_SIGNATURE]));
+	}
+}
+
+/*bits 8,9,10,11,13,14,15*/
+#define INVALID_METHOD_IMPLFLAG_BITS ((1 << 8) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 13) | (1 << 14) | (1 << 15))
 static void
 verify_method_table (VerifyContext *ctx)
 {
@@ -1945,12 +2263,14 @@ verify_method_table (VerifyContext *ctx)
 		if (flags & METHOD_ATTRIBUTE_ABSTRACT) {
 			if (flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)
 				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is Abstract and PinvokeImpl", i));
+			if (flags & METHOD_ATTRIBUTE_FINAL)
+				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is Abstract and Final", i));
 			if (!(flags & METHOD_ATTRIBUTE_VIRTUAL))
 				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is Abstract but not Virtual", i));
 		}
 
 		if (access == METHOD_ATTRIBUTE_COMPILER_CONTROLLED && (flags & (METHOD_ATTRIBUTE_RT_SPECIAL_NAME | METHOD_ATTRIBUTE_SPECIAL_NAME)))
-			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is CompileControlled and SpecialName or RtSpecialName", i));
+			ADD_WARNING (ctx, g_strdup_printf ("Invalid method row %d is CompileControlled and SpecialName or RtSpecialName", i));
 
 		if ((flags & METHOD_ATTRIBUTE_RT_SPECIAL_NAME) && !(flags & METHOD_ATTRIBUTE_SPECIAL_NAME))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is RTSpecialName but not SpecialName", i));
@@ -1959,9 +2279,6 @@ verify_method_table (VerifyContext *ctx)
 
 		//TODO check iface with .ctor (15,16)
 
-		if (!data [MONO_METHOD_SIGNATURE] || !is_valid_method_signature (ctx, data [MONO_METHOD_SIGNATURE]))
-			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d invalid signature token 0x%08x", i, data [MONO_METHOD_SIGNATURE]));
-
 		if (i + 1 < module_method_list) {
 			if (!(flags & METHOD_ATTRIBUTE_STATIC))
 				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is a global method but not Static", i));
@@ -1976,8 +2293,12 @@ verify_method_table (VerifyContext *ctx)
 		if ((flags & (METHOD_ATTRIBUTE_FINAL | METHOD_ATTRIBUTE_NEW_SLOT | METHOD_ATTRIBUTE_STRICT)) && !(flags & METHOD_ATTRIBUTE_VIRTUAL))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is (Final, NewSlot or Strict) but not Virtual", i));
 
-		if ((flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) && (flags & METHOD_ATTRIBUTE_VIRTUAL))
-			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is PinvokeImpl and Virtual", i));
+		if (flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
+			if (flags & METHOD_ATTRIBUTE_VIRTUAL)
+				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is PinvokeImpl and Virtual", i));
+			if (!(flags & METHOD_ATTRIBUTE_STATIC))
+				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is PinvokeImpl but not Static", i));
+		}
 
 		if (!(flags & METHOD_ATTRIBUTE_ABSTRACT) && !rva && !(flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) && 
 				!(implflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && code_type != METHOD_IMPL_ATTRIBUTE_RUNTIME)
@@ -1993,8 +2314,6 @@ verify_method_table (VerifyContext *ctx)
 				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d has RVA != 0 but is Abstract", i));
 			if (code_type == METHOD_IMPL_ATTRIBUTE_OPTIL)
 				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d has RVA != 0 but is CodeTypeMask is neither Native, CIL or Runtime", i));
-			if (!is_valid_method_header (ctx, rva))
-				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d RVA points to an invalid method header", i));
 		} else {
 			if (!(flags & (METHOD_ATTRIBUTE_ABSTRACT | METHOD_ATTRIBUTE_PINVOKE_IMPL)) && !(implflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && code_type != METHOD_IMPL_ATTRIBUTE_RUNTIME)
 				ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d has RVA = 0 but neither Abstract, InternalCall, Runtime or PinvokeImpl", i));
@@ -2012,6 +2331,9 @@ verify_method_table (VerifyContext *ctx)
 		if ((is_ctor || is_cctor) && !(flags & METHOD_ATTRIBUTE_RT_SPECIAL_NAME))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d is named .ctor or .cctor but is not RtSpecialName", i));
 
+		if (data [MONO_METHOD_SIGNATURE] && !is_valid_blob_object (ctx, data [MONO_METHOD_SIGNATURE], 1))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d invalid signature blob token 0x%x", i, data [MONO_METHOD_SIGNATURE]));
+
 		if (data [MONO_METHOD_PARAMLIST] == 0)
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d ParamList be be >= 1", i));
 
@@ -2026,6 +2348,25 @@ verify_method_table (VerifyContext *ctx)
 	}
 }
 
+static void
+verify_method_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_METHOD];
+	guint32 data [MONO_METHOD_SIZE], rva;
+	int i;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_METHOD_SIZE);
+		rva = data [MONO_METHOD_RVA];
+
+		if (!data [MONO_METHOD_SIGNATURE] || !is_valid_method_signature (ctx, data [MONO_METHOD_SIGNATURE]))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d invalid signature token 0x%08x", i, data [MONO_METHOD_SIGNATURE]));
+
+		if (rva && !is_valid_method_header (ctx, rva))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid method row %d RVA points to an invalid method header", i));
+	}
+}
+
 static guint32
 get_next_param_count (VerifyContext *ctx, guint32 *current_method)
 {
@@ -2059,6 +2400,12 @@ verify_param_table (VerifyContext *ctx)
 	gboolean first_param = TRUE;
 	int i;
 
+	if (ctx->image->tables [MONO_TABLE_METHOD].rows == 0) {
+		if (table->rows > 0)
+			ADD_ERROR (ctx, g_strdup ("Param table has rows while the method table has zero"));
+		return;
+	}
+	
 	remaining_params = get_next_param_count (ctx, &current_method);
 
 	for (i = 0; i < table->rows; ++i) {
@@ -2133,13 +2480,29 @@ verify_memberref_table (VerifyContext *ctx)
 		if (!is_valid_non_empty_string (ctx, data [MONO_MEMBERREF_NAME]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid MemberRef row %d Name field coded is invalid or empty 0x%08x", i, data [MONO_MEMBERREF_NAME]));
 
-		if (!is_valid_method_or_field_signature (ctx, data [MONO_MEMBERREF_SIGNATURE]))
-			ADD_ERROR (ctx, g_strdup_printf ("Invalid MemberRef row %d Signature field  0x%08x", i, data [MONO_MEMBERREF_SIGNATURE]));
+		if (data [MONO_MEMBERREF_SIGNATURE] && !is_valid_blob_object (ctx, data [MONO_MEMBERREF_SIGNATURE], 1))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid MemberRef row %d invalid signature blob token 0x%x", i, data [MONO_MEMBERREF_SIGNATURE]));
 	}
 }
 
+
 static void
-verify_constant_table (VerifyContext *ctx)
+verify_memberref_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_MEMBERREF];
+	guint32 data [MONO_MEMBERREF_SIZE];
+	int i;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_MEMBERREF_SIZE);
+
+		if (!is_valid_method_or_field_signature (ctx, data [MONO_MEMBERREF_SIGNATURE]))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid MemberRef row %d Signature field  0x%08x", i, data [MONO_MEMBERREF_SIGNATURE]));
+	}
+}
+
+static void
+verify_constant_table (VerifyContext *ctx)
 {
 	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_CONSTANT];
 	guint32 data [MONO_CONSTANT_SIZE], type;
@@ -2179,9 +2542,23 @@ verify_cattr_table (VerifyContext *ctx)
 		if (!is_valid_coded_index (ctx, CATTR_TYPE_DESC, data [MONO_CUSTOM_ATTR_TYPE]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid CustomAttribute row %d Parent field 0x%08x", i, data [MONO_CUSTOM_ATTR_PARENT]));
 
+		if (data [MONO_CUSTOM_ATTR_VALUE] && !is_valid_blob_object (ctx, data [MONO_CUSTOM_ATTR_VALUE], 0))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid CustomAttribute row %d invalid value blob 0x%x", i, data [MONO_CUSTOM_ATTR_VALUE]));
+	}
+}
+
+static void
+verify_cattr_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_CUSTOMATTRIBUTE];
+	guint32 data [MONO_CUSTOM_ATTR_SIZE];
+	int i;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_CUSTOM_ATTR_SIZE);
+
 		if (!is_vald_cattr_blob (ctx, data [MONO_CUSTOM_ATTR_VALUE]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid CustomAttribute row %d Value field 0x%08x", i, data [MONO_CUSTOM_ATTR_VALUE]));
-			
 	}
 }
 
@@ -2204,9 +2581,23 @@ verify_field_marshal_table (VerifyContext *ctx)
 		if (!data [MONO_FIELD_MARSHAL_NATIVE_TYPE])
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid FieldMarshal row %d NativeType field is null", i));
 
+		if (!is_valid_blob_object (ctx, data [MONO_FIELD_MARSHAL_NATIVE_TYPE], 1))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid FieldMarshal row %d invalid NativeType blob 0x%x", i, data [MONO_FIELD_MARSHAL_NATIVE_TYPE]));
+	}
+}
+
+static void
+verify_field_marshal_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_FIELDMARSHAL];
+	guint32 data [MONO_FIELD_MARSHAL_SIZE];
+	int i;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_FIELD_MARSHAL_SIZE);
+
 		if (!is_valid_marshal_spec (ctx, data [MONO_FIELD_MARSHAL_NATIVE_TYPE]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid FieldMarshal row %d NativeType field 0x%08x", i, data [MONO_FIELD_MARSHAL_NATIVE_TYPE]));
-			
 	}
 }
 
@@ -2228,10 +2619,21 @@ verify_decl_security_table (VerifyContext *ctx)
 
 		if (!data [MONO_DECL_SECURITY_PERMISSIONSET])
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field is null", i));
+	}
+}
+
+static void
+verify_decl_security_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_DECLSECURITY];
+	guint32 data [MONO_DECL_SECURITY_SIZE];
+	int i;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_DECL_SECURITY_SIZE);
 
 		if (!is_valid_permission_set (ctx, data [MONO_DECL_SECURITY_PERMISSIONSET]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid DeclSecurity row %d PermissionSet field 0x%08x", i, data [MONO_DECL_SECURITY_PERMISSIONSET]));
-
 	}
 }
 
@@ -2287,6 +2689,21 @@ verify_standalonesig_table (VerifyContext *ctx)
 	guint32 data [MONO_STAND_ALONE_SIGNATURE_SIZE];
 	int i;
 
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_STAND_ALONE_SIGNATURE_SIZE);
+
+		if (data [MONO_STAND_ALONE_SIGNATURE] && !is_valid_blob_object (ctx, data [MONO_STAND_ALONE_SIGNATURE], 1))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid StandAloneSig row %d invalid signature 0x%x", i, data [MONO_STAND_ALONE_SIGNATURE]));
+	}
+}
+
+static void
+verify_standalonesig_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_STANDALONESIG];
+	guint32 data [MONO_STAND_ALONE_SIGNATURE_SIZE];
+	int i;
+
 	for (i = 0; i < table->rows; ++i) {
 		mono_metadata_decode_row (table, i, data, MONO_STAND_ALONE_SIGNATURE_SIZE);
 
@@ -2320,10 +2737,8 @@ static void
 verify_event_table (VerifyContext *ctx)
 {
 	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_EVENT];
-	MonoTableInfo *sema_table = &ctx->image->tables [MONO_TABLE_METHODSEMANTICS];
-	guint32 data [MONO_EVENT_SIZE], sema_data [MONO_METHOD_SEMA_SIZE], token;
-	gboolean found_add, found_remove;
-	int i, idx;
+	guint32 data [MONO_EVENT_SIZE];
+	int i;
 
 	for (i = 0; i < table->rows; ++i) {
 		mono_metadata_decode_row (table, i, data, MONO_EVENT_SIZE);
@@ -2336,8 +2751,21 @@ verify_event_table (VerifyContext *ctx)
 
 		if (!is_valid_coded_index (ctx, TYPEDEF_OR_REF_DESC, data [MONO_EVENT_TYPE]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid Event row %d EventType field %08x", i, data [MONO_EVENT_TYPE]));
+	}
+}
+
+static void
+verify_event_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_EVENT];
+	MonoTableInfo *sema_table = &ctx->image->tables [MONO_TABLE_METHODSEMANTICS];
+	guint32 data [MONO_EVENT_SIZE], sema_data [MONO_METHOD_SEMA_SIZE], token;
+	gboolean found_add, found_remove;
+	int i, idx;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_EVENT_SIZE);
 
-		//check for Add and Remove
 		token = make_coded_token (HAS_SEMANTICS_DESC, MONO_TABLE_EVENT, i);
 		idx = search_sorted_table (ctx, MONO_TABLE_METHODSEMANTICS, MONO_METHOD_SEMA_ASSOCIATION, token);
 		if (idx == -1)
@@ -2470,12 +2898,28 @@ verify_typespec_table (VerifyContext *ctx)
 	for (i = 0; i < table->rows; ++i) {
 		mono_metadata_decode_row (table, i, data, MONO_TYPESPEC_SIZE);
 
+		if (data [MONO_TYPESPEC_SIGNATURE] && !is_valid_blob_object (ctx, data [MONO_TYPESPEC_SIGNATURE], 1))
+			ADD_ERROR (ctx, g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, data [MONO_TYPESPEC_SIGNATURE]));
+	}
+}
+
+static void
+verify_typespec_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_TYPESPEC];
+	guint32 data [MONO_TYPESPEC_SIZE];
+	int i;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_TYPESPEC_SIZE);
+		ctx->token = (i + 1) | MONO_TOKEN_TYPE_SPEC;
 		if (!is_valid_typespec_blob (ctx, data [MONO_TYPESPEC_SIGNATURE]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid TypeSpec row %d Signature field %08x", i, data [MONO_TYPESPEC_SIGNATURE]));
 	}
+	ctx->token = 0;
 }
 
-#define INVALID_IMPLMAP_FLAGS_BITS ~((1 << 0) | (1 << 1) | (1 << 2) | (1 << 7) | (1 << 8) | (1 << 9) | (1 << 10))
+#define INVALID_IMPLMAP_FLAGS_BITS ~((1 << 0) | (1 << 1) | (1 << 2) | (1 << 6) | (1 << 8) | (1 << 9) | (1 << 10))
 static void
 verify_implmap_table (VerifyContext *ctx)
 {
@@ -2505,7 +2949,7 @@ verify_implmap_table (VerifyContext *ctx)
 		if (!is_valid_non_empty_string (ctx, data [MONO_IMPLMAP_NAME]))
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid ImplMap row %d ImportName Token %x", i, data [MONO_IMPLMAP_NAME]));
 
-		if (!data [MONO_IMPLMAP_SCOPE] || data [MONO_IMPLMAP_SCOPE] > ctx->image->tables [MONO_TABLE_MODULE].rows + 1)
+		if (!data [MONO_IMPLMAP_SCOPE] || data [MONO_IMPLMAP_SCOPE] > ctx->image->tables [MONO_TABLE_MODULEREF].rows + 1)
 			ADD_ERROR (ctx, g_strdup_printf ("Invalid ImplMap row %d Invalid ImportScope token %x", i, data [MONO_IMPLMAP_SCOPE]));
 	}
 }
@@ -2528,7 +2972,7 @@ verify_fieldrva_table (VerifyContext *ctx)
 	}
 }
 
-#define INVALID_ASSEMBLY_FLAGS_BITS ~((1 << 0) | (1 << 8) | (1 << 14) | (1 << 15))
+#define INVALID_ASSEMBLY_FLAGS_BITS ~((1 << 0) | (1 << 4) | (1 << 8) | (1 << 14) | (1 << 15))
 static void
 verify_assembly_table (VerifyContext *ctx)
 {
@@ -2549,7 +2993,7 @@ verify_assembly_table (VerifyContext *ctx)
 		if (data [MONO_ASSEMBLY_FLAGS] & INVALID_ASSEMBLY_FLAGS_BITS)
 			ADD_ERROR (ctx, g_strdup_printf ("Assembly table row %d has invalid Flags %08x", i, data [MONO_ASSEMBLY_FLAGS]));
 
-		if (data [MONO_ASSEMBLY_PUBLIC_KEY] && !is_valid_blob_object (ctx, data [MONO_ASSEMBLY_PUBLIC_KEY]))
+		if (data [MONO_ASSEMBLY_PUBLIC_KEY] && !is_valid_blob_object (ctx, data [MONO_ASSEMBLY_PUBLIC_KEY], 1))
 			ADD_ERROR (ctx, g_strdup_printf ("Assembly table row %d has invalid PublicKey %08x", i, data [MONO_ASSEMBLY_FLAGS]));
 
 		if (!is_valid_non_empty_string (ctx, data [MONO_ASSEMBLY_NAME]))
@@ -2574,7 +3018,7 @@ verify_assemblyref_table (VerifyContext *ctx)
 		if (data [MONO_ASSEMBLYREF_FLAGS] & INVALID_ASSEMBLYREF_FLAGS_BITS)
 			ADD_ERROR (ctx, g_strdup_printf ("AssemblyRef table row %d has invalid Flags %08x", i, data [MONO_ASSEMBLYREF_FLAGS]));
 
-		if (data [MONO_ASSEMBLYREF_PUBLIC_KEY] && !is_valid_blob_object (ctx, data [MONO_ASSEMBLYREF_PUBLIC_KEY]))
+		if (data [MONO_ASSEMBLYREF_PUBLIC_KEY] && !is_valid_blob_object (ctx, data [MONO_ASSEMBLYREF_PUBLIC_KEY], 1))
 			ADD_ERROR (ctx, g_strdup_printf ("AssemblyRef table row %d has invalid PublicKeyOrToken %08x", i, data [MONO_ASSEMBLYREF_PUBLIC_KEY]));
 
 		if (!is_valid_non_empty_string (ctx, data [MONO_ASSEMBLYREF_NAME]))
@@ -2583,7 +3027,7 @@ verify_assemblyref_table (VerifyContext *ctx)
 		if (data [MONO_ASSEMBLYREF_CULTURE] && !is_valid_string (ctx, data [MONO_ASSEMBLYREF_CULTURE]))
 			ADD_ERROR (ctx, g_strdup_printf ("AssemblyRef table row %d has invalid Culture %08x", i, data [MONO_ASSEMBLYREF_CULTURE]));
 
-		if (data [MONO_ASSEMBLYREF_HASH_VALUE] && !is_valid_blob_object (ctx, data [MONO_ASSEMBLYREF_HASH_VALUE]))
+		if (data [MONO_ASSEMBLYREF_HASH_VALUE] && !is_valid_blob_object (ctx, data [MONO_ASSEMBLYREF_HASH_VALUE], 1))
 			ADD_ERROR (ctx, g_strdup_printf ("AssemblyRef table row %d has invalid HashValue %08x", i, data [MONO_ASSEMBLYREF_HASH_VALUE]));
 	}
 }
@@ -2605,7 +3049,7 @@ verify_file_table (VerifyContext *ctx)
 		if (!is_valid_non_empty_string (ctx, data [MONO_FILE_NAME]))
 			ADD_ERROR (ctx, g_strdup_printf ("File table row %d has invalid Name %08x", i, data [MONO_FILE_NAME]));
 
-		if (!data [MONO_FILE_HASH_VALUE] || !is_valid_blob_object (ctx, data [MONO_FILE_HASH_VALUE]))
+		if (!data [MONO_FILE_HASH_VALUE] || !is_valid_blob_object (ctx, data [MONO_FILE_HASH_VALUE], 1))
 			ADD_ERROR (ctx, g_strdup_printf ("File table row %d has invalid HashValue %08x", i, data [MONO_FILE_HASH_VALUE]));
 	}
 }
@@ -2758,7 +3202,22 @@ verify_method_spec_table (VerifyContext *ctx)
 		if (!get_coded_index_token (METHODDEF_OR_REF_DESC, data [MONO_METHODSPEC_METHOD]))
 			ADD_ERROR (ctx, g_strdup_printf ("MethodSpec table row %d has null Method token", i));
 
-		if (!is_valid_methodspec_blog (ctx, data [MONO_METHODSPEC_SIGNATURE]))
+		if (data [MONO_METHODSPEC_SIGNATURE] && !is_valid_blob_object (ctx, data [MONO_METHODSPEC_SIGNATURE], 1))
+			ADD_ERROR (ctx, g_strdup_printf ("MethodSpec table row %d has invalid signature token %08x", i, data [MONO_METHODSPEC_SIGNATURE]));
+	}
+}
+
+static void
+verify_method_spec_table_full (VerifyContext *ctx)
+{
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_METHODSPEC];
+	guint32 data [MONO_METHODSPEC_SIZE];
+	int i;
+
+	for (i = 0; i < table->rows; ++i) {
+		mono_metadata_decode_row (table, i, data, MONO_METHODSPEC_SIZE);
+
+		if (!is_valid_methodspec_blob (ctx, data [MONO_METHODSPEC_SIGNATURE]))
 			ADD_ERROR (ctx, g_strdup_printf ("MethodSpec table row %d has invalid Instantiation token %08x", i, data [MONO_METHODSPEC_SIGNATURE]));
 	}
 }
@@ -2784,6 +3243,104 @@ verify_generic_param_constraint_table (VerifyContext *ctx)
 	}
 }
 
+
+typedef struct {
+	const char *name;
+	const char *name_space;
+	guint32 resolution_scope;
+} TypeDefUniqueId;
+
+static guint
+typedef_hash (gconstpointer _key)
+{
+	const TypeDefUniqueId *key = _key;
+	return g_str_hash (key->name) ^ g_str_hash (key->name_space) ^ key->resolution_scope; /*XXX better salt the int key*/
+}
+
+static gboolean
+typedef_equals (gconstpointer _a, gconstpointer _b)
+{
+	const TypeDefUniqueId *a = _a;
+	const TypeDefUniqueId *b = _b;
+	return !strcmp (a->name, b->name) && !strcmp (a->name_space, b->name_space) && a->resolution_scope == b->resolution_scope;
+}
+
+static void
+verify_typedef_table_global_constraints (VerifyContext *ctx)
+{
+	int i;
+	guint32 data [MONO_TYPEDEF_SIZE];
+	guint32 nested_data [MONO_NESTED_CLASS_SIZE];
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_TYPEDEF];
+	MonoTableInfo *nested_table = &ctx->image->tables [MONO_TABLE_NESTEDCLASS];
+	GHashTable *unique_types = g_hash_table_new_full (&typedef_hash, &typedef_equals, g_free, NULL);
+
+	for (i = 0; i < table->rows; ++i) {
+		guint visibility;
+		TypeDefUniqueId *type = g_new (TypeDefUniqueId, 1);
+		mono_metadata_decode_row (table, i, data, MONO_TYPEDEF_SIZE);
+
+		type->name = mono_metadata_string_heap (ctx->image, data [MONO_TYPEDEF_NAME]);
+		type->name_space = mono_metadata_string_heap (ctx->image, data [MONO_TYPEDEF_NAMESPACE]);
+		type->resolution_scope = 0;
+
+		visibility = data [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_VISIBILITY_MASK;
+		if (visibility >= TYPE_ATTRIBUTE_NESTED_PUBLIC && visibility <= TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM) {
+			int res = search_sorted_table (ctx, MONO_TABLE_NESTEDCLASS, MONO_NESTED_CLASS_NESTED, i + 1);
+			g_assert (res >= 0);
+
+			mono_metadata_decode_row (nested_table, res, nested_data, MONO_NESTED_CLASS_SIZE);
+			type->resolution_scope = nested_data [MONO_NESTED_CLASS_ENCLOSING];
+		}
+
+		if (g_hash_table_lookup (unique_types, type)) {
+			ADD_ERROR_NO_RETURN (ctx, g_strdup_printf ("TypeDef table row %d has duplicate for tuple (%s,%s,%x)", i, type->name, type->name_space, type->resolution_scope));
+			g_hash_table_destroy (unique_types);
+			g_free (type);
+			return;
+		}
+		g_hash_table_insert (unique_types, type, GUINT_TO_POINTER (1));
+	}
+
+	g_hash_table_destroy (unique_types);
+}
+
+static void
+verify_typeref_table_global_constraints (VerifyContext *ctx)
+{
+	int i;
+	guint32 data [MONO_TYPEREF_SIZE];
+	MonoTableInfo *table = &ctx->image->tables [MONO_TABLE_TYPEREF];
+	GHashTable *unique_types = g_hash_table_new_full (&typedef_hash, &typedef_equals, g_free, NULL);
+
+	for (i = 0; i < table->rows; ++i) {
+		TypeDefUniqueId *type = g_new (TypeDefUniqueId, 1);
+		mono_metadata_decode_row (table, i, data, MONO_TYPEREF_SIZE);
+
+		type->resolution_scope = data [MONO_TYPEREF_SCOPE];
+		type->name = mono_metadata_string_heap (ctx->image, data [MONO_TYPEREF_NAME]);
+		type->name_space = mono_metadata_string_heap (ctx->image, data [MONO_TYPEREF_NAMESPACE]);
+
+		if (g_hash_table_lookup (unique_types, type)) {
+			ADD_ERROR_NO_RETURN (ctx, g_strdup_printf ("TypeRef table row %d has duplicate for tuple (%s,%s,%x)", i, type->name, type->name_space, type->resolution_scope));
+			g_hash_table_destroy (unique_types);
+			g_free (type);
+			return;
+		}
+		g_hash_table_insert (unique_types, type, GUINT_TO_POINTER (1));
+	}
+
+	g_hash_table_destroy (unique_types);
+}
+
+static void
+verify_tables_data_global_constraints (VerifyContext *ctx)
+{
+	verify_typeref_table_global_constraints (ctx);
+	CHECK_ERROR ();
+	verify_typedef_table_global_constraints (ctx);
+}
+	
 static void
 verify_tables_data (VerifyContext *ctx)
 {
@@ -2874,15 +3431,8 @@ verify_tables_data (VerifyContext *ctx)
 	verify_method_spec_table (ctx);
 	CHECK_ERROR ();
 	verify_generic_param_constraint_table (ctx);
-}
-
-static gboolean
-mono_verifier_is_corlib (MonoImage *image)
-{
-	gboolean trusted_location = (mono_security_get_mode () != MONO_SECURITY_MODE_CORE_CLR) ? 
-			TRUE : mono_security_core_clr_is_platform_image (image);
-
-	return trusted_location && !strcmp ("mscorlib.dll", image->name);
+	CHECK_ERROR ();
+	verify_tables_data_global_constraints (ctx);
 }
 
 static void
@@ -2891,10 +3441,10 @@ init_verify_context (VerifyContext *ctx, MonoImage *image, GSList **error_list)
 	memset (ctx, 0, sizeof (VerifyContext));
 	ctx->image = image;
 	ctx->report_error = error_list != NULL;
+	ctx->report_warning = FALSE; //export this setting in the API
 	ctx->valid = 1;
 	ctx->size = image->raw_data_len;
 	ctx->data = image->raw_data;
-	ctx->is_corlib = mono_verifier_is_corlib (image);	
 }
 
 static gboolean
@@ -2959,6 +3509,18 @@ cleanup:
 	return cleanup_context (&ctx, error_list);
 }
 
+
+/*
+ * Verifies basic table constraints such as global table invariants (sorting, field monotonicity, etc).
+ * Other verification checks are meant to be done lazily by the runtime. Those include:
+ * 	blob items (signatures, method headers, custom attributes, etc)
+ *  type semantics related
+ *  vtable related
+ *  stuff that should not block other pieces from running such as bad types/methods/fields/etc.
+ * 
+ * The whole idea is that if this succeed the runtime is free to play around safely but any complex
+ * operation still need more checking.
+ */
 gboolean
 mono_verifier_verify_table_data (MonoImage *image, GSList **error_list)
 {
@@ -2974,6 +3536,219 @@ mono_verifier_verify_table_data (MonoImage *image, GSList **error_list)
 
 	return cleanup_context (&ctx, error_list);
 }
+
+
+/*
+ * Verifies all other constraints.
+ */
+gboolean
+mono_verifier_verify_full_table_data (MonoImage *image, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	verify_typedef_table_full (&ctx);
+	CHECK_STATE ();
+	verify_field_table_full (&ctx);
+	CHECK_STATE ();
+	verify_method_table_full (&ctx);
+	CHECK_STATE ();
+	verify_memberref_table_full (&ctx);
+	CHECK_STATE ();
+	verify_cattr_table_full (&ctx);
+	CHECK_STATE ();
+	verify_field_marshal_table_full (&ctx);
+	CHECK_STATE ();
+	verify_decl_security_table_full (&ctx);
+	CHECK_STATE ();
+	verify_standalonesig_table_full (&ctx);
+	CHECK_STATE ();
+	verify_event_table_full (&ctx);
+	CHECK_STATE ();
+	verify_typespec_table_full (&ctx);
+	CHECK_STATE ();
+	verify_method_spec_table_full (&ctx);
+
+cleanup:
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_verify_field_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	is_valid_field_signature (&ctx, offset);
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_verify_method_header (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	is_valid_method_header (&ctx, offset);
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_verify_method_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	is_valid_method_signature (&ctx, offset);
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_verify_memberref_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	is_valid_method_or_field_signature (&ctx, offset);
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_verify_standalone_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	is_valid_standalonesig_blob (&ctx, offset);
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_verify_typespec_signature (MonoImage *image, guint32 offset, guint32 token, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+	ctx.token = token;
+
+	is_valid_typespec_blob (&ctx, offset);
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_verify_methodspec_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	is_valid_methodspec_blob (&ctx, offset);
+	return cleanup_context (&ctx, error_list);
+}
+
+static void
+verify_user_string (VerifyContext *ctx, guint32 offset)
+{
+	OffsetAndSize heap_us = get_metadata_stream (ctx, &ctx->image->heap_us);
+	guint32 entry_size, bytes;
+
+	if (heap_us.size < offset)
+		ADD_ERROR (ctx, g_strdup ("User string offset beyond heap_us size"));
+
+	if (!decode_value (ctx->data + offset + heap_us.offset, heap_us.size - heap_us.offset, &entry_size, &bytes))
+		ADD_ERROR (ctx, g_strdup ("Could not decode user string blob size"));
+
+	if (CHECK_ADD4_OVERFLOW_UN (entry_size, bytes))
+		ADD_ERROR (ctx, g_strdup ("User string size overflow"));
+
+	entry_size += bytes;
+
+	if (ADD_IS_GREATER_OR_OVF (offset, entry_size, heap_us.size))
+		ADD_ERROR (ctx, g_strdup ("User string oveflow heap_us"));
+}
+
+gboolean
+mono_verifier_verify_string_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	VerifyContext ctx;
+
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	init_verify_context (&ctx, image, error_list);
+	ctx.stage = STAGE_TABLES;
+
+	verify_user_string (&ctx, offset);
+
+	return cleanup_context (&ctx, error_list);
+}
+
+gboolean
+mono_verifier_is_sig_compatible (MonoImage *image, MonoMethod *method, MonoMethodSignature *signature)
+{
+	MonoMethodSignature *original_sig;
+	if (!mono_verifier_is_enabled_for_image (image))
+		return TRUE;
+
+	original_sig = mono_method_signature (method);
+	if (original_sig->call_convention == MONO_CALL_VARARG) {
+		if (original_sig->hasthis != signature->hasthis)
+			return FALSE;
+		if (original_sig->call_convention != signature->call_convention)
+			return FALSE;
+		if (original_sig->explicit_this != signature->explicit_this)
+			return FALSE;
+		if (original_sig->call_convention != signature->call_convention)
+			return FALSE;
+		if (original_sig->pinvoke != signature->pinvoke)
+			return FALSE;
+		if (original_sig->sentinelpos != signature->sentinelpos)
+			return FALSE;
+	} else if (!mono_metadata_signature_equal (signature, original_sig)) {
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
 #else
 gboolean
 mono_verifier_verify_table_data (MonoImage *image, GSList **error_list)
@@ -2992,4 +3767,66 @@ mono_verifier_verify_pe_data (MonoImage *image, GSList **error_list)
 {
 	return TRUE;
 }
+
+gboolean
+mono_verifier_verify_full_table_data (MonoImage *image, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_field_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_method_header (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_method_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_memberref_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_standalone_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_typespec_signature (MonoImage *image, guint32 offset, guint32 token, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_methodspec_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_verify_string_signature (MonoImage *image, guint32 offset, GSList **error_list)
+{
+	return TRUE;
+}
+
+gboolean
+mono_verifier_is_sig_compatible (MonoImage *image, MonoMethod *method, MonoMethodSignature *signature)
+{
+	return TRUE;
+}
+
+
 #endif /* DISABLE_VERIFIER */