1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

import asyncio
import json
import random
import sys
import websockets

guesses = dict()
matched = []
known = [-1 for i in range(56)]
done = False

async def guess(websocket, x, y):
    # msg 보내기
    msg = dict(op="guess", body=dict(x=x, y=y))
    await websocket.send(json.dumps(msg))
    # parse
    response_str = await websocket.recv()
    response = json.loads(response_str)
    board = response["board"]
    done = response["done"]
    index = y * 7 + x
    value = board[index]
    known[index] = value
    # print info
    print(f"{x}, {y}: {value}")
    # make pedigree
    if value not in guesses:
        guesses[value] = [index]
    else:
        guesses[value].append(index)
    # if Flag contain in response. than done
    if "Flag" in response_str:
        print(response["message"])
        done = True
    return value

async def solve(uri):
    # Returns 403 if origin header not set.
    origin = "https://doomed.web.ctfcompetition.com"
    async with websockets.client.connect(uri, ssl=True, origin=origin) as websocket:
        # start
        msg = dict(op="info")
        await websocket.send(json.dumps(msg))
        response = await websocket.recv()
        print(f'{response}')
        # make up dictionary of cases
        dupes = dict()
        with open("dupes.txt") as f:
            for line in f:
                dupe = json.loads(line)
                key = f"{dupe[0]}, {dupe[1]}, {dupe[2]}, {dupe[3]}"
                dupes[key] = dupe
        # Flip the first four cards.
        first = await guess(websocket, 0, 0)
        second = await guess(websocket, 1, 0)
        third = await guess(websocket, 2, 0)
        fourth = await guess(websocket, 3, 0)
        key = f"{first}, {second}, {third}, {fourth}"
        if key in dupes:
            print("FOUND DUPE!")
            for index, value in enumerate(dupes[key][4:]):
                # make pedigree
                if value not in guesses:
                    guesses[value] = [index + 4]
                else:
                    guesses[value].append(index + 4)
        else:
            print("No match. Game over.")
            return

        while(not done):
            for value in guesses.keys():
                if len(guesses[value]) == 2 and value not in matched:
                    first_index = guesses[value][0]
                    first_x = first_index % 7
                    first_y = first_index // 7
                    first = await guess(websocket, first_x, first_y)
                    second_index = guesses[value][1]
                    second_x = second_index % 7
                    second_y = second_index // 7
                    second = await guess(websocket, second_x, second_y)
                    if first == second:
                        matched.append(value)
                        print("MATCHED: ", matched)
                    else:
                        print("MISS!!" , first, second)
                        print("Dupe doesn't match. Game over.")
                        return
            not_found = [i for i, val in enumerate(known) if val == -1]
            if not_found:
                next_guess = random.choice(not_found)
            else:
                return
            x = next_guess % 7
            y = next_guess // 7
            first = await guess(websocket, x, y)
            if len(guesses[first]) == 2:
                next_guess = guesses[first][0]
                matched.append(first)
            else:
                not_found = [i for i, val in enumerate(known) if val == -1 and i != next_guess]
                next_guess = known.index(-1)
                next_guess = random.choice(not_found)
            x = next_guess % 7
            y = next_guess // 7
            second = await guess(websocket, x, y)
            if first not in matched:
                if first == second:
                    matched.append(first)
            print("MATCHED: ", matched)

uri = "wss://doomed.web.ctfcompetition.com/ws"
asyncio.get_event_loop().run_until_complete(solve(uri))

33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// We vigorously defend against CSRF/XSRF with strict origin checks.
// Note that without this, we would have severe vulnerabilities, because
// browsers don't enforce the same origin policy on websockets.
// Security is our #1 priority.
func checkOrigin(r *http.Request) bool {
    o := r.Header.Get("Origin")
    p := r.Header.Get("X-Forwarded-Proto")
    h := r.Host
    if o == "" || h == "" {
        log.Print("Websocket missing origin and/or host")
        return false
    }
    ou, err := url.Parse(o)
    if err != nil {
        log.Printf("Couldn't parse url: %v", err)
        return false
    }
    if p != "" && ou.Scheme != "https" {
        log.Print("Https websocket missing https origin")
        return false
    }
    if ou.Host != h {
        log.Print("Origin doesn't match host")
        return false
    }
    // TODO: Origin is a 3 tuple (scheme, host, port). Figure out how to check the
    // port.
    // TODO: We should enforce https origin on https ws even on non-App Engine.
    return true
}

22
23
24
25
26
27
28
29
30
31
32
33

// OsRand gets some randomness from the OS.
func OsRand() (uint64, error) {
    // 64 ought to be enough for anybody
    var res uint64
    if err := binary.Read(rand.Reader, binary.LittleEndian, &res); err != nil {
        return 0, fmt.Errorf("couldn't read random uint64: %v", err)
    }
    // Mix in some of our own pre-generated randomness in case the OS runs low.
    // See Mining Your Ps and Qs for details.
    res *= 14496946463017271296
    return res, nil
}