private void ApplyInfo(ISDnlibDef context, ProtectionSettings settings, IEnumerable <ProtectionSettingsInfo> infos, ApplyInfoType type) { foreach (var info in infos) { if (info.Condition != null && !(bool)info.Condition.Evaluate(context)) { continue; } if (info.Condition == null && info.Exclude) { if (type == ApplyInfoType.CurrentInfoOnly || (type == ApplyInfoType.CurrentInfoInherits && info.ApplyToMember)) { settings.Clear(); } } if (!string.IsNullOrEmpty(info.Settings)) { if ((type == ApplyInfoType.ParentInfo && info.Condition != null && info.ApplyToMember) || type == ApplyInfoType.CurrentInfoOnly || (type == ApplyInfoType.CurrentInfoInherits && info.Condition == null && info.ApplyToMember)) { parser.ParseProtectionString(settings, info.Settings); } } } }
/// <summary> /// Fills the protection settings with the specified preset. /// </summary> /// <param name="preset">The preset.</param> /// <param name="settings">The settings.</param> private void FillPreset(ProtectionPreset preset, ProtectionSettings settings) { foreach (Protection prot in protections.Values) { if (prot.Preset != ProtectionPreset.None && prot.Preset <= preset && !settings.ContainsKey(prot)) { settings.Add(prot, new Dictionary <string, string>()); } } }
/// <summary> /// Initializes a new instance of the <see cref="ProtectionSettings" /> class /// from an existing <see cref="ProtectionSettings" />. /// </summary> /// <param name="settings">The settings to copy from.</param> public ProtectionSettings(ProtectionSettings settings) { if (settings == null) { return; } foreach (var i in settings) { Add(i.Key, new Dictionary <string, string>(i.Value)); } }
public IDisposable Apply(ISDnlibDef target, IEnumerable <ProtectionSettingsInfo> infos) { ProtectionSettings settings; if (this.settings == null) { settings = new ProtectionSettings(); } else { settings = new ProtectionSettings(this.settings); } var infoArray = infos.ToArray(); if (stack.Count > 0) { foreach (var i in stack.Reverse()) { ApplyInfo(target, settings, i.Item2, ApplyInfoType.ParentInfo); } } IDisposable result; if (infoArray.Length != 0) { var originalSettings = this.settings; // the settings that would apply to members ApplyInfo(target, settings, infoArray, ApplyInfoType.CurrentInfoInherits); this.settings = new ProtectionSettings(settings); // the settings that would apply to itself ApplyInfo(target, settings, infoArray, ApplyInfoType.CurrentInfoOnly); stack.Push(Tuple.Create(originalSettings, infoArray)); result = new PopHolder(this); } else { result = null; } ProtectionParameters.SetParameters(context, target, settings); return(result); }
/// <summary> /// Returns only the targets with the specified type and used by specified component. /// </summary> /// <param name="context">The working context.</param> /// <param name="targets">List of targets.</param> /// <param name="phase">The component phase.</param> /// <returns>Filtered targets.</returns> private static IList <ISDnlibDef> Filter(ConfuserContext context, IList <ISDnlibDef> targets, ProtectionPhase phase) { ProtectionTargets targetType = phase.Targets; IEnumerable <ISDnlibDef> filter = targets; if ((targetType & ProtectionTargets.Modules) == 0) { filter = filter.Where(def => !(def is ModuleDef)); } if ((targetType & ProtectionTargets.Types) == 0) { filter = filter.Where(def => !(def is TypeDef)); } if ((targetType & ProtectionTargets.Methods) == 0) { filter = filter.Where(def => !(def is MethodDef)); } if ((targetType & ProtectionTargets.Fields) == 0) { filter = filter.Where(def => !(def is FieldDef)); } if ((targetType & ProtectionTargets.Properties) == 0) { filter = filter.Where(def => !(def is PropertyDef)); } if ((targetType & ProtectionTargets.Events) == 0) { filter = filter.Where(def => !(def is EventDef)); } if (phase.ProcessAll) { return(filter.ToList()); } return(filter.Where(def => { ProtectionSettings parameters = ProtectionParameters.GetParameters(context, def); Debug.Assert(parameters != null); if (parameters == null) { context.Logger.ErrorFormat("'{0}' not marked for obfuscation, possibly a bug.", def); throw new ConfuserException(null); } return parameters.ContainsKey(phase.Parent); }).ToList()); }
private void Pop() { settings = stack.Pop().Item1; }
/// <summary> /// Applies the rules to the target definition. /// </summary> /// <param name="context">The working context.</param> /// <param name="target">The target definition.</param> /// <param name="rules">The rules.</param> /// <param name="baseSettings">The base settings.</param> protected void ApplyRules(ConfuserContext context, ISDnlibDef target, Rules rules, ProtectionSettings baseSettings = null) { var ret = baseSettings == null ? new ProtectionSettings() : new ProtectionSettings(baseSettings); foreach (var i in rules) { if (!(bool)i.Value.Evaluate(target)) { continue; } if (!i.Key.Inherit) { ret.Clear(); } FillPreset(i.Key.Preset, ret); foreach (var prot in i.Key) { if (prot.Action == SettingItemAction.Add) { ret[protections[prot.Id]] = new Dictionary <string, string>(prot, StringComparer.OrdinalIgnoreCase); } else { ret.Remove(protections[prot.Id]); } } } ProtectionParameters.SetParameters(context, target, ret); }
/// <summary> /// Sets the protection parameters of the specified target. /// </summary> /// <param name="context">The context.</param> /// <param name="target">The protection target.</param> /// <param name="parameters">The parameters.</param> public static void SetParameters( ConfuserContext context, ISDnlibDef target, ProtectionSettings parameters) { context.Annotations.Set(target, ParametersKey, parameters); }
public void ParsePackerString(string str, out Packer packer, out Dictionary <string, string> packerParams) { packer = null; packerParams = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); if (str == null) { return; } this.str = str; index = 0; var state = ParseState.ReadItemName; var buffer = new StringBuilder(); var ret = new ProtectionSettings(); while (state != ParseState.End) { switch (state) { case ParseState.ReadItemName: ReadId(buffer); var packerId = buffer.ToString(); if (!items.Contains(packerId)) { throw new KeyNotFoundException("Cannot find packer with id '" + packerId + "'."); } packer = (Packer)items[packerId]; buffer.Length = 0; if (IsEnd() || Peek() == ';') { state = ParseState.EndItem; } else if (Peek() == '(') { Next(); state = ParseState.ReadParam; } else { throw new ArgumentException("Unexpected character in ReadItemName state at " + index + "."); } break; case ParseState.ReadParam: string paramName, paramValue; if (!ReadId(buffer)) { throw new ArgumentException("Unexpected end of string in ReadParam state."); } paramName = buffer.ToString(); buffer.Length = 0; Expect('='); if (!ReadId(buffer)) { throw new ArgumentException("Unexpected end of string in ReadParam state."); } paramValue = buffer.ToString(); buffer.Length = 0; packerParams.Add(paramName, paramValue); if (Peek() == ',') { Next(); state = ParseState.ReadParam; } else if (Peek() == ')') { Next(); state = ParseState.EndItem; } else { throw new ArgumentException("Unexpected character in ReadParam state at " + index + "."); } break; case ParseState.EndItem: if (IsEnd()) { state = ParseState.End; } else { Expect(';'); if (!IsEnd()) { throw new ArgumentException("Unexpected character in EndItem state at " + index + "."); } state = ParseState.End; } break; } } }