find class or code from assetbundle manifest.

hoge.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using UnityEditor;
using UnityEngine;
using System.Text.RegularExpressions;


public class CodeDebug
{

	[MenuItem ("Assets/Check")]
	static void Check ()
	{
		var result = Directory.GetFiles (Application.streamingAssetsPath, "*.manifest")
			.SelectMany (p => {
			var text = File.ReadAllText (p);
			var matches = Regex.Matches (text, "Script: \\{fileID: (?<id>.+), guid: (?<guid>.+), type: 3\\}");

			List<string> classNameList = new List<string> (matches.Count);
			foreach (Match match in matches) {
				var id = int.Parse (match.Groups [1].ToString ());
				var hash = match.Groups [2].ToString ();
				var dllPath = AssetDatabase.GUIDToAssetPath (hash);
				classNameList.Add (GetClassName (dllPath, id));
			}
			return classNameList;
		}).Where (c => c != null);

		Debug.Log("<color=red>--- request classes ---</color>");
		foreach (var className in result) {
			Debug.Log (className);
		}
	}

	static string GetClassName (string path, int id)
	{
		var assembly = Assembly.LoadFile (path);
		var modules = assembly.GetLoadedModules ();
		foreach (var module in modules) {
			foreach (var t in module.GetTypes()) {
				if (t.IsSubclassOf (typeof(Component))) {

					if (FileIDUtil.Compute (t) == id) {
						return t.FullName;
					}
				}
			}
		}
		return null;
	}
}


#region MD4

// Taken from http://www.superstarcoders.com/blogs/posts/md4-hash-algorithm-in-c-sharp.aspx
// Probably not the best implementation of MD4, but it works.
public class MD4 : HashAlgorithm
{
	private uint _a;
	private uint _b;
	private uint _c;
	private uint _d;
	private uint[] _x;
	private int _bytesProcessed;

	public MD4 ()
	{
		_x = new uint[16];

		Initialize ();
	}

	public override void Initialize ()
	{
		_a = 0x67452301;
		_b = 0xefcdab89;
		_c = 0x98badcfe;
		_d = 0x10325476;

		_bytesProcessed = 0;
	}

	protected override void HashCore (byte[] array, int offset, int length)
	{
		ProcessMessage (Bytes (array, offset, length));
	}

	protected override byte[] HashFinal ()
	{
		try {
			ProcessMessage (Padding ());

			return new [] { _a, _b, _c, _d }.SelectMany (word => Bytes (word)).ToArray ();
		} finally {
			Initialize ();
		}
	}

	private void ProcessMessage (IEnumerable<byte> bytes)
	{
		foreach (byte b in bytes) {
			int c = _bytesProcessed & 63;
			int i = c >> 2;
			int s = (c & 3) << 3;

			_x [i] = (_x [i] & ~((uint)255 << s)) | ((uint)b << s);

			if (c == 63) {
				Process16WordBlock ();
			}

			_bytesProcessed++;
		}
	}

	private static IEnumerable<byte> Bytes (byte[] bytes, int offset, int length)
	{
		for (int i = offset; i < length; i++) {
			yield return bytes [i];
		}
	}

	private IEnumerable<byte> Bytes (uint word)
	{
		yield return (byte)(word & 255);
		yield return (byte)((word >> 8) & 255);
		yield return (byte)((word >> 16) & 255);
		yield return (byte)((word >> 24) & 255);
	}

	private IEnumerable<byte> Repeat (byte value, int count)
	{
		for (int i = 0; i < count; i++) {
			yield return value;
		}
	}

	private IEnumerable<byte> Padding ()
	{
		return Repeat (128, 1)
			.Concat (Repeat (0, ((_bytesProcessed + 8) & 0x7fffffc0) + 55 - _bytesProcessed))
			.Concat (Bytes ((uint)_bytesProcessed << 3))
			.Concat (Repeat (0, 4));
	}

	private void Process16WordBlock ()
	{
		uint aa = _a;
		uint bb = _b;
		uint cc = _c;
		uint dd = _d;

		foreach (int k in new [] { 0, 4, 8, 12 }) {
			aa = Round1Operation (aa, bb, cc, dd, _x [k], 3);
			dd = Round1Operation (dd, aa, bb, cc, _x [k + 1], 7);
			cc = Round1Operation (cc, dd, aa, bb, _x [k + 2], 11);
			bb = Round1Operation (bb, cc, dd, aa, _x [k + 3], 19);
		}

		foreach (int k in new [] { 0, 1, 2, 3 }) {
			aa = Round2Operation (aa, bb, cc, dd, _x [k], 3);
			dd = Round2Operation (dd, aa, bb, cc, _x [k + 4], 5);
			cc = Round2Operation (cc, dd, aa, bb, _x [k + 8], 9);
			bb = Round2Operation (bb, cc, dd, aa, _x [k + 12], 13);
		}

		foreach (int k in new [] { 0, 2, 1, 3 }) {
			aa = Round3Operation (aa, bb, cc, dd, _x [k], 3);
			dd = Round3Operation (dd, aa, bb, cc, _x [k + 8], 9);
			cc = Round3Operation (cc, dd, aa, bb, _x [k + 4], 11);
			bb = Round3Operation (bb, cc, dd, aa, _x [k + 12], 15);
		}

		unchecked {
			_a += aa;
			_b += bb;
			_c += cc;
			_d += dd;
		}
	}

	private static uint ROL (uint value, int numberOfBits)
	{
		return (value << numberOfBits) | (value >> (32 - numberOfBits));
	}

	private static uint Round1Operation (uint a, uint b, uint c, uint d, uint xk, int s)
	{
		unchecked {
			return ROL (a + ((b & c) | (~b & d)) + xk, s);
		}
	}

	private static uint Round2Operation (uint a, uint b, uint c, uint d, uint xk, int s)
	{
		unchecked {
			return ROL (a + ((b & c) | (b & d) | (c & d)) + xk + 0x5a827999, s);
		}
	}

	private static uint Round3Operation (uint a, uint b, uint c, uint d, uint xk, int s)
	{
		unchecked {
			return ROL (a + (b ^ c ^ d) + xk + 0x6ed9eba1, s);
		}
	}
}

public static class FileIDUtil
{
	public static int Compute (Type t)
	{
		string toBeHashed = "s\0\0\0" + t.Namespace + t.Name;

		using (HashAlgorithm hash = new MD4 ()) {
			byte[] hashed = hash.ComputeHash (System.Text.Encoding.UTF8.GetBytes (toBeHashed));

			int result = 0;

			for (int i = 3; i >= 0; --i) {
				result <<= 8;
				result |= hashed [i];
			}

			return result;
		}
	}

	public static int Compute (string toBeHashed)
	{
		using (HashAlgorithm hash = new MD4 ()) {
			byte[] hashed = hash.ComputeHash (System.Text.Encoding.UTF8.GetBytes (toBeHashed));

			int result = 0;

			for (int i = 3; i >= 0; --i) {
				result <<= 8;
				result |= hashed [i];
			}

			return result;
		}
	}
}
#endregion