From 1e19efc15f372991e8e6f95ba0ec5846db7fa73a Mon Sep 17 00:00:00 2001 From: sxiii Date: Sun, 1 Dec 2019 05:44:49 +0100 Subject: [PATCH] Add new file --- archive/oldserver.py | 353 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 353 insertions(+) create mode 100644 archive/oldserver.py diff --git a/archive/oldserver.py b/archive/oldserver.py new file mode 100644 index 0000000..38bc4d0 --- /dev/null +++ b/archive/oldserver.py @@ -0,0 +1,353 @@ +#!/usr/bin/env python3 + +USERLENGTH = 50 + +import ipaddress +import random +import sys +import etcd +import json +import datetime + +from flask import Flask, abort, request, Response +from flask_restful import reqparse + +def get_random_ip(network): + net = ipaddress.IPv6Network(network) + addr_offset = random.randrange(2**64) + addr = net[0] + addr_offset + + return addr + +def require_args(*args): + parser = reqparse.RequestParser() + for arg in args: + parser.add_argument(arg, required=True) + return parser.parse_args() + +class etcdWrapper(object): + """ Generalises some etcd actions """ + + def __init__(self, client, base): + self.client = client + self.base = base + + def read_key_or_none(self, path, recursive=False): + try: + data = self.client.read(path, recursive=recursive) + except etcd.EtcdKeyNotFound: + return None + except Exception: + abort(Response(status=400, response="Error connecting to etcd")) + + return data + + def get_user_key_or_none(self, user, key): + path = "{}/user/{}/{}".format(self.base, user, key) + return self.read_key_or_none(path) + + def set_user_key(self, user, key, value): + path = "{}/user/{}/{}".format(self.base, user, key) + self.client.write(path, value) + + +class Challenge(object): + """ A sample challenge -- inherit this and overwrite accordingly """ + + points = 0 + provides = [] + requires = [] + description = None + dependencies_provided_by = {} + + def __init__(self, wrapper): + self.db = wrapper + + def game(self): + if request.method == 'GET': + return self.describe() + if request.method == 'POST': + return self.solve() + + def describe(self): + return self.description + + def save_points(self, user): + """ should be called when the challenge was solved successfully""" + + key = "points/{}".format(user, type(self).__name__) + self.db.set_user_key(user, key, self.points) + + def solve(self): + """ Needs to be implemented per challenge """ + pass + +class RegisterNet(Challenge): + points = 10 + provides = [ "network" ] + + description = """ +Register a /64 IPv6 network that you fully control. +Many other challenges depend on this. You will need to +be able to configure IPv6 addresses in this networks +and to setup services listening on these IPv6 addresses. + +Submit your network with the "network" parameter. +""" + def solve(self): + args = require_args("user", "network") + network = args['network'] + user = args['user'] + + try: + net = ipaddress.IPv6Network(network) + except Exception as e: + return Response(status=400, response="Cannot register network {}: {}".format(network, e)) + + if not net.prefixlen == 64: + return Response(status=400, response="{} mask is not /64 - please use a /64 network".format(net)) + + # Save network + self.db.set_user_key(user, "network", network) + self.save_points(user) + + return "Network {} registered, have fun with the next challenge!".format(network) + +class IPv6Address(Challenge): + points = 20 + requires = [ "network" ] + + description = """ +You have setup your network, great! +Now it is time to show that you are really controlling your network! + +Setup the IPv6 address + +{} + +and POST to this address, when it should be reachable by ping6. +""" + + def describe(self): + args = require_args("user") + user = args['user'] + key = "network" + + network = self.db.get_user_key_or_none(user, key) + if not network: + return Response(status=400, response=""" +Register a network before trying to be reachable. Possible challenges that +provide the network are: + +{} +""".format("\n".join(self.dependencies_provided_by['network']))) + + + key = "address" + address = self.db.get_user_key_or_none(user, key) + if not address: + address = get_random_ip(network.value) + self.db.set_user_key(user, key, address) + else: + address = address.value + + return self.description.format(address) + + def solve(self): + args = require_args("user") + user = args['user'] + + return Response(status=400, response=""" +Not yet implemented""") + + +class Game(object): + def __init__(self, name, etcdclient, etcbase="/ungleichgame/v1"): + self.client = etcdclient + self.etcbase = etcbase + + self.wrapper = etcdWrapper(etcdclient, self.etcbase) + + self.app = Flask(name) + + self.app.add_url_rule('/', 'index', self.index) + self.app.add_url_rule('/points', 'points', self.points) + self.app.add_url_rule('/register', 'register', self.register, methods=['POST']) + + # etcd paths are below here + + self.userbase = "{}/user".format(self.etcbase) + + # Automate this + challenges = [ RegisterNet, IPv6Address ] + challenge_instances = [] + + self.app.add_url_rule('/challenge', 'list_of_challenges', self.list_of_challenges) + self.app.add_url_rule('/challenge/', 'list_of_challenges', self.list_of_challenges) + + self.providers = {} + self.challenge_names = [] + for challenge in challenges: + c = challenge(self.wrapper) + challenge_instances.append(c) + + name = type(c).__name__ + self.challenge_names.append(name) + path = "/challenge/{}".format(name) + + self.app.add_url_rule(path, name, c.game, methods=['GET', 'POST']) + + for provider in challenge.provides: + if not provider in self.providers: + self.providers[provider] = [] + + self.providers[provider].append(name) + + # Update challenges with provider information + for challenge in challenge_instances: + for requirement in challenge.requires: + if not requirement in self.providers: + raise Exception("Unplayable server/game: {}".format(type(challenge).__name__)) + + challenge.dependencies_provided_by[requirement] = self.providers[requirement] + + + + def list_of_challenges(self): + base = request.base_url + challenges = [ "{} ({})".format(name, "{}/{}".format(base, name)) for name in self.challenge_names ] + + return """The following challenges are available on this server: + +{} + +""".format("\n".join(challenges)) + + + + def get_points(self): + """ Returns a dict['username'] = points """ + + user_points = {} + + path = "{}/".format(self.userbase) + users = self.wrapper.read_key_or_none(path) + + if users: + for user in users.children: + username = user.key.replace(path,"") + user_points[username] = 0 + + point_path = "{}/points".format(user.key) + points = self.wrapper.read_key_or_none(point_path, recursive=True) + + if not points: + continue + + for challenge in points.children: + user_points[username] += int(challenge.value) + + return user_points + + def index(self): + points = self.points() + + return """Welcome to the game server! + +Current point list is: + +{} + +For more information visit + +https://code.ungleich.ch/nico/ungleich-game +""".format(points) + + def points(self): + point_list = self.get_points() + res = [] + if not point_list: + return Response("No winners yet!") + + for k, v in point_list.items(): + res.append("{} has {} points".format(k, v)) + + return """ +Point list (aka high score) +--------------------------- +{} +""".format("\n".join(res)) + + def register(self): + args = require_args("user") + path = "{}/{}/registered_at".format(self.userbase, args['user']) + value = str(datetime.datetime.now()) + + cur = self.read_etcd(path) + + if cur: + value = cur.value + else: + self.client.write(path, value) + + return "Registered at: {}\n".format(value) + +# def get_ip_address(): +# args = self.require_args("network", "user") + +# # Needs to be fixed with ungleich-otp +# username=args['user'] + +# if request.method == 'GET': +# return Response(""" +# This is an easy level - just register any /64 network +# that you fully control. After submission the game server will generate +# a random IPv6 address in this network. +# """) + +# client = etcd.Client(port=2379) +# try: +# data = client.read("/ungleichgame/v1/{}/network".format(username)) +# # FIXME: differentiate keynotfound and other errors +# except Exception as e: +# return Response(status=400, response="Cannot read your network, try registering first (error: {})".format(e)) + +# return Response("data={}".format(data.value)) +# address = get_random_ip(data.value) +# # FIXME: catch errors +# client.write("/ungleichgame/v1/{}/address".format(username), address) + +# return Response("Your IPv6 address for this game is {}. Make it pingable and post to /level/1/result".format(address)) + +# @app.route("/level/2", methods=['GET', 'POST']) # post for username +# def pingme(): +# parser = reqparse.RequestParser() +# parser.add_argument('user', required=True) +# args = parser.parse_args() + +# # Needs to be fixed with ungleich-otp +# username=args['user'] + +# if request.method == 'GET': +# return Response(""" +# Proof that you can really control the network that you submitted: + +# - Setup the IPv6 address to be ping6 able globally +# - POST to this address when it is configured +# """) + +# if request.method == 'POST': +# try: +# data = client.read("/ungleichgame/v1/{}/address".format(username), address) +# except Exception as e: +# return Response(status=400, +# response=""" +# You need to register a network before trying to be reachable. +# Please go back to Level 1 for registering your network. +# """) +# return Response("something good") + + +if __name__ == '__main__': + g = Game(__name__, etcd.Client(port=2379)) + g.app.run(host="::", port=5002)