Wednesday, October 5, 2022

Editing Binary Files on Vim Editor

 Here's a quick method I use to edit binary files on the vim editor. Suppose that the binary file name that we need to edit is called hello. Let's open it using the xxd hex viewer utility and pipe it to the vim editor as follows using the terminal. This produces the hex view of the binary file on the vim editor.

xxd hello | vim -

Now, we are good to go with editing the hex values in the file as you would do with any text file on the vim editor. Once we are done with the editing, we can now convert this updated hexdump view on the vim editor back to a new binary file. In order to do that, go to the command mode of the vim editor, and type and enter the following command. It will save the edited binary into a new file; the new file can be named anything while I have made it to be hello-new.

%!xxd -r > hello-new

Now, you can safely quit the vim editor with q! on the command mode as you would always quit it. :) Cheers!



Tuesday, December 14, 2021

Creating a Window 10 Live USB Stick on an Ubuntu GNU/Linux Computer

As a hardcore user of GNU/Linux systems, I don't usually come across any requirement to use Windows operating system. However recently, I had to install Windows in somebody else's computer as a help. It took me a while to find out how to prepare a installation USB drive for the purpose. Here's the steps I followed, hoping that my future self may need to refer back one day.

1. Download Window 10 ISO file from the official Microsoft website.

2. Download and install WoeUSB-ng on the Ubuntu computer using the information in the following Github page:

3. Run the following command to make the USB device (/dev/sdb in my case) bootable with the downloaded Windows ISO file. If there are files in the Windows 10 ISO file that are bigger than 4GB, the following command will automatically revert to NTFS format. 

sudo woeusb --target-filesystem FAT --device ~/Downloads/Win10_21H2_EnglishInternational_x64.iso /dev/sdb 


Thursday, March 25, 2021

Enabling Hibernation in Ubuntu 20.04 LTS using a Swap File

Enabling of the hibernation option on Ubuntu 20.04 LTS didn't work in the way I used to do. So, I had to explore further and do it slightly differently. This blog post records those things I did to get hibernation option working.

1. First of all, create a swap file using the following commands.

sudo fallocate -l 17G /swapfile

sudo chmod 600 /swapfile

sudo mkswap /swapfile

sudo swapon /swapfile

Once done, add an entry to the end of /etc/fstab file to make use of this swap file as follows.

/swapfile none swap sw 0 0

2. Check the UUID of the partition where the swap file is located using the following command.

cat /etc/fstab

Take note of the UUID string, which we will need in a later step.

3. Check the offset to the swapfile with in the storage device using either of the following commands. Take note of that offset value.

sudo filefrag -v /swapfile | awk '{ if($1=="0:"){print substr($4, 1, length($4)-2)} }'

sudo swap-offset /swapfile

4. Now, open the /etc/default/grub file and add update the correct line as follows.

Original line:


Updated line:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=a27fc21e-3315-4497-99aa-1fe7fad64091 resume_offset=9807872"

Note that the UUID value and the resume offset value are found using the above steps 2 and 3.

Once this grub file is updated, run the following command to take the changes effect.

sudo update-grub

5. Test whether the hibernation option is working now, use either of the following commands. I personally prefer the second command as it provides some verbose output while the system is being hibernated and being resumed later.

sudo systemctl hibernate

sudo pm-hibernate




Tuesday, April 21, 2020

Encrypting Files Using GnuPG

This post shows how to use GnuPG to encrypt and decrypt files on a Linux environment.

1. If you haven't created your GnuPG key pair yet, you can use the following commands to create them and view their details.

Create a pair of GnuPG keys using the following command.

gpg --gen-key

The keys and their relevant information are stored in .gnupg directory under your home directory. You can view the public keys in your keyring using the following command.

gpg --list-key

You can view the private keys using the following command.

gpg --list-secret-keys

2. Encrypting a file called "private-file.txt" can be done as follows. We can either specify a new name for the encrypted file or GnuPG will automatically name the new file by appending .gpg extension to the name of the plaintext file.

gpg --encrypt --recipient private-file.txt

gpg --output encrypted.gpg --encrypt --recipient private-file.txt

3. Decrypting a file called "private-file.txt.gpg" can be done as follows. Similar to the previous case, we can either specify a name for the decrypted file or leave it to the default.

gpg --output private-file.txt --decrypt private-file.txt.gpg

gpg --decrypt encrypted.gpg > private-file.txt

4. Encrypting all the files in a directory can be done as follows.

gpg --encrypt-files --recipient /path/to/the/directory/*

5. Decrypting all the .gpg files in a particular directory can be done as follows.

gpg --decrypt-files /path/to/the/directory/*.gpg





Friday, April 17, 2020

Sending Secure Emails with OpenPGP

Use of encryption in our electronic communication is essential to protect our security and privacy. Here's how we can use OpenPGP standard to send and receive emails securly. While there are many software tools to get this done, I prefer this way.

1. Create a pair of GNU Pritty Good Privacy (PGP) keys using the following command.

gpg --gen-key

The keys and their relevant information are stored in .gnupg directory under your home directory. You can view the public keys in your keyring using the following command.

gpg --list-key

You can view the private keys using the following command.

gpg --list-secret-keys

2. Log-in to your email account from Thunderbird email client. Thunderbird is available by default in most Linux systems including Ubuntu Linux.

3. Install the Enigmail plug-in in Thunderbird. Since we have already created the GPG keys, Enigmail will automatically detect them and start using them. If we didn't have created the keys already, Enigmail facilitates creating them as well.

4. From the menu bar of Thunderbird, select the Enigmail item and then Key Management option, which will display your key. Right-click on your key and select the option "Upload Public Keys to Kerservers". This will post your public key to a public key server.

5. Now, we are good to go with sending and receiving encrypted emails. When you compose an email with Thunderbird, there is a padlock button that stands for encryption of the email. When you enable it and then hit send button, Enigmail will prompt you if the public key of the recipient is not available locally. In that case, it will also facilitate to obtain the required keys from keyservers as well.





Tuesday, March 31, 2020

Setting up Hibernation on Ubuntu 18.04 LTS

The ability to hibernate the computer when we are done for the day and get back to where we left next time was a useful feature we had in Ubuntu sometime back by default. However, unfortunately, recent Ubuntu versions does not offer this feature off-the-shelf. Recently, I wanted to get this feature into my laptop running Ubuntu 18.04 version and following are the steps I followed.

1. Creating a swap file

My laptop has 8GB of RAM. Therefore, we need to have a swap space of at least the same size of RAM. Since I didn't want to allocate a partition partition, I created a swap file as follows. 

sudo fallocate -l 8G /swapfile2
sudo chmod 600 /swapfile2
sudo mkswap /swapfile2
sudo swapon /swapfile2

Append the following line to /etc/fstab file in your system.

/swapfile2 none swap sw 0 0

2. Enabling hibernation

Check the UUID of the device where swapfile is located using the following command. The UUID is a very long number that you can see in the output.

sudo findmnt -no SOURCE,UUID -T /swapfile2

Install the following tool.

sudo apt install uswsusp

Run the following command. When prompted, go ahead without a valid swap space by giving 'yes' as the response and then select the device partition where the swap file exists (don't select the swap file itself).

sudo dpkg-reconfigure -pmedium uswsusp

I'm not sure whether I ran the following command next. Probably I did.

sudo update-initramfs -u

3. Enabling the resume from hibernation at next boot

We need to update the /etc/default/grub file as follows.

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=<swap uuid>"

The following is how mine looks like after the modification.

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash resume=UUID=cda0136e-ffd9-4a0c-8657-a6511517aa71"

4. Testing hibernation

Run the following command to hibernate your computer. When you turn the computer on next time, it should resume the execution from where you left it when you run the following command.

sudo pm-hibernate





Tuesday, January 29, 2019

Sending Samples to Python from GRC using ZMQ Sink

When we need to process some data generated by an SDR device, the most convenient approach we have currently is saving the data into a file and then reading the files from Python. However, if the requirement is to process data in real-time as they are generated from the SDR device, saving to a file is not the right way. GNURadio Companion software provides a special set of sink blocks which uses ZMQ messaging protocol for such purposes. This post demonstrates how to use one of such sink types in order to deliver raw samples generated by a GRC flow graph into a Python script.

(1) Create the following flow graph on GNURadio Companion. Instead of taking data from a real SDR device, we use two Signal Source blocks to generate two cosine wave signals with 3MHz and 5MHz frequencies. We set the sample rate to 4 MHz. The Throttle block is necessary to regulate the data flow through the flow graph since we are not using a real SDR hardware. Most importantly, we are using a ZMQ Push Sink block. Notice that we have given the localhost IP address and an arbitrarily selected port number as the destination of the data.

(2) Now, in order to capture the data, we need a Python script which implements a ZMQ Pull client. Create a Python program with the following content and save it as

import time
import zmq
import random
import numpy as np
import matplotlib.pyplot as plt

def consumer():
    consumer_id = random.randrange(1,10005)
    print("I am consumer #%s" % (consumer_id))
    context = zmq.Context()
    consumer_receiver = context.socket(zmq.PULL)
    while True:
        buff = consumer_receiver.recv()
        data = np.frombuffer(buff, dtype="float32")
        data = data[0::2] + 1j*data[1::2]
        #plt.psd(data, NFFT=len(data), Fs=4e6, Fc=1e3)

(3) We need to start the client Python program first from a terminal.


(4) Now, start the GNURadio Companion flow graph. On the terminal where our Python program running, we should be able to see the chunks of data coming now. The number of samples contained in each data set various over time which I'm not exactly sure why. Following screenshot shows the output on the terminal.

(5) If we activate the commented lines, we can save a plot in a PNG file which shows the power spectral density (PSD) of the received signal. As expect, there are two peaks in both sides of the center frequency with a gap of 1 MHz. This is because our sampling rate was 4 MHz while there were two signals with 3MHz and 5MHz in the captured signal. Following figure shows that PSD graph.

The code for the Python script and the GRC flow graph file are kept in a Github repository to try it easily. Cheers!

Useful links:

[1] More reading on PyZMQ library.

[2] A question in StackExchange where somebody had suggested to use ZMQ Sink.

[3] The Github repository with my codes illustrating this work.