/// <summary> /// Given a sequence, add dummy characters based on the strategy and seed data passed. /// </summary> /// <param name="sequence"> /// The base sequence without dummy characters. /// </param> /// <param name="strategy"> /// The strategy to be used. /// </param> /// <param name="seed"> /// The seed value to be used. /// </param> /// <returns> /// Character sequence with dummy characters merged into it, based on the strategy used. /// </returns> public static string AddDummyCharacters(string sequence, ObfuscationStrategy strategy, int seed) { if (string.IsNullOrEmpty(sequence)) { return(sequence); } var sb = new StringBuilder(); sb.Append(sequence); int dummyCharacterIndex = 0, insertionIndex = 0; while (sb.Length < Settings.MinimumLength) { if (strategy == ObfuscationStrategy.Constant) { // Compute insertionIndex in a constant way (using hash). // While allowing the possibility of first and last index. // Note that insertionIndex can exceed sb.Length by 1 (i.e. insert after last character). int hash = Math.Abs(sb.ToString().GetStableHashCode()); // int hash = Math.Abs(sb.ToString().GetHashCode()); insertionIndex = (hash ^ seed) % sb.Length; if ((hash % seed % 3) > (sb.Length / 2)) { insertionIndex++; } // Compute 'randomized' dummy character index constantly (using hash). // Note that insertionIndex cannot exceed dummyCharacterSet.Length. dummyCharacterIndex = (hash ^ seed) % Settings.DummyCharacterSet.Length; } else { // Randomize insertion index. // Note that Min-Max boundary has inclusive min, exclusive max insertionIndex = random.Next(0, sb.Length + 1); // insertion can be at last character (i.e. sb.Length) dummyCharacterIndex = random.Next(0, Settings.DummyCharacterSet.Length); } sb.Insert(insertionIndex, Settings.DummyCharacterSet[dummyCharacterIndex]); } return(sb.ToString()); }
public void EnsureCorrectConversion(ObfuscationStrategy strategy) { var obfuscator = ObfuscatorFactory.NewInstance; obfuscator.Strategy = strategy; for (int i = 0; i < 100000; i++) { string obfuscatedValue = obfuscator.Obfuscate(i); int deobfuscatedValue = obfuscator.Deobfuscate(obfuscatedValue); if (deobfuscatedValue != i) { // Assert fails. Assert.True(false); } } }
public void EnsureNoCollision(ObfuscationStrategy strategy) { var obfuscator = ObfuscatorFactory.NewInstance; obfuscator.Strategy = strategy; var hashSet = new HashSet <string>(); for (int i = 0; i < 1000000; i++) { string obfuscatedValue = obfuscator.Obfuscate(i); // HashSet.Add will return false if element already exists. if (!hashSet.Add(obfuscatedValue)) { // Assert fails. Assert.True(false); } } }
public void TestAddDummyCharacters(ObfuscationStrategy strategy) { var validCharacters = Settings.ValidCharacterSet; var dummyCharacters = Settings.DummyCharacterSet; // Generate valid input by taking first 3 characters of validCharacters. string validInput = new string(validCharacters.Dictionary.Select(x => x.Value).Take(3).ToArray()); /* Perform operation under test with constant strategy, */ var obfuscator = ObfuscatorFactory.NewInstance; int seed = obfuscator.Seed; var testResult = ObfuscatorHelper.AddDummyCharacters(validInput, strategy, seed); // Remove all valid characters from result. var dummyResult = testResult.ToCharArray().ToList(); dummyResult.RemoveAll(x => validCharacters.ContainsValue(x)); // Ensure result only contains dummy characters. Assert.True(dummyResult.All(x => dummyCharacters.Contains(x))); }