Sentinel LDK Demo Test

Sentinel LDK Demo Test

Hi everyone,

I've been testing Sentinel Envelope using the free demo provided on the website for the last couple of days and I have a couple of questions.

1. Using the following code:

1. static void Main(string[] args)
2.         {
3.             bool inputLoop = true;
4.  
5.             while (inputLoop)
6.             {
7.                 Console.Write(">");
8.                 string[] input = Console.ReadLine()?.Split(' ');
9.  
10.                 if (input != null)
11.                 {
12.                     switch (input[0].ToLower())
13.                     {
14.                         case "add":
15.                             Console.WriteLine(Calculator.Add(int.Parse(input[1]), int.Parse(input[2])));
16.                             break;
17.                         case "sub":
18.                             Console.WriteLine(Calculator.Subtract(int.Parse(input[1]), int.Parse(input[2])));
19.                             break;
20.                         case "mult":
21.                             Console.WriteLine(Calculator.Multiple(int.Parse(input[1]), int.Parse(input[2])));
22.                             break;
23.                         case "exit":
24.                             inputLoop = false;
25.                             break;
26.                         default:
27.                             Console.WriteLine("Invalid action.");
28.                             break;
29.                     }
30.                 }
31.             }
32.         }

I tried to check the string encryption option inside the Envelope tool, looking at the result using dotPeek I saw the following code:

1. private static void Main(string[] args)
2.     {
3.       \u003445698164.\u003405710557((object) null, MethodBase.GetCurrentMethod(), true);
4.       try
5.       {
6.         bool flag = true;
7.         while (flag)
8.         {
9.           Console.Write(">");
10.           string str = Console.ReadLine();
11.           string[] strArray1;
12.           if (str == null)
13.           {
14.             strArray1 = (string[]) null;
15.           }
16.           else
17.           {
18.             char[] chArray = new char[1]{ ' ' };
19.             strArray1 = str.Split(chArray);
20.           }
21.           string[] strArray2 = strArray1;
22.           if (strArray2 != null)
23.           {
24.             string lower = strArray2[0].ToLower();
25.             if (!(lower == "add"))
26.             {
27.               if (!(lower == "sub"))
28.               {
29.                 if (!(lower == "mult"))
30.                 {
31.                   if (lower == "exit")
32.                     flag = false;
33.                   else
34.                     Console.WriteLine(\u003445698180.\u003445698215.\u003405710642("懶᧭棴\x1C39엶蘍뿫摪䤠㟺熋\xEAEE貖괮駏뜱"));
35.                 }
36.                 else
37.                   Console.WriteLine(Calculator.Multiple(int.Parse(strArray2[1]), int.Parse(strArray2[2])));
38.               }
39.               else
40.                 Console.WriteLine(Calculator.Subtract(int.Parse(strArray2[1]), int.Parse(strArray2[2])));
41.             }
42.             else
43.               Console.WriteLine(Calculator.Add(int.Parse(strArray2[1]), int.Parse(strArray2[2])));
44.           }
45.         }
46.       }
47.       finally
48.       {
49.         \u003445698164.\u003405710557((object) null, MethodBase.GetCurrentMethod(), false);
50.       }
51.     }

As you can probably see, the string inside the Console.WriteLine is encrypted, but the strings inside the switch-case remained the same. 

Is it not supported or is it just a bug? Did I put wrong configuration somehow? 

2. On another class I wrote the following code:

1.     public class Calculator
2.     {
3.         [EnvelopeMethodProtectionAttributes(Protect = true, CodeObfuscation = true, Encrypt = true, MinCodeSizeForProtection = 1)]
4.         public static int Add(int num1, int num2)
5.         {
6.             return num1 + num2;
7.         }
8.  
9.         [EnvelopeMethodProtectionAttributes(Protect = true, CodeObfuscation = false, Encrypt = true, MinCodeSizeForProtection = 1)]
10.         public static int Multiple(int num1, int num2)
11.         {
12.             return num1 * num2;
13.         }
14.  
15.         [EnvelopeMethodProtectionAttributes(Protect = true, CodeObfuscation = true, Encrypt = false, MinCodeSizeForProtection = 1)]
16.         public static int Subtract(int num1, int num2)
17.         {
18.             return num1 - num2;
19.         }
20.     }

(Please note the CodeObfuscation and Encrypt attributes).

Again, using dotPeek I expected to see somehow at least 2 different outcome from those 3 methods.

The code did change but it seems that all of it look kind of the same. For example:

1. public static int Subtract(int num1, int num2)
2.     {
3.       try
4.       {
5.         DynamicMethod dynamicMethod = \u003445698164.\u003405710557((object) null, MethodBase.GetCurrentMethod(), true);
6.         object obj;
7.         if (dynamicMethod == null)
8.         {
9.           obj = (object) null;
10.         }
11.         else
12.         {
13.           object[] parameters = new object[2]
14.           {
15.             (object) num1,
16.             (object) num2
17.           };
18.           obj = dynamicMethod.Invoke((object) null, parameters);
19.         }
20.         \u003445698164.\u003405710557((object) null, MethodBase.GetCurrentMethod(), false);
21.         return (int) obj;
22.       }
23.       catch (Exception ex)
24.       {
25.         Exception innerException = ex.InnerException;
26.         // ISSUE: variable of the null type
27.         __Null local = null;
28.         if (innerException != local)
29.           throw innerException;
30.         throw;
31.       }
32.     }

Any way to know if the code is encrypted, obfuscated or both?