{"id":25102,"date":"2020-03-16T12:15:18","date_gmt":"2020-03-16T10:15:18","guid":{"rendered":"https:\/\/www.webcodegeeks.com\/?p=25102"},"modified":"2020-06-23T14:51:00","modified_gmt":"2020-06-23T11:51:00","slug":"how-to-obfuscate-code-in-python-a-thought-experiment","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/python\/how-to-obfuscate-code-in-python-a-thought-experiment\/","title":{"rendered":"How to Obfuscate Code in Python: A Thought Experiment"},"content":{"rendered":"\n

As with most articles in this series, I was doing some browsing on Google, and I found that some folks had an interest in learning how to obfuscate code in Python. Naturally, I thought that would be a fun topic. By no means am I an expert, but I\u2019m familiar with the idea. As a result, treat this like a fun thought experiment.<\/p>\n\n\n\n

Problem Description<\/h2>\n\n\n\n

Unlike most articles in this series, I\u2019m not looking for a quick answer to code obfuscation\u2014the process of making code unreadable. Instead, I want to look at various obfuscation methods. To do that, we\u2019ll need some piece of nicely formatted source code:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n
9<\/div>\n<\/td>\n
\n
\n
def read_solution(solution_path: str) -> list:<\/code><\/div>\n
    <\/code>\"\"<\/code>\"<\/code><\/div>\n
    <\/code>Reads the solution and returns it as a list of lines.<\/code><\/div>\n
    <\/code>:param solution_path: path to the solution<\/code><\/div>\n
    <\/code>:<\/code>return<\/code>: the solution as a list of lines<\/code><\/div>\n
    <\/code>\"\"<\/code>\"<\/code><\/div>\n
    <\/code>with open(solution_path, encoding=<\/code>\"utf8\"<\/code>) as solution:<\/code><\/div>\n
        <\/code>data = solution.readlines()<\/code><\/div>\n
    <\/code>return<\/code> data<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Cool! Here\u2019s a standalone function that I pulled from my auto-grader project<\/a>. It\u2019s not the best code in the world, but I figured it would serve as a nice example. After all, it\u2019s a short snippet that performs a simple function: reads a file and dumps the results as a list of lines.<\/p>\n\n\n\n

In this article, we\u2019ll take a look at a few ways of making this code snippet as unintelligible as possible. Keep in mind that I\u2019m not an expert at this. Rather, I thought this would be a fun exercise where we could all learn something.<\/p>\n\n\n\n

Solutions<\/h2>\n\n\n\n

In this section, we\u2019ll take a look at several ways to obfuscate code. In particular, we\u2019ll be taking the original solution and gradually manipulating it throughout this article. As a result, each solution will not be a standalone solution. Instead, it will be an addition to all previous solutions.<\/p>\n\n\n\n

Obfuscate Code by Removing Comments<\/h3>\n\n\n\n

One surefire way to make code hard to read is to begin by avoiding best practices. For instance, we could start by removing any comments and docstrings:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
def read_solution(solution_path: str) -> list:<\/code><\/div>\n
    <\/code>with open(solution_path, encoding=<\/code>\"utf8\"<\/code>) as solution:<\/code><\/div>\n
        <\/code>data = solution.readlines()<\/code><\/div>\n
    <\/code>return<\/code> data<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

In this case, the solution is self-documenting, so it\u2019s fairly easy to read. That said, the removal of the comment does make it slightly harder to see exactly what this method accomplishes.<\/p>\n\n\n\n

Obfuscate Code by Removing Type Hints<\/h3>\n\n\n\n

With the comments out of the way, we can begin removing other helpful pieces of syntax. For example, we have a few bits of syntax which help people track variable types throughout the code. In particular, we indicated that the input parameter solution_path<\/code> should be a string. Likewise, we also indicated that the function returns a list. Why not remove those type hints?<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
def read_solution(solution_path):<\/code><\/div>\n
    <\/code>with open(solution_path, encoding=<\/code>\"utf8\"<\/code>) as solution:<\/code><\/div>\n
        <\/code>data = solution.readlines()<\/code><\/div>\n
    <\/code>return<\/code> data<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Again, this function is still fairly manageable, so it wouldn\u2019t be too hard to figure out what it does. In fact, almost all Python code looked like this at one point, so I wouldn\u2019t say we\u2019ve reached any level of obfuscation yet.<\/p>\n\n\n\n

Obfuscate Code by Removing Whitespace<\/h3>\n\n\n\n

Another option for visual obfuscation is removing all extraneous whitespace. Unfortunately, in Python, whitespace has value. In fact, we use it to indicate scope. That said, there\u2019s still some work we can do:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
def read_solution(solution_path):<\/code><\/div>\n
    <\/code>with open(solution_path,encoding=<\/code>\"utf8\"<\/code>) as solution:<\/code><\/div>\n
        <\/code>data=solution.readlines()<\/code><\/div>\n
    <\/code>return<\/code> data<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Here, we were only able to remove three spaces: one between solution_path<\/code> and encoding<\/code>, one between data<\/code> and =<\/code>, and one between =<\/code> and solution.readlines()<\/code>. As a result, the code is still fairly readable. That said, as we begin to obfuscate our code a bit more, we\u2019ll see this solution pay dividends.<\/p>\n\n\n\n

Obfuscate Code by Abandoning Naming Conventions<\/h3>\n\n\n\n

One thing we have full control over in code is naming conventions. In other words, we decide what we name our functions and variables. As a result, it\u2019s possible to come up with names that completely obfuscate the intent of a variable or function:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
def x(a):<\/code><\/div>\n
    <\/code>with open(a,encoding=<\/code>\"utf8\"<\/code>) as z:<\/code><\/div>\n
        <\/code>p=z.readlines()<\/code><\/div>\n
    <\/code>return<\/code> p<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Here, we\u2019ve lost all semantic value that we typically get from variable and function names. As a result, it\u2019s even hard to figure out what this program does.<\/p>\n\n\n\n

Personally, I don\u2019t think this goes far enough. If we were particularly sinister, we\u2019d generate long sequences of text for each name, so it\u2019s even more difficult to understand:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(hjqk4WN0WwxM):<\/code><\/div>\n
    <\/code>with open(hjqk4WN0WwxM,encoding=<\/code>\"utf8\"<\/code>) as ltZH4QOxmGy8:<\/code><\/div>\n
        <\/code>QVsxkg07bMCs=ltZH4QOxmGy8.readlines()<\/code><\/div>\n
    <\/code>return<\/code> QVsxkg07bMCs<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Hell, I might even use a single random string of characters and only modify bits of it. For example, we could try using the function name repeatedly with slight alterations (e.g. 1 for l, O for 0, etc.):<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>with open(IdDG0v51X42t,encoding=<\/code>\"utf8\"<\/code>) as IdDGOv51X42t:<\/code><\/div>\n
        <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
    <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Of course, while this looks harder to read, nothing is really stopping the user from using an IDE to follow each reference. Likewise, compiling and decompiling this function (i.e. .py -> .pyc -> .py) would probably undo all our hard labor. As a result, we\u2019ll have to go deeper.<\/p>\n\n\n\n

Obfuscate Code by Manipulating Strings<\/h3>\n\n\n\n

Another way to make code unintelligible is to find hardcoded strings like \u201cutf8\u201d in our example and add an unnecessary layer of abstraction to them:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=chr(<\/code>117<\/code>)+chr(<\/code>116<\/code>)+chr(<\/code>102<\/code>)+chr(<\/code>56<\/code>)<\/code><\/div>\n
    <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
        <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
    <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Here, we\u2019ve constructed the string \u201cutf8\u201d from its ordinal values. In other words, \u2018u\u2019 corresponds to 117, \u2018t\u2019 corresponds to 116, \u2018f\u2019 corresponds to 102, and \u20188\u2019 corresponds to 56. This additional complexity is still pretty easy to map. As a result, it might be worthwhile to introduce even more complexity:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join([chr(<\/code>117<\/code>),chr(<\/code>116<\/code>),chr(<\/code>102<\/code>),chr(<\/code>56<\/code>)])<\/code><\/div>\n
    <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
        <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
    <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Instead of direct concatenation, we\u2019ve introduced the join method. Now, we have a list of characters as numbers. Let\u2019s reverse the list just to add a bit of entropy to the system:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>56<\/code>),chr(<\/code>102<\/code>),chr(<\/code>116<\/code>),chr(<\/code>117<\/code>)]))<\/code><\/div>\n
    <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
        <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
    <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

How about that? Now, we have even more code we can begin modifying.<\/p>\n\n\n\n

Obfuscate Code by Manipulating Numbers<\/h3>\n\n\n\n

With our \u201cutf8\u201d string represented as a reversed list of numbers, we can begin changing their numeric representation. For example, 56 is really 28 * 2 or 14 * 2 * 2 or 7 * 2 * 2 * 2. Likewise, Python supports various bases, so why not introduce hexadecimal, octal, and binary to the mix?<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101)]))<\/code><\/div>\n
    <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
        <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
    <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Suddenly, it\u2019s unclear what numbers we\u2019re even working with. To add a bit of chaos, I thought it would be fun to insert a whitespace character:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
        <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
    <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Then, we can call the strip method to remove that extra space.<\/p>\n\n\n\n

Obfuscate Code by Introducing Dead Code<\/h3>\n\n\n\n

In the previous example, we added a whitespace character to our string to make it slightly more difficult to decode. We can now take that idea and begin to add code that doesn\u2019t really do anything:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>return<\/code> list()<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Here, I\u2019ve introduce a dead branch. In other words, we\u2019re operating under the assumption that the input is a valid string<\/strong>. As a result, we can add a silly case where we check if the string has a length greater than -1\u2014which is always true. Then, on the dead branch, we return some generic value.<\/p>\n\n\n\n

At this point, what is stopping us from writing a completely ridiculous dead block? In other words, instead of returning a simple junk value, we could construct a complex junk value:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n
9<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>IdDG0v51X42t=IdDG0v51X42t[len(IdDG0v51X42t)\/<\/code>2<\/code>::<\/code>3<\/code>]*<\/code>6<\/code><\/div>\n
        <\/code>return<\/code> [I6DG0v51X42t <\/code>for<\/code> I6DG0v51X42t in IdDG0v51X42t]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Honestly, I could have put anything in the dead block. For fun, I decided to play with the input string. For instance, I constructed a substring and repeated it. Then, I constructed a list from the characters in that new string.<\/p>\n\n\n\n

Obfuscate Code by Adding Dead Parameters<\/h3>\n\n\n\n

If we can introduce dead branches, we can absolutely introduce dead parameters. However, we don\u2019t want to alter the behavior of the underlying function, so we\u2019ll want to introduce default parameters:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n
9<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t,LdDG0v51X42t=<\/code>0x173<\/code>):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>IdDG0v51X42t=IdDG0v51X42t[len(IdDG0v51X42t)\/<\/code>2<\/code>::<\/code>3<\/code>]*<\/code>6<\/code><\/div>\n
        <\/code>return<\/code> [I6DG0v51X42t <\/code>for<\/code> I6DG0v51X42t in IdDG0v51X42t]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Of course, this parameter is of no use currently. In other words, let\u2019s try doing something with it:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n
9<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t,LdDG0v51X42t=<\/code>0x173<\/code>):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> LdDG0v51X42t%<\/code>2<\/code>!=<\/code>0<\/code> or len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>IdDG0v51X42t=IdDG0v51X42t[len(IdDG0v51X42t)\/<\/code>2<\/code>::<\/code>3<\/code>]*<\/code>6<\/code><\/div>\n
        <\/code>return<\/code> [I6DG0v51X42t <\/code>for<\/code> I6DG0v51X42t in IdDG0v51X42t]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Now, there is something beautiful about the expression LdDG0v51X42t%2!=0<\/code>. To me, it looks like a password\u2014not a test for odd numbers.<\/p>\n\n\n\n

Of course, why stop there? Another cool thing we can do with parameters is take advantage of variable length arguments:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n
9<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t,LdDG0v51X42t=<\/code>0x173<\/code>,*LdDG0v51X42tf):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> LdDG0v51X42t%<\/code>2<\/code>!=<\/code>0<\/code> or len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>IdDG0v51X42t=IdDG0v51X42t[len(IdDG0v51X42t)\/<\/code>2<\/code>::<\/code>3<\/code>]*<\/code>6<\/code><\/div>\n
        <\/code>return<\/code> [I6DG0v51X42t <\/code>for<\/code> I6DG0v51X42t in IdDG0v51X42t]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Now, we\u2019ve opened the door to an unlimited number of arguments. Let\u2019s add some code to make this interesting:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t,LdDG0v51X42t=<\/code>0x173<\/code>,*LdDG0v51X42tf):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> LdDG0v51X42t%<\/code>2<\/code>!=<\/code>0<\/code> or len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>elif LdDG0v51X42tf:<\/code><\/div>\n
        <\/code>return<\/code> list()<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>IdDG0v51X42t=IdDG0v51X42t[len(IdDG0v51X42t)\/<\/code>2<\/code>::<\/code>3<\/code>]*<\/code>6<\/code><\/div>\n
        <\/code>return<\/code> [I6DG0v51X42t <\/code>for<\/code> I6DG0v51X42t in IdDG0v51X42t]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Again, we\u2019ll never hit this branch because the first condition is always true. Of course, the casual reader doesn\u2019t know that. At any rate, let\u2019s have some fun with it:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t,LdDG0v51X42t=<\/code>0x173<\/code>,*LdDG0v51X42tf):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> LdDG0v51X42t%<\/code>2<\/code>!=<\/code>0<\/code> or len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>elif LdDG0v51X42tf:<\/code><\/div>\n
        <\/code>while<\/code> LdDG0v51X42tf:<\/code><\/div>\n
            <\/code>LdDG0v51X42tx=LdDG0v51X42tf.pop()<\/code><\/div>\n
            <\/code>LdDG0v51X42tf.append(LdDG0v51X42tx)<\/code><\/div>\n
        <\/code>return<\/code> LdDG0v51X42tf<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>IdDG0v51X42t=IdDG0v51X42t[len(IdDG0v51X42t)\/<\/code>2<\/code>::<\/code>3<\/code>]*<\/code>6<\/code><\/div>\n
        <\/code>return<\/code> [I6DG0v51X42t <\/code>for<\/code> I6DG0v51X42t in IdDG0v51X42t]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Yep, that\u2019s an infinite loop! Unfortunately, it\u2019s sort of obvious. That said, I suspect that the variable names will obscure the intent for a little while.<\/p>\n\n\n\n

Other Ways to Obfuscate Code<\/h3>\n\n\n\n

Once again, I\u2019ll mention that this article was more of a thought experiment for me. I had seen obfuscated code in the past, and I thought it would be fun to give it a try myself. As a result, here\u2019s the original snippet and the final snippet for comparison:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n
6<\/div>\n
7<\/div>\n
8<\/div>\n
9<\/div>\n<\/td>\n
\n
\n
def read_solution(solution_path: str) -> list:<\/code><\/div>\n
    <\/code>\"\"<\/code>\"<\/code><\/div>\n
    <\/code>Reads the solution and returns it as a list of lines.<\/code><\/div>\n
    <\/code>:param solution_path: path to the solution<\/code><\/div>\n
    <\/code>:<\/code>return<\/code>: the solution as a list of lines<\/code><\/div>\n
    <\/code>\"\"<\/code>\"<\/code><\/div>\n
    <\/code>with open(solution_path, encoding=<\/code>\"utf8\"<\/code>) as solution:<\/code><\/div>\n
        <\/code>data = solution.readlines()<\/code><\/div>\n
    <\/code>return<\/code> data<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n
\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n<\/td>\n
\n
\n
def IdDG0v5lX42t(IdDG0v51X42t,LdDG0v51X42t=<\/code>0x173<\/code>,*LdDG0v51X42tf):<\/code><\/div>\n
    <\/code>I6DGOv51X4Rt=<\/code>\"\"<\/code>.join(reversed([chr(<\/code>2<\/code>*<\/code>2<\/code>*<\/code>7<\/code>*<\/code>2<\/code>),chr(<\/code>0x66<\/code>),chr(0o164),chr(0b1110101),chr(<\/code>0x20<\/code>)])).strip()<\/code><\/div>\n
    <\/code>if<\/code> LdDG0v51X42t%<\/code>2<\/code>!=<\/code>0<\/code> or len(IdDG0v51X42t*<\/code>3<\/code>)>-<\/code>1<\/code>:<\/code><\/div>\n
        <\/code>with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
            <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
        <\/code>return<\/code> IdDGOv51X4Rt<\/code><\/div>\n
    <\/code>elif LdDG0v51X42tf:<\/code><\/div>\n
        <\/code>while<\/code> LdDG0v51X42tf:<\/code><\/div>\n
            <\/code>LdDG0v51X42tx=LdDG0v51X42tf.pop()<\/code><\/div>\n
            <\/code>LdDG0v51X42tf.append(LdDG0v51X42tx)<\/code><\/div>\n
        <\/code>return<\/code> LdDG0v51X42tf<\/code><\/div>\n
    <\/code>else<\/code>:<\/code><\/div>\n
        <\/code>IdDG0v51X42t=IdDG0v51X42t[len(IdDG0v51X42t)\/<\/code>2<\/code>::<\/code>3<\/code>]*<\/code>6<\/code><\/div>\n
        <\/code>return<\/code> [I6DG0v51X42t <\/code>for<\/code> I6DG0v51X42t in IdDG0v51X42t]<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

At this point, I suppose we could continue to iterate, but I\u2019m not sure that would be the best use of my time. That said, there were a few things I considered trying. For instance, I thought about compressing lines of code such as:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n<\/td>\n
\n
\n
with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
    <\/code>IdDGOv51X4Rt=IdDGOv51X42t.readlines()<\/code><\/div>\n
return<\/code> IdDGOv51X4Rt<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Into something like:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n<\/td>\n
\n
\n
with open(IdDG0v51X42t,encoding=I6DGOv51X4Rt) as IdDGOv51X42t:<\/code><\/div>\n
    <\/code>return<\/code> IdDGOv51X42t.readlines()<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

However, part of me felt like this would actually make the code easier to read since we wouldn\u2019t have to map variable names.<\/p>\n\n\n\n

In addition, I thought about making some methods just to pollute the namespace a little bit. For example, we could create functions that overwrite some of the standard library. Then, give them totally different behavior. In our case, we might redefine reversed<\/code> to confuse the reader into thinking it has its typical behavior:<\/p>\n\n\n\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n<\/td>\n
\n
\n
def reversed(x):<\/code><\/div>\n
    <\/code>return<\/code> \"utf8\"<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n\n\n\n

Then, we could pass whatever we wanted into it as bait. Wouldn\u2019t that be sinister?<\/p>\n\n\n\n

Beyond that, I\u2019m aware that there are obfuscation tools out there, but I\u2019m not sure how widely used they are. Here are a few examples:<\/p>\n\n\n\n