Jamie McDonald

In recent months I have been doing many things. Mainly I’ve been keeping busy and not having anything to write about.

Since I graduated in July I’ve worked at Rail Vision in Loughborough developing application interfaces in Visual C#; I have moved house and I finally started my new job and life at IBM.

For the past few weeks I’ve been orienting myself to the IBM way of life, getting used to the people and the software/hardware I will be working with and things that I might be working with one day. Hopefully all this learning I’ve been doing will be useful when I actually get to start working on a project, but until then I’m excited for what the future holds.

In other news, I recently started playing Battlefield 3 with some friends. As Armin Ronacher points describes, the Battlelog web application which records your statistics, launches single and multiplayer games and much more; is actually a really interesting platform. I’ve been looking for an excuse to build a Ruby on Rails application and learn Ruby/Rails for a long time now and so I have set about working on a Ruby gem for parsing JSON data from the Battlelog website and an example RoR app to demonstrate some functionality.

Before starting I looked around for any similar projects and found some work by Blake Harley, who has written a PHP API for Battlelog. It is this work which I have based my Ruby code on.

The current work-in-progress can be found on github.

I’ve been going through the Hack This Site challenges and found the sixth realistic mission to be good fun. The challenge was to take an email encrypted using the XECryption and decrypt it. A little background knowledge on the algorithm was required to understand how to decrypt it.

The secret key for XECryption is created by taking each character of the password, converting them to their ASCII code equivalents and summing them together. Each character is encrypted by converting it to it’s ASCII code equivalent and then adding the value of the key to it. It is then divided into three three-digit numbers separated by a full-stop each. So as an example we will use the secret key “hello” and the letter “s” as a message:

hello = 104 + 101 + 108 + 108 + 111 = 532

s + 532 = 115 + 532 = 647

ciphertext = .214.265.263.

XECryption can easily be decrypted with the secret key by taking the sum of the three digits, minus the secret key and convert the value from an ASCII code to the character.

Knowing this information is useful but without the secret key we have to do some analysis on the ciphertext. By grouping the text into the sets of 3 numbers and finding their sums it is possible to do some frequency analysis on the ciphertext. According to studies, the most frequent letter in the alphabet is “e” however given the modern context of the scenario the most common character is likely to be a space. If you take the value of the most common character and subtract 32 (the ASCII code of a space character) you have a possible candidate for a key. The only thing left to do is to subtract the key from each of the three digit groupings and convert them from the ASCII codes to the character equivalents. If the most common character turned out not to be a space then other characters would have to be tried.

Being lazy, I wrote a script in Python to do this. However, I only learnt Python today so it might be inefficient or horribly coded, but it works and got me my solution to the challenge.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#!/usr/bin/env python
 
# Open the encrypted file
file = open("cipher.txt", "r")
 
# Read the file and split the numbers into a list
ciphertext = file.read().replace("."," ").split()
 
z = 0
 
L = list()
 
# Group the numbers into blocks of 3 and sum them
for i, x in enumerate(ciphertext):
	if (i != 0) & ((i % 3) == 0):
		z += 1
	try:
		L[z] += int(x)
	except IndexError:
		L.append(int(x))
 
# Find the most common element and subtract 32 (ascii value of space) to get the key
key = max(set(L), key=L.count) - 32
 
# Subtract key from each value and convert from it's ascii value to its character form
for i,x in enumerate(L):
	# print i, x, x - key
	L[i] = chr(x - key)
 
# Print the decrypted text
print "".join(L)

After doing this, and when writing up this post, I discovered that there already exist solutions in Python and other languages for this that are probably better, but this was much more fun

For me, installing Player/Stage was a bit of a nightmare. There isn’t a wealth of information about installing Player/Stage on any operating system, let alone on a Macbook Pro.

I tried running an Ubuntu install in VirtualBox and using the install script on this wiki page but the script failed and I didn’t understand enough to figure out what went wrong (I don’t think I would understand any better now!). I then tried using the package manager to install the Debian/Ubuntu packages but I got lots of errors about missing models and drivers. That’s when I gave up on Ubuntu.

MacPorts seemed to offer a golden solution, however after running the install for hours on end to have the process throw an error and fail numerous times made me give up on that avenue. Then, I found some magical instructions on this website. Thank you Serge Stinckwich. I’m not sure whether it was these instructions alone, or the combination of those and the attempts with MacPorts however I have a working installation of Player/Stage on Mac OS X 10.6.7. For the sake of my paranoia about things that may someday disappear on the internet, I’m reposting the instructions here, but full credit goes to the original poster.

How to install Player/Stage 3 on Mac OS X

Install MacPorts packages: cmake, pkg-config

Set INSTALL_DIR to the appropriate directory. All Player/Stage tools will be installed in this directory. For example: export INSTALL_DIR=/Users/username/playerstage3

Player 3.0.1 installation

cd

mkdir $INSTALL_DIR

curl -O http://nchc.dl.sourceforge.net/project/playerstage/Player/3.0.1/player-3.0.1.tar.gz

export CXXFLAGS="-arch x86_64" tar -xzvf player-3.0.1.tar.gz

cd player-3.0.1

mkdir build

cd build

cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR -DCMAKE_OSX_ARCHITECTURES=x86_64 -DBUILD_PLAYERCC_BOOST=OFF ../

make

make install

FLTK 1.3.X installation

The URL below didn’t work for me, I downloaded the latest version of FLTK at their website, which happened to be fltk-1.3.x-r8207.tar.gz at the time.

cd

curl -O http://ftp.funet.fi/pub/mirrors/ftp.easysw.com/pub/fltk/snapshots/fltk-1.3.x-r7243.tar.gz

tar -xzvf fltk-1.3.x-r7243.tar.gzcd fltk-1.3.x-r7243

./configure --with-archflags="-arch x86_64" --prefix=$INSTALL_DIR

make

make install

Stage 3.2.2 installation

cd

curl -O http://nchc.dl.sourceforge.net/project/playerstage/Stage/3.2.2/Stage-3.2.2-Source.tar.gz

export PKG_CONFIG_PATH=$INSTALL_DIR/lib/pkgconfig/tar -xzvf Stage-3.2.2-Source.tar.gz

cd Stage-3.2.2-Source/

mkdir build

cd build

cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR -DCMAKE_OSX_ARCHITECTURES=x86_64 ../

make

make install

Test your P/S installation

export DYLD_LIBRARY_PATH=$INSTALL_DIR/lib/

export PATH=$INSTALL_DIR/bin:$PATH

cd

player

stage Stage-3.2.2-Source/worlds/simple.world

player Stage-3.2.2-Source/worlds/simple.cfg

Hopefully, you should now have a working installation of Player/Stage! Good Luck!

I’ve just handed in my final year project at university (a few days ago) and I thought I would share my project as an example of what can be done in Player/Stage, I don’t think it’s particularly complex work but it could be a starting point for some more interesting work in the future.

The project was to demonstrate UAV Sense and Avoid techniques in a simulation environment and I chose to use Player/Stage. The techniques I looked into weren’t fairly complex and they aren’t as robust as I would like, maybe I will work on improving them in future, however I implemented the Closest Point of Approach and Potential Fields methods.

There are two parts to the code I’m including below: the Player/Stage control code for the sense and avoid techniques and some code to generate the .world, .config and main.cc files depending on the scenario. The generator code just reads an XML file and then outputs several files.

The code was built on OS X using Player version 3.0.1 and Stage version 3.2.2, it also requires the Boost libraries. Here are some running instructions in PDF format that I compiled for my tutor. Here are the actual files, the code should be fairly self explanatory however I can explain it more over an email if anyone wants to get in touch. Please bear in mind that I wrote this code whilst learning C++ so I expect there are many things that could be improved and possibly quite a few beginner’s mistakes.

If anyone does use this code for anything (a mention would be cool if it’s used in a significant way) or can suggest any improvements to it, email me because I’d appreciate it!

Welcome to the infamous first post. I don’t have great aspirations for this blog to be a literary masterpiece. Just a space to jot down my thoughts and things I observe. The main reason for doing this now is because I’ve finished my final year dissertation and I want to share some of the things that I have learnt along the way. We’ll see where it goes from there.

I have an outline in my head of what the first few posts are going to be. I’ll write it down here so that I don’t forget it:

• Installing Player/Stage on OS X
• Things I’ve learnt about Player/Stage
• Various code snippets

I want to test the method I used to install Player/Stage on OS X before I post any instructions. This is because I installed it several months ago and I tried so many things I’m half convinced it was a combination of several methods. Once I’ve got a fresh platform to test on I’ll write up my installation process (nightmare).

</firstpost>