How to Hide/ Encrypt/ Obfuscate any Python Program

Balakrishna V

2 min read

Hello everyone. Wondering what this blog post is all about? It is about obfuscating any python program. Now you all must be thinking what does this term “Obfuscate” must mean right!

Obfuscate/ Obfuscation is a process in software development where the developer intentionally/ purposefully makes the source code of the software not easily understandable to humans or in other words not understandable to the layman.

This is done mostly to protect any intellectual property or trade secrets making it difficult to understand and prevent the code from being attacked by external factors.

Here in this blog, I will be explaining how we proceed with this process for any program written in Python. We might sometimes face a situation where we need to provide code directly to a client for obvious reasons, but by doing so, we will lose control of the code. In such cases, we might encrypt the codes to protect them, retain control and add some fallback conditions to control our dependency, just like if we provided code for use only for a certain amount of time.

To address the above issues, I will be demonstrating a simple function with the above capabilities. For the purpose of obfuscation, we will be using a python package called PyArmor.

Table of Contents:

  1. Creating a simple function
  2. Using PyArmor to encrypt it
  3. Importing our function / Inference

1. Creating a simple function

For our implementation, I will be using with inference function definition and will be encrypting it later.

import os, json, sys
from datetime import datetime
def inference(name="", tag = True):
if the current year is 2021, then inference function will run successfully, otherwise fails.
Here the attribute variable holds the string version of the date in MM-DD-YYYY format
print("Hello {}, the inference function has been successfully started".format(name))
attribute = str('%m-%d-%Y'))
response = "You license has been expired, please contact us."
year_to_expire = int(2022)
assert int(attribute.split('-')[-1]) == year_to_expire, response
except AssertionError as e:
# Replace your main code to operate here.
# if the above assertion is True, it will reach until this point, otherwise it will stop in the previous line.
if tag:
print("inference function has been completed successfully")
return True
return False
if __name__ == "__main__":
_ = inference(name="Bala")
Function outputs,
Case 1: if year_to_expire = int(2021)
Hello Bala, the inference function has been successfully started
inference function has been completed successfully
[Finished in 0.2s]
Case 2: if year_to_expire = int(2022)
Hello Bala, the inference function has been successfully started
You license has been expired, please contact us.
[Finished in 0.2s]
view raw hosted with ❤ by GitHub

The inference function is pretty straightforward and doesn’t need any explanation. Save the file in a folder.

2. Using PyArmor to encrypt it

Now we will encrypt the file by running the two below-mentioned commands.

pip3 install pyarmor # pip/pip3
# Syntax : pyarmor obfuscate --restrict=0 <filename>
pyarmor obfuscate --restrict=0
1. Install-Package
2. Encrypt the function

Now if you see the folder containing our actual file, a new subfolder will be created called dist. (original file)
Inside the dist folder where we have the (encrypted) file

The below image shows the content inside the dist folder.

Encrypted file inside dist subfolder

3. Importing our function / Inference

Once we are done, until this point, now let’s try to import this encrypted in a new python file called, which is created inside the dist folder.

The necessary keys for decrypting the at run-time are taken care of by PyArmor and are present in the pytransform folder, thus making our code completely non-readable to others’ eyes.

But if you wish to modify the original code, then you have to start from step 1 and follow the same steps.

Contents inside file,

# Import the inference function definition inside the file
from utils import inference
_ = inference(name="Balakrishna")

And upon running the above line, we get the output based on our file’s configuration.

The final output.


This is merely the beginning. If you want to really protect and sell your code, consider adding an actual license with an embedded virtual date on it. Upon passing the date, it will no longer run the program and throws a license expiry error. Luckily PyArmor has that too.

I have added the license-related documentation in the references below. You can even set up a provision to email automatically once the license is expired and you can get in touch with your clients using the SMTP services in python.

Also if you have a lot of .py files to import or as dependencies, you must use the — recursive command line instead of the — restrict command for your code to work.

Also, this implementation can be done in both Windows and Ubuntu-based OS.

Hope I have explained the process of obfuscation in a very simple manner. It is the python program you need to make it difficult to read and understand and not my blog😁.


Complete Code Implementation is available at,—Python

For PyArmor:

Related posts:

Leave a Reply

Your email address will not be published. Required fields are marked *