hacks – Terence Eden’s Blog

Import Images From A Migrated WordPress

@edent — Wed, 30 Aug 2017 06:44:21 +0000

Here's how to solve a common WordPress problem.

I want to re-import all my blog's images into the media library. I've moved my blog to a new host - but kept the same domain name. I started with a new WordPress install, the uploads folder still has all my images, but WordPress can't see them.

None of the plugins I found worked with huge amounts of images spread across multiple directories.

One Line Fix

This uses the WP-CLI program. Install it on your server, then run:

./wp-cli.phar media import wp-content/uploads/2017/08/example.jpg --post_id=123 --skip-copy

That imports the image, attaches it to a post, and keeps it on disk in the same location.

Easy! But how do we get all the images, spanning a thousand blog posts?

Get All Post IDs

./wp-cli.phar post list --field=ID

Get the HTML of the post

./wp-cli.phar post get 123 --field=post_content

Extract the images

We can use PHP's DOMDocument to grab the images from the HTML.

$html = "....";
$doc = new DOMDocument();
$doc->loadHTML($html);
$images = $doc->getElementsByTagName('img');
foreach($images as $img) { 
   echo $img->getAttribute('src') . "\n";
}

And that spits out all the images in the post.

Putting it all together

BACK UP YOUR DATABASE FIRST, YOU MUPPET!

ahem

This will be a mixture of PHP and bash scripts.

Save all the post IDs to a file.
Iterate through the IDs and save the HTML to separate files, named after the post ID.
Go through each file, grab every image URL.
If the image URL starts with "https://shkspr.mobi" add it to the media library and associate it with the post.

1 Save all the post IDs

./wp-cli.phar post list --field=ID > posts.txt

Takes a minute to run.

2 Generate the HTML

cat posts.txt | while read line ; do ./wp-cli.phar post get $line --field=post_content > test/$line.html ; done

Takes a few minutes to run.

3 Grab images

Within the test directory create commands.php:

$start = "https://shkspr.mobi/blog/";

foreach (glob("*.html") as $file) {
    if($file == '.' || $file == '..') continue;
    $id = substr($file, 0, -5);
    $html = file_get_contents($file);
    $doc = new DOMDocument();
    $doc->loadHTML($html);
    $images = $doc->getElementsByTagName('img');

    foreach($images as $img) {
       $imgSrc = $img->getAttribute('src');
       $starter = substr( $imgSrc, 0, strlen($start) );
       if($starter == $start) {
          $imgLocation = substr( $imgSrc, strlen($start) );
          echo "./wp-cli.phar media import {$imgLocation} --post_id={$id} --skip-copy\n";
       }
    }
}

This can be run as php commands.php > commands.txt

After a few seconds, we now have a text file full of

./wp-cli.phar media import wp-content/uploads/2000/11/Pratchett-Truth.jpg --post_id=24322 --skip-copy
./wp-cli.phar media import wp-content/uploads/1999/12/tezza.jpg --post_id=24353 --skip-copy
./wp-cli.phar media import wp-content/uploads/1999/12/frontpag.gif --post_id=24353 --skip-copy

To run all the the commands:

Move the commands.txt into the root of your blog.
Run bash commands.txt

This will take a long time, depending on how many commands you have. Mine ran overnight.

You media library will now be full! All images will be correctly associated with their posts.

Alexa powered smarthome control for Sonoff

@edent — Tue, 06 Jun 2017 11:27:52 +0000

I've been sent a couple of Sonoff smarthome gadgets. You can read my review of the S20 WiFi plug socket and the POW in line power controller.

Here's a video of me controlling them from my Amazon Alexa:

The latency seems a little slow - hard to tell if that's Amazon only relying on US data centres for Alexa skills, or the connection to my home. Once set up, it works well. Oh... but the set up experience...

Set Up

I'll be honest - configuring a smarthome for voice control is still a pain in the arse. This is mostly Amazon's fault - but it doesn't help that all the kit I use has non-standard interfaces.

Here's the long journey I took to install the skill, configure it, and finally use it.

Read the eWeLink tutorial on setting up Alexa.
I'll assume you've already set up your Alexa, connected it to the WiFi, and configured the app.
In the Amazon app, go to Settings.
Select Skills
Search for eWeLink (not Sonoff!)
Select "eWeLink Smart Home Fan".The "fan" refers to the fact that this is not an official app, not that it only controls fans.
Enable the skill.
This takes you to the web browser which then redirects to the "coolkit" site.Usually I would tell you to be wary of putting your password into a random site - but this is, apparently, the same company as eWeLink and Sonoff. Confusing, isn't it?
Log in with your email address and password and you're eventually redirected back to Amazon
Close the browser and return to the Alexa app.
Ignore the fact that it is still asking you to enable the skill, exit this page and go back to the home screen of the app.
Go to menu, Smart Home. Then click on the Smart Home Skills.
Click on the EweLink skill.
That just gives you reviews. Because Amazon don't bother with usability testing their apps.
Go back and click on the icon for eWeLink.
Now "Manage Devices in Smart Home".
Oh, we're back here again! Select "Devices"
Scroll all the way to the bottom and select "Discover".
Wait. And marvel at how crap Philips Hue must be to need extra support text.
Hopefully the new eWeLink devices will be displayed.
You can exit the app and use voice control.

Bloody hell! No normal person is going to bother going through that many steps, are they?

Oh, and that's not even the worst part! When I first set up the lamp, it wouldn't work. Why? Because I already had an Alexa group called "lamp". There's no feedback in the app - and it's impossible to rename device in Alexa. The Echo just pathetically says that there's a problem - but not how to solve it. So you have to delete the devices, rename them in the eWeLink app, then re-add them.

Alexa is a UX disaster. If you deviate a millimetre from the happy path, you'll be lost in the woods without hope.

This is not the future.

Kit used in this demo

Internet Connected Lightswitches - Redux!

@edent — Mon, 01 May 2017 10:45:37 +0000

Regular readers will remember that I have had a disastrous experience with WiFi light switches. I've had pretty good results with LIFX bulbs - but I really wanted something which can control my lights' switches.

Enter the new WisQo smart lightswitches. The company claims that they'll work with the UK's "unique" wiring designs. They've kindly sent me a set to review - adjust your bias filters accordingly.

The good news is they actually work! The bad news is that the app is tedious to use. The good news is they work with Amazon Echo! The bad news is they're fairly insecure!

This review will show you how to fit them, and get them working with your voice assistant. I'll also take a brief look at their lack of security.

For more information, please visit https://www.wisqo.com/

Unboxing

Depending on which kit you buy, you'll get a variety of boxes.

The base kit contains a light switch, a relay, and a WiFi gateway.

The switches and relay work on 433MHz - I'm not sure what (if any) security they have. Switches need to be paired with relays. Plug the relay into a USB power source, then hold down the reset button until a LED starts flashing. Press your lightswitch and the two should pair. That was the easy part!

The switches are portable - they can be screwed to the wall, or stuck on with the included adhesive. They aren't battery powered though - as per their FAQ:

The switch does not require power supply, it utilizes the kinetic energy from the pressing force.

Nifty!

Installation

Unlike other IoT lighting solutions, you don't need to re-wire your existing switch. The relay needs to be installed in the ceiling rose. Here's mine, before installation.

The WisQo kit comes with terminal blocks so you can wire in fairly easily. WARNING electricity is dangerous. Make sure that you've turned off the circuit at the consumer unit. If in doubt, get a qualified electrician to help you fit everything.

I had more neutral wires than the kit accounted for - but they managed to squeeze into the provided couplings.

There's a handy video in case you get stuck.

Everything wired in just fine - although the relay was slightly too large to fit inside the existing covering. I used the provided sticky pad to keep it flush to the ceiling.

The white wire is the antenna.

With that done, and my wiring double checked, I turned on the power and was able to use the light switch!

Connecting to the Internet

There's a WiFi-RF gateway which comes with the kit. It is USB powered and fairly small.

WisQo claim their hub can connect to 200 devices. I don't have that many light switches - but it worked perfectly well with two.

There are no mounting holes, sadly, but it is unobtrusive enough to be tucked away. It's 2.4GHz only, so won't work with your 5GHz networks. It is WiFi only - which I found a bit annoying. I'd have preferred to wire it in to my LAN. As it is, you have to download the app to send it your WiFi credentials.

App

All the boxes have QR codes pointing you to the app.

The Android app is basic - too basic really - but it doesn't request insane permissions. Once installed, the app is very quick to respond - a tap on the light and it toggles instantly. But, oh! It is a pain to set up.

You may have noticed the QR codes stuck to the relays. These are needed to pair with the app. But first, you need to create an account and sign in.

Sometimes you open the app you have to type in a password. Why? My Lifx bulbs and my WeMo switches don't require that level of security. Annoying. The app occasionally crashes on opening. Frustrating when you need to use your lights.

Pairing the relays with the app was tricky - I'm still not sure how I did it. Lots of button mashing. Anyway, you've opened the app, typed in your password, now how do you switch on the light?

First, go to the home that your light switch is in. I'll just be using this in my main home - so a bit of a pain to have this step.

Then choose the room your light is in. (I only have one room - why do I need to do this?)

Here's the light. Is it on or off?

Tap it and it changes.

The app works whether you're on WiFi or not. So you can toggle the light switches when you're out of the house.

There's also rudimentary support for timers.

The app works, but it is slow and annoying to use. Hardware manufacturers find software difficult. If only there was a better way...!

Alexa...

The WisQo works with Amazon's Echo - the smart voice assistant. Personally, I've never seen the use for one. But I guess it would be useful to be able to shout "Computer! Lights!" and have a mechanical slave do my bidding :-)

I picked up the £50 Amazon Dot - I could write a whole blog post about how bad it is - but here's how it works with the WisQo lights.

1. Find the settings page

Tucked away in the Alexa settings is the option to connect "Smart Home Skills".

2. Connect your account

You need to connect your WisQo account to Amazon. This involves going off to a dodgy looking 3rd party page and entering your details.

Is it safe? Who knows?! Why can't it use the WisQo app to provide authentication? Who knows?!

3. Success

Because you do the account linking in a web browser, you have to close that and return to the app. Isn't there an easier way?

4. Discovery

The app presents a button which promises to kick off discovery. It doesn't work.

My WisQo account knows all the devices I own - but I still have to manually "discover" them in the Dot's app. Again, this is the sort of thing which should just happen automagically.

5. Discovered!

It found them! Can I use them? Not quite yet!

6. Groups

Scrolling back up the page (seriously - why isn't this in a logical order?) we can add the lights to a named group.

7. Naming the group

Give several lights one name.

Now I can say "Alexa, turning on the kitchen lights" and she will obey.

Proof!

Bit of a palaver to set up - but works well enough!

https://shkspr.mobi/blog/wp-content/uploads/2017/04/Alexa-Turning-the-lights-on-and-off.webm

The Alexa Skill is available in English and German. I'm still trying to find out whether I can just bark "Alexa, Kitchen" and have it understand me. The Echo's documentation is poor - there's a lot of trial and error involved to see what commands work.

Cost and Conclusion

A Switch, Relay, and Hub costs £60 on Amazon. You can buy a switch and relay for £36, and a switch by itself for £20.

Those prices are in line with other smart lighting solutions. A single Lifx bulb will be between £30 - £70 depending on which model you want. Similarly, a pair of Philips Hue bulbs and a Hub is around £60.

Lifx and Hue are simpler - just change a light bulb, no rewiring needed. They're bigger companies - so hopefully have decent support and well tested apps. They also work with Alexa, IFTTT, and have open source projects around them.

WisQo works with physical switches - that's its big advantage. Because they're wireless, you can stick them in a convenient location. It also means they'll work if your WiFi goes down, or if your phone is out of battery.

Your existing switch needs to stay in the "on" position permanently to provide power to the relay. I ended up sticking the WisQo switch to the wall above my normal switch.

It isn't ideal - I might rewire the black switch so it is permanently shorted. Then put a blank face plate on it.

For me, the big advantage is that it wires in to my existing ceiling rose. As you can see, I've got a light which takes 4 bulbs. If I had to replace each bulb with a Lifx, I'd be looking at well over £150! I've got two of them in my kitchen - basically WisQo saves me £300!

Hacking & Security

Of course, it wouldn't be a proper review without some security poking. Here's what I found.

Default passwords

The WiFi gateway asks for credentials before you can use it. On a whim, I tried the trusty "admin" as both username and password - and got straight in!

Everything is in Chinese - but there is an English option.

There's nothing particularly interesting - although there is this serial port control screen.

A quick nmap shows that only port 80 is open - that's a good thing!

Nikito thinks that the server is Microsoft-IIS/5.0. I don't think that can be right.

It appears to be running Linux - although no GPL licence was included with the product - that's a bad thing!

The HTML is a bit outdated (marquee tags!) but there are no obvious security flaws.

Reverse Engineering

Digging deeper into the app, we find some very disappointing news.

Email addresses and passwords are sent in the clear! The server returns a token which is used to "authenticate" calls to turn the lights on and off. I couldn't see a clear indication that calls were signed. I'm not sure if it is possible to switch off others' light switches.

It looks like it will be fairly easy to reverse engineer the calls to write your own controller.

The main server appears to be:

public interface Server {
    public static final String host = "47.88.22.30";
    public static final int port = 10100;
}

It appears to be a Linux box (good!) with exposed MySQL ports (bad!) running on Alibaba's cloud infrastructure (good!) but an old version of nginx/1.6.0 (bad!). So a bit of a mixed bunch!

Images from the app are downloaded over http - so there's some information leakage there.

Like most IoT devices, security is very much an afterthought. There's a limit to the amount of damage an attacker can do with access to your light switches (burn out your bulbs? Induce an epileptic fit? Send Morse code?). You also need to install a box on your network which makes a permanent connection to exotic IP addresses.

At the moment, there's no good way to design a network for IoT devices which is simultaneously usable and secure. So sit back and hope they don't get hacked.

Final thoughts

The WisQo smart light switches work very well and are fairly easy to install. The voice control is handy. They're let down by a lacklustre app and poor security.

You can buy WisQo smart lightswitches on Amazon UK.

Building an Internet Connected Fridge

@edent — Tue, 27 Dec 2016 11:16:32 +0000

The Internet Fridge is a standing joke among technologists. I was writing about them in 2002, and they still haven't appeared!

So I'm going to show you how I built one.

Stop giggling at the back! All I want is for my fridge to notify me if the door has been left over for more than a minute. I'm building this with an Onion Omega2 - but you could just as easily use a Pi Zero or any other board.

Design

This should be simple (as all complicated stories start):

When the fridge door is closed, a circuit is closed.
When the fridge door is opened, a circuit is broken.
If the circuit has been broken for more than 60 seconds, send an alert.
While the circuit is broken, repeat the alert every 60 seconds.

Easy, right?

Build

We need a circuit which will be closed when the fridge is firmly closed, but isn't so strong that it prevents the fridge door closing.

All bodged together with Blue-tack! Perfect for some impromptu Internetting.

You could just use bare wires, but that doesn't look very nice, and they tend to trail around. I'm using a simple spring-loaded button.

Hidden on top of the fridge, the USB wire is long enough to drape around the back. Inconspicuous!

Code

This Python code reads the wire at GPIO 7 every second.

import time
import onionGpio

#  The GPIO port to sense from
gpioNum = 7
gpioObj = onionGpio.OnionGpio(gpioNum)

#  Port set to Input
#  When a 5V circuit is completed, it will be active
status  = gpioObj.setInputDirection()

# read and print the value once a second
loop = 1
while loop == 1:
    value = gpioObj.getValue()
    print 'GPIO%d input value: %d'%(gpioNum, int(value))
    time.sleep(5)

That will print 0 when the fridge door is open, and 1 when it is closed.

Timing Events

There are two main ways to time how long the door has been open for.

Once the door is open, sleep for 60 seconds, if the door is still open - send an alert.
Once the door is open, add up the number of seconds where the door is open - if it reaches 60 (or a multiple of 60), send an alert.

The first solution has a disadvantage - if I open the door for 20 seconds, close it for 10 seconds, then open it for 30 seconds, an alert will be sent. Do I want an alert just because I forgot to take out the cheese for my sandwich?

The second solution is more complex. Complexity scares me. But spending more time with code is better than being annoyed by irrelevant alerts.

I replaced the previous loop with this:

#       Set a counter for how many seconds the circuit is open
counter = 0

#       Read the pin once every second
loop = 1
while loop == 1:
        value = int(gpioObj.getValue())
        if 1 == value:
                #       Door is closed, reset the timer.
                print "Closed. Sleeping"
                counter = 0
                time.sleep(1)
        elif 0 == value:
                time.sleep(1)
                counter += 1
                if (counter > 59):
                        if (0 == counter % 60):
                                #       Send an alert
                                print "Alert! The door has been open for " + str(counter) + " seconds!"

Hurrah! It works!

Sending alerts

OK, I'm not going to be staring at a console the whole day long. How do I get notified that the door is open? A speaker won't be loud enough if I'm out of the room. I could flash my lightbulbs - but I don't have them in every room. I think I'm going to have to push an alert to my phone and my wife's phone.

How?

To be clear, I don't want to install yet-another-bloody-app on my phone and I don't have the patience to develop my own.

Let's see what the peanut-gallery suggests:

I think the Wonderous Mr Whatley might be right. Email. It isn't as glamorous as the others, but it doesn't rely on frequently changing APIs, capricious library developers, flaky 3rd party services, or anything too fragile.

And it is pretty damn simple to send email using Python.

Note - if your Gmail account uses 2FA (and it should!) you will need to create an app-specific password.

import smtplib

from_email = "fridge@example.com"
password   = "Password123"
to_email   = "you@example.com"

message = "THE FRIDGE IS OPEN"

server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(from_email, password)
server.sendmail(from_email, to_email, message)
server.quit()

Which results in...

Sweeeeeet!

Run on start-up

First up, if you're not comfortable with vi you'll need to install nano

Then run:

export VISUAL=nano; crontab -e

Then add the following line:

# m h dom mon dow user  command
@reboot /usr/bin/python /root/fridge.py &

And that's pretty much it!

Final Thoughts

I'm using the $9 Omega2 prototyping board - read my full review of it - this sort of kit is cheap, reliable, and simple. So why isn't it in every domestic appliance?

We always joke about Internet Fridges - usually over-complicated devices which tell you that the potato salad has gone bad and automatically order you more wine. But it doesn't need to be so ambitious.

A basic fridge/freezer is around £200. Even the cheapest appliance should have WiFi connectivity. Not necessarily control or something as dumb as a calendar display - but just a simple, local API for reading information.

Of course, the real barrier isn't cost of the device - it's the cost of service and support. As I repeatedly say, hardware manufacturers are shit at developing software - each frustrated customer ringing a call-centre cuts into the manufacturer's profits. There are huge associated costs for updating software against security threats. That's before we get around to building apps for phones - and then updating them to match newer OS style-guides.

Even on expensive items - like BMW cars - the software experience is just crap! Go to any app store and read the reviews for the apps of "luxury" items, they're uniformly dreadful.

Until manufacturers start taking software seriously, we'll have to augment their offerings with our own home-made bionic implants.

My solar batteries on BBC's You & Yours

@edent — Mon, 14 Nov 2016 12:48:48 +0000

Always a delight to be interviewed by the BBC again. This time, talking about our Solar Batteries.

You can listen again on the BBC iPlayer.

The solar stuff starts at 14m 30s, with my interview at 17 minutes. You can also hear my electric car being charged :-)

🔊 Solar Power, Free-range Eggs and Mattress Recycling

💾 Download this audio file.

The (Connected) House Of Horrors

@edent — Wed, 09 Nov 2016 12:07:19 +0000

In September 2016, I was delighted to deliver this talk to ThingMonk 2016.

This is the 20 minute distilation of my adventures Singing to my lightbulbs, hacking my vacuum cleaner, finding my car's source code, hacking my electric car, getting hacked by my light switches, securing my security cameras, and a whole host of other IoT nonsense.

Huge thanks to Bennycrime for filming, and the whole ThingMonk team.

If you'd like me to speak at your conference, please get in touch.

A selection of comments about the talk as I gave it.

Reverse Engineering the Renault Zoe API

@edent — Sun, 16 Oct 2016 10:46:28 +0000

Last year I published details of the BMW i3's API. I've now swapped my i3 for a Renault Zoe - so I thought I'd perform the same exercise.

All these API calls can be found by using the Renault ZE Services website. I am indebted to this German blog post for kicking off this work. I'd also like to thank Renault for their "esoteric" use of JavaScript!

What's Available?

This API is fairly limited, here's what you can do with it:

See battery status, range, charging status.
Start preconditioning
See preconditioning history
See and set charging schedule.
See charging history

Getting started

First, register with Renault ZE Services. This will give you a username and password.

Secondly, you'll need to get your VIN and API token. This can be obtained by posting the username and password to Renault. For example:

curl \
   -H "Content-Type: application/json" \
   -X POST \
   -d '{"username":"you@example.com","password":"P4ssw0rd"}' \
   https://www.services.renault-ze.com/api/user/login`

This will get you back some JSON with your API tokens. Here's an example:

{
    "token": "AAAA",
    "refresh_token": "BBBB",
    "user": {
        "id": "CCCC",
        "locale": "en_GB",
        "country": "GB",
        "timezone": "Europe/London",
        "email": "you@example.com",
        "first_name": "Terence",
        "last_name": "Eden",
        "phone_number": "+447700900123",
        "vehicle_details": {
            "timezone": "Europe/London",
            "VIN": "VVVV",
            "activation_code": "GGGG",
            "phone_number": "+447700900123"
        },
        "scopes": ["BATTERY_CHARGE_STATUS",
                   "BATTERY_CHARGE_HISTORY",
                   "BATTERY_CHARGE_REMOTE_ACTIVATION",
                   "BATTERY_CHARGE_SCHEDULING",
                   "AC_REMOTE_CONTROL",
                   "BATTERY_CHARGE_LOWALERT"],
        "active_account": "DDDD",
        "associated_vehicles": [{
            "VIN": "VVVV",
            "activation_code": "GGGG",
            "user_id": "XXXX"
        }],
        "gdc_uid": "YYYY"
    }
}

Battery Status

Let's start with the battery. We need to use your token and VIN from above.

curl \
   -H "Authorization: Bearer AAAA" \
   "https://www.services.renault-ze.com/api/vehicle/VVVV/battery"

This gets us:

{
    "charging": false,
    "plugged": true,
    "charge_level": 100,
    "remaining_range": 124.0,
    "last_update": 1476472742000,
    "charging_point": "INVALID"
}

A few point to note. The remaining_range is in Kilometres. The last_update is a Unix timestamp.

Preconditioning

The Zoe can be set to warm-up or cool down depending on the last temperate you set in the car. It will also blast the front window de-mister. The process takes five minutes, so you can set it shortly before you need to set off. Preconditioning will only work when the car's battery is above 45%.

Precondition Now

curl \
   -H "Authorization: Bearer AAAA" \
   "https://www.services.renault-ze.com/api/vehicle/VVVV/air-conditioning"

This command does not return any value. There is also no way to cancel the command remotely - you have to physically enter the car and turn it off.

Precondition Later

If you know that you want to leave at a specific time, you can set the car to precondition at a set time.

curl \
   -H "Authorization: Bearer AAAA" \
   -H 'Content-Type: application/json;charset=UTF-8' \
   --data-binary '{"start":"1753"}' \
   'https://www.services.renault-ze.com/api/vehicle/VVVV/air-conditioning/scheduler'

As far as I can tell, the start time is when you want the conditioning to start - not when you want it to be finished.

There is no way to cancel a precondition.

Preconditioning Last Status

Want to see if the preconditioning message was received by the car correctly?

curl \
   -H "Authorization: Bearer AAAA" \
   "https://www.services.renault-ze.com/api/vehicle/VVVV/air-conditioning/last"

This returns information about who or what sent the request:

{
    "date": 1476538293000,
    "type": "USER_REQUEST",
    "result": "SUCCESS"
}

Preconditioning History

You can also see how often your car has been preconditioned.

curl \
   -H "Authorization: Bearer AAAA" \
   https://www.services.renault-ze.com/api/vehicle/VVVV/air-conditioning?begin=1016&end=1016

[{
    "date": 1476165377000,
    "type": "USER_REQUEST",
    "result": "ERROR"
}, {
    "date": 1476079325000,
    "type": "CAR_NOTIFICATION",
    "result": "ERROR"
}, {
    "date": 1476079270000,
    "type": "USER_REQUEST",
    "result": "SUCCESS"
}, {
    "date": 1476079266000,
    "type": "CAR_NOTIFICATION",
    "result": "SUCCESS"
}]

Start Charging

You may have set your Zoe only to charge at specific times - perhaps to take advantage of cheap rate electricity. You can override this by issuing the charge command.

curl \
   -H "Authorization: Bearer AAAA" \
   https://www.services.renault-ze.com/api/vehicle/VVVV/charge

Again, this won't return a response. If your battery cannot be charged, you'll be notified via email or SMS depending on the preference you set up when you registered.

Charging History

curl \
   -H "Authorization: Bearer AAAA" \
   https://www.services.renault-ze.com/api/vehicle/VVVV/charge/history?begin=1016&end=1016

The begin and end take MMYY as their arguments. That is, if you want October 2016 you need to use 1016.

This returns an array, the most recent charging session at the top.

[{
    "date": 1476538527000,
    "type": "START_NOTIFICATION",
    "charging_point": "SLOW",
    "charge_level": 99,
    "remaining_autonomy": 119
}, {
    "date": 1476472727000,
    "type": "END_NOTIFICATION",
    "charging_point": "INVALID",
    "charge_level": 100,
    "remaining_autonomy": 124
}, {
    "date": 1476462129000,
    "type": "START_NOTIFICATION",
    "charging_point": "ACCELERATED",
    "charge_level": 34,
    "remaining_autonomy": 42,
    "remaining_time": 10500000
}]

The remaining_autonomy is, again, the range in Km. The remaining time is expressed in milliseconds. So 10500000 is the equivalent of 2 hours and 55 minutes.

Notifications

You can use the website to set up notifications. For example, if there is a problem with your charge, Renault will send you an SMS. This API call lets you see what notifications you have set up.

Set Notifications

curl \
   -H "Authorization: Bearer AAAA" \
   -X PUT \
   -H 'Content-Type: application/json;charset=UTF-8' \
   --data-binary '{"battery_status":"EMAIL","charge_start":"SMS","charge_end":"SMS","charge_problem":"SMS","low_battery":"SMS","low_battery_reminder":"SMS","do_not_disturb":null}' \
   'https://www.services.renault-ze.com/api/vehicle/VVVV/settings/notification'

You can change any of the options with EMAIL or SMS.

You can set a "do not disturb" option. This will suppress all notifications during specific times. Sadly, this is a fairly blunt instrument - you can only set one time which then is enforced every day.

In the above example, change "do_not_disturb":null to

"do_not_disturb":{"start":"1710","end":"1811"}}'

This will give you peace between 5:10pm and 6:11pm.

See Notifications

You can use the website to set up notifications. For example, if there is a problem with your charge, Renault will send you an SMS. This API call lets you see what notifications you have set up.

curl \
   -H "Authorization: Bearer AAAA" \
   https://www.services.renault-ze.com/api/vehicle/VVVV/settings/notification

This returns:

{
    "battery_status": "EMAIL",
    "charge_start": "NONE",
    "charge_end": "SMS",
    "charge_problem": "SMS",
    "low_battery": "SMS",
    "low_battery_reminder": "SMS",
    "do_not_disturb": null
}

Charging Times

The Zoe's charging calendar is, sadly, crap. You can say "charge between these times" but you can only have one schedule per day. So if you only want the car to charge between 0300-0700 and 1800-2200 on Mondays - you're out of luck.

It also seemed to force me to set a schedule for every day.

This is a multi-stage process.

Create a schedule

In this example, I'm setting the charging to be active on Monday from 0100 for 1 hour and 15 minutes. All other days start at different times, but last only for 15 minutes. All start times must be at 00, 15, 30, 45 minutes. All durations must be in increments of 15 minutes.

curl \
   -H 'Authorization: Bearer AAAA' \
   -X PUT \
   --data-binary '{"optimized_charge":false,"mon":{"start":"0100","duration":"0115"},"tue":{"start":"0200","duration":"0015"},"wed":{"start":"0300","duration":"0015"},"thu":{"start":"1600","duration":"0015"},"fri":{"start":"1900","duration":"0015"},"sat":{"start":"1400","duration":"0015"},"sun":{"start":"1200","duration":"0015"}}' \
   'https://www.services.renault-ze.com/api/vehicle/VVVV/charge/scheduler/offboard'

View the schedule

Let's make sure the schedule has been sent correctly

curl \
   -H 'Authorization: Bearer AAAA' \
   'https://www.services.renault-ze.com/api/vehicle/VVVV/charge/scheduler/onboard'

Returned - hopefully! - is the schedule:

{
    "enabled": false,
    "schedule": {
        "mon": {
            "start": "0100",
            "duration": "0115"
        },
        "tue": {
            "start": "0200",
            "duration": "0015"
        },
        "wed": {
            "start": "0300",
            "duration": "0015"
        },
        "thu": {
            "start": "1600",
            "duration": "0015"
        },
        "fri": {
            "start": "1900",
            "duration": "0015"
        },
        "sat": {
            "start": "1400",
            "duration": "0015"
        },
        "sun": {
            "start": "1200",
            "duration": "0015"
        }
    }
}

Deploy the schedule

Be default, the schedule isn't activated. It needs to be "deployed" in order to send it to the car.

curl \
   -H 'Authorization: Bearer AAAA' \
   -X POST \
   'https://www.services.renault-ze.com/api/vehicle/VVVV/charge/scheduler/offboard/deploy'

Deactivate the schedule

If you deactivate the schedule then the car will charge whenever it is plugged in.

curl \
   -H 'Authorization: Bearer AAAA' \
   -X PUT \
   --data-binary '{"enabled":false}' \
   'https://www.services.renault-ze.com/api/vehicle/VVVV/charge/scheduler/onboard'

That's all folks?

There are a few other API calls - mostly around registering and removing vehicles, and updating personal details. I've not detailed these because I didn't want to test them with my live account.

What's Missing?

Sadly, the Renault API is quite poor compared to BMW's API. Here's what I'd love to see:

Vehicle status - doors locked, headlights on.
Efficiency - last journey, total.
Mileage.
Physical location.

The End Result

Singing to my light bulbs

@edent — Thu, 19 May 2016 10:56:55 +0000

Because I'm an idiot, I've decided that what my life needs is voice activated lightbulbs. But voice control is so 2015. Let's make these bulbs react to SINGING!

Here's a demo - fair warning, my vocal prowess is "limited".

https://shkspr.mobi/blog/wp-content/uploads/2016/05/Voice-Controlled-Lifx.mp4

OK, here's how to do this.

I recently got a bunch of Lfix bulbs as part of a bug bounty.
There's a full API for the Lifx bulbs.
My mate Ruth has written a great demo on the Chome Web Speech API
So, speech + Lifx = awesome.

This was a 5 minute hack, so my code is quite shameful, but here are the basics.

Firstly, we need an HTML page with JavaScript to detect the speech. At the moment, this only seems to work in Chrome (AKA the IE6 of 2016).

var red  = ["red", "read","ret"];
var yellow  = ["yellow", "yell", "yeah"];

// new instance of speech recognition
var recognition = new webkitSpeechRecognition();
recognition.lang = "en-GB";

// set params
recognition.continuous = true;
recognition.interimResults = true;
recognition.start();

recognition.onresult = function(event){

  // delve into words detected results & get the latest
  // total results detected
  var resultsLength = event.results.length -1 ;
  // get length of latest results
  var ArrayLength = event.results[resultsLength].length -1;
  // get last word detected
  var saidWord = event.results[resultsLength][ArrayLength].transcript;
  saidWord = saidWord.trim();

  console.log(saidWord);
  xmlhttp=new XMLHttpRequest();

  if (red.indexOf(saidWord) >= 0)
  {
      console.log("sending red!");

      xmlhttp.open("GET","lifx.php?colour=red",true);
      xmlhttp.send();
  }

  if (yellow.indexOf(saidWord) >= 0)
  {
      console.log("sending yellow!");

      xmlhttp.open("GET","lifx.php?colour=yellow",true);
      xmlhttp.send();
  }

If it detects one of our magic words, it sends it to a server component. I just don't trust JavaScript with my API keys. The server page is a simple PHP script.

$link = "https://api.lifx.com/v1/lights/all/state";
$authToken = "";
$colour = htmlspecialchars($_GET["colour"]);
$data = array("color" => $colour, "duration" => "0.5");
$ch = curl_init($link);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_POSTFIELDS,http_build_query($data));

$headers = array('Authorization: Bearer ' . $authToken);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);

Take the colour and send it to the bulb. Make the transition time fairly quick (half a second). The "Rainbow" command just sends random colours with a much shorter transition.

And... err... that's it! The Lifx API lets you send colours as strings, hex codes, HSB, etc, so it is fairly flexible.

Sure, I could have bought an Amazon Echo (not available in my country) or a Google Home (not launched, will be abandoned next year) or a Raspberry Pi (too easy to lose) or built an app for my phone (just too much hard work) - but I'm quite happy playing around in the browser.

Here's the video again, if you like watching things on Twitter.

If you enjoyed this blog post, buy yourself some Lifx bulbs or you could send me something from my wishlist.

The absolute horror of WiFi light switches

@edent — Wed, 02 Mar 2016 12:01:55 +0000

I've just got a WiFi light switch.

As I've explained previously, swapping out all my existing light bulbs with Smart Bulbs would be hugely expensive and has the disadvantage of not working when the switches are off at the wall.

A WiFi light switch (theoretically) allows me to control the lights from my phone - and anyone else to use the physical buttons on the wall. That helps avoid this scenario:

WiFi built into the switch means I don't need to use a hub to control my devices - I can connect directly to them and not have to worry about hardware incompatibilities.

The UK has a unique way of wiring houses which doesn't lend itself well to automated control. The switches which work in the USA and EU, simply won't work in a UK set up. This makes switches rare and expensive.

I've gone for the Lanbon WiFi Light Switch - £50 on Amazon - or around £35 direct from China. For more technical information (although not much) take a look at the L5-HSGT1's product page.

What's In The Box

The switch itself is pretty good looking:

The back is slightly weird - this is obviously a fairly generic design which can be re-purposed for multiway switches.

As for the rest of the kit...

Yup! A pair of mounting screws - that's it! No fitting instructions, no glossy leaflet, nothing! Oh well, how hard can this thing be to install...

Wiring In

Working with electricity is dangerous. Remember to switch off the power to your lights at your consumer unit. If in doubt, get a qualified electrician to help. I followed this guide to replacing UK light switches.

Wiring the switch is trivial - as long as you can remember which wire is which. There's just one small problem... The depth of the pattress box is insufficient to contain the switch! Obviously microchips aren't quite a tiny as necessary yet.

OK, I can try drilling that deeper later - let's power up this baby and see if it works!

Blinken lights! Touching the light icon provides a satisfying "clunk" somewhere inside the switch, but didn't change the state of the lights. Perhaps it needs to be set up first?

The App

Remember when I said that the package didn't come with any instructions? That wasn't quite true - there are some QR codes on the side:

A quick scan and...

Hmmm... Do I really want to download an app from China over HTTP? Guess I don't have a choice!

Interestingly, the Lanbon website offers a more recent version of the app to download. This obviously isn't an organisation set up with high-quality "it just works" in mind.

I prepared to install the app - when I was hit by this:

Those are some ridiculously scary permissions! I can understand wanting microphone access (voice control) and maybe GPS (turn lights on when I get home) - but why does this want to send SMS or place calls? Why does it need my contacts and the ability to take photos?

A quick virus scan showed nothing overtly malicious - but I decided to offer up a sacrificial tablet to run the app on. No way am I risking my main device with this software!

The software is of the usual sub-standard quality I've come to expect from cheap electronics. No set-up wizard, just dumped into a complicated screen.

Pressing the "User Manual" button gave this monstrosity:

I held down the light switch button until the WiFi indicator started flashing. I then connected my tablet to the WiFi (a separate network - I didn't want to risk sticking this on the same network as everything else yet). I clicked the "Auto Search" button and, somehow, the tablet found the switch and set it the network's details. Result!

The app presents this rather lazily designed screen. Only the blue icon on the left works as a switch.

Let There Be Light!

And, dear reader, can you guess what happened when I clicked it?

Yup - the square-root of bugger-all!

Under The Covers

Before trying it on another socket, I thought I'd crack it open to see what's going on inside. As I suspected, it's a generic unit which can be used for 1-, 2-, or 3-gang switches. No LEDs are soldered on to the spare ports. Interesting to note a different part number printed on the inside - L5 HSCL LB v16.

Remaining Neutral!

I made a telephone call to Prad - the Amazon seller who supplied me with the switch - he was incredibly helpful but sadly confirmed that the switch requires a neutral wire. Something which had unfortunately been left out of his listing.

It turns out that this lack of neutral wiring is a common problem.

The WiFi Plug Glass has this fairly prominent warning:

And Vesternet have an excellent page explaining the challenges of fitting smart switches to UK homes.

Short of rewiring parts of my house, it looks like the switch will be useless to me. So back it goes.

Decompiling the Software

Part of the problem with the software is that it is designed to work with a suite of products. It contains references to security cameras, home alarm systems, infrared controllers, fans, curtain controllers, and half-a-dozen other things.

There's no widget support - which is crucial for a lighting app. No one wants to find an app, wait for it to open, find the right light etc. I just want to put a simple toggle on my homescreen - in exactly the same way Lifx does.

As far as I can tell, there's nothing malicious in the software - it's just poorly constructed. Well… in this version.

Of course, with Android Lollipop's new permission model, I can deny the app access to anything that I'm uncomfortable with. During my brief use of the app it didn't ask for anything other than WiFi access.

API

As I didn't get the switches working, I didn't dive too deeply into the API. I did spot this curious activity though.

When the light switch wasn't connected to the WiFi, the app assumes that it is on a different network to the switch and tries to communicate over a cloud service.

That IP is hard-coded into the app.

whois 58.96.172.115? An unknown server in Hong Kong! The venerable nmap reckons the server is running Microsoft Windows Vista Home Premium SP1, Windows 7, or Windows Server 2008. Ok...

Right, it's communicating on port 80 - but let's see what incredibly secure authentication it is performing...

Hmmm... Some of those numbers look familiar...

Ah. So it sends a packet with the light switch's ID number in it. That appears to be all. I assume that the switch makes a similar persistent connection to that IP address so it can listen out for instructions. I was too scared to port scan the light switch.

I'm guessing, with a small amount of effort, you could toggle strangers' lights to your heart's content.

Verdict

It looks like I'm going to have to go for the hub and spoke model of smart switches. That is, a light switch which trickles enough electricity to power an RF receiver while keeping the lights off - controlled by a WiFi connected hub.

Hopefully one which is more secure than this!

Onwards!

Cheap BlueTooth Buttons and Linux

@edent — Sat, 20 Feb 2016 18:06:40 +0000

Selfie sticks - like most modern inventions - are utter tosh. But they've rapidly brought down the price of Bluetooth buttons. So who am I to complain?

Let's take the venerable AB Shutter 3 - You can find it on Amazon for around £2 including postage - or around $2 on AliExpress. Frankly, that's stupidly cheap.

OK, let's put this to work as something other than a vanity clicker! There are no instructions which come with this, it's delivered in a little plastic bag and that's it. Time to get hacking!

Aim

Once paired to a server, like the Raspberry Pi, pressing the button should run a program to turn on my Lifx bulbs.

Cracking It Open

With the battery panel slipped off and the cell removed, it's fairly easy to open the case. Fingernails are sufficient - no screws or glue!

It's an AIROHA AB1126A.

AB1126A is an optimized single-chip solution which integrates baseband and radio for wireless human input device applications especially for remote smartphone camera control. It complies with Bluetooth system version 3.0.

But what happens when we ZOOM! ENHANCE!?

The 24C16N is a fairly generic EEPROM.

But what's this?!?! The chip is listed as an AB1127A. A chip which, seemingly, doesn't exit. Onwards!

Getting Started

When switched into the "on" position, the dongle is ready to pair.

From the Ubuntu command line:

$ hcitool scan
Scanning ...
   80:00:00:00:EE:E0   AB Shutter 3

Aha! We've found it. What sort of device is it?

$ hcitool inq
Inquiring ...
   80:00:00:00:EE:E0   clock offset: 0x0acd   class: 0x002540

It shows up a a keyboard. Let's connect to it and trust it.

$ bluez-simple-agent hci0 80:00:00:00:EE:E0
   Release
   New device (/org/bluez/794/hci0/dev_80_00_00_00_EE_E0)
$ bluez-test-device trusted 80:00:00:00:EE:E0
$ bluez-test-input connect 80:00:00:00:EE:E0

To check that it is seen and connected properly:

$ xinput
    ↳ AB Shutter 3   id=13   [slave  keyboard (3)]

Nice! Running xinput query-state "AB Shutter 3" allows us to see which keyboard keys are activated when the buttons are pressed.

It turns out that the iOS buttons sends Volume Up (key 123) whereas the Android button sends Enter (key 36).

It works! Sorta...

Pressing the selfie-button instantly sends the command to my computer! Well... until the button goes to sleep. The device is powered by a CR2032 battery which, despite the power efficiencies of Bluetooth, isn't magical.

After a few minutes of idleness, the device goes to sleep. Pressing any button wakes it up and repairs the connection - but then another button press is required to send a key press. The pairing process only takes a couple of seconds, so it's not quite instant.

Make it do something useful

Having an external button which can increase the volume or send an enter command isn't very useful. I want to press the button and have a program run which will (for example) turn on my lights.

Run a program when the Bluetooth connection is made

Because the device goes to sleep after a few minutes of inactivity, we need a way to listen for a connection. So, when a button is pressed for the first time, the device connects and a program is run.

I've half-inched the instructions from this InOut Board tutorial.

First of all, make sure Python has the ability to work with Bluetooth: sudo apt-get install python-bluez

#!/usr/bin/python

import bluetooth
import time

while True:
    print "Checking " + time.strftime("%a, %d %b %Y %H:%M:%S", time.gmtime())

    result = bluetooth.lookup_name('80:00:00:00:EE:E0', timeout=5)
    if (result != None):
        print "Device detected"
        # Do Something
    else:
        print "Device NOT detected"

    time.sleep(6)

With that running constantly in the background, you can perform an action whenever the device connects.

Run a program when a button is pressed

Right, this is where it gets tricky! Ubuntu doesn't seem to differentiate between different keyboards attached to a device. This means you can't use loadkeys to swap keys, nor xkb.

You can, however, use xkbcomp to remap the buttons on a specific device (thanks to Stephen Wing for that tip).

This will convert the Volume Up to XF86Launch1 and Enter to XF86Launch2 - those are multimedia keycodes which shouldn't be assigned to anything by default.

remote_id=$(
    xinput list |
    sed -n 's/.*AB Shutter 3.*id=\([0-9]*\).*keyboard.*/\1/p'
)
[ "$remote_id" ] || exit

mkdir -p /tmp/xkb/symbols
cat >/tmp/xkb/symbols/custom <<\EOF
xkb_symbols "remote" {
    key   { [ XF86Launch1 ] };
    key   { [ XF86Launch2 ] };
};
EOF

setxkbmap -device $remote_id -print | sed 's/\(xkb_symbols.*\)"/\1+custom(remote)"/' | xkbcomp -I/tmp/xkb -i $remote_id -synch - $DISPLAY 2>/dev/null

The script needs to be re-run every time the Bluetooth connection is re-established. Probably best to run it on reconnect as part of the Python code above.

So, that remaps the inputs for that Bluetooth button. Ok, but how do we get XF86Launch1 to launch a program?

It's pretty easy to set keyboard shortcuts in the GUI- but how do we do it on the command line? Well, you can't. There's no way to tell a shell to run a program when a specific key has been pressed.

So, it's back to Python and listening for the key to be pressed. Which I have no idea how to do!

If you know how to detect multimedia keys, please leave a comment or answer this StackOverflow question.

Or - let me know a better, more obvious way that I'm missing!

BlueTooth buttons are available on AliExpress and Amazon for UK customers.

Raspberry Pi Zero Hidden In An Xbox Controller

@edent — Mon, 30 Nov 2015 08:22:21 +0000

I like to tinker. My wife picked me up the new Raspberry Pi Zero. It's an ultra small and ridiculously cheap computer. How small and cheap? They give it away free on the cover of magazines...

Ok, so what can I do with a wafer-thin Linux box? I had thought of turning it into a simple door sensor, or perhaps wiring it in to a lightswitch, or swallowing it to see if I would get super powers. Then it struck me - turn it into a games console!

Now, don't get me wrong, this has been done many times before - but I think I've come up with a unique twist. Build it directly into the controller!

My original plan was to buy some USB NES controllers - they're about the right size, but with only two buttons I'd be restricted to playing, well, old NES games. Also, buying new plastic stuff... nah! Reduce, Reuse, Recycle!

Long term readers will remember that I turned my original Xbox into a Linux running media centre. I still have the original (giant) controllers, my brilliant wife suggested that there was probably enough space in one to fit the Pi Zero.

Let's Go!

Getting Started

WARNING! Playing around with electric items can be dangerous. You risk damaging yourself or, worse, breaking your toys. Proceed with caution.

Equipment

Raspberry Pi Zero (£5).
Original large-sized Xbox Controller (£variable).
USB OTG cable (65p).
2A USB power supply (£5).
Mini HDMI adapter (80p) or Mini HDMI cable (£5).
MicroSD card (£5).
The usual assortment of screwdrivers, knives, wire-strippers, and nerves of steel!

Right, remember this big brute?

The Pi nestles neatly between the triggers, so it should fit.

Open it up:

I removed the chunky memory card holder. I left in the physical slots as a wedge to hold the Pi.

After unscrewing all the cross-head screws, we can see how well it fits.

Nifty!

Ah, but can you spot the problem?

The Pi is blocking that strut. Only one thing to do...

The plastic was soft enough that a penknife made short work of this.

As you can see, the inside of the controller has lots of room.

In order to connect the controller to the Pi, we need to do some wire stripping. The Xbox controller uses bog-standard USB wiring, but has a proprietary plug. So, chop the ends of that and wire it into a USB OTG cable.

I suppose I could have just wired in a regular USB plug, or bought an Xbox USB adapter. But where's the fun in that?

One thing to note, you'll need to insulate the bottom of the Pi against all the contacts on the controller. For this quick hack, I'm using some of the cardboard packaging. Not exactly sustainable from a long term POV! Nor is the BluTak used to hold everything into place.

So, the controller's cable loops back into itself and plugs into the Pi. The Pi takes in power and outputs over HDMI.

It would have been great if HDMI also supplied the power - but I don't think that's possible. There is enough space inside the controller for a USB battery pack should you want a more portable solution.

And... errr... that's it really!

Emulation

The good folks at RetroPie have a pre-built image which contains everything you need in order to run a variety of emulators. It even includes some built in shareware games.

We want the build for the Raspberry Pi version 1. It automagically detected the Xbox controller, and after a few clicks I was playing Doom!

The Raspberry Pi Zero is, without exaggeration, a marvel.

When I was a kid, computers were unreasonably expensive. I remember reading this passage from The Demon Headmaster series of books:

I felt so angry that the computer revolution was restricted to those whose parents or schools could afford such luxuries. The Pi is (almost) cheap enough to give away with cornflakes. Sure, the sundry items cost a little bit more - but this puts powerful computers within the reach of everyone.

The size is also... It's almost too small! If you lose one in your home, it's probably cheaper to buy another than waste an hour looking for it. That also means it can sneak into unexpected places - I can see kids hiding these in games controllers, hair brushes, or flick knives. Add a battery pack and a mesh-networking module and you've got a communications infrastructure that a school cannot censor.

Interesting times ahead!

Update! Well, that went better than expected. You can read what people have to say about the project at:

Reverse Engineering the BMW i3 API

@edent — Fri, 27 Nov 2015 12:03:32 +0000

I'm really enjoying driving the BMW i3.

I'd love to have it tweet its driving efficiency, or upload its location to my server, or let me turn on its air-conditioning when the temperature gets too warm - there are a hundred interesting things to do with the car's data. The official app has some of these features - but is slow, ugly, and a pain to use.

BMW used to have an API available for hackathons, but they shut it down.

Right! Only one thing to do - HACK THE MAINFRAME*!

https://shkspr.mobi/blog/wp-content/uploads/2015/11/sp.mp4

*No mainframes were harmed in the writing of this blog post

Aim

The ultimate aim is to get access to all the car's functions which are exposed by the API - so I can do something like this:

Equipment

For this relatively simple bit of work you will need...

A BMW i3.
An account with BMW's ConnectedDrive.
The BMW i Remote App for Android. (I'm using the non-US version.)
An Android phone or tablet.
A way to intercept encrypted communications leaving your device - I recommend Packet Capture by Grey Shirts.

With Packet Capture installed, close all other apps, start the logging, then log in to the i Remote app. Click around on a few functions, then flip back to the Packet Capture app.

You'll see a bunch of API calls which have been captured.

Click on one and you'll see the full API call, plus the JSON response. I've stripped out some of my personal details.

The most important thing you'll need is the Authorization: Bearer token. This is a 32 character alphanumeric string.

Description

The latest version can always be found on GitHub.

These API calls are designed to allow you to interact with your BMW i3. They were reverse engineered from the official BMW i Remote Android app.

Your use of these API calls is entirely at your own risk. They are neither officially provided nor sanctioned.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Servers

There are three API servers.

https://b2vapi.bmwgroup.cn:8592 China
https://b2vapi.bmwgroup.us USA
https://b2vapi.bmwgroup.com Europe / Rest of World

Authorisation

In order to authenticate against the API you will need to be registered on BMW's Connected Drive service.

You will need:

Your ConnectedDrive registered email address.
Your ConnectedDrive registered password.
The i Remote API Key.
The i Remote API Secret.

You can get the i Remote details from either decompiling the Android App or from intercepting communications between your phone and the BMW server. This is left as an exercise for the reader ☺

Firstly, we use Basic authentication. That means taking the API Key and Secret and Base64 encoding them.

So key:secret becomes a2V5OnNlY3JldA==

We also need to send the following parameters as

Content-Type: application/x-www-form-urlencoded

 grant_type=password
&username=whatever%40example.com
&password=p4ssw0rd
&scope=remote_services+vehicle_data

Here's how to do it with curl:

curl \
   -H "Authorization: Basic a2V5OnNlY3JldA==" \
   -H "Content-Type: application/x-www-form-urlencoded" \
   -d "grant_type=password&username=whatever%40example.com&password=p4ssw0rd&scope=remote_services+vehicle_data" \
   "https://b2vapi.bmwgroup.com/webapi/oauth/token/"

If everything has worked, you should get back the following JSON:

{
  "access_token": "RCQ1hLP4AFaUBW9BjcPUN3i4WgkwF90R",
  "token_type": "Bearer",
  "expires_in": 28800,
  "refresh_token": "7WgKmEJ2kD1ydl9Hefp01eS8qDGzKnzjeORpA6vtsoFIEanz",
  "scope": "vehicle_data remote_services"
}

You must include

Authorization: Bearer RCQ1hLP4AFaUBW9BjcPUN3i4WgkwF90R

in your headers with every request.

The expires_in is in seconds - giving you 8 hours before you have to renew the token.

I've no idea what the refresh_token is for. Once the access_token expires, you can simply re-authenticate and gain a new one.

API

You must include

Authorization: Bearer RCQ1hLP4AFaUBW9BjcPUN3i4WgkwF90R

in your headers with every request.

Get Vehicle Data

/webapi/v1/user/vehicles/
- Remember to include the Authorization: Bearer header.

The most important thing here is the VIN - Vehicle Identification Number. You'll need that for all the other API calls as well as the Authorization Bearer.

Response

{
    "vehicleStatus": {
        "vin": "WAB1C23456V123456",
        "mileage": 1234,
        "updateReason": "VEHICLE_SHUTDOWN_SECURED",
        "updateTime": "2015-10-30T18:45:04+0100",
        "doorDriverFront": "CLOSED",
        "doorDriverRear": "CLOSED",
        "doorPassengerFront": "CLOSED",
        "doorPassengerRear": "CLOSED",
        "windowDriverFront": "CLOSED",
        "windowDriverRear": "CLOSED",
        "windowPassengerFront": "CLOSED",
        "windowPassengerRear": "CLOSED",
        "trunk": "CLOSED",
        "rearWindow": "INVALID",
        "convertibleRoofState": "INVALID",
        "hood": "CLOSED",
        "doorLockState": "SECURED",
        "parkingLight": "OFF",
        "positionLight": "OFF",
        "remainingFuel": 8.9,
        "remainingRangeElectric": 73,
        "remainingRangeElectricMls": 45,
        "remainingRangeFuel": 126,
        "remainingRangeFuelMls": 78,
        "maxRangeElectric": 134,
        "maxRangeElectricMls": 83,
        "fuelPercent": 99,
        "maxFuel": 9,
        "connectionStatus": "DISCONNECTED",
        "chargingStatus": "INVALID",
        "chargingLevelHv": 58,
        "lastChargingEndReason": "UNKNOWN",
        "lastChargingEndResult": "FAILED",
        "position": {
            "lat": 51.123456,
            "lon": -1.2345678,
            "heading": 211,
            "status": "OK"
        },
        "internalDataTimeUTC": "2015-10-30T18:47:44"
    }
}

Values

mileage is in Km.
remainingFuel is in Litres.
maxRangeElectric is in Km.
maxRangeElectricMls is in miles.
chargingLevelHv is the percentage of charge left in the (High voltage?) battery.
maxFuel is in Litres.
heading is in degrees.

Valid chargingStatuses appear to be:

CHARGING
ERROR
FINISHED_FULLY_CHARGED
FINISHED_NOT_FULL
INVALID
NOT_CHARGING
WAITING_FOR_CHARGING

Valid connectionStatuses appear to be:

CHARGING_DONE
CHARGING_INTERRUPED [sic]
CHARGING_PAUSED
CHARGIN_STARTED [sic]
CYCLIC_RECHARGING
DOOR_STATE_CHANGED
NO_CYCLIC_RECHARGING
NO_LSC_TRIGGER
ON_DEMAND
PREDICTION_UPDATE
TEMPORARY_POWER_SUPPLY_FAILURE
UNKNOWN
VEHICLE_MOVING
VEHICLE_SECURED
VEHICLE_SHUTDOWN
VEHICLE_SHUTDOWN_SECURED
VEHICLE_UNSECURED

Get Last Trip

Shows the details about your most recent trip.

/webapi/v1/user/vehicles/:VIN/statistics/lastTrip
- Where :VIN is your vehicle's VIN.
- Remember to include the Authorization: Bearer header.

Response

{
   "lastTrip":{
      "efficiencyValue":0.53,
      "totalDistance":141,
      "electricDistance":100.1,
      "avgElectricConsumption":16.6,
      "avgRecuperation":2,
      "drivingModeValue":0,
      "accelerationValue":0.39,
      "anticipationValue":0.81,
      "totalConsumptionValue":0.79,
      "auxiliaryConsumptionValue":0.66,
      "avgCombinedConsumption":1.9,
      "electricDistanceRatio":71,
      "savedFuel":0,
      "date":"2015-12-01T20:44:00+0100",
      "duration":124
   }
}

Values

Distances appear to be in Kilometres rather than miles, so be sure to adjust accordingly. Multiply by 0.621371 to get miles.

totalDistance is in Km.
electricDistance is in Km.
avgElectricConsumption is in kWh/100Km.
avgRecuperation is in kWh/100Km.
duration is in minutes.

To convert kWh/100Km to Miles/kWh.

1 / (0.01609344 * avgElectricConsumption)

Get Charging Times

Shows when the car is scheduled to charge.

/webapi/v1/user/vehicles/:VIN/chargingprofile
- Where :VIN is your vehicle's VIN.
- Remember to include the Authorization: Bearer header.

Response

{
   "weeklyPlanner":{
      "climatizationEnabled":true,
      "chargingMode":"DELAYED_CHARGING",
      "chargingPreferences":"CHARGING_WINDOW",
      "timer1":{
         "departureTime":"07:30",
         "timerEnabled":true,
         "weekdays":[
            "MONDAY"
         ]
      },
      "timer2":{
         "departureTime":"13:00",
         "timerEnabled":false,
         "weekdays":[
            "SATURDAY"
         ]
      },
      "timer3":{
         "departureTime":"08:00",
         "timerEnabled":false,
         "weekdays":[

         ]
      },
      "overrideTimer":{
         "departureTime":"07:30",
         "timerEnabled":false,
         "weekdays":[
            "MONDAY"
         ]
      },
      "preferredChargingWindow":{
         "enabled":true,
         "startTime":"05:02",
         "endTime":"17:31"
      }
   }
}

Values

departureTime appears to be the car's local time.

Get Vehicle Destinations

Shows the destinations you've previously sent to the car.

/webapi/v1/user/vehicles/:VIN/destinations
- Where :VIN is your vehicle's VIN.
- Remember to include the Authorization: Bearer header.

Response

{
   "destinations":[
      {
         "lat":51.53053283691406,
         "lon":-0.08362331241369247,
         "country":"UNITED KINGDOM",
         "city":"LONDON",
         "street":"PITFIELD STREET",
         "type":"DESTINATION",
         "createdAt":"2015-09-25T08:06:11+0200"
      }
   ]
}

Values

An array of locations.

Get All Trip Details

Shows the statistics for all trips taken in the vehicle.

/webapi/v1/user/vehicles/:VIN/statistics/allTrips
- Where :VIN is your vehicle's VIN.
- Remember to include the Authorization: Bearer header.

Response

{
    "allTrips": {
        "avgElectricConsumption": {
            "communityLow": 0,
            "communityAverage": 16.33,
            "communityHigh": 35.53,
            "userAverage": 14.76
        },
        "avgRecuperation": {
            "communityLow": 0,
            "communityAverage": 3.76,
            "communityHigh": 14.03,
            "userAverage": 2.3
        },
        "chargecycleRange": {
            "communityAverage": 121.58,
            "communityHigh": 200,
            "userAverage": 72.62,
            "userHigh": 135,
            "userCurrentChargeCycle": 60
        },
        "totalElectricDistance": {
            "communityLow": 1,
            "communityAverage": 12293.65,
            "communityHigh": 77533.6,
            "userTotal": 3158.66
        },
        "avgCombinedConsumption": {
            "communityLow": 0,
            "communityAverage": 1.21,
            "communityHigh": 6.2,
            "userAverage": 0.36
        },
        "savedCO2": 87.58,
        "savedCO2greenEnergy": 515.177,
        "totalSavedFuel": 0,
        "resetDate": "1970-01-01T01:00:00+0100"
    }
}

Values

chargecycleRange is in Km.
totalElectricDistance is in Km.

I'm not sure what units of the other values are.

Get Range Map

Generate a polyline displaying the predicted range of the vehicle.

/webapi/v1/user/vehicles/:VIN/rangemap
- Where :VIN is your vehicle's VIN.
- Remember to include the Authorization: Bearer header.

Response

{
    "rangemap": {
        "center": {
            "lat": 51.123456,
            "lon": -1.2345678
        },
        "quality": "AVERAGE",
        "rangemaps": [
            {
                "type": "ECO_PRO_PLUS",
                "polyline": [
                    {
                        "lat": 51.6991281509399,
                        "lon": -2.00423240661621
                    },
                    {
                        "lat": 51.6909098625183,
                        "lon": -1.91526889801025
                    },
                    ...
                ]
            },
            {
                "type": "COMFORT",
                "polyline": [
                    {
                        "lat": 51.7212295532227,
                        "lon": -1.7363977432251
                    },
                    {
                        "lat": 51.6991496086121,
                        "lon": -1.73077583312988
                    },
                    ...
                ]
            }
        ]
    }
}

Values

ECO_PRO_PLUS driving using the efficient Eco mode.
COMFORT driving using comfort mode.

Sending information to the car

Sending information to the car is slightly complicated.

Your app communicates with the API, the API then communicates with the car's 3G modem, then you have to wait for a response.

If your car is in poor coverage, you can expect significant latency. Often much higher than a typical timeout will allow for.

At a basic level, you can just send a request - for example to lock the doors, or set off-peak charging.

Get Request status

Shows the status of a POSTed request

/webapi/v1/user/vehicles/:VIN/serviceExecutionStatus?serviceType=:SERVICE
- Where :VIN is your vehicle's VIN.
- Remember to include the Authorization: Bearer header.

Response

{
   "executionStatus":{
      "serviceType":"DOOR_LOCK",
      "status":"EXECUTED",
      "eventId":"123456789012345AB1CD1234@bmw.de"
   }
}

Values

Valid statuses are:

DELIVERED
EXECUTED
INITIATED
NOT_EXECUTED
PENDING
TIMED_OUT

The following are valid :SERVICE types, but may not be supported by your vehicle.

CHARGE_NOW
CHARGING_CONTROL
CLIMATE_CONTROL
CLIMATE_NOW
DOOR_LOCK
DOOR_UNLOCK
GET_ALL_IMAGES
GET_PASSWORD_RESET_INFO
GET_VEHICLES
GET_VEHICLE_IMAGE
GET_VEHICLE_STATUS
HORN_BLOW
LIGHT_FLASH
LOCAL_SEARCH
LOCAL_SEARCH_SUGGESTIONS
LOGIN
LOGOUT
SEND_POI_TO_CAR
VEHICLE_FINDER

POST a command

Instructs the car to perform an action.

/webapi/v1/user/vehicles/:VIN/executeService
- Where :VIN is your vehicle's VIN.
- Remember to include the Authorization: Bearer header.

Available Commands

These commands are all available via the API, but may not be supported by your vehicle.

These are just what I've discovered so far.

Data must be POSTed to the server.

Initiate Charging

If the vehicle is plugged in, but not charging (due to an off peak setting?) it is possible to force the car to charge.

serviceType=CHARGE_NOW

Start Climate Control

This will activate climate control within your vehicle.

It appears to be limited to the last temperature you set when you were in the car. I can't find a way to instruct the car to reach a specific temperature.

serviceType=CLIMATE_NOW

Lock the doors

Performs central locking.

serviceType=DOOR_LOCK

Unlock the doors

This will unlock all the doors on your vehicle.

Please use extreme caution when sending this command. Ensure that you are in sight of the vehicle and are able to lock it if needed.

serviceType=DOOR_UNLOCK

Flash the headlights

If you can't find the vehicle, or need to illuminate something in its vicinity, you can briefly activate the headlights.

serviceType=LIGHT_FLASH&count=2
- I assume that count relates to the number of seconds to keep the light on?

Charging Schedule

Set the peak / off peak charging schedule.

serviceType=CHARGING_CONTROL
- I haven't bothered to figure this out, but the error it returns should give you some pointers:

{
   "error":{
      "code":500,
      "description":"(SmartPhoneUtil-A-102) Bad value(s) for parameter(s): Invalid chargingProfile, expected weeklyPlanner or twoTimesTimer"
   }
}

Vehicle Finder

serviceType=VEHICLE_FINDER
- I'm not sure what this does.

Response

An example response for all POST commands:

{
    "executionStatus": {
        "serviceType": "LIGHT_FLASH",
        "status": "INITIATED",
        "eventId": "123456789012345AB1CD1234@bmw.de"
    }
}

What's Next

Using these commands you should be able to replicate the functionality of the official app.

As you can see, I've managed to get my car to Tweet:

It would be lovely if BMW decided to open up an official API so that people could fiddle with their cars. The API seems secure and there's limited scope for damaging the vehicles.

I've added all the documentation to GitHub. Please raise an issue or send a Pull Request with any changes.

Adding WiFi To A Roomba

@edent — Thu, 05 Mar 2015 12:35:10 +0000

There are two very clear signs that I'm getting old. The first is that I bought a domestic robot to help me with the chores. The second is that, rather than spending my evenings and weekends reading decades old forum postings, reverse engineering serial interfaces, and soldering components together - I plunked €99 on a bit of kit which "just works".

Enter the Thinking Cleaner - it's a replacement faceplate for Roombas which adds WiFi and a sweet hackable API.

This post looks at how the unit performs - its good points and its flaws - and how the API works.

Let's take a step back. The Roomba 620 is iRobot's entry level vacuum cleaning robot. Unlike the more expensive models, the 620 doesn't have any scheduling - you have to manually set the Roomba to clean. The Thinking Cleaner is a cheap way of adding a brain and extra connectivity to an otherwise simple robot.

A few days after ordering, the package arrived from the Netherlands.

The instructions say that you should carefully remove the cover from the Roomba. To be honest, I was a little nervous about this. The plastic feels fragile and tightly clipped on. That said, it pealed off easily without breaking.

The whole process really was as quick as this video demonstrates :

The replacement cover is delightful gunmetal grey - I think it looks better than the white original. Although the WiFi unit protrudes from the surface, it doesn't seem any taller than the Roomba's sensor.

Incidentally, flipping the cover over reveals the WiFi unit. I may be wrong, but the casing looks 3D printed.

The cover also has a sticker with the MAC address on it.

Clipping the new cover on took seconds. Resulting in a little flashing LED on the unit.

Set Up

Ok, here's where things went a little awry. The Thinking Cleaner needs to connect to a WiFi network. To set this up, you need to connect to the Roomba via an app. When I initially installed it, the Android App didn't yet work on Lollipop. I had to dig out an old Android tablet to get it connected. Literally two hours afterwards the Android app updated - whereupon it worked flawlessly with Lollipop!

The unit only works on 2.4GHz WiFi - not a huge problem. If you're in the US, the unit won't work on channels 12 and 13.

The App is simple enough to use - allowing you to set the Roomba cleaning, drive it yourself, set up a schedule, and get alerts from the cleaner.

It will also send you notifications when something interesting happens to your robot.

The Web Interface

The app doesn't tell you the IP address which the Roomba is using. This is an annoying oversight. You'll need to pop on to your WiFi router and see what it has been assigned.

There is a basic web interface but there is no security available - not even a username and password. Any one who has access to your your WiFi network will also have full access to your Roomba. Make sure that when any friends come round, you give them access to a guest WiFi network - and try to make sure that your WiFi and LAN are as secure as possible.

There is currently no way to set a user name and password.

The web interface is basically fine - it doesn't look brilliant, and the colours are a bit intense - but it allows you to control the Roomba and set up scheduling.

It also works well on mobile web browsers :

That's pretty handy if you're inside your house - but what if you want to get notifications or control it while you are away?

Remote Access

In order to access your device when about and about, you need to sign up for a free ThinkingSync. That's a safer and easier option than teaching users how to set up Port Forwarding and getting them to punch holes in their firewalls - they have a detailed privacy page which explains their reasoning.

To connect to your Thinking Cleaner when you are not at home without modifying your home network settings, you need a (free) account on Thinkingsync server. Thinking Cleaner will periodically contact the server and check for updates. Maximum delay is approximately 1 minute. You can log in or sign up here.
For push notifications on your smartphone you need an account. Without an account you can only use the app when your are connected to the same wifi network as your Thinking Cleaner.
Firmware updates are only possible when logged in to your account. Documentation

There are two main problems I have with this :

Availability. I've no control over the uptime of their server. If it breaks, or they decide to stop offering the service, or want to charge for it - I'm out of luck. They have indicated that they're willing to allow people to run their own servers. I'll have to give that a go!
Registration is not done over https! I don't like sending passwords in clear text which then allow access to a robot operating inside my house! Call me a paranoid hacker - but it just doesn't feel safe.

I think it's time to put my Roomba on it's own VLAN!

There is only one account available per Roomba. I guess this makes sense - although I'm not quite sure if I can have cleaning alerts sent to my phone, while my wife's phone only gets low battery alerts.

If you're out of the house, the app doesn't seem to be able to access the remote driving, nor the scheduling. Again, probably sensible. You don't want to be driving blind.

The API

If you don't fancy getting your hands dirty Thinking Cleaner have some pre-built API integrations - allowing you to connect your Roomba to a variety of existing home automation services and the Pebble smart watch!

For those of us who like to fiddle, there's a (mostly) REST API with comprehensive documentation. This spits back JSON so should be fairly easy to work with.

Once again, there's no authentication - so anyone with access to your network can force your Roomba to commit suicide.

The API allows you to take manual control of your Roomba, driving it wherever you like. You can alter its schedules and access some basic information about the unit.

Sadly, there's no way yet to get the Roomba to tell you what it is doing. In order to find out whether it has started cleaning, you would need to continually poll the API and notice when it changes state. I would like it if the unit were to make an HTTP call to a server of my choosing - then I could, say, get it to tweet when it finished cleaning.

Incidentally, a quick nmap shows that only port 80 is open.

Wish List

I've been a little harsh on the unit. For €99 it's an exceptionally good bit of kit. There are still a few bugs and kinks to work out, but for day-to-day usage it is excellent. Here's what I'd like to see in future versions of the software.

HTTPS everywhere! It appears that their servers do support secure connections, but it doesn't seem to be mandated. I'd be much happier if all the communications went over a secure channel.
Authentication! Yes, even HTTP Basic Digest would be nice. Just something to prevent people on the network fiddling where they shouldn't! If you have a kids in your house, you don't want them playing with the robot's settings.
A push API. Let me define an HTTP request for the Roomba to make when it has finished cleaning.
Open Source firmware. I'd love to be able to tinker with the look and feel of the website. At the moment they say
The firmware running inside the Thinking Cleaner module is not going to be open source. This is because the module has to be certified and certification includes the firmware.

I can understand that the radio module has to obey local laws. I just wish there were a way to separate the radio logic from the web server. Perhaps the code could be made open source but have the unit only accept signed versions from the manufacturer?
Play sounds or voices. At the moment, the software only lets the Roomba play one "jingle". It would be great if it were possible to make it play different sounds - or even get it to speak some of its stock phrases.
Mapping. This is one I think I can build myself! It would be great to be able to draw a map of the route taken by the Roomba on its travels.
More diagnostic information. Adding WiFi signal strength, for example, would make for an easy way to map your network propagation.
Twitter integration :-) I guess I'll have to build that myself as well!

Conclusion

The Thinking Cleaner upgrades even the cheapest Roomba into a WiFi connected, super cleaner. I love the fact that I can get schedule cleaning while I'm away, and play with an API. There are some minor issues, which I'm sure will be fixed as the software matures.

The Thinking Cleaner is available for €99 plus shipping (€14 to the UK). It's a fantastic little unit and I hope to write some more blog posts showing you all the cool things it can do.

And, if this blog doesn't convince you, perhaps this cheesy video will!

Which Painting Do You Look Like? Comparing Faces Using Python and OpenCV

@edent — Sat, 14 Jun 2014 08:33:32 +0000

Many years ago, as I was wandering around the Louvre, I came across a painting which bore an uncanny resemblance to me!

Spooky, eh?

Yeah, yeah, it's not the greatest likeness ever, but people who know me seem to think I look like the chap on the left.

This got me thinking... Wouldn't it be great if when you entered an art gallery, a computer could tell you which painting you look most like?

Well, I think it would be great. This is my blog, so what I say goes!

Getting The Data

I'm using the Tate's Open Data Set to grab scans of all their artwork. ~60,000 images in total.

Finding Faces

Not all paintings are of people. Some artsy types like to paint landscapes, dogs, starry nights, etc.

Using Python and OpenCV, we can detect faces in paintings. Then crop out the face and save it. The complete code is on GitHub - but here are the essentials.

import sys, os
import cv2
import urllib
from urlparse import urlparse

def detect(path):
    img = cv2.imread(path)
    cascade = cv2.CascadeClassifier("haarcascade_frontalface_alt.xml")
    rects = cascade.detectMultiScale(img, 1.3, 4, cv2.cv.CV_HAAR_SCALE_IMAGE, (20,20))

    if len(rects) == 0:
        return [], img
    rects[:, 2:] += rects[:, :2]
    return rects, img

def box(rects, img, file_name):
    i = 0   #   Track how many faces found
    for x1, y1, x2, y2 in rects:
        print "Found " + str(i) + " face!"  #   Tell us what's going on
        cut = img[y1:y2, x1:x2] #   Defines the rectangle containing a face
        file_name = file_name.replace('.jpg','_')   #   Prepare the filename
        file_name = file_name + str(i) + '.jpg'
        file_name = file_name.replace('n','')
        print 'Writing ' + file_name
        cv2.imwrite('detected/' + str(file_name), cut)   #   Write the file
        i += 1  #   Increment the face counter

def main():
    #   all.txt contains a list of thumbnail URLs
    for line in open('all.txt'):
        file_name = urlparse(line).path.split('/')[-1]
        print "URL is " + line

        if (urllib.urlopen(line).getcode() == 200):
            #   Download to a temp file
            urllib.urlretrieve(line, "temp.jpg")
            #   Detect the face(s)
            rects, img = detect("temp.jpg")
            #   Cut and kepp
            box(rects, img, file_name)
        else:
            print '404 - ' + line

if __name__ == "__main__":
    main()

We now have a directory of files. Each file is a separate face. We assume that no two faces are of the same person - this is important for the next stage...

Building Eigenfaces

Imagine that a picture of your face could be represented by a series of properties. For example

How far apart your eyes are.
Distance from nose to mouth.
Ratio of ear length to nose width.
etc.

That is, in grossly simplified terms, what an Eigenface is.

If I have a database of Eigenfaces, I can take an image of your face and compare it with all the others and find the closest match.

We'll split this process into two parts.

Generate the EigenFaces

We need the arrange the images so that each unique face is in its own directory. If you know that you have more than one picture of each person, you can put those images in the same directory.

E.G.

   |-path
    -|-Alice
      | |-0.jpg
      | |-1.jpg
      |
      |-Bob
      | |-0.jpg
      |
      |-Carly
      ...

This code is adapted from Philipp Wagner's work.

It takes a directory of images, analyses them, and creates an XML file containing the Eigenfaces.

WARNING: This code will take a long time to run if you're using thousands of images. On a dataset of 400 images, the resulting file took up 700MB of disk space.

import os
import sys
import cv2
import numpy as np

def normalize(X, low, high, dtype=None):
    """Normalizes a given array in X to a value between low and high."""
    X = np.asarray(X)
    minX, maxX = np.min(X), np.max(X)
    # normalize to [0...1].
    X = X - float(minX)
    X = X / float((maxX - minX))
    # scale to [low...high].
    X = X * (high-low)
    X = X + low
    if dtype is None:
        return np.asarray(X)
    return np.asarray(X, dtype=dtype)

def read_images(path, sz=None):
    X,y = [], []
    count = 0
    for dirname, dirnames, filenames in os.walk(path):
        for subdirname in dirnames:
            subject_path = os.path.join(dirname, subdirname)
            for filename in os.listdir(subject_path):
                try:
                    im = cv2.imread(os.path.join(subject_path, filename), cv2.IMREAD_GRAYSCALE)
                    # resize to given size (if given)
                    if (sz is not None):
                        im = cv2.resize(im, sz)
                    X.append(np.asarray(im, dtype=np.uint8))
                    y.append(count)
                except IOError, (errno, strerror):
                    print "I/O error({0}): {1}".format(errno, strerror)
                except:
                    print "Unexpected error:", sys.exc_info()[0]
                    raise
            count = count+1
    return [X,y]

if __name__ == "__main__":
    if len(sys.argv) < 1:
        print "USAGE: eigensave.py "
        sys.exit()
    # Now read in the image data. This must be a valid path!
    [X,y] = read_images(sys.argv[1], (256,256))
    # Convert labels to 32bit integers. This is a workaround for 64bit machines,
    y = np.asarray(y, dtype=np.int32)

    # Create the Eigenfaces model.
    model = cv2.createEigenFaceRecognizer()
    # Learn the model. Remember our function returns Python lists,
    # so we use np.asarray to turn them into NumPy lists to make
    # the OpenCV wrapper happy:
    model.train(np.asarray(X), np.asarray(y))

    # Save the model for later use
    model.save("eigenModel.xml")

After that has run - assuming your computer hasn't melted - you should have a file called "eigenModel.xml"

Compare A Face

So, we have a file containing the Eigenfaces. Now we want to take a photograph and compare it to all the other faces in our model.

This is called by running:

python recognise.py /path/to/images photo.jpg 100000.0

The "100000.0" is a floating-point number which determines how close you want the match to be. A value of "100.0" would be identical. The larger the number, the less precise the match.

import os
import sys
import cv2
import numpy as np

if __name__ == "__main__":
    if len(sys.argv) < 4:
        print "USAGE: recognise.py  sampleImage.jpg threshold"
        print "threshold is an float. Choose 100.0 for an extremely close match.  Choose 100000.0 for a fuzzier match."
        print str(len(sys.argv))
        sys.exit()

    # Create an Eign Face recogniser
    t = float(sys.argv[3])
    model = cv2.createEigenFaceRecognizer(threshold=t)

    # Load the model
    model.load("eigenModel.xml")

    # Read the image we're looking for
    sampleImage = cv2.imread(sys.argv[2], cv2.IMREAD_GRAYSCALE)
    sampleImage = cv2.resize(sampleImage, (256,256))

    # Look through the model and find the face it matches
    [p_label, p_confidence] = model.predict(sampleImage)

    # Print the confidence levels
    print "Predicted label = %d (confidence=%.2f)" % (p_label, p_confidence)

    # If the model found something, print the file path
    if (p_label > -1):
        count = 0
        for dirname, dirnames, filenames in os.walk(sys.argv[1]):
            for subdirname in dirnames:
                subject_path = os.path.join(dirname, subdirname)
                if (count == p_label):
                    for filename in os.listdir(subject_path):
                        print subject_path

                count = count+1

That will spit out the path to the face that most resembles the photograph.

Who Am I?

Well, it turns out that my nearest artwork in the Tate's collection is...

Sir John Drake!

So, there you have it. My laptop isn't powerful enough to crunch through the ~3,000 faces found in The Tate's collection. I'd love to see how this works given a powerful enough machine with lots of free disk space. If you fancy running the code - you'll find it all on my GitHub page.

Pareidolia and Computer Vision

@edent — Fri, 13 Jun 2014 14:03:03 +0000

Humans are pretty spectacular at image recognition. We have a seemingly innate ability to look at an image and tell if it is that of a human face - even if it has been severely distorted.

Occasionally though, the software in our brains is a little too eager to see a face.

This phenomenon is called Pareidolia. It's what causes you to see dragons when you look at the clouds, and a smiling face when you see :-)

Recently, I've been running facial recognition software on artworks held by Britain's Tate Gallery. They have an amazing Open Data set for their entire collection - including fairly high quality scans of each piece of artwork.

Using OpenCV and Python, it's possible to examine an image for facial features. Running over some of the artwork, I was surprised at just how good it was at picking up facial features from a wide variety of art styles.

All of the above were automatically identified as being sufficiently face-like.

As it happens, computers also suffer from Pareidolia!

Again, all of the above were automatically identified as being sufficiently face-like. Even the window pane...

I find it fascinating that we can create such high quality image recognition digitally, and yet still have it subject to the same bugs as our organic brains.

You can read the code that I used to recognise the images, and see the faces themselves, on my GitHub page.

Can You Power an iBeacon with a Lemon?

@edent — Thu, 27 Mar 2014 12:34:08 +0000

This is a necropost - resurrected from the now defunct blog of a previous employer. Sadly, most of the photos have fallen down the memory hole. So use your imagination.

Energy efficiency is the next battleground for electronics. As the price of electricity soars, people will become less and less enamoured with charging their devices every single day. Even if cold-fusion brings us unlimited free energy - plugging your gadgets into a wall just seems so primitive!

That's where BlueTooth Low Energy (BLE) comes in. It's an ultra low powered transmitter which can be found in FitBits, iBeacons, pacemakers, and all sorts of other devices.

The key, as per its name, is that it uses very little energy. A simple watch battery should be enough to power an iBeacon for a year.

When Life Gives You Lemons…

Today was one of The Lab's regular hackdays. We challenge ourselves to spend a day playing with new technology, trying to get it to do something interesting.

I'm sure you remember from school building a simple power source using a lemon or potato. Zinc plated nails, copper wiring, an acid source, and - hey presto - a lightbulb comes on.

So, can we harness the awesome power of fruit to bring life to a little iBeacon?

We used RedBear Lab's BLE Mini board. It can be powered via USB (boring!) or via a direct electrical contact on the back.

Better BlueTooth Through Chemistry

It's been ages since any of us in The Lab did basic physics and chemistry at school, so we turned to the Mighty Internet for help.

With three lemons wired in parallel, we got approximately 0.5 Volts and 120μAmps.

According to Red Bear's support forum, we'd need about 3 volts and 340μAmps.

With 6 lemons, we were at ~200μAmps, closing in on the figure we needed.

It occurred to us that we may need to construct some kind of super-fruit mega battery in order to get the voltage up as well. I really wish I'd paid more attention in GCSE physics. Sorry Mrs Perkins…

10 is the Magic Number

With 10 C. limon in parallel, we hit 369μAmps! Perfect!

That still wasn't enough to get the BLE Mini board to power up - we needed to raise the voltage. But how?

Errr…. with difficulty…! Turns out it's really frickin' hard to get enough power out of a bunch of lemons to power modest hardware.

So we did what any enterprising startup does - pivot!

Power Extreme!

Ok, so can our juicers deliver sufficient juice to act as an emergency battery for your smartphone?

We found the lowest powered phone we could - the GeeksPhone Keon - running FireFox OS.

In keeping with our fruit theme, we butchered an old BlackBerry charger - and got to work…

Wires stripped, plugged into our lemon battery… What was the result?

Errr… The square root of nowt! Nothing happened. The power wasn't high enough for the phone's charging circuitry to register anything.

We grabbed a Nexus 5, installed a power monitor widget, and tried again.

Ooooooh!

This is the very definition of trickle charging. The amount of energy from 10 lemons, zinc plated nails, and copper wire is just enough to give you a few more minutes of talk time - nothing more. In a MacGyver situation, you're probably better off squeezing the lemons into your enemies' eyes.

Lessons Learned

Hackdays are a great way of playing about with technology and having a bit of experimental fun.

It's temping to think BLE is so efficient that it can be powered from harvested kinetic energy and stray WiFi beams - that's not the case. Modern battery technology is pretty complex - and that's why tiny button cells can power modern electronics and a whole bunch of lemons doesn't even get close.

One of the reasons The Lab exists in O2 is to develop a culture of "Fast Failure". We didn't spend millions of Euros and half-a-dozen months in planning meetings, requesting proposals from suppliers, and updating PowerPoint decks to do this - instead, two of us spend half a day actually trying to build something and finding out pretty quickly that it wasn't going to work.

For those of you wondering just how much of your monthly bill we spent on this? The cost was a couple of quid for the nails and wire, and we had the multimeter already. The lemons cost £3.00 for 10. I wonder if I should have splashed out on organic ones…. ;-)

What's Next

It's possible to power Xmas tree lights from hundreds of Brussels Sprouts. Would it be possible to set up a "Charge your Apple with apples" stand at one of O2's larger stores? Sure! It could make a great marketing stunt - and teach people a little basic science - but, for now, I'll stick to my wall socket.

Toodle pip!

Introducing Corkr at #NHTG14

@edent — Tue, 11 Mar 2014 20:14:23 +0000

What a crazy weekend! I made the last minute decision to attend Rewired State's "National Hack The Government 2014" hackathon.

Rather than hack on any of the provided datasets, I wanted to work on an interesting way to present all the security flaws I had found in Government websites.

I teamed up with Mark, Marcello, and Orlando - together we created "Corkr - Plugging the Government's Digital Holes"

We were looking for different and interesting ways to visualise the data. Interactive infographics, space-trees, leader boards, top-trumps - all classic staples of hackdays.

In the end, we thought what would be the most visually impressive would be to present the sites on a map. That way we could show the scale of the problems - and let local authorities know where they needed to target.

It's hard to quantify just how bad the bugs are - is a single SQL Injection worse than two XSS flaws, for example - so we settled on just doing a raw count. Marcello and Orlando were able to convert the wpscan results files into JSON - which made doing the calculations a lot easier.

Mark, our graphics / UI guy came up with a really strong design to help showcase just how bad some of the problems are. We decided against revealing the nature of the vulnerabilities and instead went for a traffic light system.

Using OpenStreetMap and LeafletJS meant it was incredibly easy to create lush looking maps which were zoomable. Adding markers to specific locations was also really easy.

Where In The Country Is A Website?

Some websites have a defined geographic location - a tiny Parish Council's website can reasonably be centred on a map.

The WHOIS data for *.gov.uk sites is not standardised. Very few of the sites spat out a Post Code when queried. Going to each website and looking for a "contact us" link was just too much work for a hackday - so we cheated!

Google has a pretty good API for getting the geographic location from a search query. So I manually converted all the domain names into something Google could use. For example "10downingstreet.gov.uk" became "10 downing street" (used as an example - it's not a vulnerable site).

Here's the PHP code:

$location = $argv[1];
$json = file_get_contents('https://maps.googleapis.com/maps/api/geocode/json?address='.$location.',%20uk&sensor=false');
$obj = json_decode($json, true);
echo $obj["results"][0]["geometry"]["location"]["lat"] . ", " . $obj["results"][0]["geometry"]["location"]["lng"];

Now, obviously that requires a lot of copying and pasting. Luckily, Linux makes it very easy to automatically copy the output of a script onto the clipboard:

php -e locate.php West%20Byfleet | xclip -sel clip

And then we created a master JSON file which tallied up the number of flaws, where the sites were, and what they were named.

And then we did the same for the NHS sites!

In the end, due to time constraints, we only managed to get around 200 .gov.uk sites and 150 .nhs.uk sites.

And so, on very little sleep, we demo'd it...

The Competition

As ever with Rewired State, the standard of hacks was incredibly high. They ranged from the silly (dating MPs) to the serious (statistical comparisons of local areas). We presented towards the end, and were painfully aware of just how tough this was going to be. When you're up against a physicist using LIDAR calculated height data to infer shadow mapping and Pseudo-facial recognition using photoresistors, you know you're competing against the very best in the UK.

I am delighted to say that we were one of the four winners!

Some Thoughts On The Day

It was an absolutely amazing weekend. The food was good - and healthy - there was a wide range of people and some top notch government people there to talk with.

It might have been nice to have a bit more of a formal "what are people working on" session at the start. With 80ish hackers it may have taken some time, but it would have helped people introduce themselves and recruit for teams. All in all, a minor concern.

Prizes. I've written before about the corrupting influence of big money prizes. Luckily, the prizes on offer at #NHTG14 weren't jewel encrusted! About £30 - £40 worth of tech - plus some O’Reilly books. Just the right sort of level - not so extravagant that people would be gutted to lose, but expensive enough to make you go "Ooooh! What a lovely treat!".

Of course, the real value is in the taking part. And that's not just hokum; it really is.

For me, I think the real prize is making the government take notice and fix their broken sites. I think that is slowly happening - but a bit more on that later.

Congratulations to all the teams who took part - and many thanks to the judges for their impeccable taste.

Hacking Around With Network Cameras

@edent — Thu, 14 Nov 2013 12:50:05 +0000

I was recently given 3 rather locked-down network cameras. Each camera was pre-programmed to communicate with a specific website, and only attach to a predefined wireless access point. Naturally, there was no supplied username or password.

I thought about how I might get access. Using a man-in-the-middle attack to sniff the password, or trying to dump the firmware and examine that. Sadly, all the vulnerabilities previously reported no longer work. After a little bit of thought, I went for decided low-tech solution; I hit the reset button! Yes, each camera had a recessed switch, accessible only with a paperclip, which reset the device to factory settings after holding it down for 10 seconds.

Anyway, this is my voyage of discovery with the three cameras. They are:

RC8221 - a basic internal camera.
OC821D - an external camera with weatherproof features.
RC8230 - a pan/tilt camera.

All of them are manufactured by Taiwanese OEM Sercomm. Annoyingly, Sercomm don't have any customer services. They mostly resell the cameras to Linksys, Cisco, Xanboo.

SerComm don't offer any firmware, GPL downloads, or much information about the cameras - so it's all very much trial and error.

Defaults

After resetting the cameras, they'll happily attach up to any wired network via the Ethernet port. Visit the IP address assigned by DHCP and you'll get to the admin panel. The default username is "administrator" - there is no password set. You can now go and fiddle with all the settings.

High Resolution Mode

The cameras are meant to be able to record at 720p - yet the user interface doesn't seem to allow it. Luckily, the API allows us to force the resolution.

http://192.168.0.42/adm/set_group.cgi?group=H264&resolution=4

http://192.168.0.42/adm/set_group.cgi?group=JPEG&resolution=4

Wait! What? API?!

Oh yes, all the cameras come with a variety of commands which can be controlled by simple a HTTP GET request.

Discovering The API

As I said previously, Sercomm provides no documentation. Luckily, their resellers do! EyeSpy247 have the admin manual for the RC8221. Use-IP have the admin manual for the OC821D. I haven't yet found a manual for the RC8230 - but it uses most of the same API commands. The only main addition is the ability to move the camera via its pan/tile functionality. After a bit of digging, I found a discussion on how to activate this functionality.

Up:

http://192.168.0.42/pt/ptctrl.cgi?mv=U,10

Down:

http://192.168.0.42/pt/ptctrl.cgi?mv=D,10

Left:

http://192.168.0.42/pt/ptctrl.cgi?mv=L,11

Right:

http://192.168.0.42/pt/ptctrl.cgi?mv=R,11

The manuals give all sorts of instructions, how to view video streams, get photos, set and get various options. There are, sadly, some omissions.

Sending Sounds

One of the tasks I wanted to accomplish was to make the cameras play some of the turret sounds from the video game "Portal". This is proving tricky, despite the manual's promises to the contrary.

It should be possible to POST an audio file to the cameras, either in G.726, or G.711 (a-law or u-law). Despite creating the audio files correctly, and POSTing them to the cameras - they make not a peep!

curl -vv --data-binary @alaw8k.wav http://user:pass@192.168.0.42/img/g711a.cgi

curl -vv -X POST -d @alaw8k.wav http://user:pass@192.168.0.42/img/g711a.cgi --header "Content-Type:audio/x-wav"

I get a 200 OK, and the volume is set on the camera. Most vexing!

If you think you can help, please leave an answer on StackOverflow.

Arming - or lack thereof

With my other cameras, I can send a command to arm or disarm. I don't need the motion detection to send me emails every second of the day - only when I'm out of the house.

Looking at the source code of one of the pages, it looks like it's possible to POST some data to /adm/file.cgi - but it's not clearly documented which parameters are required. It will take me some time to work through the tangled nest of JavaScript.

Email

The cameras will send video when they detect motion - although getting this to work isn't at all obvious. Firstly, the password is hard-coded to be a maximum of 16 characters. If your password is "StarTrekIntoDarkness1" you're out of luck. Secondly, the "Test the Server" button doesn't actually work. It randomly gave me errors about not being able to reach the server. I struggled for hours until I discovered that the error messages were lying to me! If you enter the details correctly, and the camera has access to the Internet, it should just work.

That said, once enabled, it will happily send emails with large video attachments to you.

Video Audio

All the cameras have microphones, and all do audio triggering (sending an alert when noise levels rise). Yet none of the cameras would embed audio in with the video. When streaming over RTSP, it was possible to pick up audio from the microphone. Lowish quality, 8kHz, mono - but better than nothing. Again, if anyone knows how to get the alert videos to include audio, please let me know!

Motion Detection

Setting the motion detection area is very useful. You might want to ignore movement on the floor if you have a pet, or concentrate on a door handle. Sadly, with these cameras, you have to use IE6 or greater to set the detection area.

You can try and use the API to set areas - but without being able to see the area in question, it's an exercise in frustration.

For my needs, having full screen video detection is fine. I may have to borrow a Windows machine if that changes.

Open Source

Each camera has an embedded Open Source page at /adm/Licenses.txt which includes all the text of the relevant GPL etc.

All three cameras have the following Open Source components:

Davicom Ethernet driver
Linux kernel 2.6.18
wireless_tools 26
busybox 1.16.0
dhcpcd 1.3.22-pl1
ez-ipupdate 3.0.11b7
iptables 1.3.4
ppp 2.4.1
cron daemon
samba client 3.06
glibc 2.8
alsa-lib-1.0.16
wpa_supplicant 0.4.5
NTP
thttpd-2.25b

Interesting to note that BusyBox is an unstable release version from 2010, thhtpd supports IPv6 even though the cameras don't appear to. wpa_supplicant is ancient - that may explain why it can't cope with SSIDs with spaces in them. I presume it's the hardware which won't scan the 5GHz range. The Linux kernel is from 2006 - that's common enough in embedded systems, but I do wonder if it presents a security risk.

Security

The cameras offer an SSL connection. However, the certificate is self signed and uses MD5 with 1024 bits. Basically, a security signing which was advised against in 2010. There's no way to replace the certificate without replacing the firmware. If you are willing to trust it, the connection is secured via SSL. Assuming you can confirm the certificate is correct, the encryption should be sufficient to stop anyone but the NSA peeking through your cameras.

That said, the RTSP channel isn't protected by SSL. You can give a username/password, set time of day access, and restrict to specific IP addresses - but the video is transmitted in the clear.

For now, I'm keeping my cameras on my LAN with no external access to them.

What Next

At the moment, I've set the cameras up, but I'm not actively monitoring them - it's just too much work to switch each of them on when I leave for work.

So, if you can help....

How do I send sound to the cameras?
How do I get audio with the video alerts?
How do I arm the cameras via the API?

3D Printing the 2600 Whistle

@edent — Sat, 28 Sep 2013 20:19:17 +0000

Perhaps the most legendary piece of plastic in the hacker community is the humble "Cap'n Crunch" whistle. The free-in-cereal whistle was able to emit a piercing shriek at 2600Hz - the exact tone required to unlock the US phone network.

So, because it's all I seem to do these days, I turned my my trusty RepRapPro and decided to see whether it was possible to 3D print a whistle which could produce the same frequency.

I found a customisable whistle on Thingiverse and customised it to include the Over The Air hashtag.

Rather than do any funky customisations with radius or length, I simply scaled the whistle in Slic3r.

I made them at 75%, 85%, 100%, and 100%.

The print wasn't without issues. Because of the large opening, the top layer didn't seal properly - even on the smallest print. The logo printed reasonably well - and the holes in the side were easily sealed with my fingers. But I might adjust the model for a thicker top layer.

The models come with an integrated "pea". The little ball in printed inside the barrel - a hard poke with a sharp stick set the ball free.

So, how did it sound?

🔊 3D printed whistle at #ota13
🎤 The BooBot

💾 Download this audio file.

Not bad! We broke out a tonal analyser on a smartphone and, on the smallest whistle, I managed to just about hit 2600Hz!

The 3D print is rather rough and was quite harsh on the lips - so it's worth sanding the final print down or rubbing some acetone on it before blowing.

Now, obviously, this doesn't look exactly like the original whistle. There are no 3D models I could find - although there are several rather detailed photos.

For my next step I can go one of two ways. Either refine the existing whistle so it reliably produces the 2600Hz tone - or try to make a replica of the bo'sun whistle and then get that pitch perfect. Thoughts?

Oh, and the tone is really loud and annoying for anyone nearby!

Text Adventures Via Text Message

@edent — Fri, 14 Jun 2013 10:55:20 +0000

Remember text adventures, eh? They were pretty nifty!

"You are in a maze of twisty little passages, all alike"
>Go East
"You have been eaten by a Grue. A dwarf starts singing about gold"

Smashing! Just like the pictures are better on the radio, so the graphics are immeasurably superior when they're in your head. Don't get me wrong, I love the 5.1 surround sound snarl of a rabid beast rendered in 1080p - but nothing is quite as good as using your imagination.

Text Adventures - or, more properly, Interactive Fiction - is enjoying a mini-renaissance at the moment. There are emulators for smart phones, computers, and consoles.

But for SMS? None that I could find. Think about it; SMS is close to the perfect medium for Interactive Fiction. Your commands are concise enough to fit into a single message, you don't have to worry about the speed of your response, everything is text based.

So, I present to you, Zork via SMS (with a little help from Twilio).

Brilliant!

HOWTO

Although superficially a simple project, there are a few gotchas along the way. This documentation is mostly for me - but may be of use to you :-)

Let's start at the end.... Using Twilio you can send an SMS to a phone number, that is then POSTed to a webserver of your choice.

Twilio will send an SMS back if it receives a response such as



  You are in an open field west of a big white house with a boarded
front door.
There is a small mailbox here.

Easy enough. (NB the free account prepends your messages with a trial message. Once you pay, that goes away.)

So, how do we get a text adventure like Zork running server side? There are plenty of client side emulators out there - but I only found one which was purely server side.

THCnet have a PHP interpreter for Zork. It's slightly cludgy - but it works. I'm checking to see if I can distribute it on GitHub.

The game library "dtextc.dat" must be installed in "/usr/games/lib/". The source code is available if you want to recompile it and place it somewhere more accessible.

A MySQL database needs to be created to keep track of users and sessions.

A temporary directory (which must be readable and writeable) will also be needed to store the state of play for each session. I've used "tmp/404/" but you can alter config.php to point wherever is convenient. You will also need to adjust index.php and functions.php with the new location.

Finally, the executable "zork" must be runable.

That's pretty much it.

When a user (or, in this case, Twilio) first makes a request to the URL, we check to see if they already have a session cookie. If they don't, create one, and start the game by returning the opening text.

For every subsequent connection, we check the state of the game based on their cookie, then apply the body of their SMS to the game engine. Whatever Zork spits out, we return as an SMS.

By default, Twilio kills unused sessions after 4 hours, and all cookies will be lost.

Where Next?

It strikes me that the various forms of text adventures are excellent as a sort of mini-IVR. A nice little finite-state-machine which can quite happily run for years. Services like Frontline SMS are great for information sharing, but they're really not designed for this sort of work.

Could we use interactive fiction in places where SMS is cheap but other forms of entertainment are expensive? Could IF be used to augment existing media events? SMS is lowest common denominator - even iPhones can use it.

But, for now, all I have to worry about is someone texting me "Go west'); DROP TABLE ..." ;-)