Skip to main content

Using PGPy to encrypt and decrypt files and messages

 PGPy is a library for python that enables the creation, storage, and encryption/decryption of PGP keys and files in python. Recently, in a small project to reacquaint myself with python, I used PGPy for key generation and encryption and decryption. That project can be found in my github at https://github.com/lpowell. The goal of the project was to use command-line switches to control the program, and to provide basic encryption and decryption capabilities, along with rot13 and base64 encoding. 


First, to load in a key use key, _ = pgpy.PGPKey.from_file(keyfilename). This loads the key from either a binary or ASCII armored file. You can swap out .from_file for .from_blob, if you plan on using a key stored in a string or bytes object rather than a file. In my example code, I pull the key from a file, as I found it to be the simpler method. 


Next, you'll need to open a file or create a string or bytes object that contains the message you wish to encrypt. We'll call this file_message. To open a message from a file, you will want to do something like this, file_message = pgpy.PGPMessage.new(message_file_location, file=True). This will create a PGPMessage object called file_message. You can also import from a string or bytes object string_message = pgpy.PGPMessage.new("string or string object here"). To encrypt this message, encrypted_file_message = key.encrypt(file_message). This uses the key we opened early to encrypt the file or message. This will give an error if a private key is loaded, so make sure that the key object is loaded with a public key.  Outputting this is easy enough, output_file.write(str(encrypted_file_message). This will convert the encrypted message to a string, and store it inside a file. I recommend writing to PGP files.


To decrypt this message, make sure that the key you have open is the matching private key to the public key that was used to encrypt the original message. To open the encrypted message, encrypted_message = pgpy.PGPMessage.from_file(encrypted_message_file_location). This opens the encrypted message file we made earlier as a PGPMessage object. You can also run this with .from_blob and use a string or bytes object. 


Now that the encrypted message is open, we need to decrypt it. We can decrypt it using key.decrypt. decrypted_message = key.decrypt(encrypted_message). This creates a new object containing the decrypted message. This cannot be written directly to a file, as it is still an encrypted object. To get the decrypted message from the object, we need to use decrypted_message.message. This will give us access to the decrypted message. It sounds a bit silly, but this took me ages to figure out. Fully written out, this looks like str_decrypted_message = decrypted_message.message. To write this to a file, we do output_file.write(str_decrypted_message). I believe you could do output_file.write(decrypted_message.message), but I didn't do this myself.


More info on PGPy can be found on their website, https://pgpy.readthedocs.io/en/latest/api.html

Labels:

Comments

  1. AnonymousSeptember 22, 2023 12:01 PM

    Just want to say you're post here has literally fixed hours of head scratching, so many subtle ways to go horribly wrong, like creating encrypted messages from .new() :/

    ReplyDelete
  2. AnonymousNovember 21, 2023 5:17 PM

    When I decrypted file I see empty line added in between rows any idea why

    ReplyDelete

Post a Comment

Popular posts from this blog

Huntress CTF Challenge Writeups: HumanTwo: MoveIt IoC Analysis Challenge

HumanTwo: MoveIT IoC Analysis Challenge The HumanTwo challenge is a malware CTF from the 2023 Huntress CTF. This write-up walks through the initial discovery, de-obfuscation, and solving of the challenge. The actual flag will be redacted from the document, but interested parties should be able to follow the steps and derive it themselves. While the write-up assumes a base level of knowledge regarding the command line and Linux. Most tools and commands will be accompanied by short explanations. Step 1: Initial Analysis To start off, we are given an archive with 1000 files named after their file hash. The hint we are given is that there are minor differences between each file. We also know that HumanTwo relates to the MoveIT vulnerability and exploit. The easy way to progress is to look up articles that tell you about the vulnerability and what stands out in each exploit script. However, I didn’t do that, so I’ll put the process I followed down instead. First, because I knew that...
Post a Comment
Read more

Huntress CTF Challenge Writeups: VeeBeeeee & Fetch

  VeeBeeeee: A Microsoft Script Forensics Challenge VeeBeeeee starts with an extensionless file. When attempting to open this file, we get a bunch of random junk. I used PowerShell to display the content of the file and then dropped the output into CyberChef to decode it. Using the “Magic” function on CyberChef told me that it was a Microsoft Script, and CyberChef applied the Microsoft Script Decoder function to the text blob. Copy/Pasting the cleartext code into VSCode lets us use the find and replace function to get rid of some of this junk data. While going through the script and getting rid of the tacked-on strings and characters, we can see that there is an array being built called Request. If we follow the link in this array, we get to a Pastebin file with the flag.   Fetch: A Prefetch and WIM File Analysis Challenge Fetch provided an unknown file with no extension. Like previous challenges, we can use the “file” command to determine the file type. Using ...
Post a Comment
Read more