Looking Out To Sea

This second part of the problem was more difficult, though the solution is much shorter to present. The input message looks like this, in part:

68edcdec4e2c8eae8d2c8e2dedcd6e04d2042fedae52ceac
04ccedaecd8c042ccd8c046cedad0e8dac8eac8c048e0dac

Under the assumption that each pair of characters represents a byte, we split the stream into pairs.

splitStream = splitEvery 2

Of course each pair isn’t actually a hexadecimal number, though it looks like one. It’s a string of characters, so we need to turn it into something the computer will recognise as a number.

Now, there’s a robust, I’m-a-serious-engineer way of doing this and then there’s the way I chose, which is to prefix all the strings with “0x” and use the read routine. The Read typeclass is not meant to represent a robust parsing mechanism but since this is a one-shot thing I think we’ll both just ignore it, yeah?

hexToInt :: String -> Int
hexToInt = read . ("0x" ++) -- ouch!

Having read in our number I tried to do what I did in the previous exercise and print it out, which produced complete nonsense. Then I decided that reversing the string before converting it to numbers would be helpful. I did that, but the result was still nonsense, just of a different shade.

Then I decided that my resulting numbers were a bit large. The number which represent capital A is 65, and I was getting numbers in the 200 range. Then I realised, “all these numbers are even, aren’t they?” So I divided the whole lot by two.

Outputting that message gave me a backwards English message. Aha! It’s close but there’s something wrong. I threw in another “reverse” statement and got an answer. At this point I noticed I had two reverse statements — one at the beginning and one at the end. This seemed like it would be the cause of my problems so I removed them both and, Robert’s your father’s brother, I was back to gibberish again.

What happened? What I had failed to realise was that when I had reverse my original message I had done so before splitting into pairs of characters. So ABCD becomes DCBA. After splitting this is [DC,BA]. If each pair is converted into a printable character, represented by f(XY), then the result is [f(DC),f(BA)]. I then reversed the message to get [f(BA),f(DC)].

If I didn’t do any reversing but went through the same splitting and conversion process, I got [f(AB),f(CD)]. Look — f(AB) is not the same as f(BA)! By reversing the list before splitting and again after conversion, I was implicitly reversing the order of the characters in each pair.

Obviously I had to reverse only the pairs after they’d been split, rather than the whole list at the beginning and end. If I do this then print the result I get an answer which is close to right.

byteToChar = chr . flip div 2 . hexToInt . reverse
message = map byteToChar . splitStream
 
loadfile = (head . lines) `fmap` readFile "hexstring.txt"
main = loadfile >>= putStrLn . message

The resulting message is:

Congratulations youve found and completed the REAL challenge. Your win code is cyb3r=s3cur1ty*ch@ll3nge+26-07-2010.

Please email this code to our team at media@cybersecuritychallenge.org.uk. If youre the first person to do so, and can prove you meet the eligibility criteria (British citizen currently resident in the UK) we will be in touch to advise how to claim your prize. Well done and good luck in the Cyber Security Challenge competitions taking place throughout the rest of the year.

There are a few infelicities which are explained by the official solution. My divide-by-two technique is not the proper approach so I think some of the characters get lost in the decryption process. But as the saying goes, close enough for government work!

The solution states:

The challenge was based on a bitshift operation applied to a string, here each byte’s “3 least significant bits” have been added to the left side of the byte (making them the most significant bits respectively)

Assuming we have bits one to eight:

1 2 3 4 5 6 7 8

what I did was divide everything by two, which we do in binary by shifting everything to one side so the least significant bit disappears. We fill the opposite edge with a zero here:

0 1 2 3 4 5 6 7

What the solution demands is to rotate the bits like so:

6 7 8 1 2 3 4 5

I am still not sure how it is that my solution matches so neatly with their own. Answers on a postcard.

If I hadn’t stumbled on a solution like this, the sensible approach might have been to produce a histogram of common characters. In this case, the most commonly used character encoded the space, followed closely by “e”, the most common letter in standard English texts. From there it would have been a bit of a slog to produce the result but it could be done.

The two other solutions I have found both use the official method without problems. I suspect it’s got something to do with default word lengths (8 bit versus 32 bit) and signed integers, though I’ve not thought deeply on the issue.

The first part of the Cyber Security Challenge requires you to decode a long stream of letters, numbers and symbols into something coherent. This was by far the easiest part of the challenge. The symbols look like this:

/9j/4AAQSkZJRgABAQEAYABgAAD/4QBaRXhpZgAATU0AKgAAAAgABQMBAAUAAAABAAAASgMDAAEA
AAABAAAAAFEQAAEAAAABAQAAAFERAAQAAAABAAAOxFESAAQAAAABAAAOxAAAAAAAAYagAACxj//b
AEMACAYGBwYFCAcHBwkJCAoMFA0MCwsMGRITDxQdGh8eHRocHCAkLicgIiwjHBwoNyksMDE0NDQf

This is only the first three lines — there’s 362 lines of this. The most important bit is that the last line ends in a = sign. This symbol is used for padding out messages when they are encoded in Base 64 format, so if any string has an equals symbols on the end it’s worth seeing what happens if you decode it as if it were Base64. (The truth of the matter is that by the time my mate Rich had told me about this challenge he’d already decoded the image so I didn’t do any of this stuff!)

Thankfully there are plenty of programs that will do the decoding for you, and the resulting file is a JPEG file. Brilliant:

This is XKCD comic number 538, with a subtle difference. Round the outside of the image there is an uneven dotted border. This isn’t in the original comic, and it looks irregular which suggests that it’s not just a pretty pattern but that it encodes some further information.

For the next stage I converted the image to PNG format because it was the easiest format to load and process.

The first part we need to do is load the image file and extract all the bytes from the actual image part, ignoring any metadata. The PNG file is represents a 24 bit colour image, with each component (red, green and blue) stored as an 8 bit number from 0–255. We just return the whole thing as a long list of bytes, starting at the top left and scanning left to right, top to bottom. It’s not efficient but it’s very simple to reason about because we don’t need to think about array locations.

getimage :: IO [Word8]
getimage = do
  (Right img) <- loadPNGFile "decode.png"
  getElems (imageData img)

The long list may be conceptually simple but it’s not representative of the structure of the image. Since each pixel is represented by 3 consecutive numbers we want to gather those numbers together, so we can start dealing with them as pixels. Thus we convert [r,g,b,r,g,b,r,g …] into [[r,g,b],[r,g,b],…]

splitIntoBytes = splitEvery 3

Even though each pixel can represent many colours we’re really only dealing with black and white here so we can represent each component as fully-on or fully-off. Each pixel can really be stored as boolean values like [True, False, False]. Since it’s possible that some values are not absolutely 0 or absolutely 255 I’ve divided them up the middle — anything darker than 128 is 0, and anything lighter is white.

Once each pixel is a list of booleans we can collapse that down into a single black/white value by taking the conjunction. If all values are True then the pixel is True (ie, black) otherwise False (white).

normalise = and . map (< 128)

At this stage our image is no longer a list of integers but a list of booleans. The original list had height-times-width-times-3 elements. Since we’ve collapsed all those three elements into a single value representing each pixel we now have height-times-width elements. The image is 350x175 pixels so we can split it into rows by cutting the list every 350 elements. This gives us 175 rows.

tomatrix = splitEvery 350 . map normalise . splitIntoBytes

The next stage is, I think, the most beautiful aspect of representing the image as a list of lists. We have a full image but we only want the wavy lines of pixels which make up the border. How do we extract those pixels?

The first thing to notice is that the border is not continuous. The top and bottom edges go to the edge of the screen at both sides, but the two sides don’t meet at the top or bottom. To illustrate:

#################
 
#               #
#               #
#               #
 
#################

So the first question, “where do we start and end?” is answered for us. Each segment is discrete. It was my colleague Rich which pointed out the slight gaps in the border which makes this simplification possible. If the border were complete we’d have to determine whether the corner pieces were part of both the horizontal and the vertical (like a crossword where Across and Down share letters) or not.

The second question we ask is, “which direction does the sequence go in?”. Do we go clockwise from top left, following this alphabetical sequence?

a b c d e
n       f
m       g
l k j i h

Or do we maybe scan left-to-right, ignoring gaps?

a b c d e
f       g
h       i
j k l m n

What about anticlockwise? A mixture of the above? I took the approach which seemed obvious to me, clockwise from top left, and it turned out to be correct. But interestingly the final message is repeated in part so choosing the wrong start point would not have mattered, and it would have been obvious that the output was almost right.

Each row is a list, stored in order from top to bottom. This means the top border is just the first list:

topedge = head

The bottom border is the last list, but because we’ve chosen clockwise we need to reverse the list too.

bottomedge = reverse . last

The right edge is the last element of each list, ignoring the first 3 rows and the last three rows, because as mentioned above, the side patterns are shorter. These two look slightly complicated but it’s mostly dealing with trimming the top and bottom edges off.

rightedge = reverse . drop 3  . reverse . map last . drop 3
leftedge = drop 3 . reverse . map head . drop 3

Now we can extract each edge of the border we can join them all together into our encoded message. This converts our list of lists, which is a complete picture, into a list of bits encoded in the border.

msgstream :: [[Bool]] -> [Bool]
msgstream bits = concatMap ($ bits) [topedge, rightedge, bottomedge, leftedge]

Now we have a long list of bits. And it just so happens the number of bits we have is divisible by eight! This is a good sign because binary information is typically grouped into sets of eight. For the next stage we group our list into sets of 8 bits and turn each 8 into a single number.

One of the tricky aspects about any number is that you can’t tell in advance which end to start from. You and I know that 12 is “twelve” not “twenty-one” but that’s because we know to read numbers from left to right. Computer formats have used both in the past so I wasn’t sure which one would be important to me — is the biggest number the first digit or the last digit? The actual question is, “is the leading digit the most significant bit or the least significant bit?”. I calculated both to see what would happen, and it turned out that most-significant-bit was the way to go. Thankfully, MSB and LSB are just the reverse of each other, so by implementing one we get the other for free!

msb,lsb :: [Bool] -> Int
msb = lsb . reverse
lsb = bitsToInt . map (fromIntegral . fromEnum)

We calculate least significant bit by converting all the True values to 1 and all the False values to zero, and then multiplying element-wise by a stream of powers of two. To illustrate:

  1 2 4 8 16
* 0 1 1 0 1
= 0 2 4 0 16

Then we just add that list up, so “0 1 1 0 1” is “0+2+4+0+16” or 22.

bitsToInt = sum . zipWith (*) (iterate (2*) 1)

After all that prelude we can put this segment together, dividing the image up into its matrix, extracting the bits from the border of the image, splicing them up into sets of eight and converting each 8 bits into a single number:

msgbits = map msb . splitEvery 8 . msgstream . tomatrix

Now what do we do with our numbers? Readable characters are represented internally as numbers, so it is a simple thing to convert between number and printable characters. If we convert each number to a character we get nonsense, but consistent and tantalising nonsense:

Cyrnfr sbyybj guvf yvax: uggcf://plorefrphevglpunyyratr.bet.hx/834wgc.ugzy uggcf://plorefrphevglpunyyratr.bet.hx/834wgc.ugzy

Look at those sequences “uggcf://” repeated twice. That looks so much like a web address, “https://”. If we assume that it is a web address how has it been altered? Each letter in a pair, h/u, t/g, c/p, is 13 characters apart from its partner. But the punctuation symbols aren’t any different.

This looks like the encoding called “rot13” where each character is shifted 13 characters along in the alphabet, and if we reach the end we wrap back to the start. Also, since the first letter of the nonsense message is a capital and none of the rest are it seems like case is being preserved by this encoding.

We convert back to sensible words by rot13 encoding again, since 13+13=26 so any two applications of this transformation will undo each other.

Uppercase and lowercase are treated separately but by the same process. We’re processing some character which we call c and we want to know how many characters it is away from the start of the alphabet. The letter ‘a’ (or ‘A’) is 0 characters away from the start, ‘b’ is 1 character and so on.

If we assume an infinite stream of letters “a b c … x y z a b c…” repeating the alphabet, then the Nth letter in that stream is the one which is N away from the start. The 0th letter is ‘a’, the first letter ‘b’. But if we chop the first 13 characters off this stream, so it’s “n o p … y z a b c …” then the 0th letter is ‘n’, the 1st letter ‘o’ and so on. Each offset now directly maps one letter onto its partner letter. And because the sequences of letters is endless we don’t have to worry about falling off the end. The mapping just loops back on itself:

0 1 2 3 4 5 6 ...
a b c d e f g ...
n o p q r s t ...

Thus we can find the alternate character in our pair by checking first of all how many characters our current letter is from the start, and then looking for the equivalent character in the list which has had its head chopped off. We do the same for the upper case characters and just pass through unchanged anything which isn’t upper or lower case — all the punctuation and spaces.

rot13 :: Char -> Char
rot13 c | isLower c = lowercase!!(ord c - ord 'a')
        | isUpper c = uppercase!!(ord c - ord 'A')
        | otherwise = c
  where lowercase = drop 13 $ cycle ['a'..'z']
        uppercase = map toUpper lowercase

By now I think you’re dying to know what the message says, so let’s finish up here. We decipher a message by converting each integer to a character and performing a rot13 transformation — then we print it.

decipher = putStrLn . map (rot13 . chr)
main = getimage >>= decipher . msgbits

The whole thing is pulled together so we can run it from the command line and we receive the sensible output of:

Please follow this link:
https://cybersecuritychallenge.org.uk/834jtp.html https://cybersecuritychallenge.org.uk/834jtp.html

Next time I’ll look at what happens when we follow that link, and how we complete the next phase of the challenge.

If any of this doesn’t make sense or is confusing please ask questions in the comments. If you want to look at the code in full you can read the solutions for part 1 and part 2 online at http://www.dougalstanton.net/code/cybersecurity/.

As I mentioned in my introductory post I was incredibly impressed by the easy exploratory power of the Haskell code I wrote. Writing little segments to splice, decode, convert and transform made it simple to try out different ways of getting sensible output. I had no idea when I started which way the answer would take me, but putting them together in different combinations in the interpreter was easy and provided instant feedback. (That being said, Rich kinda floored me with his ability to wrangle Excel of all things into solving this problem, though that doesn’t mean it’s the right tool for the job!) Tune in next time for more exciting cryptographic games!

For the past three and a half years I have been working on router redundancy protocols. When your router (or its upstream connection) dies for some reason you want to minimise the loss on people using the network. Ideally users should never notice loss of connection, though in the real world there will be some time delay before things are working again. The work I’ve been doing relies on having a second router which has its own connection to the local network and to the wider world. It acts as a redundant backup so that when the first one dies the second can step into its place within some short period.

When the primary router is working normally the secondary doesn’t do much. Its only role is to monitor the liveliness of the primary machine. The redundant router can often be used for other things when the primary is operating — and many times the primary acts as a redundant router for the secondary’s clients. Each provides backup for the other.

So when I found out recently that I was being made redundant I thought “great! I’ll just sit and watch other people working and take over if they burst into flames”. But it turns out that when people are redundant it’s totally different from when routers are redundant. Instead of being relied on for backup in case of failure, it means “no longer working”. Strange but true! I can see why it wouldn’t catch on very well in networking.

My last day at Cisco is this Friday (30 July). It’s been an interesting few years and provided novel experiences, silly conversations about Star Trek and given me a bit more confidence. I’m sad to be going, and though there will always be loose ends to tie up and the promise of interesting projects on the horizon, the team I’m leaving behind seems to have a glut of these at the moment. I’m also disappointed that the study group at work will continue reading SICP without me. Obviously I can read it alone but the discussion and peer support/pressure was a useful part of it.

Meanwhile, the job hunt continues. Recruitment agencies make this process at least ten times harder by hiding the employer, the industry and the specifics of the job for their own ends. I have had a few friends pass on job details, and had some telephone discussions, but no success yet. Watch this space, or one very much like it.

A few weeks ago I mentioned the idea of a study group at work, for the purpose of reading through some programming-relevant texts and discussing them. We’ve been working on Structure and Interpretation of Computer Programs (SICP) for a few weeks now. I’m enjoying it more than I expected. The exercises are mostly within grasp and I’m happy to note that I’m not being left behind intellectually. There are a few mathematical proof exercises I’ve been skipping and some of the more boring “run this computation by hand” are not worth taking to completion once you’ve seen the basic point. But mostly we’re following the exercises as planned.

Scheme is not so interesting so far. The parentheses still bug me and we haven’t got to the stage where dynamic typing has proven useful so I’m smarting from the lack of a decent type system. From what I remember when I skimmed the book in the past most of Scheme development involves creating ad hoc type systems in the runtime. :-) Many people insist that dynamic languages are good for something so hopefully this something will become apparent.

I have enjoyed several of the exercises which require rewriting recursive algorithms in an iterative style. Seeing the contrast and thinking up different routes to the end product is fun, and I’m glad we’ve got a unit test framework (SchemeUnit) to help in that regard. I tried to track down a Scheme version of QuickCheck but while one used to exist it’s disappeared off the net.

Would it be “ludicrous to think of hiring a juggler without first seeing him perform”? Raganwald has made this point in the past, with reference to professional interviews. But if someone comes to you claiming to be a yo-yo champion it would be rude to challenge them on this point.

At work there’s a tentative conversation about a book group, to read and discuss (and presumably work through) books like SICP. I’m tempted to join in but I wonder if I’d actually get anything done. I haven’t been to the Science and Society Reading Group for several sessions because I just haven’t had time to read the books in question.

(This is why our other book group is better because reading books is optional and finishing books is not necessary.)

But the combination of SICP and discussion with some of the engaged programmers at work might be really useful. I will put my name down and see what happens. The starting book suggested was the aforementioned SICP but after that they’re going to look at something Agile/XP related which is generally an area I know nothing about except by hyped reputation. I’d also be interested in reading research papers so I might suggest that too.

When we moved into our flat on Leith Walk there was an arrangement with a man from Penicuik to get the stair cleaned. At each visit he’d post a bill through someone’s door, so each person only had to pay every eighth time. He’s stopped coming — in fact, he’s stopped business altogether — and he didn’t tell us. And because there was always a long gap between bills anyway it took a while to sink in that the stair was definitely getting dirtier.

At the weekend we sent round a note asking people to come in on Monday evening for a meeting to decide what we wanted to do. Helen had done some research and found prices for the council and for a local company to clean, and we were also willing to entertain a bucket-and-mop rota if that was the consensus.

Out of the 7 other flats we had one apology and two shows, which leaves four flats technically unaccounted for. Someone is apparently on holiday for 3 weeks, so that seems a reasonable excuse. Another were only just moving in that day so maybe they’re just snowed under. Overall I’m still annoyed by the lack of communication. As I guessed would happen, we settled on our preferred option. Of course now we have to get people to go along with this — to agree to paying regularly. If we can’t do that where are we? Whatever happens we lose if there are people who can’t be bothered — if the stair gets slowly more filthy that’s rubbish for everyone, but some care less than others; if some of us pay then we’re taking a bigger hit and others are free-loading; and if no-one wants to pay then people who care about the stairwell end up cleaning it themselves, when they can, while others look on. It may be worth noting that the people who bothered their arses this time round are the ones who own their flats.

(A similar issue can be found when you look at the garden. Who uses it? Who cares about it? Who weeds and tends it? Who has a lawnmower or can pay someone to trim the grass? This is made much harder because the dividing fence between our half of the garden and the half belonging to the adjacent tenement has been removed. It’s a bigger, nicer garden, but there are double the number of people to rope into any discussion.)

To help foster the impression that it’s not just me or Helen forcing the issue one of our neighbours is going to write up a wee note saying what we decided and who decided it. Once everyone knows what our decision was we have to work on getting the other tenants of the stair involved. Knocking on doors and such. It’s not the kind of thing I’m very good at or relish in particular but it has to be done and right now there is no real community here. I want to see if we can sort some of that out. Just starting with a core of two or three households that hold a common opinion, and working from there.

And that also leads onto the garden and the issue of the next tenement over. We need to make some friends there too — to even see some faces would be an incredible help. Last summer there were regular barbecues from the other tenement so maybe we’ll be able to build on that too.

I’m sure this is a recurrent problem. The renting tenants in the stair just seem to come and go, and we’ve recently lost two owners who had been for a long time, so we lost a lot of common understanding and knowledge in a short period of time. This happens all over the city, all over the country. But how, right now, do we deal with it?

I’m not long back from Greener Leith’s latest evening community talk. This is the second event I’ve been to, held in the Kirkgate Community Centre at the foot of Leith Walk. Last month was about hedgerow foraging which was quite interesting — I bought the book! — but I haven’t really followed up on any of the notions it inspired. It is much easier to just buy the book…

Today they were continuing the food theme with a talk from Donald from the local convivium of the Slow Food movement. Last month’s talk was very well attended so it was quite embarrassing to realise that I was the only person in the room that wasn’t (a) a presenter or (b) on the Greener Leith organising committee. I was “the public”.

I don’t really have much to say about Slow Food as an organisation — they are bound up by some vague notion of anti–fast food but don’t define themselves particularly. Most of their members internationally are local food producers and independent farmers of one type or another. There are a lot of them, and they have a big meeting once every two years to celebrate their strange unity, but they are not really important for Leith.

Leith has not much in the way of wheat fields or cattle so the focus locally is obviously on the more urban concerns — local producers and retailers, and hooking them up with each other and the general public. Getting people to investigate the bakers rather than Tesco, and getting the local farmed produce into the hands of people who live in Edinburgh.

Since there were so few of us in the room it was just a chat rather than a presentation, and the presenter brought some small examples of local produce — a loaf of sourdough from the Manna House and some bottles of Stewart Brewery beers. We talked (well, they talked; I mostly listened) about local food issues and small ideas to change the way food is seen.

The most concrete, and actually quite interesting, idea that was mentioned was a Slow Food Table at the Leith Gala. Try to get as many people to contribute something to a table of food which people are encouraged to sit at and take time to eat. Provide a contrast to fast food served elsewhere at the gala. Maybe there will be more of this?

Of course the real problem with food, locally and in many urban areas, is that so many people have been disconnected from food for so long that, even if given a plentiful and cheap supply of good food, they don’t know what to do with it. Trying to bring together local professional chefs and schoolchildren has not met with much success. I have no real solutions to offer, other than to note that the people who sell fruit, vegetables, meat and fish must have some passion for it, and should be consulted. (Obviously I’m ignoring the supermarkets in this, but there are a fair number of “high street” food shops in Leith which fit the butcher, greengrocer, fishmonger archetype.)

Well, I have volunteered what I can and hopefully come June we’ll have a plan to put into execution for the Leith Gala.

Some of you might remember a TV broadcast from a couple years ago called The Great Global Warming Swindle. The central thesis, that cosmic rays are the central cause of global warming, has been long disproved. (To make the film-makers’ case more appealing they, uh, “omitted” the last 30 years of data.) Two of the interviewees filed official complaints with Ofcom because their views were misrepresented and their scientific findings distorted in order to show the opposite effect. The producer has previous record on this point and it’s a wonder anyone wants to work with him at all.

I bring all this up to mention that I saw the Ofcom summary by accident the other day:

However, whilst Ofcom is required by the 2003 Act to set standards to ensure that news programmes are reported with “due accuracy” there is no such requirement for other types of programming, including factual programmes of this type.

You heard it here first — factual programmes do not have to be factual.

It seems documentaries, or programmes which look like documentaries, do not have to hew to anything we might call reality. Graphs, figures and statistics can be pulled out of the producer’s… hat and this wouldn’t matter.

The remainder of the ruling makes for some quite depressing reading. You can get away with whatever you want if you introduce your detractors as “the orthodoxy”, mention that they represent a “distortion of a whole area of science” and that they are conspiring to “invok[e] the threat of climatic disaster, to hinder vital industrial progress in the developing world”. Because despite all that you are letting the opposing view have a say. The excuses can stretch even further if your programme is viewed as being “polemical”, as if unsubstantiated nonsense is its own rightness.

Totally unrelated to the above, the same document also contains other rulings, the last of which quite amused me. It was regarding a complaint against subscription-only SportXXXGirls, in which the female presenters “perform[ed] explicit sexual acts” and “invited viewers to contact them for ‘adult chat’ via a premium rate text service”. The complaint was that the “live chat” was a repeat from the week before, which wasn’t obvious (unless you’d seen the previous screening, I guess…). I can only imagine how often they get complaints like this — I don’t know how many people consider complaining about subscription porn channels — but the result was that “Ofcom viewed the recordings supplied and noted that the material shown on the 10 February 2008 was a repeat of that shown on 3 February 2008”. What a strange job…

Tomorrow (that is, 30 January 2010) there are going to be a number of demonstrations/protests outside branches of Boots, under the general name of the 10:23 campaign. At 10:23, a bunch of not-very-brave people will be “overdosing” on homeopathic pills. I think the plan is that each person takes a bottle full. This will, of course, have no downsides whatsoever because there is nothing in it.

The point in this case is not to point out the stupidity of homeopathy to the people in the street, though it will no doubt do that. It’s to make the point that Boots sell these things — have whole aisles devoted to these little white pills — even though they admit there is no evidence for their effectiveness. There are even Boots-branded homeopathic pills on the shelves! And at the same time they sell you something useless, they want you to know that their pharmacists are trustworthy enough to dispense medicines with active ingredients, and give advice about these medicines.

I leave you with James “the Amazing!” Randi, to explain the absurd details of homeopathy in his wonderful way: