private void Init()
{
this.data = null;
this.rva = null;
this.idxm = null;
this.pe1 = null;
this.pe2 = null;
this.pe3 = null;
this.pe4 = null;
this.imptbl = null;
this.sects = null;
this.cli = null;
this.mdroot = null;
}
/// <summary>
/// Creates a new immutable instance of this class.
/// </summary>
/// <param name="filePath">A file path the points to a PE file.</param>
public PortableExecutable(string filePath)
{
_data = File.ReadAllBytes(filePath);
using (var br = new BlobReader(_data, 0, _data.Length))
{
br.Read(ref _dosHeader);
br.Seek((int)_dosHeader.e_lfanew);
br.Read(ref _signature);
br.Read(ref _fileHeader);
if (_fileHeader.OptionalHeaderSize > 0)
{
br.Read(ref _imageType);
switch (_imageType)
{
case ImageType.PE32:
br.Read(ref _optionalHeader32);
br.Read(ref _dataDirectories, (int)_optionalHeader32.DataDirectoryCount);
break;
case ImageType.PE64:
br.Read(ref _optionalHeader64);
br.Read(ref _dataDirectories, (int)_optionalHeader64.DataDirectoryCount);
break;
default:
throw new ArgumentException("UnknownImageType");
}
}
br.Read(ref _sectionHeaders, _fileHeader.SectionCount);
if (_dataDirectories[(int)DataDirectoryType.CliHeader].RVA > 0)
{
var cliHeaderOffset = FindDataDirectoryOffset(DataDirectoryType.CliHeader);
br.Seek(cliHeaderOffset);
br.Read(ref _cliHeader);
var metaDataRootOffset = FindRvaOffset(_cliHeader.MetadataRVA);
_metadataRoot = new MetadataRoot(new Slice(_data, metaDataRootOffset, (int)_cliHeader.MetadataSize));
}
var resourceHeader = _dataDirectories[(int)DataDirectoryType.Resource];
if (resourceHeader.RVA > 0)
{
var offset = FindDataDirectoryOffset(DataDirectoryType.Resource);
br.Seek(offset);
_resourceDirectory = new ResourceDirectory(br.ReadSlice((int)resourceHeader.Size), this);
}
}
}
protected void CommitSourcingFromChange(SourcingFrom record)
{
var subjectRoots = record.Subject.ResolveRoots();
var fromRoot = record.From.ResolveRoot();
MetadataRoot subjectOriginalRoot = null;
foreach (var root in subjectRoots)
{
if (subjectOriginalRoot == null)
{
subjectOriginalRoot = root;
}
else
{
if (subjectOriginalRoot.OriginalPath.Levels.Count > root.OriginalPath.Levels.Count)
{
subjectOriginalRoot = root;
}
}
}
List <NodeRelation> relations = new List <NodeRelation>();
foreach (var r in subjectRoots)
{
var sourcePath = fromRoot.CurrentPath.Concat(r.OriginalPath.RelativeTo(subjectOriginalRoot.OriginalPath).WithLanguage(fromRoot.CurrentPath.Language));
var fromNode = this.metadataIndexed.AllocateNode(sourcePath);
var subjectNode = this.metadataIndexed.AllocateNode(r.CurrentPath);
relations.Add(new NodeRelation(RelationKind.SourcingFrom, subjectNode, fromNode));
relations.AddRange(this.RefineSourcingFromRelations(fromNode, subjectNode, record.Subject));
}
var nodeRecord = new NodeRecord(record.BatchIndex, record.StageName, record.PluginId, record.PluginMetadata, record.Tags, null, relations.ToArray());
foreach (var relation in relations)
{
relation.Node1.AddRecord(nodeRecord);
relation.Node2.AddRelation(relation);
}
}
public void FindChildMetadata_NoChildAdded_ReturnNull()
{
var metadataRoot = new MetadataRoot("Default", 1);
Assert.IsNull(metadataRoot.FindChildMetadata("Child.Resource1"));
}
public void HasChild_NoChildAdded_ReturnFalse()
{
var metadataRoot = new MetadataRoot("Default", 1);
Assert.IsFalse(metadataRoot.HasChild("Child.Resource1"));
}
public void Constructor_WithCorrectParameters_CreatedMetadataNode()
{
var metadataRoot = new MetadataRoot("Default", 1);
}
public CodeReader(ReflectionReader reflectReader)
{
m_reflectReader = reflectReader;
m_root = m_reflectReader.MetadataRoot;
m_instructions = new Hashtable();
}
public void AddChild_WithNullResourceName_ThrowException()
{
var metadataRoot = new MetadataRoot("Default", 1);
metadataRoot.AddChild(null);
}
public void ResourceName_Get_Succeed()
{
var metadataRoot = new MetadataRoot("Default", 1);
Assert.AreEqual("Default", metadataRoot.ResourceName);
}
public void UpdateStartUp()
{
string script = ReqBuilder.GetRequestScript(RequestType.Startup, "");
string ret = (string)StaticData.jsExecutor.ExecuteAsyncScript(script);
string[] responses = ret.Split(new[] { "##@##" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string res in responses)
{
var methode = res.Substring(0, res.IndexOf("{"));
var body = res.Substring(res.IndexOf("{"));
dynamic ress = null;
switch (methode)
{
case "getSittingPlayersCount":
ListClass.OwnTavern = JsonConvert.DeserializeObject <OwnTavernStates>(body);
break;
case "getOtherTavernStates":
FriendsTavernRoot rootTavern = JsonConvert.DeserializeObject <FriendsTavernRoot>(body);
ListClass.FriendTaverns = rootTavern.responseData.ToList();
break;
case "getOverview":
HiddenRewardRoot rootHiddenReward = JsonConvert.DeserializeObject <HiddenRewardRoot>(body);
foreach (HiddenReward item in rootHiddenReward.responseData.hiddenRewards)
{
DateTime endTime = Helper.UnixTimeStampToDateTime(item.expireTime);
DateTime startTime = Helper.UnixTimeStampToDateTime(item.startTime);
bool vis = (endTime > DateTime.Now) && (startTime < DateTime.Now);
item.isVisible = vis;
}
ListClass.HiddenRewards = rootHiddenReward.responseData.hiddenRewards.ToList();
break;
case "getResourceDefinitions":
ress = JsonConvert.DeserializeObject(body);
ListClass.ResourceDefinitions = ress;
UpdatedSortedGoodList();
break;
case "getPlayerResources":
ress = JsonConvert.DeserializeObject(body);
ListClass.Resources = ress;
UpdatedSortedGoodList();
break;
case "getMetadata":
MetadataRoot rootMetadata = JsonConvert.DeserializeObject <MetadataRoot>(body);
ListClass.MetaDataList = rootMetadata.responseData.ToList();
if (StaticData.jsExecutor == null)
{
break;
}
if (ListClass.AllBuildings.Count <= 0)
{
string url = ListClass.MetaDataList.Find((m) => { return(m.identifier == "city_entities"); }).url;
script = ReqBuilder.GetMetaDataRequestScript(url, MetaRequestType.city_entities);
string cityMeta = (string)StaticData.jsExecutor.ExecuteAsyncScript(script);
BuildingsRoot rootBuilding = JsonConvert.DeserializeObject <BuildingsRoot>("{\"buildings\":" + cityMeta + "}");
ListClass.AllBuildings = rootBuilding.buildings.ToList();
if (ListClass.Startup.Count > 0)
{
UpdateBuildings(ListClass.Startup["responseData"]["city_map"]["entities"]);
}
}
if (ListClass.Eras.Count <= 0)
{
string url = ListClass.MetaDataList.Find((m) => { return(m.identifier == "research_eras"); }).url;
script = ReqBuilder.GetMetaDataRequestScript(url, MetaRequestType.research_eras);
string researchMeta = (string)StaticData.jsExecutor.ExecuteAsyncScript(script);
ResearchEraRoot rootResearch = JsonConvert.DeserializeObject <ResearchEraRoot>("{\"reserach\":" + researchMeta + "}");
ListClass.Eras = rootResearch.reserach.ToList();
UpdatedSortedGoodList();
}
break;
case "getUpdates":
QuestServiceRoot rootQuest = JsonConvert.DeserializeObject <QuestServiceRoot>(body);
ListClass.QuestList = rootQuest.responseData.ToList();
break;
case "getData":
ress = JsonConvert.DeserializeObject(body);
ListClass.Startup = ress;
ListClass.UserData = ress["responseData"]["user_data"];
UpdateBuildings(ListClass.Startup["responseData"]["city_map"]["entities"]);
break;
case "getLimitedBonuses":
BonusServiceRoot rootBonusService = JsonConvert.DeserializeObject <BonusServiceRoot>(body);
ListClass.Bonus = rootBonusService.responseData.ToList();
ListClass.ArcBonus = ListClass.Bonus.Sum(e => { if (e.type == "contribution_boost")
{
return(e.value);
}
else
{
return(0);
} });
break;
default:
break;
}
}
}
public virtual void TerminateMetadataRoot(MetadataRoot root)
{
}
public virtual void VisitMetadataRoot(MetadataRoot root)
{
}
public SecurityDeclarationReader(MetadataRoot root, ReflectionReader reader)
{
sr = new SignatureReader(root, reader);
}
protected override void LoadInternal(VirtualReader rdr)
{
s = rdr.ReadUInt32();
maVer = rdr.ReadUInt16();
miVer = rdr.ReadUInt16();
dats = new CLRDatas(this);
dats.IsLoading = true;
Rva mdAdr = rdr.ReadRva();
uint mdSze = rdr.ReadUInt32();
f = (RuntimeFlags)rdr.ReadUInt32();
if ((f & RuntimeFlags.NativeEntryPoint) == RuntimeFlags.NativeEntryPoint)
{
Rva ep = rdr.ReadRva();
rdr.SaveLocation();
rdr.SetPosition(ep);
byte[] ec = NativeHelper.GetNativeCodes(rdr);
rdr.LoadLocation();
e = ep;
dats.Add(new CLRData()
{
Address = ep, Data = ec
});
}
else
{
t = rdr.ReadUInt32();
}
Rva resAdr = rdr.ReadRva();
uint resSze = rdr.ReadUInt32();
Rva snAdr = rdr.ReadRva();
uint snSze = rdr.ReadUInt32();
Rva cmAdr = rdr.ReadRva();
uint cmSze = rdr.ReadUInt32();
Rva vtAdr = rdr.ReadRva();
uint vtSze = rdr.ReadUInt32();
Rva eatAdr = rdr.ReadRva();
uint eatSze = rdr.ReadUInt32();
Rva mnAdr = rdr.ReadRva();
uint mnSze = rdr.ReadUInt32();
rdr.SetPosition(resAdr);
res = rdr.ReadBytes((int)resSze);
rdr.SetPosition(snAdr);
sn = rdr.ReadBytes((int)snSze);
rdr.SetPosition(cmAdr);
cm = rdr.ReadBytes((int)cmSze);
rdr.SetPosition(eatAdr);
eat = rdr.ReadBytes((int)eatSze);
rdr.SetPosition(mnAdr);
mn = rdr.ReadBytes((int)mnSze);
vt = new VTableFixups(this);
vt.Load(rdr, vtAdr, vtSze);
md = new MetadataRoot(this);
md.Load(rdr, mdAdr);
dats.IsLoading = false;
// Save the read info
MetadataDirEntry = new CLRDataDirectoryEntry("MetaData", mdAdr, mdSze);
ResourceDirEntry = new CLRDataDirectoryEntry("Resources", resAdr, resSze);
StrongNameDirEntry = new CLRDataDirectoryEntry("Strong Name Signature", snAdr, snSze);
CodeManagerTableDirEntry = new CLRDataDirectoryEntry("Code Manager Table", cmAdr, cmSze);
VTableFixupsDirEntry = new CLRDataDirectoryEntry("VTable Fixups", vtAdr, vtSze);
ExportAddressTableJumpsDirEntry = new CLRDataDirectoryEntry("Export Address Table Jumps", eatAdr, eatSze);
ManagedNativeHeaderDirEntry = new CLRDataDirectoryEntry("Managed Native Header", mnAdr, mnSze);
}
private void ReadCLIHeader()
{
int addr_cli = RVAManager.GetAddress(this.pe4.CLIHeader);
if (addr_cli == 0) return;
cli = new CLIHeader();
this.cli.ReadData(this.data, this.rva.ConvertToPhysical(addr_cli));
int offset = this.rva.ConvertToPhysical(RVAManager.GetAddress(this.cli.MetaData));
this.mdroot = new MetadataRoot();
this.mdroot.ReadData(this.data, offset);
offset += this.mdroot.Length + 18;
int nStreams = Util.GetInt16(this.data, offset);
offset += 2;
this.idxm = new IndexManager(this.data, this.rva);
for (int i = 0; i < nStreams; i++)
{
StreamHeader sh = new StreamHeader();
sh.mdroot = mdroot;
sh.ReadData(this.data, offset);
offset += sh.GetStreamSize();
this.SetStreamHeader(sh);
}
this.ReadTilde();
}
public void Constructor_WithNullResourceName_ThrowException()
{
var metadataRoot = new MetadataRoot(null, 1);
}
public void Constructor_WithWhiteSpaceResourceName_ThrowException()
{
var metadataRoot = new MetadataRoot(" ", 1);
}
void ReadRvaData(MetadataTable tbl, MetadataReader mdRdr, List <Rva> rvas, MetadataRowCollection rows)
{
List <Rva> sorted = new List <Rva>(rvas);
sorted.Sort();
for (int i = 0; i < rvas.Count; i++)
{
Rva rva = rvas[i];
MetadataRow r = rows[i + 1];
byte[] dat = null;
VirtualReader rdr = new VirtualReader(mdRdr.BaseStream.File.SectionHeaders.GetVirtualStream());
if (tbl.Type == TableType.FieldRVA)
{
MetadataRoot root = tbl.Heap.Stream.Root;
rdr.SetPosition(rva);
MetadataRow fd = (r["Field"] as TableToken).ResolveRow();
FieldSig sig = new FieldSig();
SignatureReader sigRdr = new SignatureReader(new MetadataReader(root[MetadataStreamType.Blob]));
sigRdr.BaseStream.Position = (fd["Signature"] as BlobToken).Token.Index;
sig.Read(sigRdr);
int c = 0;
switch (sig.Type.Element)
{
case ElementType.Boolean:
case ElementType.UInt8:
case ElementType.Int8:
c = 1; break;
case ElementType.UInt16:
case ElementType.Int16:
case ElementType.Char:
c = 2; break;
case ElementType.UInt32:
case ElementType.Int32:
case ElementType.Single:
c = 4; break;
case ElementType.UInt64:
case ElementType.Int64:
case ElementType.Double:
c = 8; break;
case ElementType.ValueType:
TableToken vt = (sig.Type as VALUETYPE).Type;
foreach (MetadataRow cl in tbl.Heap[TableType.ClassLayout])
{
if (cl["Parent"] == vt)
{
c = (int)cl["ClassSize"];
break;
}
}
break;
default:
throw new InvalidOperationException("ReadRvaData");
}
dat = rdr.ReadBytes(c);
}
else if (tbl.Type == TableType.MethodDef && rva != 0)
{
//MethodBody bdy;
//if (((MethodImplAttributes)r["ImplFlags"] & MethodImplAttributes.Native) == MethodImplAttributes.Native)
//{
// bdy = new NativeMethodBody(r);
//}
//else
//{
// bdy = new ManagedMethodBody(r);
//}
//rdr.SetPosition(rva);
//bdy.Load(rdr);
//rdr.SetPosition(rva);
//dat = rdr.ReadBytes((int)bdy.Size);
int idx;
Rva next;
if ((idx = sorted.IndexOf(rva)) == sorted.Count - 1)
{
CLRDirectory root = tbl.Heap.Stream.Root.Directory;
Rva now;
next = uint.MaxValue;
rdr.SetPosition(root.Location.Address);
rdr.BaseStream.Seek(0x8, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0xC, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
rdr.BaseStream.Seek(0x4, System.IO.SeekOrigin.Current);
if ((now = rdr.ReadRva()) < next && now != 0 && now > rva)
{
next = now;
}
}
else
{
next = sorted[idx + 1];
}
rdr.SetPosition(rva);
dat = rdr.ReadBytes((int)(next - rva));
}
if (!tbl.Heap.Stream.Root.Directory.Datas.ContainsAddress(rva) && dat != null)
{
tbl.Heap.Stream.Root.Directory.Datas.Add(new CLRData()
{
Address = rva, Data = dat
});
}
}
}
public void MetadataLayerId_Get_Succeed()
{
var metadataRoot = new MetadataRoot("Default", 1);
Assert.AreEqual(1, metadataRoot.MetadataLayerId);
}
public virtual void TerminateMetadataRoot(MetadataRoot root)
{
}
public void AddChild_WithWhiteSpacesResourceName_ThrowException()
{
var metadataRoot = new MetadataRoot("Default", 1);
metadataRoot.AddChild(" ");
}
public virtual void VisitMetadataRoot(MetadataRoot root)
{
}
public CodeReader(ReflectionReader reflectReader)
{
m_reflectReader = reflectReader;
m_root = m_reflectReader.MetadataRoot;
}
public virtual void VisitMetadataRootHeader(MetadataRoot.MetadataRootHeader header)
{
}
