// this method creates a new class for the given namespace
public NamespaceTypeDefinition createNewClass(String className, IUnitNamespace containingUnitNamespace, bool isPublic,
bool isStatic)
{
// create a new class object
NamespaceTypeDefinition newClass = new NamespaceTypeDefinition();
newClass.ContainingUnitNamespace = containingUnitNamespace;
newClass.InternFactory = this.host.InternFactory;
newClass.IsClass = true;
newClass.IsForeignObject = false;
newClass.IsInterface = false;
newClass.IsPublic = isPublic;
newClass.IsStatic = isStatic;
newClass.Methods = new List <IMethodDefinition>();
newClass.Name = this.host.NameTable.GetNameFor(className);
// create list of base classes (only base class is System.Object)
newClass.BaseClasses = new List <ITypeReference>();
newClass.BaseClasses.Add(this.host.PlatformType.SystemObject);
// add new class to module assembly
Assembly tempAssembly = (Assembly)this.module;
tempAssembly.AllTypes.Add(newClass);
return(newClass);
}
internal static string ModuleQualifiedUnitNamespace(IUnit currentUnit, IUnitNamespace unitNamespace, out bool wasRoot)
{
INestedUnitNamespace nestedUnitNamespace = unitNamespace as INestedUnitNamespace;
if (nestedUnitNamespace != null)
{
StringBuilder sb = new StringBuilder(Helper.ModuleQualifiedUnitNamespace(currentUnit, (IUnitNamespace)nestedUnitNamespace.ContainingNamespace, out wasRoot));
if (!wasRoot)
{
sb.Append(".");
}
sb.Append(nestedUnitNamespace.Name.Value);
wasRoot = false;
return(sb.ToString());
}
else
{
wasRoot = true;
if (!unitNamespace.Unit.Equals(currentUnit))
{
return(Helper.Unit(unitNamespace.Unit));
}
}
return(string.Empty);
}
private INamedTypeDefinition GenerateTypeA(IUnitNamespace rootNamespace)
{
var nt = Host.NameTable;
var typeA = new NamespaceTypeDefinition
{
ContainingUnitNamespace = rootNamespace,
Name = nt.GetNameFor("A"),
InternFactory = Host.InternFactory,
IsClass = true
};
var typeParameter = new GenericTypeParameter
{
Name = nt.GetNameFor("T"),
InternFactory = Host.InternFactory,
DefiningType = typeA,
};
typeA.GenericParameters.Add(typeParameter);
var baseGetMethod = new MethodDefinition
{
Name = nt.GetNameFor("Get"),
IsCil = true,
IsVirtual = true,
Visibility = TypeMemberVisibility.Assembly,
Type = typeParameter,
ContainingTypeDefinition = typeA,
InternFactory = Host.InternFactory,
IsNewSlot = true
};
typeA.Methods.Add(baseGetMethod);
var il = new ILGenerator(Host);
var localVar = new LocalDefinition
{
Type = typeParameter,
Name = nt.GetNameFor("local1"),
};
// tricky moment, ILGeneratorMethodBody fills internal collection of local vars only in constructor.
// lines below should not be swapped
il.AddVariableToCurrentScope(localVar);
var body = new ILGeneratorMethodBody(il, true, 1)
{
MethodDefinition = baseGetMethod
};
baseGetMethod.Body = body;
il.Emit(OperationCode.Ldloca, localVar);
il.Emit(OperationCode.Initobj, typeParameter);
il.Emit(OperationCode.Ldloc_0);
il.Emit(OperationCode.Ret);
return(typeA);
}
public override void Visit(IUnitNamespace unitNamespace)
{
if (Process(unitNamespace))
{
visitor.Visit(unitNamespace);
}
base.Visit(unitNamespace);
}
internal static IGlobalMethodDefinition GetGlobalMethod(IUnitNamespace unitNamespace, IName methodName)
{
foreach (INamespaceMember nm in unitNamespace.GetMembersNamed(methodName, false))
{
if (nm is IGlobalMethodDefinition)
{
return(nm as IGlobalMethodDefinition);
}
}
return(null);
}
internal static INamespaceTypeDefinition GetNamespaceType(IUnitNamespace unitNamespace, IName typeName)
{
foreach (INamespaceMember nm in unitNamespace.GetMembersNamed(typeName, false))
{
if (nm is INamespaceTypeDefinition)
{
return(nm as INamespaceTypeDefinition);
}
}
return(null);
}
// this method creates an new interface for the given namespace
public NamespaceTypeDefinition createNewInterface(String className, IUnitNamespace containingUnitNamespace)
{
// create a new class object and modify it to be an interface
NamespaceTypeDefinition newInterface = this.createNewClass(className, containingUnitNamespace, false, false);
newInterface.IsAbstract = true;
newInterface.IsInterface = true;
newInterface.BaseClasses = null;
return(newInterface);
}
private static IUnitNamespace GetUnitNamespace(INamespaceDefinition containingNamespace)
{
INestedUnitNamespace nestedUnitNamespace = containingNamespace as INestedUnitNamespace;
if (nestedUnitNamespace != null)
{
containingNamespace = nestedUnitNamespace.ContainingUnitNamespace;
}
IUnitNamespace unitNamespace = containingNamespace as IUnitNamespace;
return(unitNamespace);
}
private INamedTypeDefinition GenerateTypeA(IUnitNamespace rootNamespace)
{
var nt = Host.NameTable;
var typeA = new NamespaceTypeDefinition
{
ContainingUnitNamespace = rootNamespace,
Name = nt.GetNameFor("A"),
InternFactory = Host.InternFactory,
IsClass = true
};
var typeParameter = new GenericTypeParameter
{
Name = nt.GetNameFor("T"),
InternFactory = Host.InternFactory,
DefiningType = typeA,
};
typeA.GenericParameters.Add(typeParameter);
var baseGetMethod = new MethodDefinition
{
Name = nt.GetNameFor("Get"),
IsCil = true,
IsVirtual = true,
Visibility = TypeMemberVisibility.Assembly,
Type = typeParameter,
ContainingTypeDefinition = typeA,
InternFactory = Host.InternFactory,
IsNewSlot = true
};
typeA.Methods.Add(baseGetMethod);
var il = new ILGenerator(Host);
var localVar = new LocalDefinition
{
Type = typeParameter,
Name = nt.GetNameFor("local1"),
};
// tricky moment, ILGeneratorMethodBody fills internal collection of local vars only in constructor.
// lines below should not be swapped
il.AddVariableToCurrentScope(localVar);
var body = new ILGeneratorMethodBody(il, true, 1) {MethodDefinition = baseGetMethod};
baseGetMethod.Body = body;
il.Emit(OperationCode.Ldloca, localVar);
il.Emit(OperationCode.Initobj, typeParameter);
il.Emit(OperationCode.Ldloc_0);
il.Emit(OperationCode.Ret);
return typeA;
}
internal static IUnitNamespace GetNamespace(IUnit unit, params IName[] nameList)
{
IUnitNamespace unitNamespace = unit.UnitNamespaceRoot;
for (int i = 0; i < nameList.Length; ++i)
{
foreach (INamespaceMember nsm in unitNamespace.GetMembersNamed(nameList[i], false))
{
unitNamespace = nsm as IUnitNamespace;
if (unitNamespace == null)
{
break;
}
}
}
return(unitNamespace);
}
private void MergeNamespaces(UnitNamespace result, IUnitNamespace namespaceToMerge)
{
Contract.Requires(result != null);
Contract.Requires(namespaceToMerge != null);
foreach (var member in namespaceToMerge.Members)
{
var nestedNs = member as NestedUnitNamespace;
if (nestedNs != null)
{
UnitNamespace nestedResult = null;
foreach (var rmember in result.Members)
{
Contract.Assume(rmember != null);
if (rmember.Name != nestedNs.Name)
{
continue;
}
nestedResult = rmember as UnitNamespace;
if (nestedResult != null)
{
break;
}
}
if (nestedResult == null)
{
nestedResult = new NestedUnitNamespace()
{
ContainingUnitNamespace = result, Name = nestedNs.Name
}
}
;
this.MergeNamespaces(nestedResult, nestedNs);
continue;
}
result.Members.Add(member);
}
}
// Walk up the path of defining namespaces and units until we get to the assembly
public static IAssembly GetDefiningAssembly(IAliasForType aliasForType)
{
INamespaceAliasForType namespaceAliasForType = GetAliasForType(aliasForType);
if (namespaceAliasForType == null)
{
return(null);
}
INamespaceDefinition containingNamespace = namespaceAliasForType.ContainingNamespace;
IUnitNamespace unitNamespace = GetUnitNamespace(containingNamespace);
if (unitNamespace == null)
{
return(null);
}
IUnit unit = unitNamespace.Unit;
IAssembly assembly = GetAssembly(unit);
return(assembly);
}
private NamespaceTypeDefinition GenerateTypeB(IUnitNamespace rootNamespace, ITypeReference baseType)
{
var nt = Host.NameTable;
var typeB = new NamespaceTypeDefinition
{
ContainingUnitNamespace = rootNamespace,
Name = nt.GetNameFor("B"),
InternFactory = Host.InternFactory,
IsClass = true,
BaseClasses = { baseType }
};
var overrideGetMethod = new MethodDefinition
{
Name = nt.GetNameFor("Get"),
IsCil = true,
IsVirtual = true,
Visibility = TypeMemberVisibility.Assembly,
Type = Host.PlatformType.SystemString,
ContainingTypeDefinition = typeB,
InternFactory = Host.InternFactory
};
typeB.Methods.Add(overrideGetMethod);
var il = new ILGenerator(Host);
var body = new ILGeneratorMethodBody(il, true, 1)
{
MethodDefinition = overrideGetMethod
};
overrideGetMethod.Body = body;
il.Emit(OperationCode.Ldstr, "1");
il.Emit(OperationCode.Ret);
return(typeB);
}
public GraphTransformer(IModule module, PeReader.DefaultHost host, Log.Log logger, Random prng, IUnitNamespace targetNamespace, NamespaceTypeDefinition targetClass, int depth, int dimension, bool debugging = false) {
this.host = host;
this.logger = logger;
this.module = module;
this.prng = prng;
this.helperClass = new Helper(module, host, logger);
this.cfgBuilder = new Cfg.CfgBuilder(module, host, logger);
this.targetClass = targetClass;
this.graphDepth = depth;
this.graphDimension = dimension;
this.debugging = debugging;
this.debuggingNumber = 0;
// create iNode interface
this.createNodeInterface(targetNamespace);
// add created iNode interface to the given target class
this.addNodeInterfaceToTargetClass(this.targetClass);
}
public override void Visit(IUnitNamespace unitNamespace)
{
allElements.Add(new InvokInfo(Traverser, "IUnitNamespace", unitNamespace));
}
/// <summary>
/// Traverses the specified unit namespace definition.
/// </summary>
public virtual void TraverseChildren(IUnitNamespace namespaceDefinition)
{
Contract.Requires(namespaceDefinition != null);
this.TraverseChildren((INamespaceDefinition)namespaceDefinition);
}
public FilteredNamespace(IUnitNamespace ns, IFilterAssembly filter)
{
_ns = ns;
_filter = filter;
}
internal static string ModuleQualifiedUnitNamespace(IUnit currentUnit, IUnitNamespace unitNamespace, out bool wasRoot) {
INestedUnitNamespace nestedUnitNamespace = unitNamespace as INestedUnitNamespace;
if (nestedUnitNamespace != null) {
StringBuilder sb = new StringBuilder(Helper.ModuleQualifiedUnitNamespace(currentUnit, (IUnitNamespace)nestedUnitNamespace.ContainingNamespace, out wasRoot));
if (!wasRoot) {
sb.Append(".");
}
sb.Append(nestedUnitNamespace.Name.Value);
wasRoot = false;
return sb.ToString();
} else {
wasRoot = true;
if (!unitNamespace.Unit.Equals(currentUnit))
return Helper.Unit(unitNamespace.Unit);
}
return string.Empty;
}
/// <summary>
///
/// </summary>
/// <param name="containingUnitNamespace"></param>
/// <param name="name"></param>
/// <param name="unit"></param>
public NestedUnitNamespace(IUnitNamespace containingUnitNamespace, IName name, IUnit unit)
: base(name, unit)
//^ requires containingUnitNamespace is RootUnitNamespace || containingUnitNamespace is NestedUnitNamespace;
{
this.containingUnitNamespace = containingUnitNamespace;
}
public override void TraverseChildren(IUnitNamespace namespaceDefinition)
{ MethodEnter(namespaceDefinition);
base.TraverseChildren(namespaceDefinition);
MethodExit(); }
public FilteredNamespace(IUnitNamespace ns, IFilterAssembly filter)
{
_ns = ns;
_filter = filter;
}
public override void Visit(IUnitNamespace unitNamespace)
{
if(Process(unitNamespace)){visitor.Visit(unitNamespace);}
base.Visit(unitNamespace);
}
/// <summary>
/// Visits the specified unit namespace.
/// </summary>
public virtual void Visit(IUnitNamespace unitNamespace) {
Contract.Requires(unitNamespace != null);
this.Visit((INamespaceDefinition)unitNamespace);
}
/// <summary>
/// Visits the specified unit namespace.
/// </summary>
public virtual void Visit(IUnitNamespace unitNamespace)
{
Contract.Requires(unitNamespace != null);
}
private NamespaceTypeDefinition GenerateTypeB(IUnitNamespace rootNamespace, ITypeReference baseType)
{
var nt = Host.NameTable;
var typeB = new NamespaceTypeDefinition
{
ContainingUnitNamespace = rootNamespace,
Name = nt.GetNameFor("B"),
InternFactory = Host.InternFactory,
IsClass = true,
BaseClasses = { baseType }
};
var overrideGetMethod = new MethodDefinition
{
Name = nt.GetNameFor("Get"),
IsCil = true,
IsVirtual = true,
Visibility = TypeMemberVisibility.Assembly,
Type = Host.PlatformType.SystemString,
ContainingTypeDefinition = typeB,
InternFactory = Host.InternFactory
};
typeB.Methods.Add(overrideGetMethod);
var il = new ILGenerator(Host);
var body = new ILGeneratorMethodBody(il, true, 1) {MethodDefinition = overrideGetMethod};
overrideGetMethod.Body = body;
il.Emit(OperationCode.Ldstr, "1");
il.Emit(OperationCode.Ret);
return typeB;
}
/// <summary>
/// Rewrites the specified unit namespace.
/// </summary>
public virtual IUnitNamespace Rewrite(IUnitNamespace unitNamespace)
{
return unitNamespace;
}
void QualifiedUnitNamespace(IUnitNamespace unitNamespace, out bool wasRoot) {
INestedUnitNamespace nestedUnitNamespace = unitNamespace as INestedUnitNamespace;
if (nestedUnitNamespace != null) {
this.QualifiedUnitNamespace((IUnitNamespace)nestedUnitNamespace.ContainingNamespace, out wasRoot);
if (!wasRoot) {
this.ILDasmPaper.Symbol(".");
}
this.ILDasmPaper.Identifier(nestedUnitNamespace.Name.Value);
wasRoot = false;
return;
}
wasRoot = true;
return;
}
void SimpleUnitNamespace(IUnitNamespace unitNamespace, out bool wasRoot) {
INestedUnitNamespace nestedUnitNamespace = unitNamespace as INestedUnitNamespace;
if (nestedUnitNamespace != null) {
this.ILDasmPaper.Identifier(nestedUnitNamespace.Name.Value);
wasRoot = false;
return;
}
wasRoot = true;
return;
}
/// <summary>
/// Traverses the specified unit namespace definition.
/// </summary>
public virtual void TraverseChildren(IUnitNamespace namespaceDefinition)
{
this.TraverseChildren((INamespaceDefinition)namespaceDefinition);
}
/// <summary>
/// Returns a unit namespace definition, nested in the given unitNamespace if possible,
/// otherwise nested in the given unit if possible, otherwise nested in the given host if possible, otherwise it returns Dummy.UnitNamespace.
/// If unitNamespaceReference is a root namespace, the result is equal to the given unitNamespace if not null,
/// otherwise the result is the root namespace of the given unit if not null,
/// otherwise the result is root namespace of unitNamespaceReference.Unit, if that can be resolved via the given host,
/// otherwise the result is Dummy.UnitNamespace.
/// </summary>
public static IUnitNamespace Resolve(IUnitNamespaceReference unitNamespaceReference, IMetadataHost host, IUnit unit = null, IUnitNamespace unitNamespace = null)
{
Contract.Requires(unitNamespaceReference != null);
Contract.Requires(host != null);
Contract.Requires(unit != null || unitNamespace == null);
Contract.Ensures(Contract.Result <IUnitNamespace>() != null);
var rootNsRef = unitNamespaceReference as IRootUnitNamespaceReference;
if (rootNsRef != null)
{
if (unitNamespace != null)
{
return(unitNamespace);
}
if (unit != null)
{
return(unit.UnitNamespaceRoot);
}
unit = UnitHelper.Resolve(unitNamespaceReference.Unit, host);
if (unit is Dummy)
{
return(Dummy.UnitNamespace);
}
return(unit.UnitNamespaceRoot);
}
var nestedNsRef = unitNamespaceReference as INestedUnitNamespaceReference;
if (nestedNsRef == null)
{
return(Dummy.UnitNamespace);
}
var containingNsDef = UnitHelper.Resolve(nestedNsRef.ContainingUnitNamespace, host, unit, unitNamespace);
if (containingNsDef is Dummy)
{
return(Dummy.UnitNamespace);
}
foreach (var nsMem in containingNsDef.GetMembersNamed(nestedNsRef.Name, ignoreCase: false))
{
var neNsDef = nsMem as INestedUnitNamespace;
if (neNsDef != null)
{
return(neNsDef);
}
}
return(Dummy.UnitNamespace);
}
// this method creates a new class for the given namespace
public NamespaceTypeDefinition createNewClass(String className, IUnitNamespace containingUnitNamespace, bool isPublic,
bool isStatic)
{
// create a new class object
NamespaceTypeDefinition newClass = new NamespaceTypeDefinition();
newClass.ContainingUnitNamespace = containingUnitNamespace;
newClass.InternFactory = this.host.InternFactory;
newClass.IsClass = true;
newClass.IsForeignObject = false;
newClass.IsInterface = false;
newClass.IsPublic = isPublic;
newClass.IsStatic = isStatic;
newClass.Methods = new List<IMethodDefinition>();
newClass.Name = this.host.NameTable.GetNameFor(className);
// create list of base classes (only base class is System.Object)
newClass.BaseClasses = new List<ITypeReference>();
newClass.BaseClasses.Add(this.host.PlatformType.SystemObject);
// add new class to module assembly
Assembly tempAssembly = (Assembly)this.module;
tempAssembly.AllTypes.Add(newClass);
return newClass;
}
internal static INamespaceTypeDefinition GetNamespaceType(IUnitNamespace unitNamespace, IName typeName) {
foreach (INamespaceMember nm in unitNamespace.GetMembersNamed(typeName, false)) {
if (nm is INamespaceTypeDefinition)
return nm as INamespaceTypeDefinition;
}
return null;
}
// this method creates an new interface for the given namespace
public NamespaceTypeDefinition createNewInterface(String className, IUnitNamespace containingUnitNamespace)
{
// create a new class object and modify it to be an interface
NamespaceTypeDefinition newInterface = this.createNewClass(className, containingUnitNamespace, false, false);
newInterface.IsAbstract = true;
newInterface.IsInterface = true;
newInterface.BaseClasses = null;
return newInterface;
}
internal static IGlobalFieldDefinition GetGlobalField(IUnitNamespace unitNamespace, IName fieldName) {
foreach (INamespaceMember nm in unitNamespace.GetMembersNamed(fieldName, false)) {
if (nm is IGlobalFieldDefinition)
return nm as IGlobalFieldDefinition;
}
return null;
}
private void createNodeInterface(IUnitNamespace targetNamespace) {
this.nodeInterface = this.helperClass.createNewInterface("iNode", targetNamespace); // TODO: interface name
// create getter and setter for the startPointer variable
this.interfaceStartPointerGet = this.helperClass.createNewMethod("startPointer_get", this.nodeInterface, this.nodeInterface, TypeMemberVisibility.Public, null, CallingConvention.HasThis, false, true, true); // TODO: method name
List<IParameterDefinition> parameters = new List<IParameterDefinition>();
ParameterDefinition parameter = new ParameterDefinition();
parameter.IsIn = false;
parameter.IsOptional = false;
parameter.IsOut = false;
parameter.Name = host.NameTable.GetNameFor("value");
parameter.Type = this.nodeInterface;
parameters.Add(parameter);
this.interfaceStartPointerSet = this.helperClass.createNewMethod("startPointer_set", this.nodeInterface, host.PlatformType.SystemVoid, TypeMemberVisibility.Public, parameters, CallingConvention.HasThis, false, true, true); // TODO: method name
// create getter and setter for the childNodes array variable
parameters = new List<IParameterDefinition>();
// int parameter
parameter = new ParameterDefinition();
parameter.IsIn = false;
parameter.IsOptional = false;
parameter.IsOut = false;
parameter.Type = this.host.PlatformType.SystemInt32;
parameters.Add(parameter);
this.interfaceChildNodesGet = this.helperClass.createNewMethod("childNodes_get", this.nodeInterface, this.nodeInterface, TypeMemberVisibility.Public, parameters, CallingConvention.HasThis, false, true, true); // TODO: method name
parameters = new List<IParameterDefinition>();
// iNode parameter
parameter = new ParameterDefinition();
parameter.IsIn = false;
parameter.IsOptional = false;
parameter.IsOut = false;
parameter.Type = this.nodeInterface;
parameters.Add(parameter);
// int parameter
parameter = new ParameterDefinition();
parameter.IsIn = false;
parameter.IsOptional = false;
parameter.IsOut = false;
parameter.Type = this.host.PlatformType.SystemInt32;
parameters.Add(parameter);
this.interfaceChildNodesSet = this.helperClass.createNewMethod("childNodes_set", this.nodeInterface, host.PlatformType.SystemVoid, TypeMemberVisibility.Public, parameters, CallingConvention.HasThis, false, true, true); // TODO: method name
// when debugging is activated
// => create getter for the id variable that distinct identifies the object
if (this.debugging) {
this.logger.writeLine("Debugging activated: Adding getter for unique object id to node interface");
this.debuggingInterfaceIdGet = this.helperClass.createNewMethod("DEBUG_objectId_get", this.nodeInterface, this.host.PlatformType.SystemString, TypeMemberVisibility.Public, null, CallingConvention.HasThis, false, true, true); // TODO: method name
}
}
/// <summary>
/// Traverses the specified unit namespace definition.
/// </summary>
public void Traverse(IUnitNamespace namespaceDefinition)
{
Contract.Requires(namespaceDefinition != null);
namespaceDefinition.Dispatch(this.dispatchingVisitor);
}
/// <summary>
/// Visits the specified unit namespace.
/// </summary>
public virtual void Visit(IUnitNamespace unitNamespace)
{
Contract.Requires(unitNamespace != null);
}
/// <summary>
/// Visits the specified unit namespace.
/// </summary>
public void Visit(IUnitNamespace unitNamespace)
{
this.Visit((INamespaceDefinition)unitNamespace);
}
static void Main(string[] args)
{
String inputFile;
String targetFile;
String targetNamespace;
String targetClass;
String targetMethod;
int depth;
int dimension;
int numberValidPaths;
int duplicateBasicBlockWeight;
int duplicateBasicBlockCorrectionValue;
int stateChangeWeight;
int stateChangeCorrectionValue;
int insertOpaquePredicateWeight;
int seed;
// Add debugging code into the obfuscated method (dump obfuscation graphs and so on)
bool graphTransformerDebug = false;
// Should the obfuscated code contain information to trace the control flow?
bool basicBlockTrace = false;
// When debugging is active, should the whole obfuscation graph be dumped or only the vpaths in it?
bool graphOnlyDumpVPaths = true;
// The number of random interfaces that are added to the program
int numberRandomInterfaces = 100;
if (args.Length != 14)
{
System.Console.WriteLine("Needed parameters: <inputBinary> <outputBinary> <namespace> <class> <method> <depth> <dimension> <numberValidPaths> <duplicateBasicBlockWeight> <duplicateBasicBlockCorrectionValue> <stateChangeWeight> <stateChangeCorrectionValue> <insertOpaquePredicateWeight> <seed>");
return;
}
else
{
inputFile = args[0];
targetFile = args[1];
targetNamespace = args[2];
targetClass = args[3];
targetMethod = args[4];
depth = Convert.ToInt32(args[5]);
dimension = Convert.ToInt32(args[6]);
numberValidPaths = Convert.ToInt32(args[7]);
duplicateBasicBlockWeight = Convert.ToInt32(args[8]);
duplicateBasicBlockCorrectionValue = Convert.ToInt32(args[9]);
stateChangeWeight = Convert.ToInt32(args[10]);
stateChangeCorrectionValue = Convert.ToInt32(args[11]);
insertOpaquePredicateWeight = Convert.ToInt32(args[12]);
seed = Convert.ToInt32(args[13]);
}
String logDir = Path.GetDirectoryName(targetFile);
Log.Log logger = new Log.Log(logDir, "probfuscation_logfile.txt");
System.Console.WriteLine("Obfuscating: " + inputFile);
logger.writeLine("Obfuscating: " + inputFile);
System.Console.WriteLine("Output file: " + targetFile);
logger.writeLine("Output file: " + targetFile);
System.Console.WriteLine("Target namespace: " + targetNamespace);
logger.writeLine("Target namespace: " + targetNamespace);
System.Console.WriteLine("Target class: " + targetClass);
logger.writeLine("Target class: " + targetClass);
System.Console.WriteLine("Target method: " + targetMethod);
logger.writeLine("Target method: " + targetMethod);
System.Console.WriteLine("Depth: " + depth);
logger.writeLine("Depth: " + depth);
System.Console.WriteLine("Dimension: " + dimension);
logger.writeLine("Dimension: " + dimension);
System.Console.WriteLine("Number of vpaths: " + numberValidPaths);
logger.writeLine("Number of vpaths: " + numberValidPaths);
System.Console.WriteLine("Basic Block duplication weight: " + duplicateBasicBlockWeight);
logger.writeLine("Basic Block duplication weight: " + duplicateBasicBlockWeight);
System.Console.WriteLine("Basic Block duplication correction value: " + duplicateBasicBlockCorrectionValue);
logger.writeLine("Basic Block duplication correction value: " + duplicateBasicBlockCorrectionValue);
System.Console.WriteLine("State change weight: " + stateChangeWeight);
logger.writeLine("State change weight: " + stateChangeWeight);
System.Console.WriteLine("State change correction value: " + stateChangeCorrectionValue);
logger.writeLine("State change correction value: " + stateChangeCorrectionValue);
System.Console.WriteLine("Opaque predicate weight: " + insertOpaquePredicateWeight);
logger.writeLine("Opaque predicate weight: " + insertOpaquePredicateWeight);
System.Console.WriteLine("Seed: " + seed);
logger.writeLine("Seed: " + seed);
// Seed PRNG for interfaces
PRNGRandomInterfaces = new Random(seed);
using (var host = new PeReader.DefaultHost()) {
IModule /*?*/ module = host.LoadUnitFrom(inputFile) as IModule;
if (module == null || module == Dummy.Module || module == Dummy.Assembly)
{
Console.WriteLine(inputFile + " is not a PE file containing a CLR module or assembly.");
return;
}
module = new MetadataDeepCopier(host).Copy(module);
if (module as Assembly == null)
{
logger.writeLine("File does not have CIL assembly");
return;
}
// create analyzer object object
CfgBuilder analyze = new Cfg.CfgBuilder(module, host, logger);
PdbReader /*?*/ pdbReader = null;
string pdbFile = Path.ChangeExtension(module.Location, "pdb");
if (File.Exists(pdbFile))
{
using (var pdbStream = File.OpenRead(pdbFile)) {
pdbReader = new PdbReader(pdbStream, host);
}
}
else
{
logger.writeLine("Could not load the PDB file for '" + module.Name.Value + "' . Proceeding anyway.");
}
using (pdbReader) {
Microsoft.Cci.ILGenerator.LocalScopeProvider localScopeProvider = null;
if (pdbReader != null)
{
localScopeProvider = new ILGenerator.LocalScopeProvider(pdbReader);
}
// search the namespace the interface should be added to
IUnitNamespace foundNamespace = null;
foreach (var tempMember in module.UnitNamespaceRoot.Members)
{
if ((tempMember as IUnitNamespace) == null)
{
continue;
}
IUnitNamespace tempNamespace = (tempMember as IUnitNamespace);
if (tempNamespace.ToString() == targetNamespace)
{
foundNamespace = tempNamespace;
break;
}
}
if (foundNamespace == null)
{
throw new ArgumentException("Not able to find target namespace.");
}
// add created interface (and implemented methods) to all classes
bool classFound = false;
foreach (var tempClass in module.GetAllTypes())
{
if ((tempClass as NamespaceTypeDefinition) == null ||
tempClass.IsAbstract)
{
continue;
}
NamespaceTypeDefinition foundClass = (tempClass as NamespaceTypeDefinition);
if (foundClass.ContainingUnitNamespace.ToString() == "")
{
continue;
}
if (foundClass.ToString() != targetNamespace + "." + targetClass)
{
continue;
}
classFound = true;
Random prng = new Random();
GraphTransformer graphTransformer = new GraphTransformer(module, host, logger, prng, foundNamespace, foundClass, depth, dimension, graphTransformerDebug);
graphTransformer.duplicateBasicBlockWeight = duplicateBasicBlockWeight;
graphTransformer.duplicateBasicBlockCorrectionValue = duplicateBasicBlockCorrectionValue;
graphTransformer.stateChangeWeight = stateChangeWeight;
graphTransformer.stateChangeCorrectionValue = stateChangeCorrectionValue;
graphTransformer.insertOpaquePredicateWeight = insertOpaquePredicateWeight;
graphTransformer.trace = basicBlockTrace;
graphTransformer.graphOnlyDumpVPaths = graphOnlyDumpVPaths;
graphTransformer.debuggingDumpLocation = logDir;
// Add 100 random interfaces to the namespace
Helper testHelper = new Helper(module, host, logger);
List <NamespaceTypeDefinition> randomInterfaces = new List <NamespaceTypeDefinition>();
for (int i = 0; i < numberRandomInterfaces; i++)
{
String randName = randomString(20);
NamespaceTypeDefinition temp = testHelper.createNewInterface(randName, foundNamespace);
randomInterfaces.Add(temp);
}
InterfaceTransformer interfaceTransformer = new InterfaceTransformer(module, host, logger);
foreach (var classToAdd in module.GetAllTypes())
{
if ((classToAdd as NamespaceTypeDefinition) == null ||
classToAdd.IsAbstract ||
classToAdd.IsInterface ||
classToAdd.IsEnum ||
classToAdd.IsDelegate ||
classToAdd.IsGeneric ||
classToAdd.IsStruct)
{
continue;
}
if (((NamespaceTypeDefinition)classToAdd).ContainingUnitNamespace.ToString() == "")
{
continue;
}
/*
* // Use this code if you want to add standard interfaces to the target class
* interfaceTransformer.addStdInterfacesGivenByFile(@"e:\code\dotnet_standard_interfaces.txt");
*
* // add std interfaces to class
* if (foundClass != (classToAdd as NamespaceTypeDefinition)) {
* foreach (ITypeDefinition temp in interfaceTransformer.getInterfacesList()) {
* interfaceTransformer.addInterface((classToAdd as NamespaceTypeDefinition), temp);
* }
* }
*/
// Add random interfaces to the classes
List <NamespaceTypeDefinition> alreadyAdded = new List <NamespaceTypeDefinition>();
int max = PRNGRandomInterfaces.Next(numberRandomInterfaces);
NamespaceTypeDefinition interfaceClass = (classToAdd as NamespaceTypeDefinition);
logger.writeLine("Adding " + max + " random interfaces to class \"" + interfaceClass.ToString() + "\"");
for (int i = 0; i < max; i++)
{
NamespaceTypeDefinition randInterface = randomInterfaces.ElementAt(PRNGRandomInterfaces.Next(randomInterfaces.Count));
if (alreadyAdded.Contains(randInterface))
{
continue;
}
alreadyAdded.Add(randInterface);
logger.writeLine("Adding interface: \"" + randInterface.ToString() + "\"");
// add nodes interface to class
if (interfaceClass.Interfaces != null)
{
interfaceClass.Interfaces.Add(randInterface);
}
else
{
interfaceClass.Interfaces = new List <ITypeReference>();
interfaceClass.Interfaces.Add(randInterface);
}
}
logger.writeLine("");
// Add special interface for the obfuscation scheme to the class
// (makes sure that all needed attributes and methods are implemented)
graphTransformer.addNodeInterfaceToTargetClass((classToAdd as NamespaceTypeDefinition));
}
// Prepare obfuscation graph
graphTransformer.generateGraph(numberValidPaths);
graphTransformer.createGraphMethods();
// Search method to obfuscate
MethodDefinition methodToObfu = null;
foreach (MethodDefinition tempMethod in foundClass.Methods)
{
if (tempMethod.Name.ToString() == targetMethod)
{
methodToObfu = tempMethod;
break;
}
}
if (methodToObfu == null)
{
throw new ArgumentException("Not able to find target method.");
}
// Obfuscate target method
MethodCfg cfg = analyze.buildCfgForMethod(methodToObfu);
logger.dumpMethodCfg(cfg, "before");
graphTransformer.addObfuscationToMethod(cfg);
analyze.createMethodFromCfg(cfg);
logger.dumpMethodCfg(cfg, "after");
break;
}
if (!classFound)
{
throw new ArgumentException("Not able to find target class.");
}
/*
* This code can be used if not only one specific method should be obfuscated,
* but the whole class.
* List<ClassCfg> classCfgList = new List<ClassCfg>();
* foreach (var tempClass in module.GetAllTypes()) {
* if ((tempClass as NamespaceTypeDefinition) == null
|| tempClass.IsAbstract) {
|| continue;
|| }
||
|| // create basic blocks
|| NamespaceTypeDefinition foundClass = (tempClass as NamespaceTypeDefinition);
||
|| logger.writeLine("Create CFG for class \"" + foundClass.Name.ToString() + "\"");
|| ClassCfg temp = analyze.buildCfgForClass(foundClass);
|| classCfgList.Add(temp);
|| logger.writeLine("\n---------------------------------\n");
||}
||
||// transform each function
||NopTransformer transformator = new NopTransformer(module, host, logger);
||foreach (ClassCfg tempClassCfg in classCfgList) {
|| foreach (MethodCfg tempMethodCfg in tempClassCfg.methodCfgs) {
|| logger.writeLine("Transform method CFG of \"" + tempMethodCfg.method.ToString() + "\"");
|| transformator.addNopsToCfg(tempMethodCfg);
|| logger.writeLine("\n---------------------------------\n");
|| }
||}
||
||foreach (ClassCfg tempClassCfg in classCfgList) {
|| logger.writeLine("Create class from CFG for \"" + tempClassCfg.classObj.Name.ToString() + "\"");
|| analyze.createClassFromCfg(tempClassCfg);
|| logger.writeLine("\n---------------------------------\n");
||}
*/
using (var peStream = File.Create(targetFile)) {
using (var pdbWriter = new PdbWriter(Path.ChangeExtension(targetFile, ".pdb"), pdbReader)) {
PeWriter.WritePeToStream(module, host, peStream, pdbReader, localScopeProvider, pdbWriter);
}
}
}
}
}
public override void TraverseChildren(IUnitNamespace namespaceDefinition)
{
MethodEnter(namespaceDefinition);
base.TraverseChildren(namespaceDefinition);
MethodExit();
}
/// <summary>
/// Traverses the specified unit namespace definition.
/// </summary>
public void Traverse(IUnitNamespace namespaceDefinition)
{
namespaceDefinition.Dispatch(this.dispatchingVisitor);
}
