Forem: Chigozie Oduah

Intentional Exercise Hacker 101 CTF writeup

Chigozie Oduah — Sat, 14 Feb 2026 21:33:20 +0000

A moderate-difficulty android-based hacker 101 CTF exercise. The goal of this exercise is to get the app to display the flag.

Getting Started

After starting the challenge, we're given an Android APK to work with, and we'll start by opening this file in Android Studio. To do that, we'll click on the three dots menu on the top right and then Profile or Debug APK, or More Actions > Profile or Debug APK in the welcome menu, and select the level13.apk file we're provided with.

Next, we'll start up a virtual device, and drag the APK to the device to install the app. And now we can start our analysis.

App analysis

We'll start by exploring the app to get a surface level understanding of how it works. Immediately after opening the app, we're greeted with this page:

When we click Flag, we get an "invalid request" page message. Since our goal is to access this page, let's look into how the app's logic will allow us to do that. To do this, we'll need to get more technical.

Technical analysis

For this analysis there're three parts of the application we'll be going into:

The manifest file (AndroidManifest.xml)
The app's entrypoint (MainActivity.smali)
The app's server

AndroidManifest.xml

We'll start by looking at the AndroidManifest.xml file:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:versionCode="1"
    android:versionName="1.0"
    android:compileSdkVersion="28"
    android:compileSdkVersionCodename="9"
    package="com.hacker101.level13"
    platformBuildVersionCode="28"
    platformBuildVersionName="9">

    <uses-sdk
        android:minSdkVersion="23"
        android:targetSdkVersion="28" />

    <uses-permission
        android:name="android.permission.INTERNET" />

    <application
        android:theme="@ref/0x7f0c0005"
        android:label="@ref/0x7f0b0027"
        android:icon="@ref/0x7f0a0000"
        android:allowBackup="true"
        android:supportsRtl="true"
        android:usesCleartextTraffic="true"
        android:roundIcon="@ref/0x7f0a0001"
        android:appComponentFactory="android.support.v4.app.CoreComponentFactory">

        <activity
            android:name="com.hacker101.level13.MainActivity">

            <intent-filter>

                <action
                    android:name="android.intent.action.MAIN" />

                <category
                    android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

            <intent-filter>

                <action
                    android:name="android.intent.action.VIEW" />

                <category
                    android:name="android.intent.category.DEFAULT" />

                <category
                    android:name="android.intent.category.BROWSABLE" />

                <data
                    android:scheme="http"
                    android:host="level13.hacker101.com" />
            </intent-filter>

            <intent-filter>

                <action
                    android:name="android.intent.action.VIEW" />

                <category
                    android:name="android.intent.category.DEFAULT" />

                <category
                    android:name="android.intent.category.BROWSABLE" />

                <data
                    android:scheme="https"
                    android:host="level13.hacker101.com" />
            </intent-filter>
        </activity>
    </application>
</manifest>

In this file, we can see two valuable pieces of information, the program's entrypoint com.hacker101.level13.MainActivity:

...
<activity
            android:name="com.hacker101.level13.MainActivity">
...

And the intent filters:

...
            <intent-filter>

                <action
                    android:name="android.intent.action.VIEW" />

                <category
                    android:name="android.intent.category.DEFAULT" />

                <category
                    android:name="android.intent.category.BROWSABLE" />

                <data
                    android:scheme="http"
                    android:host="level13.hacker101.com" />
            </intent-filter>

            <intent-filter>

                <action
                    android:name="android.intent.action.VIEW" />

                <category
                    android:name="android.intent.category.DEFAULT" />

                <category
                    android:name="android.intent.category.BROWSABLE" />

                <data
                    android:scheme="https"
                    android:host="level13.hacker101.com" />
            </intent-filter>
...

A simplified explanation of what intent filters are, are they're essentially a description of the signals (intents) that applications listen for. The android manifest file tells the operating system that the application wants to listen for intents on URIs that point to http://level13.hacker101.com and https://level13.hacker101.com.

This is going to be useful information for understanding the application.

MainActivity.smali

This is where the application's logic resides. We'll start by opening up MainActivity.smali and navigate to the onCreate method definition This is the part of the code that runs when the app is opened:

.method protected onCreate(Landroid/os/Bundle;)V
    .registers 9

    .line 19
    invoke-super {p0, p1}, Landroid/support/v7/app/AppCompatActivity;->onCreate(Landroid/os/Bundle;)V

    const p1, 0x7f09001c

    .line 20
    invoke-virtual {p0, p1}, Lcom/hacker101/level13/MainActivity;->setContentView(I)V

    const p1, 0x7f070090

    .line 21
    invoke-virtual {p0, p1}, Lcom/hacker101/level13/MainActivity;->findViewById(I)Landroid/view/View;

    move-result-object p1

    check-cast p1, Landroid/webkit/WebView;

    .line 22
    new-instance v0, Landroid/webkit/WebViewClient;

    invoke-direct {v0}, Landroid/webkit/WebViewClient;-><init>()V

    invoke-virtual {p1, v0}, Landroid/webkit/WebView;->setWebViewClient(Landroid/webkit/WebViewClient;)V

    .line 23
    invoke-virtual {p0}, Lcom/hacker101/level13/MainActivity;->getIntent()Landroid/content/Intent;

    move-result-object v0

    .line 24
    invoke-virtual {v0}, Landroid/content/Intent;->getData()Landroid/net/Uri;

    move-result-object v0

    const-string v1, "https://ctf-id.ctf.hacker101.com/appRoot"

    const-string v2, ""

    if-eqz v0, :cond_41

    .line 28
    invoke-virtual {v0}, Landroid/net/Uri;->toString()Ljava/lang/String;

    move-result-object v0

    const/16 v2, 0x1c

    invoke-virtual {v0, v2}, Ljava/lang/String;->substring(I)Ljava/lang/String;

    move-result-object v2

    .line 29
    new-instance v0, Ljava/lang/StringBuilder;

    invoke-direct {v0}, Ljava/lang/StringBuilder;-><init>()V

    invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    invoke-virtual {v0, v2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;

    move-result-object v1

    :cond_41
    const-string v0, "?"

    .line 31
    invoke-virtual {v1, v0}, Ljava/lang/String;->contains(Ljava/lang/CharSequence;)Z

    move-result v0

    if-nez v0, :cond_5a

    .line 32
    new-instance v0, Ljava/lang/StringBuilder;

    invoke-direct {v0}, Ljava/lang/StringBuilder;-><init>()V

    invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    const-string v1, "?"

    invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;

    move-result-object v1

    :cond_5a
    :try_start_5a
    const-string v0, "SHA-256"

    .line 34
    invoke-static {v0}, Ljava/security/MessageDigest;->getInstance(Ljava/lang/String;)Ljava/security/MessageDigest;

    move-result-object v0

    const-string v3, "s00p3rs3cr3tk3y"

    .line 35
    sget-object v4, Ljava/nio/charset/StandardCharsets;->UTF_8:Ljava/nio/charset/Charset;

    invoke-virtual {v3, v4}, Ljava/lang/String;->getBytes(Ljava/nio/charset/Charset;)[B

    move-result-object v3

    invoke-virtual {v0, v3}, Ljava/security/MessageDigest;->update([B)V

    .line 36
    sget-object v3, Ljava/nio/charset/StandardCharsets;->UTF_8:Ljava/nio/charset/Charset;

    invoke-virtual {v2, v3}, Ljava/lang/String;->getBytes(Ljava/nio/charset/Charset;)[B

    move-result-object v2

    invoke-virtual {v0, v2}, Ljava/security/MessageDigest;->update([B)V

    .line 37
    invoke-virtual {v0}, Ljava/security/MessageDigest;->digest()[B

    move-result-object v0

    const-string v2, "%064x"

    const/4 v3, 0x1

    .line 38
    new-array v4, v3, [Ljava/lang/Object;

    const/4 v5, 0x0

    new-instance v6, Ljava/math/BigInteger;

    invoke-direct {v6, v3, v0}, Ljava/math/BigInteger;-><init>(I[B)V

    aput-object v6, v4, v5

    invoke-static {v2, v4}, Ljava/lang/String;->format(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;

    move-result-object v0

    .line 39
    new-instance v2, Ljava/lang/StringBuilder;

    invoke-direct {v2}, Ljava/lang/StringBuilder;-><init>()V

    invoke-virtual {v2, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    const-string v1, "&hash="

    invoke-virtual {v2, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    invoke-virtual {v2, v0}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;

    invoke-virtual {v2}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;

    move-result-object v0

    .line 40
    invoke-virtual {p1, v0}, Landroid/webkit/WebView;->loadUrl(Ljava/lang/String;)V
    :try_end_a0
    .catch Ljava/security/NoSuchAlgorithmException; {:try_start_5a .. :try_end_a0} :catch_a1

    goto :goto_a5

    :catch_a1
    move-exception p1

    .line 42
    invoke-virtual {p1}, Ljava/security/NoSuchAlgorithmException;->printStackTrace()V

    :goto_a5
    return-void
.end method

Smali code is just a higher-level representation of the dex byte code. It is relatively straight forward to convert Smali to Java code, but it takes some getting used to. But for ease of understanding this writeup, I'll also the Java translation. However, if you want to learn more about Smali code, this cheatsheet and this article are very useful resources.

Here's its equivalent Java translation:

@Override
protected void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    setContentView(R.layout.activity_main);

    WebView webView = (WebView) findViewById(R.id.webview);
    webView.setWebViewClient(new WebViewClient());

    Intent intent = getIntent();
    Uri data = intent.getData();

    String baseUrl = "https://ctf-id.ctf.hacker101.com/appRoot";
    String extraPath = "";

    if (data != null) {
        String dataString = data.toString();
        extraPath = dataString.substring(28);
        baseUrl = baseUrl + extraPath;
    }

    if (!baseUrl.contains("?")) {
        baseUrl = baseUrl + "?";
    }

    try {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        String secretKey = "s00p3rs3cr3tk3y";

        // Hash the secret key first
        digest.update(secretKey.getBytes(StandardCharsets.UTF_8));
        // Then hash the extra path provided in the intent
        digest.update(extraPath.getBytes(StandardCharsets.UTF_8));

        byte[] hashBytes = digest.digest();

        // Convert hash to a 64-character hex string
        String hexHash = String.format("%064x", new BigInteger(1, hashBytes));

        // Append the hash as a query parameter and load
        String finalUrl = baseUrl + "&hash=" + hexHash;
        webView.loadUrl(finalUrl);

    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
}

From this code sample, we can see that the application listens for if an intent was used to run the app and gets its URI data:

    Intent intent = getIntent();
    Uri data = intent.getData();

Looking at the url we added to our intent, we can see that http://level13.hacker101.com is exactly 28 characters.

Then it takes a slice of the string 28th character to the end of the string and hashes it with the secret key:

        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        String secretKey = "s00p3rs3cr3tk3y";

        // Hash the secret key first
        digest.update(secretKey.getBytes(StandardCharsets.UTF_8));
        // Then hash the extra path provided in the intent
        digest.update(extraPath.getBytes(StandardCharsets.UTF_8));

        byte[] hashBytes = digest.digest();

        // Convert hash to a 64-character hex string
        String hexHash = String.format("%064x", new BigInteger(1, hashBytes));

After that, it combines everything into a URL and loads it into the WebView element:

        String finalUrl = baseUrl + "&hash=" + hexHash;
        webView.loadUrl(finalUrl);

Without any intent to get the data from, the url it generates is https://ctf-id.ctf.hacker101.com/appRoot?&hash=61f4518d844a9bd27bb971e55a23cd6cf3a9f5ef7f46285461cf6cf135918a1a (You can see the page by disabling wifi and cellular in the android virtual device and opening the app) which it loads as the first page.

Web server

In this section, we'll be taking a look at the server https://492b0cfd403532a8fa21fd4c01adcbb7.ctf.hacker101.com/appRoot. We'll start by opening the url in a browser and take a look at the dev tools panel to see the page's HTML code:

<h1>Welcome to Level13</h1>
<a href="appRoot/flagBearer">Flag</a>

From that, we can see that clicking the Flag link takes us to the appRoot/flagBearer page, which gives us the "Invalid request" message.

And now we have all the information we need to begin exploiting the application to open the page.

Exploitation

The idea I have for how we can access the flag page is: we craft an intent with http://level13.hacker101.com/flagBearer. Because the application takes a substring from the data string, which becomes "/flagBearer". Following the application logic with the this intent, it would hash the substring with the secret key, and combine the appRoot url, the substring from the intent and its hash, and load it into the WebView.

We can craft and trigger intents using the adb command by following these steps:

Run adb devices to list the device that we're connected to, this should show the emulated device.
```
$ adb devices
List of devices attached
emulator-5554   device
```
Run adb shell to get a shell to the device we're connected to.

Craft and trigger our intent in the shell:

$ am start -d "http://level13.hacker101.com/flagBearer"

After triggering this intent, we will see a dialog in the virtual device prompting you for what app you want to open it in. Select the level13 app and any of "just once" or "Always":

This will take you to the flagBearer page in the app, where the flag will appear:

Guess password easy Google beginner's quest CTF 2026 write up

Chigozie Oduah — Tue, 10 Feb 2026 17:17:30 +0000

The first CTF of the beginner’s quest CTFs: Guess password Easy. A crypto category CTF with the description: You will never guess my password, even if I give you the first 5 letters!

Looking at the challenge, we're provided a sample of the source code and a server to connect to to solve the challenge.

First, connecting to the server to see what we're working with, we get:

$ nc guess-password-easy.2025-bq.ctfcompetition.com 1337
== proof-of-work: disabled ==
Password is mnyko...............
Your guess:

And cross-checking with the source code given to us, we can see that the program first seeds the random number generator with srand(time(0)). Then, enters a while-loop where it generates the random password, prints out the first 5 characters, and prompts you to guess the password.

Taking a deeper look into the code, we can see these important lines:

// Lines 14 to 21
string generateRandomPassword()
{
    string res(20, '.');
    for (int i = 0; i < 20; ++i) {
        res[i] = 'a' + rand() % 26;
    }
    return res;
}

// line 24 in `main()`
    srand(time(0));

// lines 27 and 28 in `main()`
    string serverPassword = generateRandomPassword();
    cout << "Password is " << serverPassword.substr(0,5) << "..............." << endl;

And in these lines, we can see the most critical line:

srand(time(0));   // line 24

This line tells us that the random number generator is seeded with the current time, provided by the time(0) function. The time(0) functions returns the current date and time, represented as the number of seconds epoch (January 1, 1970, 00:00:00 UTC).

Now to the next thing, we don’t know the exact time the generator was seeded since when we run the server command there can be a delay. But since we get the first 5 digits of the password in our guess, we can create our own password generator using a range of time to seed the it’s generator.

For the generator I created, I will use a 2-hour range, just to be safe (+1 hour and -1 hour). This will give us 3600 password combinations. Since we already get the first 5 digits given to us, we can search the generated passwords for our combination.

To generate these passwords, I created this C++ code:

#include <fstream>
#include <string>

std::string generateRandomPassword()
{
    std::string res(20, '.');
    for (int i = 0; i < 20; ++i) {
        res[i] = 'a' + rand() % 26;
    }
    return res;
}

int main() {
    int seed = time(0);
    std::ofstream outputFile("output.txt");

    for (int i = -1800; i <= 1800; i++) {
        srand(seed + i);

        outputFile  << "Seed " << i << ": " << seed + i << " - "
                    << "Password 1 is: " << generateRandomPassword() << '\n'
                    << "Password 2 is: " << generateRandomPassword() << '\n'
                    << "Password 3 is: " << generateRandomPassword() << '\n';
    }

    outputFile << std::endl;
    return 0;
}

NOTE: srand behaves differently on different operating systems. To get the same random number with the challenge, you need to also use a linux system.

Beginning the process of solving the challenge, I compile my script:

$ g++ main.cpp

Then, I connect to the challenge server:

$ nc guess-password-easy.2025-bq.ctfcompetition.com 1337
== proof-of-work: disabled ==
Password is ftbrh......
Your guess:

After that, I ran the compiled script, then use less to preview the output file:

$ ./a.out
$ less output.txt

Then I typed /ftbrh to search for the password and sure enough:

After typing in the password, I got the flag:

$ nc guess-password-easy.2025-bq.ctfcompetition.com 1337
== proof-of-work: disabled ==
Password is ftbrh......
Your guess: ftbrhpjdhohfnmqqaddv
CTF{flag}

Developing a projects in docker containers

Chigozie Oduah — Sun, 10 Aug 2025 16:50:48 +0000

One of Docker’s biggest advantages is reproducible builds. With it, you can bundle your project together with the exact environment it needs to run.

This becomes invaluable when your project grows, when you’re collaborating with other developers, when you need a quick-spinup development environment, or even when you want non-developers to try your work without a complicated setup.

In this article, I’ll walk you through setting up your development environment inside a docker container to get the benefits of autocompletes and suggestions while maintaining the consistent environments that docker containers provide.

Prerequisites and assumptions

This article assumes that the IDE you want to set up to develop in the container is VS code, and that you have the Docker CLI & Desktop installed on your system and running.

What project are we working with?

Let’s start by creating a new main.py file and pasting the following into it:

from flask import Flask, request
from collections import defaultdict

app = Flask(__name__)

storage = defaultdict(str)

@app.get('/<key>')
def get_key(key: str):
   return storage[key]

@app.post('/<key>')
def store_key(key: str):
   storage[key] = request.data.decode()
   return 'success'

if __name__ == "__main__":
   app.run(debug=True, host='0.0.0.0', port=8080)

This is a simple flask app you can get running by following these steps:

Install flask:

pip install flask

Run the code

python main.py

All this project does is it allows you to store a string of text in a route using POST requests that you can retrieve using a GET request. For example:

$ curl -X POST -d 'Show me the way' 127.0.0.1:8080/show -H "Content-Type: text/plain" 
success
$ curl http://127.0.0.1:8080/show
Show me the way

To finish up this project, create a requirements.txt file and paste the following into it:

Flask==3.1.1

Step 1: Writing the dockerfile

This step allows us to containerize our projects, and run it. All you need to do in this in this step is to create a Dockerfile file in the project directory and paste the following into it:

FROM python:3.13.5-bullseye

WORKDIR /code

COPY requirements.txt .
RUN pip install -r requirements.txt
EXPOSE 8080

CMD [ "sleep", "infinity" ]

Here’s a break down of the file:

Use python:3.13.5-bullseye as the project’s base container.

FROM python:3.13.5-bullseye

Create a work directory in the container called code in the container (this is where all your project files would be mounted).

WORKDIR /code

Copy the requirements.txt file to the work directory.

COPY requirements.txt .

Install the project’s dependencies.

RUN pip install -r requirements.txt

Expose the port 8080 outside the container.

EXPOSE 8080

Start the container and keep awake indefinitely.

CMD [ "sleep", "infinity" ]

Since we want to create the container for development, keeping it awake allows us to develop in it without it shutting down in the middle of development.

Step 2: Writing the compose file

The compose file allows us to configure the project container in the ways that will allow us to develop in it. So let’s begin by creating a compose.yaml file in the project directory and paste the following into it:

services:
  project:
    build: .
    ports:
      - 8080:8080
    volumes:
      - type: bind
        source: .
        target: /code

What does this compose file do?

First, it tells docker to create a new service called project for our project.

services:
  project:
    # ...

Next, it tells docker what folder to look for the Dockerfile in.

# …
    build: .
    # …

Next, it exposes the container’s port 8080 to the host environment:

# …
    ports:
      - 8080:8080
    # …

Finally, it bind-mounts the project directory into the docker container’s work directory (the “code” folder).

# …
    volumes:
      - type: bind
        source: .
        target: /code

Step 3: Setting up the dev container

To complete this step, install the VS Code Dev Containers extension. VS Code to open your project in docker containers.

Once the extension is installed, create a new file in .devcontainer/devcontainer.json, and paste the following into it.

{
    "name": "Containerized project",
    "dockerComposeFile": "../compose.yaml",
    "workspaceFolder": "/code",
    "service": "project",
    "extensions": [
        "ms-python.python"
    ]
}

Once you’ve pasted the contents into the file, open VS code’s command palette and type “Open Folder in Container” and select the Dev Containers option.

This will open a file picker to select the folder you want to open in the container, In this file picker, stay in (or navigate to) the project folder and open.

Next, VS Code will begin setting up the project container.

Once this is done, you will be able to work with the project files in the container like usual, and you would also have VSCode’s autocompletes, intellisense and suggestions with the packages that are installed in the container.
Conclusion
Being able to set up development environments in docker containers has saved me a lot of time in a surprising amount of scenarios, and I can’t find myself developing a multi-service project without docker.

You can learn more about how to extend Dev Container setups further by going through the docker compose documentation, or through the Dev Containers extension page.

Thanks for reading!

Overview of asynchronous functions in JavaScript

Chigozie Oduah — Fri, 10 Nov 2023 08:27:25 +0000

In this article, I'll explain what asynchronous functions are, the types there are in JavaScript, and I'll also give example.

So let's get to it!

What is an asynchronous function?

An asynchronous function is a type of function that doesn't block the thread that it's running on while it's doing its task.

To put it in context, when a normal function is running, the thread waits for the function to finish running before moving on with what it has to do. In asynchronous functions the thread doesn't wait for the function to finish running before moving on.

To get the results from an asynchronous function, or to know when it's finished with its task, you need to use event-driven programming. You'll see how this works in the next section.

Types of asynchronous functions

In JavaScript, there are two main types of asynchronous functions: Ones that use callbacks, and ones that use promises.

Ones that use Callbacks

Callbacks are functions that you pass to other functions as arguments. Take a look at this example:

setTimeout(function () {
  console.log("Hello!");
}, 5000);

The first argument in the setTimeout function is a callback. setTimeout is a built in asynchronous function for executing a callback function after a specific period.

Some asynchronous functions allow you to get their results through callbacks too. For example the fs.readFile method from the fs library:

const fs = require("fs");

fs.readFile("./package.json", function (err, buffer) {
  if (!err) {
    const content = buffer.toString();
    console.log(content);
  }
});

The fs.readFile method reads the file specified in its first argument. When the method is done with reading the file, it runs the callback specified in its second argument, passes the results from reading the file and any potential errors it might've ran into while reading the file.

Ones that use Promises

Promises are objects that asynchronous functions can use to signify that it will complete its task eventually. The function does this by returning the Promise object.

If an asynchronous function chooses to return a promise, you won't have access to it's the results of the function directly or immediately. But with the promise object, you can create an event listener that the promise object will trigger when the function is done with it's task.

To create an event listener, use the .then method of the promise object. Take a look at the fs.readFile promise version:

const fs = require("fs/promises");

const promise = fs.readFile("./package.json");

promise.then(function (buffer) {
  const content = buffer.toString();
  console.log(content);
});

Instead of returning the contents of package.json directly, fs.readFile returns a promise. With it's .then method, an event listener was set up.

The function you pass into the .then method is a callback function.

Conclusion

In this article, I just went over the basics of asynchronous functions in JavaScript.

There are lots of different and new concepts to still learn about asynchronous functions. So I hope this article gives you a solid beginning.

Thanks for reading!

Pinning in Rust

Chigozie Oduah — Mon, 03 Jul 2023 17:45:05 +0000

Pinning is a very confusing topic I encountered while programming in Rust. I tried hard to learn it, but the guides, articles, and videos I’ve seen are hard to understand. They usually involve having to know another complex concept in Rust, and that just made me go back and forth between other articles, videos, and guides on those other concepts.

In this article, I’ll filter out all those other concepts and focus solely on pinning. After reading this article, you’ll learn to apply it in your code and understand its use in other codes.

First, what is pinning?

Pinning is an essential feature in Rust. It is the process of locking the position of an object in memory. Pinning prevents your code from moving an object while it is using the object.

Pinning is a vital feature when you're working with code that points to other objects. Because objects tend to change their position in memory. And those changes cause any reference to the previous position to become null.

Objects changing memory location affects data structures like linked lists and a lot of asynchronous processes. The null references cause unpredictable behaviors.

How do you pin an object?

Pinning an object is simple. Rust provides a Pin struct for pinning objects. The struct is a part of Rust’s standard library; you can access it via std::pin::Pin.

Take a look at this example:

struct MyStruct {
    value: u32
}

fn main() {
    let my_struct = MyStruct{ value: 10 };
    println!("{}", my_struct.value);
}

This example contains a struct, MyStruct, that the main function uses in the following way:

Creating an instance of MyStruct as my_struct.
Printing my_struct.value to the terminal.

To pin my_struct, you need to do a few things:

Add a _pin field to MyStruct for storing a PhantomPinned object.
Pass my_struct to Box::pin to pin my_struct.

use std::marker::PhantomPinned;

struct MyStruct {
    value: u32,
    _pin: PhantomPinned,
}

fn main() {
    let my_struct = MyStruct {
        value: 10,
        _pin: PhantomPinned,
    };

    let pinned_struct = Box::pin(my_struct);

    println!("{}", pinned_struct.value);
}

I haven’t discussed Box, so let’s look into it. Box lets you manually allocate memory in the heap storage.

Rust has two types of memory that it uses for storing values in your code: stack and heap memory. If Rust can determine the size of an object at compile time it stores that object in the stack memory. If it can't determine the size of the object it stores the data in the heap memory.

That behavior is there because stack memory is rigid but very fast. While heap memory is flexible and extensive, but slow compared to stack memory.

With Box::pin() you can store an object in the heap memory and pin it in place.

This list contains a few more things you need to know about pinned objects.

Modifying a pinned object
The _pin field
The risks of using pinned objects

Let’s take a look at all of these in detail!

Modifying pinned objects

One of the things you’ll get stuck in immediately after pinning an object is trying to modify data on it. It can be frustrating, but there’s no need to worry. There’s a way to do it, but it involves some rule-breaking processes. So you have to do it in an unsafe block.

Let’s revisit the last example we had in the previous section. To follow along, I’ll paste it below:

use std::marker::PhantomPinned;

struct MyStruct {
    value: u32,
    _pin: PhantomPinned,
}

fn main() {
    let my_struct = MyStruct {
        value: 10,
        _pin: PhantomPinned,
    };

    let pinned_struct = Box::pin(my_struct);

    println!("{}", pinned_struct.value);
}

Let’s say we want to change the value of my_struct.value to 32. If we just try my_struct.value = 32, the compiler will generate an error message telling you that it's against the rules to change the value.

To change the value of my_struct.value, there are a few steps that you must follow:

First, collect a mutable reference to the pinned object with Pin::as_mut(&mut my_struct).
Then, use that mutable reference to reference the object stored in the pin with Pin::get_unchecked_mut(mut_ref).
Finally, use the reference to the object to modify the object however you like.

Any modifications you make will now reflect in the pinned object.

Let’s see how the code looks after following these steps.

use std::pin::Pin;

struct MyStruct {
    value: u32,
    _pin: PhantomPinned,
}

fn main() {
    let mut my_struct: Pin<Box<MyStruct>> = Box::pin(MyStruct {
        value: 10,
        _pin: PhantomPinned,
    });

    println!("{}", my_struct.value);

    unsafe {
        let mut_ref: Pin<&mut MyStruct> = Pin::as_mut(&mut my_struct);
        let mut_pinned: &mut MyStruct = Pin::get_unchecked_mut(mut_ref);
        mut_pinned.value = 32;
    }
    println!("{}", my_struct.value);
}

If you run the code, it displays the value of my_struct.value in the terminal before and after modifying it.

The `_pin` field

If you noticed, you had to add a _pin field to the struct in the first modifications to the code. Now, you may be asking yourself what the field is and what it does. That’s what we’ll cover in this section.

_pin is a field you place in the struct you want to pin. It tells the compiler that the struct should be pinned. When you apply the Box::pin() method to a struct without the _pin field, the method call may be successful, but it won’t pin the object in the memory. You can test this with this code:

use std::pin::Pin;

struct MyStruct {
    value: u32,
}

fn main() {
    let mut my_struct: Pin<Box<MyStruct>> = Box::pin(MyStruct {
        value: 10,
    });

    println!("{}", my_struct.value);

    my_struct.value = 32;   // without `_pin`, this works without any issue
    println!("{}", my_struct.value);
}

When you apply the _pin field to the struct and initialize it with PhantomPinned, the line 14 (my_struct.value = 32;) becomes invalid.

use std::pin::Pin;

struct MyStruct {
    value: u32,
    _pin: PhantomPinned,
}

fn main() {
    let mut my_struct: Pin<Box<MyStruct>> = Box::pin(MyStruct {
        value: 10,
        _pin: PhantomPinned,
    });

    println!("{}", my_struct.value);

    my_struct.value = 32;   // This will cause a compilation error
    println!("{}", my_struct.value);
}

If you look at the _pin field, you may also be asking why you need to initialize it with PhantomPinned. The answer is simple: PhantomPinned is a type Rust uses to enforce the pinning rules on an object. You should always apply PhantomPinned to the _pin field of a struct when you want to pin it. PhantomPinned doesn’t hold any value in memory and does nothing other than enforce pinning rules on the struct you apply it on.

What do you risk by using pinned objects?

One of the biggest problems with pinned objects is safety. Don’t get me wrong, pinning objects before using them in specific applications promotes safety. Now you might be wondering: I just said that their problem is with safety; what going on? The safety issue with pinned objects lies in using them.

You may have noticed that when modifying the pinned object, my_struct, we had to wrap the processes in an unsafe block. Surrounding the expressions with unsafe had a reason. As it turns out, you should be careful when tampering with a pinned object. If you’re not, you can risk causing undefined behavior and other problems to essential parts of your code.

Our example was simple, so there wasn’t much to risk. But you still need to wrap it in an unsafe block, even as it is.

Conclusion: why pin an object, then?

Now that you’ve gone through all that, the ultimate question remains. Why bother with pinning objects at all? This question is essential because pinning objects will hold no value without answering them.

To answer these questions, I have compiled a short list that states each of the reasons:

Pinning an object in Rust ensures that the object remains in a fixed location in memory (vital for asynchronous programming).
Pinning can help prevent data races and other concurrency issues from arising when multiple processes access the same data.
Pinning can also help improve performance by reducing the copying and moving of the code when working with asynchronous data.
Pinning ensures that certain types of data are always available in memory, even if the computer swaps out other parts of the program.

Handling request methods: Golang http library

Chigozie Oduah — Thu, 15 Jun 2023 21:07:29 +0000

Handling request methods in Golang's net/http library isn't as intuitive as you'd expect.

In the request, library there's a Method field that allows you to see what method a request uses.

func hello(w http.ResponseWriter, req *http.Request) {
  fmt.Fprintln(w, "Hello, world")
}

Starting with the example above, if you want the method to only respond to GET requests, add a conditional statement to make the request respond to only GET requests, and reject non-GET requests.

Take a look at an example of how the code will look after doing this:

func hello(w http.ResponseWriter, req *http.Request) {
  if req.Method == "GET" {
    fmt.Fprintln(w, "Hello, world")
  } else {
    w.WriteHeader(http.StatusMethodNotAllowed)
    fmt.Fprintf(w, "Cannot %s %s", req.Method, req.URL)
  }
}

You can apply this technique to any other type of request method, and you'll achieve the result you want.

Calling C++ functions from your Rust code

Chigozie Oduah — Sat, 10 Jun 2023 17:24:52 +0000

C++ provides an extern keyword allowing you to specify functions other programming languages, including Rust, can interact with.

Calling this function requires you to provide parts you want other languages to interact with in your C++ code, compile it, and link it to your Rust project. And, In this article, I’ll go into the details of doing it.

Why would you want to do this?

You can import from one language to another for several reasons. These reasons may include the following:

Efficiency: Functions written in one language may be more efficient than if you write them in the other language.
Readability: Sometimes, reading and writing functions in one language are more manageable than in the other.
Availability of support: One of the languages may have the necessary libraries you need to carry out a task that the other may not have.

The list goes on, but let’s look at the next section for now and learn how to import and bind C++ functions in Rust.

Calling C++ functions from your Rust code

In this section, I’ll show you how to run C++ functions from your Rust code.

To start, you need to prepare your C++ file. Let’s imagine you have a main.cpp file in your src/, and it contains this code in it:

// src/main.cpp
extern "C" {
  bool UniqueFunction(int a, int b) {
    return true;
  }
}

To prepare this C++ code, follow these steps:

Create a build.rs file in src/.

Copy the code below into build.rs:

// src/build.rs
fn main() {
cc::Build::new()
.cpp(true)
.file("src/main.cpp")
.compile("main.a");
}

Add a pointer to build.rs in Cargo.toml under [packages]
```
[package]
# ...
build = "src/build.rs"
```

build.rs uses the cc library, so install it by adding the package name under [build-dependencies] in Cargo.toml.

[build-dependencies]
cc = "1.0"

Now you can easily call UniqueFunction from your Rust code like below:

// src/main.rs
extern "C" {
  fn UniqueFunction(a: i32, b: i32) -> bool;
}

fn main() {
  unsafe {
    println!("Value: {}", UniqueFunction(23, 4));
  }
}

Can you call Rust functions from C++?

A short answer to this question is “Not easily.”To get C++ to call your Rust function is always different. Calling Rust functions from C++ varies depending on how you are calling the function and what your function does.

I’m not covering that in this article, but I’ll give you resources that may help.

Ownership And Borrowing In Rust

Chigozie Oduah — Wed, 11 May 2022 11:15:02 +0000

In this article, you will learn how ownership and borrowing works, and what they are in Rust.

Prerequisites

To follow through this article, you need to have at least a basic knowledge of Rust, and you need the Rust compiler installed in your system.

What is ownership

Ownership is a set of rules that regulates memory usage in rust programs. These rules are key to rust’s memory safety, despite the lack of a garbage collector. Ownership provides a way for the Rust compiler to track all allocated memory at compile time.

The following are the rules governing ownership:

Each value must have only one owner at any time: that means that if you attempt to store an owner in another one the previous one passes its value to the new owner and loses its value.
An owner can only exist in one scope: that means if you pass an owner to a function, the owner leaves its current scope and moves to the new function’s scope. The example below shows name being moved from main’s scope to greet’s scope:

fn main() {
    let name = "John".to_string();
    greet(name);
    println!("Name: {}", name);     // <- throws an error because it is out of scope
}

fn greet(name: String) {
    println!("Hello, {}", name);
}

Owners in Rust are similar to variables or constants in other programming languages.

Borrowing and References

Borrowing allows functions to reference owners from a scope without moving them to the new function’s scope. To borrow an owner, you first need to get a reference to it. To get the reference, you need the & operator:

fn main() {
    let name = "John".to_string();
    greet(&name);
    println!("Name: {}", name);
}

fn greet(name: &String) {
    println!("Hello, {}", name);
}

Borrowing the owner in a function lets you use its value without necessarily moving the owner to the new function’s scope.

Mutable References

My default, Rust doesn’t let you modify the value of a borrowed owner. For example, the following code won’t compile:

fn main() {
    let mut greeting = "Hello, ".to_string();
    add_name(&greeting);
    println!("{}!", greeting);
}

fn add_name(greeting: &String) {
    greeting.push_str("John");
}

To make the above example work, you need to retrieve a mutable reference to the owner:

fn main() {
    let mut greeting = "Hello, ".to_string();
    add_name(&mut greeting);
    println!("{}!", greeting);
}

fn add_name(greeting: &mut String) {
    greeting.push_str("John");
}

To specify a mutable reference to an owner prefix the owner name with &mut. Like in the 3rd line in the code above. A mutable reference allows a function to borrow and mutate an owner.

Conclusion

This article focuses on how ownership and borrowing works, and how to use them. I’ve compiled some links that can help you with any further research you may want to make:

Overview of ExpressJS

Chigozie Oduah — Sat, 07 May 2022 20:49:38 +0000

Introduction

This article covers the basics of the ExpressJS framework, and how to build RESTful APIs using the Express framework in JavaScript. The Express framework makes fast, scalable, and complex APIs very easy to build and maintain.

Prerequisites

To fully understand this article you need the following:

Node installed on your system.
yarn or npm package manager installed.
Working knowledge of JavaScript.
An understanding of the REST architecture

What is Express?

Express is a simple and lightweight JavaScript framework for building RESTful APIs. This framework provides a thin layer of abstraction over the Node’s module, and provides utilities for building more complex applications.

REST APIs are APIs that adhere to the REST architectural style requirements. REST APIs provide its interface via the HTTP protocol. These types of APIs are useful in building client-side applications that need to interact with a server.

Features of Express

Express provides a lot of benefits to you as a developer, which are the as follows:

Lightweight: The Express library is very small and light, which means that the library won’t take up much space once installed, and the JS runtime won’t take much time loading up the library.
Flexible: The Express framework is a light abstraction over the Node JS runtime, which means using Express doesn’t stop you from using native JS functionality in your application. The Flexibility also allows you to install and use all libraries in Node JS.
Performance: The Express framework does not reduce the performance of a normal node application. A REST API created using express runs just as fast as an API created using.
Robustness: The Express framework presents a lot of usable tools and utilities that can be used to build large scale and complex APIs.

Setup Express

There are two ways to create express applications, which are the following:

Installing express into an empty project.
Using the express-generator script.

Empty project

To install into an empty project, start by initializing the project:

npm init

Then install the library into the project:

npm install express

After installing the express library, create an index.js file in the project root. By convention, all Node applications always start with an index.js file.

Express Generator

To create a project using the express-generator tool, use the following command:

npx express-generator

The above command creates the application in the current directory.

To create an express project into a new application use the following command:

npx express-generator my-express-app

This command creates a new folder named my-express-app and creates the application in it.

After creating the application skeleton install the project’s dependencies:

npm install

A Simple API using Express

Endpoints are routes of a URL that points to resources served by an API. Endpoints help in organizing REST API interfaces.

To create this application, write the following into the index.js file:

// import the library
const express = require('express');

// create an express application
const app = express();

let recipient = "World";

// register a middleware to all the routes
app.use(express.text());

// create a simple endpoint
app.get("/greet", (req, res) => {

  res.send(`Hello, ${recipient}!`);  // <- the response
});

// create a simple endpoint to change the recipient
app.post("/change-recipient", (req, res) => {

  recipient = req.body;              // <- the body of the request
  res.send(`Hello, ${recipient}`);   // <- the response
});

// launch application on port 8080
app.listen(8080);

console.log("Server running..."); // <- display "Server running…" on the console

To create an endpoint, you need to create the express application first:

// import the library
const express = require('express');

// create an express application
const app = express();

Then you use app.use method to register an express middleware called express.text():

app.use(express.text());

A middleware is a callback function that the app executes before calling your endpoint’s callback function. Middlewares help in processing requests before finally sending a response.

The express.text() middleware function returns an anonymous function, which is the middleware for the application. The app.use() method registers the middleware to all the routes.

Then you create a GET endpoint with the app.get() method:

app.get("/greet", (req, res) => {

  res.send(`Hello, ${recipient}!`);  // <- the response
});

The endpoint in this example is located on the /greet route, and the callback function passed as the second argument is executed whenever you send a request GET to the route

The res.send() method is used to send a response back to a client.

And create a POST endpoint with the app.post() method:

app.post("/change-recipient", (req, res) => {

  recipient = req.body;              // <- the body of the request
  res.send(`Hello, ${recipient}`);   // <- the response


});

The endpoint in this example is located at the /change-recipient route. To get the request body, use the req.body property from the req argument.

This endpoint changes recipient and return a hello message directed to the new recipient.

Before you can run your API you need to specify the port it will run on:

app.listen(8080);

Conclusion

This article covers what express is and its features, how to set up express, and how to create a simple express API. If you want to learn more about the express framework and RESTful APIs be sure to check the following links:

Overview of Actix Web in Rust

Chigozie Oduah — Fri, 06 May 2022 17:35:15 +0000

Introduction

This article presents the actix-web framework for building restful apis with Rust. The actix-web framework helps you to quickly build fast and efficient restful apis with the Rust programming language.

Prerequisites

To understand this article, you need to have a working knowledge of Rust, and you need to have Rust installed in your computer.

What are REST APIs?

REST APIs are APIs that conforms to the Representational State Transfer design principle. REST APIs allow the use HTTP requests to control data and resources on a server. These APIs are very useful in building interfaces for other applications to access the resources on a server.

What is Actix Web?

Actix Web is a micro-framework for building REST APIs in Rust. This framework is small, simple, powerful, and fast. It is built with Rust, which is a reason for its speed.

It is very easy to pick up this framework, especially if you are a Rust programmer. If you don’t have much experience with Rust, It would be a little more challenging when you go into the details too early. This framework is very easy to start with, but takes some time to get used to it.

Why use Actix Web?

The following are the reasons to be using Actix Web for your APIs:

It is type safe, which means that it is strongly-typed, everywhere.
It comes with a lot of features, like static serving, middlewares, WebSockets and so on.
It is efficient, which means a single server can serve billions of users without leaving a large footprint.
It is pragmatic, which means it is easy to pick up for the majority of Rust developers.

A Simple API with Actix Web

In this section, you will learn how to create a simple API with Actix Web. This example will give you a basic understanding of how we create RESTful APIs using Actix Web.

Before creating the API, you need to initialize your project and add the version 4.0.1 Actix Web Dependency in your Cargo.toml file.

actix-web = "4.0.1"

After adding the above to the Cargo.toml file, build the project to install the library and all its dependencies using the command below:

cargo build

When the project is built, navigate to the src folder, and copy the below into the main.rs file.

use actix_web::{
    HttpServer,
    App,
    web,
    get,
    post,
    Responder,
};

#[get("/")]
async fn greet() -> impl Responder {
    "Hello"
}

#[post("/hello-post")]
async fn hello_post() -> impl Responder {
    let greeting = "Hello";
    format!("{}, from the post method", greeting)
}

async fn route_hello() -> impl Responder {
    let greeting = "Hi";
    format!("{greeting}, from route-hello")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running...");
    HttpServer::new(|| {
      // Create and return an new app
        App::new()
            .service(greet)
            .service(hello_post)
            .route("/route-hello", web::get().to(route_hello))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

The program above creates three routes when you run the program.

The first route is the root ( “/” ). When you send a get request to this route, it responds with “Hello”.

The second route is “/hello-post”. When you send a post request to this route, it responds with “Hello, from the post method”.

The third route is “/route-hello”. When you send a get request to this route, it responds with “Hello, from route-hello”

The third route is created using a more manual method of creating an API route. If you are building your API in a single file ( without splitting code into modules ), I recommend using the first two methods of creating routes. Tracking which function belongs to a route gets harder when all the functions are in a single file.

Path Parameters

Path parameters are used to specify the category of data to get or manipulate on the API. An example program that uses the path parameters is below:

use actix_web::{
    HttpServer,
    App,
    web,
    get,
    Responder,
};

#[get("/hello/{name}/{age}")]
async fn hello_1(path: web::Path<(String, u32)>) -> impl Responder {
    // The method call below moves "path" out of scope
    let (name, age) = path.into_inner();
    format!("Name: {name}\nAge: {age}")
}

#[get("/{person}/greet")]
async fn hello_2(path: web::Path<(String, )>) -> impl Responder {
    // path is borrowed here, which means you can use it again and again
    let person = &path.0;
    format!("{person}: Hello!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(hello_1)
            .service(hello_2)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

The program above creates three routes when you run the program.

The first route is “/hello/{name}/{age}”. If you send a get request to “/hello/John/23”, you will receive the response below.

Name: John
Age: 23

The second route is “/{person}/speak”. If you send a get request to “/Hannah/speak”, you will receive the response below.

Hanna: Hello!

State variables

Rust doesn’t allow global variables, which means that you can’t have a general application state in the normal way. Application state is useful for sharing data between the API routes. To have an application state, create a struct variable and register it to the application.

An example API that uses an application state is given below.

use actix_web::{
  HttpServer,
  App,
  get,
  web,
  Responder,
};

// The App State's structure
struct AppState {
  name: String,
  numbers: Vec<u32>,
}

#[get("/")]
async fn display(data: web::Data<AppState>) -> impl Responder {
  // data is a borrowed version of the state
  format!("Name: {}\nNumbers: {:?}", &data.name, &data.numbers)
}

#[get("/{query}")]
async fn access_data(path: web::Path<(String, )>, data: web::Data<AppState>) -> impl Responder {
  let query = &path.0;

  if query == "list" {
    return format!("{:?}", &data.numbers);
  } else {
    return "not found".to_string();
  }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
  HttpServer::new(|| {
    App::new()
      .app_data(web::Data::new(
          // Register the app state
          AppState {
            name: "numbers".to_string(),
            numbers: vec![10, 20, 30],
          }
      ))
      .service(display)
      .service(access_data)
  })
  .bind(("127.0.0.1", 8080))?
  .run()
  .await
}

The app state makes it possible to use the “name” and “numbers” variables across all routes.

Mutable State variables

The application state created in the last section is immutable, which means it cannot change. By default, Rust makes these variables immutable to prevent them from changing at runtime. To make the app state mutable you need to use Mutex.

Mutex is a structure that is provided by the standard library, and can be used to add mutable state variables to the application’s general state.

To create a mutable state variable, we create a normal struct and initialize each field as a Mutex<T> type. The Mutex structure is generic, and can be initialized with any other data structure.

An example of a simple API with mutable state variables is given below:

use std::sync::Mutex;
use actix_web::{
  HttpServer,
  App,
  get,
  web,
  Responder,
};

struct AppState {
  numbers: Mutex<Vec<u32>>,
}

#[get("/add/{number}")]
async fn add_number(path: web::Path<(u32, )>, data: web::Data<AppState>) -> impl Responder {
  /* Add the number from the path parameter to the end of "numbers"
     in the app state */

  let mut number = data.numbers.lock().unwrap();
  let number_to_add = path.into_inner().0;
  number.push( number_to_add );

  format!("Current list: {:?}", number)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {

  // Mutable app state should be created outside
  let state = web::Data::new(AppState {
    numbers: Mutex::new(vec![10, 20, 30])
  });

  HttpServer::new(move || {
    App::new()
      .app_data(state.clone())   // <- move created app state to closure and register
      .service(add_number)
  })
  .bind(("127.0.0.1", 8080))?
  .run()
  .await
}

In the main function of the program above, the state variable was created outside the closure because web::Data uses an Arc internally. Creating the app state prevents the app from creating more Arc’s.

Conclusion

If you want to understand more about the Actix Web framework be sure to check its documentation. I hope you found this article very useful.

Thanks for reading! And Happy Hacking!

Structs in Rust

Chigozie Oduah — Tue, 03 May 2022 15:55:34 +0000

Structs are one of the most useful features that Rust provides. They give programmers the ability to model complex data structures. And, they also enable programmers to abstract objects involved in a problem. In this article, we'll go through their basics and see how we can improve our codes with them.

Prerequisites

Before you fully understand this article it will be nice to have the following.

You should have a basic understanding of Rust
You should also have Rust version 1.0 upwards installed

What is a Struct?

This is a keyword used in Rust for building data structures. These structures are used to group related data together. Being able to hold related data can make development speed and runtime of your code much faster. Aside from improving those, they also help in debugging and in understanding how a piece of data interacts with other pieces.

Data structures are the core of software development. They help in organizing data within our code. With the right data structures, our code can easily either take up less memory space, less runtime or both. This is especially useful when trying to create scalable systems that serve millions of users at once.

Types

There are three different types of structs in rust, they are field structs, tuple structs and unit structs.

Field Structs

In this type of structs, each field has a name and the type of data they hold. This is like the regular structs you see in C. In Rust, the way we define them is by using the struct keyword. For example, we will be creating a Person struct. This struct has the properties name and age.

struct Person {
    name: String,
    age: u8,
}

In this snippet, the properties are called fields. The fields of these structs are defined in a pair of curly braces "{ }" and separated by a comma.

After we have defined the struct, we can then initialize it. Initialization is the process of creating an instance of a struct. The struct is like a blueprint, and the instance is the adaptation of the blueprint. These are similar to objects in object-oriented programming. Although it's similar, there are still some differences. Because Rust is not that type of language, some core features like Inheritance, construction and deconstruction are not supported.

To initialize the struct above we do the following.

let person = Person {
    name: "John".to_string(),
    age: 23,
};

In this example, we initialize the name of the person as "John" and set the age to 23. We can now access the fields in this struct. We get the name of the person using person.name and the age using person.age.

println!("Name: {}\nAge: {}", person.name, person.age);

And we can have a full program like so.

struct Person {
    name: String,
    age: u8,
}

fn main() {
    let person = Person {
        name: "John".to_string(),
        age: 23,
    };

    println!("Name: {}\nAge: {}", person.name, person.age);
}

When we run this in the console, we get the following output.

Name: John
Age: 23

Tuple Structs

These are structs that hold data in a tuple-like format. A tuple is a collection of data in series. The data stored can either be of similar or different data types. This structure generally gives a name to a tuple structure. Using the person example, we will be declaring the tuple struct of it.

struct Person (String, u8);

Now that we have created it, we can initialize it. The initialization process of this structure is similar to a normal tuple. The only difference is that we put the name of the struct before the parentheses.

let person = Person ("John".to_string(), 23);

We access the elements in this struct using the position they are in inside the tuple. This is the same with normal tuples. We access the person's name using person.0 and the age using person.1.

println!("Name: {}\nAge: {}", person.0, person.1);

Using this concept, we can create a simple program like so.

struct Person (String, u8);

fn main() {
    let person = Person ("John".to_string(), 23);

    println!("Name: {}\nAge: {}", person.0, person.1);
}

Unit Structs

These types of structs do not hold any data. This makes their size zero bytes. It is useful when we want to group related functions together without necessarily holding any data. You will see how we can use them to do that later in this tutorial.

We declare them using the struct keyword like so.

struct Unit;

After declaring, we can now initialize it with the name of the struct below.

let unit_struct = Unit;

Mutability of Structs

Aside from creating and using structs, Rust also gives us the ability to change and modify them. This is a useful feature if our struct will need to change while our code is running.

A good example of this would be activating a user's account. The user's account is going to be a data structure. In this structure we will have a name and an is_active field.

struct User {
    name: String,
    is_active: bool,
}

We initialize it using the mut keyword. This keyword is short for mutable. Meaning we are making our variable mutable. Meaning that it is open to modifications. Without it, Rust will not allow the variable to change once it is initialized.

let mut user = User {
    name: "John".to_string(),
    is_active: false,
};

After initializing this struct as mutable, we can then modify the is_active field.

user.is_active = true;

We can now have a simple code like this.

struct User {
    name: String,
    is_active: bool,
}

fn main() {
    let mut user = User {
        name: "John".to_string(),
        is_active: false,
    };

    println!("{} is active: {}", user.name, user.is_active);

    // Perform some processes needed
    // to activate the user's account.
    // Then activate it
    user.is_active = true;
    println!("{} is active: {}", user.name, user.is_active);
}

When we run the above in our terminal, we get the output below.

John is active: false

John is active: true

Passing and Returning From Functions

Structs can also be passed into functions and returned from them. This improves the level of abstraction we can make in our code. A higher level of abstraction can be really helpful in making your code easier to understand. By abstracting our code, we are grouping lower-level actions into a single high-level operation. For example, we will be creating a function called create_person. That function will create a new instance of the struct whenever it is called.

fn create_person(name: String, age: u8) -> Person {
    return Person {
        name: name,
        age: age,
    };
}

With this in our code, we will be able to create an instance by passing the name and the age to our function. Then, our function will return an instance of the Person struct. In Rust, there is a shortcut we can use to return data from functions. That is, to remove the semi-colon of the last expression. If we do this there, we will not need to use return.

fn create_person(name: String, age: u8) -> Person {
    Person {
        name: name,
        age: age,
    }
}

To pass a struct to a function, we set the data type of the argument to the name of the struct. For example, we will create a display function that prints the struct to the terminal.

fn display(person: Person) {
    println!("Name: {}\nAge: {}", person.name, person.age);
}

In this example, what we did was to create an argument person with struct-type Person. This is where we will be passing our struct to. Then, we can access its elements. Now we can have a full program.

struct Person {
    name: String,
    age: u8,
}

fn main() {
    let person = create_person("John".to_string(), 23);
    display(person);
}

fn create_person(name: String, age: u8) -> Person {
    Person {
        name: name,
        age: age,
    }
}

fn display(person: Person) {
    println!("Name: {}\nAge: {}", person.name, person.age);
}

Using impl

Sometimes, when we create functions that interact with our structs they usually get mixed up with other functions. This disorder makes it hard to easily understand what our code does. Fortunately, Rust allows us to group functions directly related to the struct together. It is done using the impl block. For example, we start with our struct.

struct Person {
    name: String,
    age: u8,
}

Then we have an impl block to define the functions we will be using with this struct.

impl Person {
    fn create_person(name: String, age: u8) -> Person {
        Person {
            name: name,
            age: age,
        }
    }

    fn display(&self) {
        println!("Name: {}\nAge: {}", self.name, self.age);
    }
}

In the snippet above, we added the name of the struct we are modifying immediately after the impl keyword. This tells Rust that any function declared in the block will be attached to the struct.

In our example, we created two types of functions for the struct. The first one is a static function and the second is a method. The static functions are functions that are accessed directly from the struct and not its instance. The static function in our code is create_person and the way we access it is as follows.

let person = Person::create_person("John".to_string(), 23);

Methods are a type of function that belongs to an instance of the struct. The way we declare a method is by adding &self as the first argument of the function. And then we can access the elements of the struct instance that calls it using self.property_name. The method in our code is called display and the way we assess it is as follows.

person.display();

A simple program based on the previous example is.

struct Person {
    name: String,
    age: u8,
}

impl Person {
    fn create_person(name: String, age: u8) -> Person {
        return Person {
            name: name,
            age: age,
        };
    }

    fn display(&self) {
        println!("Name: {}\nAge: {}", self.name, self.age);
    }
}

fn main() {
    let person = Person::create_person("John".to_string(), 23);
    person.display();
}

Finally, we can use the unit structures to hold related functions. The functions will then be accessed like a namespace. These functions are static and will be created in an impl block. For example, have a simple one like this.

struct SomeFunctions;

impl SomeFunctions {
    fn print_hello() {
        println!("Hello");
    }

    fn print_goodbye() {
        println!("Goodbye");
    }
}

Which can then be accessed like so.

SomeFunctions::print_hello();
SomeFunctions::print_goodbye();

Conclusion

In this tutorial, we walked through the process of creating a data structure using struct. Then, we also added more functionality to the structs. And, we saw how we can use empty structs to create modules to organize our code.

I hope this helps in understanding how structs work in rust and how we can use them to improve the quality of our code.

Thanks for reading and happy hacking!

Build a GraphQl server with NodeJS and Express

Chigozie Oduah — Tue, 03 May 2022 15:51:19 +0000

Introduction

In this article, you will learn how to build GraphQl servers using Express in NodeJS. GraphQl is a quick, and easy way to build backends that communicate effectively with frontends, and control resources.

Prerequisites

This article only covers the basics of GraphQL, which means you have to have knowledge of NodeJS and ExpressJS to fully understand the contents.

What is GraphQL?

GraphQL is an open-source data query language, and runtime for creating APIs and responding to queries with existing data. GraphQL makes it very simple to create backend APIs. To retrieve all the data an app needs from the server, it only needs a single query to a GraphQL API instead of sending multiple requests to more than one endpoint.

GraphQL APIs can be created in common programming languages, like Python, Java, JavaScript, Scala, Ruby, and a lot more. Any type of application can interact with a GraphQL API, as long as it can make requests to an endpoint.

Benefits of GraphQL

GraphQl APIs have numerous benefits over RESTful APIs. They are:

Getting the exact data needed: In GraphQL, we can get exactly what we need from the server using a query. Unlike REST APIs that give you all the data that can be gotten from an endpoint, which makes communication between server and clients very slow and inefficient.
Retrieve large amounts of data with a single query: With GraphQL APIs, we can get all the data that our app needs in a single request, unlike most REST APIs, which require loading from multiple endpoints.
Rich Type system: GraphQL APIs don’t use endpoints for organization. Instead, they are organized in types and fields, which helps to give helpful messages if the server encounters any error. GraphQL uses a single endpoint, usually named “/graphql”, that a client uses to communicate with the backend.
Uniform API design: GraphQL APIs have a uniform design across multiple programming languages. GraphQL APIs don’t need much modifications to be ported from one programming to another. In GraphQL, we use a schema to describe what our API can do. Designing objects that fit the schema is easy to do in GraphQL.

Building a RESTful API with Express

Before building our API using GraphQL, we will build its REST version The API we create will have two endpoints:

/say-message, which responds with a message from the server.
/change-message, which changes the message on the server.

To create this API, we perform the following steps in our already initialized project folder:

Install the express package using any of the following commands:

Package Manager	Command
Yarn	npm install express
Npm	yarn add express

Create an index.js file, and write the following into it:

// import the express library
const express = require('express');


// create the express application
const app = express();


// register the "express.text()" middleware to parse incoming text requests
app.use(express.text());





// This variable stores a string that the endpoints below manipulate
let text = "Hello, World";


// create an endpoint to get the `text` string
app.get("/say-message", (req, res) => {


  // send a response with text
  res.send(text);

});

// create an endpoint to change the `text` string
app.post("/change-message", (req, res) => {


  // change the text of "text" variable to the one sent in the request
  text = req.body;


  // send a response with text
  res.send(text);

});





// Run the server on localhost port 8080
app.listen(8080, () => console.log("Server running...."));

If we run the following requests in our frontend, we get the following responses from the server:

Action

Frontend request

Response

Getting the message from the server

fetch("http://localhost:8080")

.then(req => req.text())

.then(message => console.log(message));

Hello, World!

Changing the message on the server

// change the message

fetch("http://localhost:8080", {

'method': 'POST',

'headers': {

'Content-type': 'application/text',

'body': 'Humans'

})

.then(req => req.text())

.then(message => console.log(message));

// get the message

fetch("http://localhost:8080")

.then(req => req.text())

.then(message => console.log(message));

Hello, Humans!

Building an API with GraphQL and Express

In this section, we will build the GraphQL version of the API we built above. To build our API, we have to install the following libraries:

graphql, to use core graphql features in our code.
express, to build the graphql endpoint.
express-graphql, to use graphql in an express application.

To install the libraries above, we use any of the following commands:

Package Manager	Command
Yarn	yarn add express graphql express-graphql
Npm	npm install express graphql express-graphql

Once we have the libraries installed, we create an index.js file and copy the following into it:

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

let schema = buildSchema(`
  type Query {
    message: String
  }

  type Mutation {
    changeMessage(message: String): Boolean
  }
`)

class Root {
  text = "Hello, World!";

  message() {
    return this.text;
  }

  changeMessage({ message }) {
    this.text = message;
    return true;
  }
}

const app = express();

app.use('/graphql', graphqlHTTP({
  graphiql: true,
  schema: schema,
  rootValue: new Root(),
}))

app.listen(8080, () => {
  console.log("Server running...");
})

The following is an explanation of the program above:

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

In the snippet above, we imported the following:
- express, a constructor function for creating backend applications
- graphqlHttp, an express middleware function for using graphql in the application
- buildSchema, a function from graphql that creates a schema using the schema language

let schema = buildSchema(`
  type Query {
    message: String
  }

  type Mutation {
    changeMessage(message: String): Boolean
  }
`)

In the snippet above, we built our schema using the graphql schema language.In GraphQL, a schema is a description of the requests that a client can make to the backend. The Schema defines all of the queries and mutations that clients can make. Queries return data from the server, while mutation changes data on the server.

class Root {
  text = "Hello, World!";

  message() {
    return this.text;
  }

  changeMessage({ message }) {
    this.text = message;
    return true;
  }
}

In the snippet above, we create a class that defines the methods for the schema. Just having our schema is not enough, we also need to implement it. We use a class to create the interface between our backend and GraphQL. This class defines methods that respond to a specific request made to the api.

const app = express();

app.use('/graphql', graphqlHTTP({
  graphiql: true,
  schema: schema,
  rootValue: new Root(),
}))

In the snippet above, we create our application by calling the express factory function. Then we register the graphqlHTTP middleware function to the /graphql endpoint. In the graphqlHTTP middleware function, we pass an object that contains the following:
- graphiql, to enable a GUI, which looks like the image below, for testing graphql queries.
- schema, to register the schema that we created.
- rootValue, to register the root object for graphql.

In the interface above, if we make the following queries in the order on the table below, we will get the below responses:

Query

Response

query {

message

}

{

"data": {

"message": "Hello, World!"

}

mutation {

changeMessage(message: "Humans")

}

{

"data": {

"changeMessage": true

}

query {

message

}

{

"data": {

"message": "Hello, Humans!"

}

In GraphQL, a request can either be a query, or a mutation, but not both, which means you cannot send a request like the below:

mutation {
  changeMessage(message: "Humans")
}
query {
  message
}

The table below represents the schemas, and queries and classes for different types of ways we can create and interact with GraphQL applications.

Type

Request body

Schema

Basic class

Single Query

query {

message

}

type Query {

message: String

}

class Root {

message() {

…

}

Multi Query

query {

message

number

}

type Query {

message: String

number: Int

}

class Root {

message() {

…

}

number() {

…

}

Nested Multi Query

query {

message

extraData {

number

}

type Query {

message: String

extraData: ExtraData

}

type ExtraData {

number: Int

}

class Root {

message() {

…

}

extraData() {

…

return new ExtraData();

}

class ExtraData {

number() {

…

}

Single Query With Arguments

query {

message(text: "Hi")

}

type Query {

message(text: String): String

}

class Root {

message({ text }) {

…

}

Single Mutation

mutation {

message(text: "Hi")

}

type Mutation{

message(text: String): String

}

class Root {

message({ text }) {

…

}

Multi Mutation

mutation {

message(text: "Hi")

age(number: 18)

}

type Mutation {

message(text: String): String

age(number: Int): Int

}

class Root {

message({ text }) {

…

}

age({ number }) {

…

}

Nested Multi Mutation

mutation {

message(text: "Hi")

properties {

age(number: 18)

}

type Mutation {

message(text: String): String

properties: Properties

}

type Properties {

age(number: Int): Int

}

class Root {

message({ text }) {

…

}

properties() {

…

return new Properties();

}

class Properties{

age({ number }) {

…

}

Conclusion

In this article, we covered the basics of creating APIs with Express, the GraphQL framework and creating GraphQL based APIs. GraphQL is a quick and easy way to join both frontend and backend applications together. I hope this article helps to understand creating APIs with GraphQL better. To further your knowledge on the subjects you can use the following links:

Forem: Chigozie Oduah

Intentional Exercise Hacker 101 CTF writeup

Getting Started

App analysis

Technical analysis

AndroidManifest.xml

MainActivity.smali

Web server

Exploitation

Guess password easy Google beginner's quest CTF 2026 write up

Developing a projects in docker containers

Prerequisites and assumptions

What project are we working with?

Step 1: Writing the dockerfile

Step 2: Writing the compose file

Step 3: Setting up the dev container

Overview of asynchronous functions in JavaScript

What is an asynchronous function?

Types of asynchronous functions

Ones that use Callbacks

Ones that use Promises

Conclusion

Pinning in Rust

First, what is pinning?

How do you pin an object?

Modifying pinned objects

The _pin field

What do you risk by using pinned objects?

Conclusion: why pin an object, then?

Handling request methods: Golang http library

Calling C++ functions from your Rust code

Why would you want to do this?

Calling C++ functions from your Rust code

Can you call Rust functions from C++?

Ownership And Borrowing In Rust

Prerequisites

What is ownership

Borrowing and References

Mutable References

Conclusion

Overview of ExpressJS

Introduction

Prerequisites

What is Express?

Features of Express

Setup Express

Empty project

Express Generator

A Simple API using Express

Conclusion

Overview of Actix Web in Rust

Introduction

Prerequisites

What are REST APIs?

What is Actix Web?

Why use Actix Web?

A Simple API with Actix Web

Path Parameters

State variables

Mutable State variables

Conclusion

Structs in Rust

Prerequisites

What is a Struct?

Types

Field Structs

Tuple Structs

Unit Structs

Mutability of Structs

Passing and Returning From Functions

Using impl

Conclusion

Build a GraphQl server with NodeJS and Express

Introduction

Prerequisites

What is GraphQL?

Benefits of GraphQL

Building a RESTful API with Express

Building an API with GraphQL and Express

Conclusion

The `_pin` field