How It Works | Northern Kyber CTF Platform

A Northern Light in Cyber

Get Started

About Us

How It Works

Get Started

About Us

How It Works

Classes

The first thing you do is create a Class This is an easy way to seperate groups of students. You may have some that are more advanced than others, creating a class allows you to create different flags for each group of students.

Contests

The Contests themselves are super simple, they are the main hub that gives access to your flags. Contests are created with a title and a description of the contest itself. Below is their different states that you can change depending on if you want to allow your students access to the flags.

Active

Lets students access
Counts towards leaderboards and stats

Unactive

Does not let students access at all
Deactivating makes the contest disabled by default

Practice

Lets students access
Does not count towards leaderboards and stats

Disabled

Does not let students access at all
Great way to add flags without the students looking at them yet

Flags

Creating your own flags is the crutch of any CTF. Whether it be a rather simple challenge or a more complex one, you are able to do it with our platform. Below is the checklist of creating a flag along with which ones are required for each flag and which are optional.

Basic Info

Hints

File Tree

Extra Configurations

Basic Info

Required: name, description, inject, path / env name, contest

These are the basics of every flag. The name of the flag must be unique per contest meaning, you cannot have the same name for two different flags in the same contest. The inject field is how the flag gets placed into the environment. More on that later on below.

Hints

Optional: up to 3 per flag

These are used to guide the students through the challenge to find the flag. They do not hinder on the student at all when used. No penalties, no time deduction, nothing in that realm at all, just some extra help if needed.

File Tree

Optional: folders and files

This is where you can add any files or folders into the environment as you would like. There are two ways to insert files: a drag and drop from your file explorer or use the file editor to create a brand new file. Any kind of file can be dropped into the environment, there is also syntax highlighting for some file extensions inside the editor.

Extra Configurations

Optional: fully customizable tool

This is what makes our platform super unique and customizable the way it is. There is a bash script which runs to set up every environment. This script is fully customizable by you allowing any kind of challenge to be done as long as you can script it.

Also in this section is a checklist of commands. Some commands are simple ones like: gcc wget python3 java nano These are commands that are available inside the environment and can be checked to be included or not inside of the environment. For example, if you don't want your students to be able to use nano then you can disable it with the checklist. This will cause some code to show up in the script, but do not worry it cannot be edited by you so you don't have to worry about deleting it accidentally.

Testing

With any good software or anything that's created on the fly, you have to be able to test it. That's why we allow testing of flags right after creation to make sure what you wanted to create actually happened. Any errors that happen while running the bash script is right there inside the terminal you are testing on for easy debugging.

Placing The Flag

Flags can be placed using two distinct methods. Depending on how you want your students to find them. Either way you pick, the flag itself is in the format of NKCTF$:{ } Where inside the braces, is the hash itself which is unique to each student and challenge. This prevents reuse of flags and sharing.

File Based

Use Cases: file discovery, reverse engineering, permission based access

This is the easiest way to insert a flag. You provide the name of the file where you want the flag to go. Somewhere in the file, there must be the placeholder [FLAG] which we automatically replace once the challenge starts up. This method works with any file type (.txt, .py, .cpp, etc).

Environment Variable

Use Cases: hidden config, stealthy or logic based challenges, dynamic apps

The flag hash can also be placed as an environment variable within the environment itself. This way opens the door to more clever ways you can access the flag. You also have the ability to name the variable. To prevent bypassing the challenge itself, commands like printenv are disabled by default.

In order to disable commands like printenv we simply overwrite what the command itself does. This shows up inside the bash script automatically so you do not have to worry about it or do it yourself at all. When disabling other commands like: gcc nano python3 java This is what is shown in the bash script so don't be alarmed when you see it. This section is not editable so you don't have to worry about accidentally deleting it. Below is an example of when choosing to add the flag via an environment variable.

bash

1#!/bin/bash
2
3for cmd in printenv env; do
4    echo -e "#!/bin/bash\necho \"$cmd has been removed\"" > /override/bin/$cmd
5    chmod 555 /override/bin/$cmd
6    ln -sf /override/bin/$cmd /usr/local/bin/$cmd
7done
8# this is where you start adding whatever you would like

Terminals

The Terminal itself is pretty flexible but there are a few security measures inside each one. The user has no way to switch to the Root user. This is so escaping the Terminal is not possible (at least a lot less likely, bugs happen).

The / Directory cannot be changed by the user. Commands like sudo can only be used inside of the user's home directory with specific commands also to mitigate escaping. The Bash Script however does run as Root if you want to hide something there for example. Students can investigate the root directory, they just cannot change anything.

* All of these are currently in experimentation to see what works best, this is subject to change. *

What is here to stay however are our custom commands These are commands inserted into every container by us for you to use. They are designed to be simple to use for a simple purpose. Each one can be disabled if needed. To see all of our available commands inside the terminal just run NK-commands. There are plenty of them but an example is our rc command shown below.

shell

1  ===== Rotation Cipher =====
2
3  Goal:
4    rotate the characters of a string a specific amount
5
6  Usage:
7    rc <string | file_path> <shift_amount>
8
9  Examples:
10
11    rc "abc def" 2
12
13    Output:
14      cde fgh
15
16    rc "abc def" -2
17
18    Output:
19      yza bcd

Example Challenges

There are many different types of challenges you can create. Some may require specific knowledge of a program or cipher. Some may be super simple and just use some basic linux commands. Either way you can do it all with our cutomized tools.

The most basic example you can have is just giving the flag directly to the user. You can do so in a number of ways. One way, is to have a file with the placeholder [FLAG] inside a file so the flag gets placed there and just let the user use the cat command to see the contents of the file itself.

text

1here is the flag: [FLAG]

shell

1NKCTF@you:~$ cat flag.txt
2here is the flag: NKCTF$:{a9eR2}

There are a multitude of ways of doing this. You can also take advantage of the bash script and straight up give the user the flag right off the bat. For example, if you set an environment variable named FLAG_HASH in the script you can put the following which will run as soon as the user starts the challenge.

bash

1#!/bin/bash
2
3echo $FLAG_HASH

shell

1NKCTF$:{a9eR2}
2NKCTF@you:~$

Another easy way to hand over the flag, or add some logic, is by taking advantage of the bash script. Here, is an example of using binary via a cpp file. If we add the flag by using the env var FLAG_HASH we can then just add the cpp file that grabs that env var and prints it when the compiled cpp is ran. Using the env var lets printenv be disabled.

cpp

1#include <iostream>
2#include <cstdlib>
3using namespace std;
4
5int main() {
6	const char* var = getenv("FLAG_HASH");
7	cout << "here is the flag: " << var << endl;
8}

We can then take advantage of the bash script by compiling the cpp file and deleting the original source code. This way, the user cannot use commands like cat to take a look at the file contents since it will be gibberish. With the source code gone, only option is to run the actual file itself.

bash

1#!/bin/bash
2
3g++ SourceCode.cpp -o ExecutableFile
4rm SourceCode.cpp

shell

1NKCTF@you:~$ ls
2ExecutableFile
3NKCTF@you:~$ cat ExecutableFile
4Scrt1.o__abi_tagcrtstuff.cderegister_tm_clones__do_global_dtors_auxcompleted.0__do_global_dtors_aux_fini_array_entry
5NKCTF@you:~$ printenv
6printenv has been removed
7NKCTF@you:~$ ./ExecutableFile
8here is the flag: NKCTF$:{a9eR2}

Cheating

In order to mitigate cheating as much as possible, we have dynamic flags. Meaning, every hash for each user is different. The hash itself is comprised of the flag's name and the username of the user. This way, each hash per flag per user is completely different from one another. This mitigates sharing of flags themselves among users which doesn't allow circumventing the challenge. In case anything goes wrong, the Admin can see each of their user's hashes while they are in the middle of a challenge.

Want to Know More?

Whether you're an educator looking to build custom training scenarios, a CTF organizer looking for flexability, or just someone interested in how our platform works and want a peek - we would be more than happy to show you more. Feel free to reach out to us or check out our pricing options to get started.

our pricing plans are currently not ready quite yet.