It works for me on python 3.8 , so I've modified the answer (including a minor bugfix in the code) 2021-11-10T08:34:26.173Z+00:00 ... Save this answer. ... Show activity on this post. You can do this easily by using the library cryptocode. Here is how you install: ... import cryptocode encoded = cryptocode.encrypt... More on stackoverflow.com

Simply put, you don't. Obfuscating the code is possible, but doesn't really prevent anyone from modifying or seeing it, and it can be made readable again. You could create executable binaries, but often these would just be executable ZIP-files that package the Python interpreter with your code. You could transpile the code to C and compile that (Cython and Nuitka are examples), which could work, but even that won't stop the most curious individuals from decompiling it. The thing with encryption is that in order to even run an encrypted program, you need to decrypt it, which needs the decryption key. So if the users could run it, they already have the key. The option most resistant to such tampering would be to host the code on a web service and have the users use that, as they don't have access to the back-end where your Python code would run. But that doesn't work for everything. My advice? Have a license on your code that meets your needs. Then you would at least have some leverage if you need to challenge someone misusing your work. More on reddit.com

I'm going to assume you are trying to learn how to do this and don't just want a solution posted. The simplest way is to use the cryptography library , which you'll need to install (usually pip install cryptography). If you aren't sure how to install modules, let me know, but I'll proceed assuming you either know or can find it. Next, we want to use the Fernet module to encrypt and decrypt files. Note that this encrypts and decrypts files, not just images and text, as there's no real meaningful distinction there. For illustration purposes, I'm going to use basic input and no looping, but in an actual program you'd want to save and load to files and add looping functionality for multiple files. I'm also having it create copies of the encrypted files as it's safer and less complicated. Once we're set up, we import the module and create a function to generate a key: from cryptography.fernet import Fernet user_key = input("Generate new key (y/n) ") if user_key.lower() == 'y': user_key = Fernet.generate_key() with open('key.key', 'wb') as f: f.write(user_key) else: with open('key.key', 'rb') as f: user_key = f.read() Now we've got a key, which is a string the program will use to encrypt or decrypt files. IMPORTANT: If you lose your key, you cannot decrypt the file. Be sure to save your keys somewhere safe. I save it to a file here because trying to copy and paste keys can be problematic. Why Fernet? There are multiple options, but I believe this is the easiest, using a direct "secret key" form of encryption. Encryption is a huge topic and there are all sorts of different methods for encrypting files, but things like public keys vs. private keys and different encryption algorithms are far beyond the beginner level and aren't necessary to know to get started. Just keep in mind this was chosen for simplicity while still being quite secure, however, there are many other options that may be better depending on the purpose of your encryption. Next, we need to encrypt a file. This is just a matter of reading the file and encrypting the contents, then saving the file again: file = input("Enter a file to encrypt (enter to skip): ") if file != '': with open(file, 'rb') as f: data = f.read() fernet = Fernet(user_key) encrypted = fernet.encrypt(data) new_file = file[:-4] + '_encrypted' + file[-4:] with open(new_file, 'wb') as f: f.write(encrypted) What's going on here? First, we read the file we want to encrypt as bytes (this is important). Then we create a Fernet object that can be used for encryption with our user key. This uses encrypt to encrypt the contents of the file. The new_file line just adds _encrypted into the file name so it doesn't overwrite the contents; if you like to live dangerously, just use file again in the second with block, which will overwrite the existing file. That's basically it to get an encrypted file. There are a lot of things you could do to make this more user-friendly, but for "simplest" this is about as simple as you can get. Having an encrypted file is kind of pointless if we can't decrypt it. So our next block will do just that: file = input("Enter a file to decrypt (enter to skip): ") if file != '': with open(file, 'rb') as f: data = f.read() fernet = Fernet(user_key) decrypted = fernet.decrypt(data) new_file = file[:-4] + '_decrypted' + file[-4:] with open(new_file, 'wb') as f: f.write(decrypted) Unsurprisingly, it's the same process, you just use decrypt instead of encrypt. Be sure to enter your encrypted file, not the original! You'll get an error if you try to decrypt a file that isn't encrypted. And that's basically it. This could be greatly improved by adding better error handling, saving keys more securely, etc. If you just want something encrypted that you can later decrypt, though, and someone isn't going to have access to the file on the computer to encrypted it on (and therefore can read your key file), this should be enough to get you started. Let me know if you have questions! More on reddit.com

Good job, and I like that you included the original file too so we can see how much you've improved. Here's a couple tips: When you're defining the plaintext and ciphertext lists, you can save some time by just making them strings instead of lists of characters You can use the "find" method built into strings instead of the inner loop in your functions To make it so it uses a "key" to encrypt/decrypt, you can use the "shuffle" function in the "random" library to create an arbitrary ciphertext string, and you can use the key as a seed for the process. There's going to be people that come in here and tell you that this really isn't an adequate cryptographic algorithm. What you've got is called a "substitution cipher", and its susceptible to quite a lot of effective attacks. Modern encryption techniques generally do some complex operation on each byte which is dependent on the byte, the key, the position of the byte, and some state based on all of the bytes already processed. This way, knowing some information about the original text doesn't give you any head start in attacking it. Also, I should note that the "random" module isn't actually a cryptographically secure random number generator, meaning that there are ways to predict it's output. More on reddit.com