Forem: Ray Jones Muiruri

How RSA Works (for Dummies)

Ray Jones Muiruri — Tue, 14 Oct 2025 23:31:45 +0000

RSA stands for Rivest Shamir Adleman, and it was invented by:

Ron Rivest
Adi Shamir
Leonard Adleman

RSA comes from the first letters of their last names.

There are 2 types of encryption algorithms:

Symmetric
Asymmetric

Symmetric encryption algorithms use one key to encrypt and decrypt.

Asymmetric encryption algorithms use two keys — a public key and a private key.

RSA works by creating a pair of “commutative keys” — meaning if you encrypt with one, you can decrypt with the other.

In RSA, if you use the public key to encrypt, you must use the private key to decrypt (and vice versa).

RSA Math

Let's look at the mathematics behind RSA.

Here are the basic math concepts you need to know first:

0. Basic Math Operations

You should know how addition (+), subtraction (-), multiplication (×), and division (÷) work.

1. Factor

A factor — numbers you multiply to get the original number.

If N is the original number, and multiplying a and b gives you N, then a and b are factors of N.

Example:

N = 12
1 * 12 = 12
2 * 6  = 12
3 * 4  = 12

Factors of 12: 1, 2, 3, 4, 6, 12

Now for:

N = 7
1 * 7 = 7

Factors of 7: 1, 7

2. Prime

A prime number is a number that has only two factors: 1 and itself.

So from the example above, 7 is prime because its only factors are 1 and 7.

Other prime numbers: 2, 3, 5, 11, 13, 29, 37, 61, ...

3. Semi-Prime

A semi-prime number is a number whose factors are both prime numbers.

Example:

21 = 3 * 7

Here 3 and 7 are both prime numbers.

So 21 is a semi-prime.

Note:
We exclude 1 and the number itself since they are common factors in every number.

4. Modulo

Modulo just means the remainder after division.

The symbol for modulo is % (or sometimes MOD).

Example:

7 % 3 = 1   → because 3*2=6 and 7-6=1

So 1 is the remainder (modulo).

You can think of it as: what’s left over after dividing.

So that’s the 5 basic math concepts you need.

But as we go along, I’ll introduce another one that combines them.

RSA Algorithm

There are 2 main steps in RSA:

Generating keys
Using them for encryption and decryption

1. Generating Keys

Step a: Select 2 prime numbers (p, q)

Let p = 7 and q = 19.

Step b: Calculate their product

Let this be N.

N = p * q
N = 7 * 19 = 133

Step c: Calculate the Totient (T), also called Euler’s Totient Function.

Euler’s Totient function tells us how many numbers less than N share no common factors with N.

For RSA, since p and q are prime, φ(N) = (p − 1)(q − 1).

This counts how many numbers less than N are coprime (relatively prime) with N — meaning their GCD is 1.

Example:
Let N be 13.

How many numbers less than 13 will produce a GCD of 1 with 13.
Answer is 12

For RSA, you can simply compute:

T = (p - 1) * (q - 1)
T = (7 - 1) * (19 - 1)
T = 6 * 18 = 108

Step d: Choose a Public Key (E)

This value must satisfy:

E must be coprime with T (i.e., gcd(E, T) = 1)
E must be less than T
Let E = 29.

29 is less than 108
gcd(29, 108) = 1 So:

E = 29

Step e: Find the Private Key (D)

D must satisfy the condition:

(D * E) mod T = 1

This means D is the modular multiplicative inverse of E modulo T.

Let D be 41

(41 * 29) mod 108 = 1

(41 * 29) = 1189

1189 % 108 = 11 remainder 1

108 * 11 = 1188

1189 - 1188 = 1

So:

D = 41

2. Encryption and Decryption

Now that we have:

N = 133
E = 29
D = 41

We can encrypt and decrypt messages (which are represented as numbers).

Encryption (using Public Key)

Cipher = Message ^ E mod N

Example:

Message = 60
Cipher  = 60^29 mod 133 = 72

Decryption (using Private Key)

Message = Cipher ^ D mod N

Example:

Message = 72^41 mod 133 = 60 (the original)

So we got back our message — RSA works!

Note

RSA only works with numbers.

So if you have a message like "Hello, World!", it’s first converted to numbers using ASCII or UTF-8 before applying RSA.

After decryption, the number is converted back to text.

How Secure Is RSA?

RSA’s security relies on the difficulty of factoring semi-prime numbers.
RSA security depends on how hard it is to factor n = p × q, the larger n (in bits), the harder the math problem.

If you’re given 133, could you easily find 7 and 19? Sure.

But what about a 2048-bit number — something with hundreds of digits?

That’s practically impossible with current computers.

A 2048-bit RSA key means the digit can be as large as (2^2048)-1
Which is roughly a 617-digit decimal number

Here is a table of different key lengths and time it would take to crack them

RSA Key Size	Approximate Decimal Digits	Factoring Difficulty	Approximate Time to Break (with modern computers)
256-bit	~77 digits	Very easy	Few seconds
512-bit	~155 digits	Still easy	Minutes to hours
768-bit	~232 digits	Hard, but done in labs	Months (if you use supercomputers)
1024-bit	~309 digits	Very hard	Thousands of years
2048-bit	~617 digits	Practically impossible	Longer than universe’s age
4096-bit	~1234 digits	Even harder	Astronomically impossible

As you can see it gets harder every time the number gets larger. If you read my blog on how software works-encryption I talked about the goal of modern encryption was to make encryption computationally expensive - so expensive that its useless to even try.

Summary

Public Key  = (E, N)
Private Key = (D, N)

Encrypt:   Cipher = Message ^ E mod N
Decrypt:   Message = Cipher ^ D mod N

How Software Works: Encryption

Ray Jones Muiruri — Wed, 04 Jun 2025 13:09:09 +0000

How Software Works: Chapter 1

Encryption

Welcome to the first chapter of How Software Works—a series where we explore the inner workings of the technology that powers our digital lives. We’re kicking things off with a foundational concept in digital security: encryption.

What is Encryption?

We rely on software to protect our data every day, but the average person rarely stops to ask: How does this protection actually work?

Ever wondered how your phone password prevents unauthorized access? Or what stops attackers from logging into your Facebook, Google, or X account? The answer begins with computer security—and at the heart of that is encryption.

A Brief Look at Computer Security

Let’s start with a basic definition:
Computer security is the science of protecting digital data.

In many ways, computer security is technology’s solution to a problem created by technology itself.

Not long ago, people stored sensitive data in filing cabinets or shoeboxes under their beds. To steal that data, someone had to break into your home or office. Today, your bank details, private messages, and personal photos travel the world through the internet—and someone can steal them from the other side of the planet without you knowing.

In fact, you may only realize it happened when your bank calls to ask why you just spent KSH 300,000 on digital gift cards in another country.

This is where encryption comes in—why it’s important, and what it tries to solve.

What Encryption Does

Encryption lets us lock our data so that only we (or those we authorize) can unlock it. It’s not the only tool used in computer security, but it’s the most essential one.

The Goal of Encryption

Imagine a file on your device. It could be text, a photo, a spreadsheet, or a video. You want to keep it private—but also be able to access it easily.

Encryption allows you to convert that file into a new, scrambled format that appears meaningless to anyone without permission. This scrambled version is called ciphertext. When you want to read or view the original file again, you decrypt the ciphertext back into its original form—called plaintext.

Plaintext: The original readable data (even if it’s not text—could be an image, video, etc.)
Ciphertext: The unreadable, encrypted version of that data

Why Encryption Matters

Attackers—malicious hackers, criminals, or snoopers—try to decrypt ciphertext without having the proper key. Good encryption is designed to make this practically impossible.

Of course, just like no physical lock is truly unbreakable, no encryption scheme is theoretically unbreakable either. Given unlimited time and computational power, any encrypted data can eventually be cracked.

But modern encryption aims to make cracking so expensive—so computationally demanding—that it's useless to even try.

This is the key idea behind secure systems: make attacks infeasible rather than impossible.

Before we get into how encryption works in the digital age, let’s look at where it all began—before computers, when secrets were passed in whispers, codebooks, and handwritten messages.

Historical Roots: Ciphers and Spies

Even centuries before the internet, people had secrets worth protecting. Early forms of encryption were used by generals, kings, and spies. These simple methods laid the groundwork for today’s digital encryption.

Transposition: Same Data, Different Order

One of the simplest historical techniques is called transposition. It’s exactly what it sounds like—rearranging the letters or elements of a message into a new order.

For example, the message “MEET AT DAWN” could be scrambled as “TAM WNE EED” using a transposition scheme. The letters are all still there—but out of order.

Early transposition ciphers often relied on grids, patterns, or other agreed-upon structures. The trick was knowing the pattern to reverse the scrambling and reconstruct the original message.

However, once someone figures out the pattern, the encryption breaks. This leads us to a critical rule in modern cryptography.

Kerckhoffs’s Principle

In the 19th century, Dutch cryptographer Auguste Kerckhoffs proposed a key principle for any good encryption system:

The security of a system should depend only on the secrecy of the key—not the secrecy of the method.

This is still true today. Modern encryption algorithms (like AES or RSA) are publicly known and published. Anyone can study or use them—but without the key, they’re useless for decrypting data.

This naturally leads to the concept of...

Cipher Keys

If the encryption method itself isn’t secret, how is your data protected?

The answer is the cipher key. A cipher key is a secret, randomly generated value used during the encryption and decryption process. It ensures that even though everyone knows how the algorithm works, only those with the correct key can unlock the data.

So, while the algorithm might be standard, the key is unique to your data and must be kept secret.

What's Next?

In the next chapter of How Software Works, we’ll dive into symmetric and asymmetric encryption—two fundamental approaches to securing communication. We’ll explore how your web browser uses encryption when you visit a website, and what’s really happening when you see that little padlock icon in the address bar.

Thanks for reading Chapter 1!
Feel free to share your thoughts, questions, or ideas you'd like me to cover next.

🔌 Using Plugins in Go: A Simple Introduction

Ray Jones Muiruri — Thu, 08 May 2025 11:57:15 +0000

🔧 What Are Go Plugins?

A plugin in Go is a .so (shared object) file built from a Go package. It can be loaded at runtime using Go’s plugin package, allowing you to call its functions and access its variables dynamically.

Plugins are supported on Linux and macOS (not Windows).

Create a directory with this similar structure.

go-plugin-tutorial/
├── main.go         # the main program that loads the plugin
├── plugin/
│   └── greet.go    # Plugin code

✏️ Step 1: Create the Plugin

package main
import "fmt"
// the variables or functions must be exported
func Greet(name string) {
    fmt.Printf("Hello %s\n",name)
}

Important: the plugin must use package main and exported symbols (capitalized).

🛠️ Step 2: Build the Plugin

From the root directory, run:

go build -buildmode=plugin -o greet.so plugin/greet.go

This generates greet.so, a shared object file you can load at runtime.

💡 Step 3: Load the Plugin in Your App

package main

import (
    "plugin"
    "log"
)

func main() {
    // Load plugin
    plug, err := plugin.Open("plugin/greet.so")
    if err != nil {
        log.Fatal(err)
    }
    // Lookup exported symbol
    symGreet, err := plug.Lookup("Greet")
    if err != nil {
        log.Fatal(err)
    }
    // Assert that it's a function with the right signature
    greetFunc, ok := symGreet.(func(string))
    if !ok {
        log.Fatal("unexpected type from module symbol")
    }
    // Call it!
    greetFunc("Go Developer")
}

▶️ Step 4: Run It

Make sure greet.so is in the same directory as main.go or provide accurate path and run:

go run main.go

Output

Hello Go Developer

Hello World

Ray Jones Muiruri — Fri, 11 Apr 2025 22:41:11 +0000

Hello, World!