Coding on Polaris64's blog

Writing a custom Hugo theme

Mon, 24 Aug 2020 18:33:00 +0200

I am currently in the process of creating this Hugo blog and I decided to create my own theme in order to learn Hugo internals. While testing this theme I of course needed content, so I thought “why not document the process of creating the theme as the first post in the blog?”. This is that post!

Initial theme creation and set-up

First steps

After creating a base Hugo site with: -

Syswall: a firewall for syscalls

Sat, 16 Feb 2019 22:07:00 +0000

Motivation

A while back I started thinking about software and how it does what it does. Perhaps even more importantly, I started thinking about how we can know what software does, without relying on the software’s marketing pitch.

Software analysis

Software can be good and can also be bad; this is what we know as malware. For malware, a lot of time and effort is spent reverse-engineering the program’s machine code in order to figure out what it does and how it does it. This is a highly specialised skill, requiring a huge amount of time and effort to be able to perform this reverse-engineering successfully. We also use virtual machines (VMs) in order to execute untrustworthy executable files in a safe environment in order to limit their effectiveness when performing an analysis.

My Dissertation Project

Sun, 28 Dec 2014 14:24:00 +0000

“To investigate development of an extensible 2D game engine for use by programmers and non-programmers”

I am currently working on a final-year university project and dissertation and this blog is used to track my progress. I’ll post regular updates as the project progresses so please check back to see what’s happening!

Could Emacs Have a Set-up Wizard?

Mon, 28 Sep 2020 22:05:00 +0200

Introduction

There have been a number of discussions recently about modernising Emacs. Some people feel that Emacs is not aesthetically pleasing, while others feel that Emacs’s default key-bindings put off potential newcomers.

In these discussions, I normally see comments fall into two main groups: -

People who are proficient with Emacs and do not want the quest for new users to interfere with their way of using Emacs; and
People who want to welcome new users and for Emacs to be used by as many people as possible.

I agree with both groups to some extent. I consider myself a proficient Emacs user who is comfortable with the defaults and with changing them myself where necessary. However, when viewed through the eyes of a beginner, I do see Emacs as intimidating.

I strongly agree that Emacs should remain as it is and I wouldn’t want to introduce simplifications just to cater to people who might want to use it. I also don’t think that Emacs should unnecessarily try to follow the latest trends just to be “up to date”. I do however think that we can do more to provide a pathway for newcomers to follow, so this post will explore one idea for doing just that.

Hidden in Plain Sight: how attackers use obfuscation to hide code

Mon, 01 May 2017 19:10:00 +0100

Introduction

Many articles, including my own, make references to code obfuscation. This article takes a look at what this actually is, as well as why it is often used by attackers to hide malicious code.

What is obfuscation?

Obfuscation is the process of converting something to a form where its meaning and purpose is less apparent. When related to computer source code, this can be done for many reasons; sometimes as a challenge, sometimes even for art!. However it can also be used for more sinister purposes which is what we’ll investigate today.

Network Editor Progress

Fri, 03 Apr 2015 11:43:00 +0100

I have just finished an early alpha version of the tool, called “SG2D script editor”, which will be used to generate the Python script used to drive the engine.

The tool currently has the following features: -

Node-graph editor similar to Blender’s node editor, Unreal Engine 4’s Blueprint editor, etc.
Ability to add custom functions
Multiple game states which all build to custom classes
A set of basic language nodes which allow for general Python scripting
A set of engine-specific nodes providing a simple interface to the engine
Colour coding for readability
Pan and zoom controls
Loading and saving of networks
The ability to run and test the script with the SG2D engine and to view the output

Here’s a video of the tool in action: -

Web Exploit Detector: NPM module

Sat, 22 Apr 2017 15:23:00 +0100

Introduction

As a follow-up to the previous article about my Web Exploit Detector, I am happy to announce that I have just made the project available as an NPM module. This allows the application to be installed, used and updated much more easily than before.

This article is intended to be a brief introduction to the Web Exploit Detector as an NPM module, as well as a brief introduction to NPM itself for those that are unfamiliar with it.

Engine Python Scripting Interface

Sun, 28 Dec 2014 14:55:00 +0000

My first development task was to add a scripting interface to the engine. This allows the game logic to be separated from the engine code and loaded in as with any other asset such as a sprite or audio clip.

I chose Python for scripting due to its power, flexibility, popularity and ease of integration. I am using IronPython for the .NET support with XNA, but I am being careful not to introduce any .NET dependencies as the engine needs to be portable, and game scripts should be able to be run with any version of the engine. The script itself is loaded during initialisation of a “script harness” executable, which is the framework under which the game runs in the engine. The engine can of course still be used directly by coding natively in XNA and using the engine assembly as a library.

Browser Scripting and Google Go

Mon, 21 Nov 2011 00:00:00 +0000

The latest era in the so-called “Browser Wars” seems to be focused largely on JavaScript execution speed. With more and more websites using client-side scripting to enhance functionality (Google Docs, Google Maps, Facebook etc.), the faster these scripts can run the better.

Currently the most popular web browsers are Mozilla Firefox, Google Chrome, Microsoft Internet Explorer, Opera and Apple Safari. In JavaScript execution speed benchmarks, currently Chrome is at the top, with Safari, Firefox following closely for second and third and Opera and finally IE losing out with times over double that of the others. But what does this actually mean for the average user? Some websites are evolving past the traditional request-response model and employing a much more real-time and dynamic feel. So called web applications make heavy use of technologies such as AJAX and use client-side scripting to allow everything to run as seamlessly as possible for the user. Web applications like Google Docs and Gmail would not be possible in their current form without heavy use of client-side scripting.

Rust WebAssembly and JavaScript: Floyd-Steinberg Dithering

Sat, 20 Jan 2018 13:16:00 +0100

Code examples

Introduction

Further to my recent post comparing the performance of a WebAssembly module written in Rust to plain JavaScript and WebGL shaders for rendering the Mandelbrot set, I have added an additional example comparing the performance of WebAssembly and plain JavaScript for the Floyd-Steinberg dithering algorithm. Check out the demo!

Floyd-Steinberg dithering algorithm

The Floyd-Steinberg dithering algorithm is used as a way to distribute quantization errors to neighbouring pixels in an image.

Web Exploit Detector: Node.js security scanner

Sun, 16 Apr 2017 19:16:00 +0100

Introduction

After detecting some new exploits on one of my web servers, I decided to start work on a new application called the “Web Exploit Detector”. This project is open-source and hosted on GitHub, meaning that it’s free for anyone to use and, more importantly, anyone can contribute their own rules to make the tool better.

I now use this tool on my own servers to check for infections on a daily basis and it works well so far. It is my hope that, given time and the help of others, it can become even more useful and capable of detecting even the most recent of exploits.

Pre-built Engine and Toolkit

Sun, 28 Dec 2014 14:36:00 +0000

For development of my project I decided to use an engine and set of tools that I have already built: the SG2D engine and the SGDK set of tools.

SG2D: this is the engine itself, currently running on the Microsoft XNA Game Studio platform, allowing it to run on PC, Xbox, Windows Phone and Linux currently.
SGDK: this is a set of tools used currently for asset creation (maps, animated sprites, etc). This will be expanded to provide a visual script-building interface.

My dissertation project will involve converting these two elements so that they will become an effective tool for game creation for both programmers and non-programmers. This will involve adding a scripting interface to the engine and visual scripting interface to the tool kit. The ultimate goal is to allow designers and programmers to work together using one set of tools.

WebAssembly and Rust: performance analysis

Tue, 09 Jan 2018 21:05:00 +0100

Code examples

Introduction

I have recently been learning The Rust programming language and I absolutely love it! Rust is a systems-level language (like C and C++) which provides compile-time guarantees about memory safety and safe concurrent behaviour. Readers of my Cybersecurity and technology blogs will know that I am interested in computer security, and we’re reminded on an almost monthly basis at the moment that computer security often leaves a lot to be desired, what with vulnerabilities and exploits of public data sadly being a frequent occurrence. Rust programs simply will not compile when the program contains code which often causes these problems, meaning that bad code can be caught during development rather than later when there is more at stake. This is definitely the way we need to go, so I’d recommend anyone with an interest in programming or security to give it a try!

Shared Canvas: the next generation

Sun, 13 Dec 2015 23:37:00 +0000

It has been quite a while since I created the original Shared Canvas, so I decided it was a good time for an upgrade…

So here is Shared Canvas, mark 2! Well almost; it’s still an early alpha and there’s a lot still left to do. But feel free to have a play with it in its current state :) Currently multi-user chat and drawing is supported, and multiple rooms (with passwords) can be created.

OpenGL game: Tank Battleground

Fri, 03 Apr 2015 12:10:00 +0100

Here’s a new game that I created for a university assignment called “Tank Battleground!”

The assignment required me to create a 3D game which used physics and demonstrated OpenGL and GLSL. I decided to use the idea of an arcade tank game so that I could demonstrate physics for movement (acceleration, velocity and displacement), projectile trajectories, friction, recoil, etc.

The game was written from the ground up using C++, OpenGL, GLSL, GLFW, SDL_mixer, FreeImage and FreeType. I first coded a game library (simple engine) and then used that to build the game.

A* Path-finding

Thu, 24 Apr 2014 20:35:00 +0100

As you may or may not know, I am currently working on a game called Mendel’s Farm with the rest of the team at Static Games. Over the last couple of days I have been thinking about various ways of adding AI-controlled actors to the game and how best to make them navigate the farm…

I decided that path-finding over a grid will be required to achieve this, so I decided to investigate the A* path-finding algorithm. Before implementing it in-game (in UnrealScript) I decided to create a test implementation in JavaScript using HTML for rendering and the UI. I’ve uploaded the result here, so click here to run the A* test!

C#: Normal Map Generator

Mon, 07 Jan 2013 00:54:00 +0000

For a recent university assignment, I needed to create many different textures for both 3D models and surfaces. I wanted to create normal maps for each of these but I didn’t know how to do it.

I decided therefore to experiment with different approaches including photographing a surface with light from different sides and by using filters in GIMP and Photoshop. Both techniques worked well and I realised that I could create a program to speed up the process.

C: Commodore 64 Emulator

Wed, 27 Jun 2012 09:46:00 +0100

This is a work in progress Commodore 64 emulator written from the ground up in C. I’m lucky enough to own an original Commodore 64 together with the technical reference manual, and using both of these I was able to create a working emulator.

My first step was to code the MOS 6510 processor core. From there I coded the memory manager, the I/O, interrupt handling, the VIC chip etc. All I then needed to do was plug in the original C64 ROMs (Kernal, Character Generator and Basic) and I had bare-bones emulated C64, which was quite a thrill!

C++: "Malevolent Revenge!", Linux Allegro Game

Sun, 11 Mar 2012 00:24:00 +0000

Downloads

Linux build: malevolent_revenge_linux_v1.0.0.zip (29.5KB)
Windows build: malevolent_revenge_win_v1.0.0.zip (364.5KB)
Source code: malevolent_revenge_src_v1.0.0.zip (38.5KB)
The resource files (bitmaps, music etc), same for Linux and Windows versions, to be placed in the same directory as the executable: malevolent_revenge_files_v1.0.0.zip (14.6MB)

Building from source in Ubuntu aside from the usual also requires liballegro4.2-dev and running requires liballegro4.2 and liballegro4.2-plugin-esd. Running under Windows requires alleg42.dll (included in the ZIP file) and the MS Visual C++ 2010 runtime, which can be downloaded from https://www.microsoft.com/download/en/details.aspx?id=5555

Delphi (Pascal): 3D Test

Sat, 01 Jan 2011 00:00:00 +0000

This is a program I wrote in Delphi quite a few years ago. I wanted to investigate the principles of 3D graphics so I decided to create this program to explore this.

All of the rendering is performed on a pixel-by-pixel basis using my own graphics routines. It is not meant to be a viable 3D engine or renderer; it’s far too slow for that due to the fact it uses Delphi’s VCL to access graphics memory.

C: SDL 3D renderer

Tue, 01 Feb 2011 00:00:00 +0000

Following on from the Delphi 3D test program, I have started to code another 3D renderer, this time in C using SDL. Again my goal is not to create a viable renderer for games, 3D applicatins etc, but rather as an exercise that will teach me more about 3D rendering. I have always been fascinated with how things work, so doing something like this will give me a better understanding to the internals of OpenGL, DirectX graphics etc.

Lishwist (beta)

Wed, 05 Jan 2022 21:50:00 +0100

I’ve just released a beta version of a new project that I’ve been working on: Lishwist!

Lishwist is a web app which allows you to create and share wish-lists. There’s no registration requirement: just create a new wish-list (called a Wist) and bookmark the page! You can then share the list with others (one share per person) and these people can “claim” items to mark their intent to get the item for you. People to whom you’ve shared your Wist can see who has claimed an item (to avoid people buying the same thing), but you can’t see that yourself (so as not to spoil the surprise).

Rust really is a superpower!

Tue, 02 Jan 2024 00:00:00 +0000

This is a small post in appreciation of Rust, the programming language, and its ecosystem.

If you’ve read my other posts you’ll know that I have a strong interest in Rust. I have been using Rust for quite a number of years and I have released several posts about it, for example the performance of Rust when compiled to WASM. I’ve also built some software using Rust: Lishwist, Syswall and the Rust/WASM graphics library.

Verlet Physics Playground

Sun, 22 Sep 2024 12:51:00 +0200

I recently started playing around with the p5.js web editor and I created what I called the “Verlet Physics Playground”. That got me interested in other libraries in other languages that could be used for building real-time simulations like this.

The rabbit hole I ended up in first took me to Common Lisp’s Sketch library. I love using Common Lisp and I’m especially enamoured with the interactive/REPL-driven development workflow. I had a lot of fun rebuilding the p5.js version using Sketch.

Coding on Polaris64's blog

Writing a custom Hugo theme

Initial theme creation and set-up

First steps

Syswall: a firewall for syscalls

Links

Motivation

Software analysis

My Dissertation Project

Could Emacs Have a Set-up Wizard?

Introduction

Hidden in Plain Sight: how attackers use obfuscation to hide code

Introduction

What is obfuscation?

Network Editor Progress

Web Exploit Detector: NPM module

Introduction

Engine Python Scripting Interface

Browser Scripting and Google Go

Rust WebAssembly and JavaScript: Floyd-Steinberg Dithering

Code examples

Introduction

Floyd-Steinberg dithering algorithm

Web Exploit Detector: Node.js security scanner

Introduction

Pre-built Engine and Toolkit

WebAssembly and Rust: performance analysis

Code examples

Introduction

Shared Canvas: the next generation

OpenGL game: Tank Battleground

A* Path-finding

C#: Normal Map Generator

C: Commodore 64 Emulator

C++: "Malevolent Revenge!", Linux Allegro Game

Downloads

Delphi (Pascal): 3D Test

C: SDL 3D renderer

Lishwist (beta)

Rust really is a superpower!

Verlet Physics Playground