NDH Writeups

2015 Nuit du Hack CTF Quals by Hackerzvoice

It was a great moment of fun to participate to this year's CTF Quals organised by Hackerzvoice
Solving challenges involved all Pollypocket team members, here is only some polished results.

Game-of-Life

tar xzf GOL.tar.gz
./jdlv.py $RANDOM cipher.txt |grep -ia flag
Flag : ToBeAndToLast

Yes, $RANDOM, any password works!
If you want a much nicer write-up, see here but honestly I don't see the point of spending so much time to solve it and writing a cracking script...

Bleep

"The clock is running. Make the most of today. Time waits for no man. Yesterday is history. Tomorrow is a mystery. Today is a gift. That's why it is called the present." (A)
Bleeeep Bleep Bleep Bleep Bleep Bleeeep Bleep Bleep Bleep Bleep Bleep Bleeeep Bleeeep Bleep.
I'm the bleep, unbleep me.
It was a 200 misc but only solved by 6 teams so I think it deserves a little write-up :-)
You get a file Bleep.tar.gz
It contains a "consigne" (FR for instructions) text file:

[ Bleep ]
[+] You got this .hex file from a firmware dump can, you understand what's going on?

And a chall.hex that looks like:

:100000000C945F000C9487000C9487000C9487007C
:100010000C9487000C9487000C9487000C94870044
:100020000C9487000C9487000C9487000C94870034
etc.

chall.hex is indeed a firmware image in the classical Intel HEX format.
One can use e.g. http://sourceforge.net/projects/hex2bin/ to convert it to a bin/raw format.
By an educated guess (what's most popular microcontroller especially in non-elec circles?) we assume it could be Arduino / Atmel AVR.
Actually knowing this kind of details is not that important ;-)
So the initial approach was to open the firmware image in Ida but I felt demotivated and didn't want to reverse all those little interrupt-driven functions.
From the description (Bleep Bleeeep) the microcontroller is probably outputting a kind of Morse-encoded signal.
Using my ElectronicColoringBook.py I can see quite a lot of patterns in the binary:

./ElectronicColoringBook.py -x 128 chall.bin

And a quick look at the disassembly confirms the repetition of patterns made of args & fct calls:

avr-objdump -D -m avr5 chall.hex
[...]
    17a:	61 e0       	ldi	r22, 0x01	; 1
    17c:	80 91 00 01 	lds	r24, 0x0100
    180:	0e 94 a5 0a 	call	0x154a	;  0x154a
    184:	68 ee       	ldi	r22, 0xE8	; 232
    186:	73 e0       	ldi	r23, 0x03	; 3
    188:	80 e0       	ldi	r24, 0x00	; 0
    18a:	90 e0       	ldi	r25, 0x00	; 0
    18c:	0e 94 46 0b 	call	0x168c	;  0x168c
    190:	60 e0       	ldi	r22, 0x00	; 0
    192:	80 91 00 01 	lds	r24, 0x0100
    196:	0e 94 a5 0a 	call	0x154a	;  0x154a
    19a:	68 ee       	ldi	r22, 0xE8	; 232
    19c:	73 e0       	ldi	r23, 0x03	; 3
    19e:	80 e0       	ldi	r24, 0x00	; 0
    1a0:	90 e0       	ldi	r25, 0x00	; 0
    1a2:	0e 94 46 0b 	call	0x168c	;  0x168c
    1a6:	61 e0       	ldi	r22, 0x01	; 1
    1a8:	80 91 00 01 	lds	r24, 0x0100
    1ac:	0e 94 a5 0a 	call	0x154a	;  0x154a
    1b0:	68 ee       	ldi	r22, 0xE8	; 232
    1b2:	73 e0       	ldi	r23, 0x03	; 3
    1b4:	80 e0       	ldi	r24, 0x00	; 0
    1b6:	90 e0       	ldi	r25, 0x00	; 0
    1b8:	0e 94 46 0b 	call	0x168c	;  0x168c
    1bc:	60 e0       	ldi	r22, 0x00	; 0
    1be:	80 91 00 01 	lds	r24, 0x0100
    1c2:	0e 94 a5 0a 	call	0x154a	;  0x154a
    1c6:	68 ee       	ldi	r22, 0xE8	; 232
    1c8:	73 e0       	ldi	r23, 0x03	; 3
    1ca:	80 e0       	ldi	r24, 0x00	; 0
    1cc:	90 e0       	ldi	r25, 0x00	; 0
    1ce:	0e 94 46 0b 	call	0x168c	;  0x168c
    1d2:	61 e0       	ldi	r22, 0x01	; 1
    1d4:	80 91 00 01 	lds	r24, 0x0100
    1d8:	0e 94 a5 0a 	call	0x154a	;  0x154a
    1dc:	64 ef       	ldi	r22, 0xF4	; 244
    1de:	71 e0       	ldi	r23, 0x01	; 1
    1e0:	80 e0       	ldi	r24, 0x00	; 0
    1e2:	90 e0       	ldi	r25, 0x00	; 0
    1e4:	0e 94 46 0b 	call	0x168c	;  0x168c
etc

Looking at the byte level it means we have an interleaved repetition of the following patterns:

• 60e0809100010e94a50a
• 61e0809100010e94a50a
• 60ed77e080e090e00e94460b
• 64ef71e080e090e00e94460b
• 68ee73e080e090e00e94460b

Now time for some black magic one-liner! Let's print the patterns in a more compact form:

dd if=chall.bin bs=1 skip=378 count=1000 2>/dev/null|xxd -p|tr -d '\n' |\
  sed 's/61e0809100010e94a50a/^/g;s/68ee73e080e090e00e94460b/./g;s/60e0809100010e94a50a/_/g;s/64ef71e080e090e00e94460b/o/g;s/60ed77e080e090e00e94460b/O/g'
^._.^._.^o_O^._.^._.^._O^._.^o_.^o_O^._.^._O^._.^._.^._O^._.^o_.^o_O^o_O^._.^._.^._O^._.^._

At first I tried to interpret the 5 individual patterns as Morse . and _ and as pauses (short between symbols, longer between letters, longer between words) but nothing made properly sense.
Then I realized combination of patterns was the key: one was there to toggle the output (^ =up, _ =down) and the other one indicates duration.

^o = .
^. = -
_. = pause between symbols
_O = pause between letters

So we can convert our previous output with

sed 's/\^\./-/g;s/\^o/./g;s/\^O/@/g;s/_\.//g;s/_o/ /g;s/_O/  /g'

or more elegantly rewrite our one-liner as: (split in several lines to show up more nicely on this wiki)

dd if=chall.bin bs=1 skip=378 count=990 2>/dev/null|xxd -p|tr -d '\n' |\
  sed 's/61e0809100010e94a50a64ef71e080e090e00e94460b/./g;
       s/61e0809100010e94a50a68ee73e080e090e00e94460b/-/g;
       s/60e0809100010e94a50a68ee73e080e090e00e94460b//g;
       s/60e0809100010e94a50a60ed77e080e090e00e94460b/ /g;
       s/$/\n/'
--. --- -.. -- --- -.. . --- --

Which translates to "GODMODEOM".
The flag didn't validate but "GODMODEON" worked so last symbol should be a "." and not a "-", maybe an error in the challenge or a side effect?
Actually by carefully tuning the options and selecting a suitable color palette, my ElectronicColoringBook.py can reveal directly the code too: (red=-, green=.)

./ElectronicColoringBook.py -x 1280 -b 22 -o 11.18 -P "#ff0000#aaaaaa#000000#00ff00#000000" chall.bin 

Weshgrow

wget -q -O - --content-on-error "http://weshgrow.challs.nuitduhack.com/flag?hmac=%fd"|grep  FLAG
<li onclick="toggle('pre29839800', 'post29839800')">            flag=FLAG</li>
<tr><td>fvars</td><td class="code"><div>{'FLAG': 'Can_I_haz_s3cureD_hm4c_plz?',

This python stacktrace because of the utf8 parser is probably not the intended way ;-)
For a write-up of the "real" solution, see here

2014 Nuit du Hack CTF by Hackerzvoice

Unter Cab Command and Control Radio Module

Not exactly a write-up as I could not finish this one but still, here are my notes:

Discovering

We got a DVB-T dongle and its drivers on a Windows CD.
I directly recognize this kind of beast, it's a RTL-SDR-based dongle which means it gets a 50MHz-2GHz tuner and sends its I/Q samples to the PC where everything else is done in pure software.
On our server we could find a README.md with the following content:

Unter Cab Command and Control Radio Module
==========================================

Description
-----------
This document describes the radio module designed by Unter to broadcast data to cabs through Radio Frequency.

Specifications
--------------
* Baseband: 433.92 MHz
* Encryption used: Ron's code
* Micro-controler: ATmega328P-PU
* Data structure: Datagram-based TX/RX
* CRC error control

Datagram
--------
* 0x00: Magic (3 bytes)
* 0x03: Reserved (3 bytes)
* 0x06: IV (2 bytes)
* 0x08: Encrypted DATA (N bytes)
* 0x08 + N: Datagram CRC (from 0x00 to (0x08 + N), 1  byte) )

Microcontroller seems to indicate the emitter is made with an Arduino.
Ron's code refers probably to Ron Rivest RC family. Later someone from the orga confirmed it was RC4.

Scanning the radio bands

I first ran gqrx to see a waterfall around 433.92 MHz
There were indeed strong "pulses" every second around 433.815 MHz
Not exactly the same frequency but maybe the Arduino or the dongle weren't that precise so it's always good to first have a look with gqrx to fine tune the frequency to watch.
With gqrx you can also listen to the chosen frequency and try different demodulations like FM, AM, ... and clearly AM gave the less noisy signal.

Acquiring analog signal

At this point you can make your own demodulator with GnuRadio but if it's just to demodulate AM you can also use rtl_fm which is part of the basic librtlsdr tools (librtlsdr-bin on Debian).

rtl_fm -f 433815000 -s 12k -p 45 -l 50 -M -o 4 data.out

Then opening data.out in Audacity, we see:

Zooming:

which can be decoded visually into (H=high / L=low)

HLHHLLLHHLHHHLHHHLHHLHHHHHHHHHHHHHHHHHHHHHLHHLLHHLLLHHLLLHHLLHLHLHHHLHHHHHHHHLLHLLLHLLHLLHHLLLHHHLHHLLLLLLHHHHHLHLHHHHHHLHHLLH

Decoding the captured signal

Now is H=1 and L=0 or vice versa?
Let's assume H=1:

10110001101110111011011111111111111111111111011001100011000110010101110111111110010001001001100011101100000011111010111111011001
= B1BBB7FFFFF663195DFE4498EC0FAFD9

Let's assume H=0:

= 4E44480000099CE6A201BB6713F05026

From README.md, first three bytes are "magic", a signature and as 4E4448 = "NDH" that's probably the right decoding :-)
So if we try to decode the frame:

magic.  reserv  IV..  Encrypted..... CRC
4E4448  000009  9CE6  A201BB6713F050  26

Then I wrote a little crappy python script to decode the analog AM signal, which can take rtl_fm output in live:

#!/usr/bin/python
import os, sys, struct
scaledown=10
x=struct.unpack_from('h',sys.stdin.read(2),0)[0]
d, t, mode, s=0, 0, 1, ""
def printbits(bitstring):
    bytes=len(bitstring) / 8
    if bytes > 0:
        n=0
        while len(bitstring)>7:
            n=(n<<8) + \
              (int(bitstring[0])<<7) + (int(bitstring[1])<<6) + (int(bitstring[2])<<5) + (int(bitstring[3])<<4) + \
              (int(bitstring[4])<<3) + (int(bitstring[5])<<2) + (int(bitstring[6])<<1) + int(bitstring[7])
            bitstring=bitstring[8:]
        print '%0*X' % (bytes*2,n)

while True:
    x2=struct.unpack_from('h',sys.stdin.read(2),0)[0]
    d2=(x2-x)>>scaledown
    if d2 < 0:
        d2=d2+1
    if d2==0 or (d>0 and d2>0 and t<30) or (d<0 and d2<0 and t<30):
        t=t+1
    else:
        if d<0:
            t=-t
        if (abs(t)>50):
            if mode == 2:
                mode=1
                if tl > 5:
                    s+="0"
                else:
                    s+="1"
            if len(s) == 16*8:
               printbits(s)
               pass
            s=""
        else:
            if mode == 1:
                tl=t
                mode=2
            else:
                if mode == 2:
                    mode=1
                    if tl >= 5:
                        s+="0"
                    else:
                        s+="1"
        d=d2
        t=1
    x=x2

rtl_fm -f 433815000 -s 12k -p 45 -l 50 -M -o 4 - |./raw2bin.py

I collected about 8342 such beacons, which you can download here

Filtering thanks to CRC... or not

Some may be wrong hopefully there is a CRC so let's filter them:
Hum not so easy, there are several CRC definitions over a byte.
After many attempts, even trying XOR, nothing works :-(
Ok let's take another approach:

cat ucccrm.log |sort|uniq -c|sort -r -n|uniq -c -w 7|cut -c -15
    11       3
   228       2
  7853       1

7853 beacons are unique, 228 repeat once and 11 repeat twice.
But something striked me when I looked at the sorted beacons:

cat ucccrm.log |sort|head
4e44480000090021b8ae87bdb188bc05
4e44480000090021b8ae87bdb188bc07
4e44480000090021b8ae87bdb188bc0a
4e44480000090021b8ae87bdb188bc0e
4e44480000090021b8ae87bdb188bc13
4e44480000090021b8ae87bdb188bc16
4e44480000090021b8ae87bdb188bc1b
4e44480000090021b8ae87bdb188bc1d
4e44480000090021b8ae87bdb188bc1e
4e44480000090021b8ae87bdb188bc1e

Only the CRC byte is varying at each line!!
That can't be.
Another team considered the beacons were 15 bytes instead of 16 bytes (I think their decoder simply missed the last bit, therefore the last byte).
Ok let's assume we remove the last byte so now the 15th byte becomes the CRC.
The problem is that you can also find many things like this:

cat ucccrm.log|grep -o "4e4448....09002163703a8a832a.."
4e44487f4709002163703a8a832aea
4e4448bde209002163703a8a832aea
4e444848ba09002163703a8a832aea
4e44480af709002163703a8a832aea

Here we get beacons with different reserved bytes but still always the same 15th byte so it can't be CRC neither.

Filtering thanks to IVs & packets repetition

Forget about CRC and let's investigate those IVs:

cat ucccrm.log |cut -c 13-16|sort|uniq -c|sort -n -r|head
    228 0ff6
    206 a712
    164 960b
    164 6805
    157 790c
    151 ef1a
    140 0021
    137 4e03
    128 20fd
    123 c114

Oops, not that random! Actually a closer inspection shows that for a given value for the first IV byte, the second part of the IV is always the same:

cat ucccrm.log |cut -c 13-16|grep ^0f|uniq -c
   228 0ff6

Let's try to look at the IV+payload and filter errors without the CRC:

cat ucccrm.log |cut -c 13-30|sort|wc -l
8342
cat ucccrm.log |cut -c 13-30|sort|uniq|wc -l
1518

Out of those 1518 unique beacons we want to filter away those that don't repeat less than three times:

cat ucccrm.log |cut -c 13-30|sort|uniq -c|grep -v "^ *[12] "|wc -l
596

Ok it seems we've 596 reliable unique beacon values that have been seen at least three times, so those ones are unlikely to be corrupted.
Top cryptograms are:

cat ucccrm.log |cut -c 13-30|sort|uniq -c|grep -v "^ *[12] "|sort -n -r|head
   126 0ff62634969a205607
    97 790c0c02ced3211618
    89 a71299662e43a51052
    88 68050eb867d375b4ae
    77 20fdd32f4c6d471ae1
    74 0021b8ae87bdb188bc
    63 ef1af164362a274bd6
    62 c1148882b72d4db20e
    62 4e03b62b9150d90d91
    61 960bc050ef31b7a950
cat ucccrm.log |cut -c 13-30|sort|uniq -c|grep -v "^ *[12] "|cut -c 9- > uniq_cryptograms.log

Investigating IVs further

Out of those beacons, let's see those starting with the same IV:

cat ucccrm.log |cut -c 13-30|sort|uniq -c|grep -v "^ *[12] "|cut -c 9-|sort |uniq -w 4 -c|sort -r -n|cut -c 4-12|head
 10 a712
  7 960b
  6 b53d
  6 9d90
  6 868c
  6 6805
  6 4e03
  6 43d7
  5 f749
  5 f5f5

a712 seems a promising IV and we have 10 different messages encrypted with the same IV:

cat ucccrm.log |cut -c 13-30|sort|uniq -c|grep -v "^ *[12] "|cut -c 9-|grep ^a712
a71202303bb038c35f
a7120a71d6528ef2d1
a7120af9e1382039f2
a71226587dbb1dfa57
a712594cf717dd99ff
a7126f6cc1f15a5510
a7127047b9ea596e4d
a71271abbc20a25c31
a7127e5ad415a22f61
a71299662e43a51052

Bruteforcing RC4 keystream... or not

If IV is constant and the key is the same, the RC4 keystream should be constant.
So we can try to bruteforce it: let's assume one value for the first byte of the keystream and apply it to the first byte of each encrypted message. We should get for the good keystream candidates only plaintexts which are printable ASCII.

#!/usr/bin/env python

c=["02303bb038c35f",
   "0a71d6528ef2d1",
   "0af9e1382039f2",
   "26587dbb1dfa57",
   "594cf717dd99ff",
   "6f6cc1f15a5510",
   "7047b9ea596e4d",
   "71abbc20a25c31",
   "7e5ad415a22f61",
   "99662e43a51052",
   "b5b3efa256e41a"]
c=[[ord(j) for j in x.decode('hex')] for x in c]
keybyte=0
for i in range(256):
  print i,
  for x in c:
    print repr(chr(x[keybyte]^i)),
  print ""

0 '\x02' '\n' '\n' '&' '8' 'Y' 'g' 'm' 'o' 'p' 'q' '~' '\x91' '\x99' 
1 '\x03' '\x0b' '\x0b' "'" '9' 'X' 'f' 'l' 'n' 'q' 'p' '\x7f' '\x90' '\x98' 
2 '\x00' '\x08' '\x08' '$' ':' '[' 'e' 'o' 'm' 'r' 's' '|' '\x93' '\x9b' 
3 '\x01' '\t' '\t' '%' ';' 'Z' 'd' 'n' 'l' 's' 'r' '}' '\x92' '\x9a' 
4 '\x06' '\x0e' '\x0e' '"' '<' ']' 'c' 'i' 'k' 't' 'u' 'z' '\x95' '\x9d' 
5 '\x07' '\x0f' '\x0f' '#' '=' '\\' 'b' 'h' 'j' 'u' 't' '{' '\x94' '\x9c' 
6 '\x04' '\x0c' '\x0c' ' ' '>' '_' 'a' 'k' 'i' 'v' 'w' 'x' '\x97' '\x9f' 
etc

But none of the key candidates can decode the first byte of each of those beacons with same IV systematically into printable char.
Same for the other keystream bytes.
That's the point where I'm lost!

Conclusions so far

To recap, the situation is:

• byte 16 cannot be consistently a checksum byte, no matter the encoding
• byte 15 cannot be consistently a checksum byte, no matter the encoding
• no keystream is able to decrypt payload into printable chars
• datagram format is described with a variable length in README.md but we only encountered 16-byte long beacons.

As sometimes submitting things like email addresses of encrypted .htpasswd files gave you points I tried to submit all the beacons I got to the scoreboard, without any result.
Anybody has a better idea?
You can edit here or ping me on twitter @doegox or reply to my desperate tweet :-)
You can get all the 8342 intercepted beacons here: ucccrm.log
They are in chronological order, unfiltered so a few might be corrupted

UPDATE June 2015

During NDH2015 CTF final I could discuss with the author of this challenge, who was unfortunately not present during the NDH2014 when I was facing those troubles.
It appeared that there was a 1-byte memory leakage in the Arduino code.
So when he started the devic, it was working fine, then he left, then the leakage went on till the Arduino got completely messed up.
So there was nothing we could have done, Garbage In, Garbage Out
Too bad, but at least now I got an explanation ;)

2014 Nuit du Hack CTF Quals by Hackerzvoice

It was a great moment of fun to participate to this year's CTF Quals organised by Hackerzvoice
Solving challenges involved all Pollypocket team members, here is only some polished results.

The greatest

The greatest was a steganography challenge:

We are sure that this e-mail contains hidden information, go get it !
Score 500
Link http://static.nuitduhack.com/mail.tar

Let's get this one:

wget http://static.nuitduhack.com/mail.tar
file mail.tar 
mail.tar: POSIX tar archive (GNU)

And a quick inspection through an hexadecimal editor didn't reveal anything suspicious or noticeable.
So let's open it:

tar tvf mail.tar 
-rw-r--r-- null/null    296008 2014-04-05 07:05 Mail
tar xvf mail.tar

And we get a file called Mail containing an email from BOOBA#rapfr.fr to theflag#nuitduhack.com

Hi dude!
Check out this pic. I used the cool tool I told you about last time, except that I played around with the code a bit.
Speaking of tools, Gregory Evans right?
Have fun trying to find the hidden data ;)
Peace out.

Together with an attachment (well, two attachments as the email was text+html)
The html version differed slightly ("this pic" => "this pick") but that didn't reveal to be of importance.
The other attachment:

Content-Type: image/gif; name=greg.gif
Content-Disposition: attachment; filename=greg.gif
Content-Transfer-Encoding: base64

Let's get it out of the mail using munpack from package mpack

munpack Mail
file greg.gif
greg.gif: GIF image data, version 89a, 500 x 645

greg.gif is... a GIF showing #1 world hacker :-)


Here again, after inspection, nothing else than the GIF itself in the file.
Using gifsicle from the eponym package

gifsicle --xinfo greg.gif
* greg.gif 1 image
  logical screen 500x645
  global color table [256]
  background 65
  + image #0 500x645

There is no much possibilities for stegano in GIF as the image is made of refs to the colormap so it could be:

• position of pixels of a given color
• duplicates or alike in the colormap (e.g. #cccccc and #cccbcc) or other tricks

So let's dump the colormap:

gifsicle --color-info greg.gif
* greg.gif 1 image
  logical screen 500x645
  global color table [256]
  |   0: #FFFFFF      64: #A3835C     128: #1E3E71     192: #769DD1
  |   1: #FCF5F6      65: #A37F81     129: #030915     193: #0F314D
  |   2: #F5E9E8      66: #A27C58     130: #546473     194: #5982BB
[...]
  |  61: #A48A64     125: #675847     189: #4B3A47     253: #000000
  |  62: #A3BCE1     126: #101627     190: #7CA2CD     254: #000000
  |  63: #A38C6B     127: #4C6169     191: #594837     255: #000000
  background 65
  + image #0 500x645

243 colors were used (it's #000000 from 244 to 255)
They are globally sorted from #FFFFFF to #000000 but there are quirks in the sorting: e.g. #126, #129, #191 and #193 in the partial dump above are not sorted properly.
Clearly that can be a way to hide info but the problem as often in steganography challenges is that it's hard to guess how info was stored without the original tool.
And indeed the mail was talking about a modified tool, remember?
Googling for "gif stegano colormap" one of the hits mentioned gifshuffle: a tool used to conceal messages which are stored in GIF images by “shuffling” the color map.
That sounds promising!
And source code is available: http://www.darkside.com.au/gifshuffle/gifshuffle.tar.gz
It compiles smoothly.
Its man page explains very well how it embeds information by first sorting the colormap then changing the order of some of the colors.
Exactly what we observed!
There is also an encryption mode but that would be hard to crack and when used the colormap looks completely randomly sorted, which is not what we observed, luckily!
There is also a basic compression option
But when we try on the gif:

./gifshuffle greg.gif
<output is binary garbage>
./gifshuffle -C greg.gif
                                 uttEioe)udi
sgahat	aam wttf?ltkt tc(w a't weuos nllopcdyiccefohtr*c'npi na iarinrrrmgY rtolra"dbedna0tywUpea)ph   ic.i@t)w   i  Rdlnos 
igoi atyd	tns s t  hb bs0.iianiubiksiata gOobroiaw ..occsasniDtmdder tdpcatr. nI*ti	inmuaoitdfK  voesd ab leany0. l,nnetuCi .aabsas th e  g
Eo)bvrncitrid
sa	n.  Msdree

Hmmm.
Remember the mail, the tool was modified by the sender...
We can use gifshuffle ourselves on a gif to add some data into it.
We can use greg.gif as it will first sort the table, erasing the old data, then embed ours.

./gifshuffle -m fooooooooooooooooooooooooooooooooooooooooooooooooooooo greg.gif greg2.gif
Message used approximately 27.25% of available space.

gifsicle --color-info greg2.gif 
* greg2.gif 1 image
  logical screen 500x645
  global color table [256]
  |   0: #000000      64: #3B608F     128: #7C9CC5     192: #95675B
  |   1: #010001      65: #3C4230     129: #7CA2CD     193: #9C9499
  |   2: #030915      66: #44555D     130: #7CA3D2     194: #968C94
[...]
  |  61: #372819     125: #7B654B     189: #DFC69D     253: #000000
  |  62: #372925     126: #7B9ECB     190: #E6D9D8     254: #000000
  |  63: #394A58     127: #7C7456     191: #CFD8E9     255: #000000
  background 214
  + image #0 500x645

See, sorted colormap except for #191, #194
But global sorting is from #000000 to #FFFFFF (then some #000000 for the unused colors)
That's the thing we need to modify too in the tool
gifshuffle/encode.c colourmap_encode() starts by sorting the colormap:

if (encrypting_colourmap ()) {
    ...
    qsort (ci_array, ncols, sizeof (CMAP_INFO), cmap_encrypt_cmp);
} else
    qsort (ci_array, ncols, sizeof (CMAP_INFO), cmap_cmp);

Sorting is based on the comparison function cmap_cmp() defined in the same file:

static int cmap_cmp ( const void *p1, const void *p2) {
    return (rgb_cmp (&((CMAP_INFO *) p1)->rgb, &((CMAP_INFO *) p2)->rgb));
}

Let's just swap its arguments to inverse its effect:

static int cmap_cmp ( const void *p1, const void *p2) {
    return (rgb_cmp (&((CMAP_INFO *) p2)->rgb, &((CMAP_INFO *) p1)->rgb));
}

Let's try it:

gifshuffle_inverted greg.gif
The flag for this wonderful Gregory D. Evans picture is : L0n9L1v3TheW0rldN00n3Hack3rGr3g0ryD.3van

Another One

The Another One was a crypto challenge:

This is a crypted image, you must extract the data.
Score 300
Link http://static.nuitduhack.com/crypted.bmp

Let's get this one:

wget http://static.nuitduhack.com/crypted.bmp
hd crypted.bmp |head 
00000000  16 3c 04 03 3d 66 9e 02  ad 35 5d d0 3d ea 22 1e  |.<..=f...5].=.".|
00000010  c2 6c 32 02 13 d4 51 cc  37 3b 04 a9 7a ab 24 44  |.l2...Q.7;..z.$D|
00000020  ed dd 39 17 4c 18 8e 20  f3 42 ab 86 c4 1c 4c a4  |..9.L.. .B....L.|
00000030  da dc e7 65 22 33 97 9c  f5 95 fd e1 34 cd a7 bb  |...e"3......4...|
00000040  fb 5e a1 b7 89 5c 5e 8d  a7 5a 0d df 03 00 fe 3b  |.^...\^..Z.....;|
*
00001ec0  35 2e 5c 08 66 50 4d ab  60 04 d5 db da 80 32 17  |5.\.fPM.`.....2.|
00001ed0  fb 5e a1 b7 89 5c 5e 8d  a7 5a 0d df 03 00 fe 3b  |.^...\^..Z.....;|
*
00003180  d4 76 9b 3c d0 aa a5 57  e2 11 a3 e6 9e ab c5 6d  |.v.<...W.......m|

A 128 bits sequence is repeating itself quite often:

fb 5e a1 b7 89 5c 5e 8d  a7 5a 0d df 03 00 fe 3b 

This is typical of the usage of a block cipher in ECB mode when plaintext is repeating, which is likely to happen on an encrypted BMP drawing (much less likely if it's an actual photography).
Let's XOR the file with that sequence and 0xFF to get 0xFF (white pixels?) (very dirty way... at CTF we want to code fast, not the program to be the most optimized...)

#!/usr/bin/env python
c=open("crypted.bmp", 'rb').read()
p=open("out.bmp",'wb')
k=[]
for i in range(len(c)):
  if not k:
    k=list("fb 5e a1 b7 89 5c 5e 8d  a7 5a 0d df 03 00 fe 3b".replace(" ","").decode('hex'))
  p.write(chr(ord(c[i]) ^ ord(k.pop(0)) ^ 0xFF))
p.close()

The result is a file with many zeroes but it's still not a valid BMP (BTW is it really a BMP? Can we trust the file extension??). The background color was not encoded with 0x00 apparently.
Neither with 0xFF, we tested it by XORing additionally with 0xFF.
Time to read some BMP file format description...
Guessing what would be the initial header content is quite hard.
I took another approach:
Dump the raw content in a PPM file by adding a simple header.
PPM encodes each pixel in 3 bytes
BMP can encode each pixel in 2,3 or 4 bytes
We'll see...
We've also to provide the image size... Let's try 1200x1200: (1200*1200*3=4320000, the filesize)
We also flip top and bottom as BMP encodes the image from bottom to top

(echo -e -n "P6\n1200\n1200\n255\n";cat out.bmp)|pnmflip -tb|pnmtopng > out.png

We see things!
Playing around with the image size, we find out a satisfying ratio:

(echo -e -n "P6\n1600\n900\n255\n";cat out.bmp)|pnmflip -tb|pnmtopng > out.png

And this is enough to get our flag!
Never never use EBC mode ;-)
The quality is enough but actually one can do better, e.g. in cases the image is not that clear.
By carefully choosing replacements for repeating or non-repeating ECB blocks we can obtain something like this:

See https://doegox.github.io/ElectronicColoringBook/ for more ECB coloring fun!