Add server version to master api

Add IsEvadedOffense to EFPenalty
Fix remote log reading in not Windows

Master/env_master/Lib/site-packages/flask_restful/utils/__init__.py

@@ -0,0 +1,35 @@
+import sys
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    from ordereddict import OrderedDict
+
+from werkzeug.http import HTTP_STATUS_CODES
+
+PY3 = sys.version_info > (3,)
+
+
+def http_status_message(code):
+    """Maps an HTTP status code to the textual status"""
+    return HTTP_STATUS_CODES.get(code, '')
+
+
+def unpack(value):
+    """Return a three tuple of data, code, and headers"""
+    if not isinstance(value, tuple):
+        return value, 200, {}
+
+    try:
+        data, code, headers = value
+        return data, code, headers
+    except ValueError:
+        pass
+
+    try:
+        data, code = value
+        return data, code, {}
+    except ValueError:
+        pass
+
+    return value, 200, {}

Master/env_master/Lib/site-packages/flask_restful/utils/cors.py

@@ -0,0 +1,54 @@
+from datetime import timedelta
+from flask import make_response, request, current_app
+from functools import update_wrapper
+
+
+def crossdomain(origin=None, methods=None, headers=None, expose_headers=None,
+                max_age=21600, attach_to_all=True,
+                automatic_options=True, credentials=False):
+    """
+    http://flask.pocoo.org/snippets/56/
+    """
+    if methods is not None:
+        methods = ', '.join(sorted(x.upper() for x in methods))
+    if headers is not None and not isinstance(headers, str):
+        headers = ', '.join(x.upper() for x in headers)
+    if expose_headers is not None and not isinstance(expose_headers, str):
+        expose_headers = ', '.join(x.upper() for x in expose_headers)
+    if not isinstance(origin, str):
+        origin = ', '.join(origin)
+    if isinstance(max_age, timedelta):
+        max_age = max_age.total_seconds()
+
+    def get_methods():
+        if methods is not None:
+            return methods
+
+        options_resp = current_app.make_default_options_response()
+        return options_resp.headers['allow']
+
+    def decorator(f):
+        def wrapped_function(*args, **kwargs):
+            if automatic_options and request.method == 'OPTIONS':
+                resp = current_app.make_default_options_response()
+            else:
+                resp = make_response(f(*args, **kwargs))
+            if not attach_to_all and request.method != 'OPTIONS':
+                return resp
+
+            h = resp.headers
+
+            h['Access-Control-Allow-Origin'] = origin
+            h['Access-Control-Allow-Methods'] = get_methods()
+            h['Access-Control-Max-Age'] = str(max_age)
+            if credentials:
+                h['Access-Control-Allow-Credentials'] = 'true'
+            if headers is not None:
+                h['Access-Control-Allow-Headers'] = headers
+            if expose_headers is not None:
+                h['Access-Control-Expose-Headers'] = expose_headers
+            return resp
+
+        f.provide_automatic_options = False
+        return update_wrapper(wrapped_function, f)
+    return decorator

Master/env_master/Lib/site-packages/flask_restful/utils/crypto.py

@@ -0,0 +1,35 @@
+import pickle
+from Crypto.Cipher import AES
+from base64 import b64encode, b64decode
+
+
+__all__ = "encrypt", "decrypt"
+
+BLOCK_SIZE = 16
+INTERRUPT = b'\0'  # something impossible to put in a string
+PADDING = b'\1'
+
+
+def pad(data):
+    return data + INTERRUPT + PADDING * (BLOCK_SIZE - (len(data) + 1) % BLOCK_SIZE)
+
+
+def strip(data):
+    return data.rstrip(PADDING).rstrip(INTERRUPT)
+
+
+def create_cipher(key, seed):
+    if len(seed) != 16:
+        raise ValueError("Choose a seed of 16 bytes")
+    if len(key) != 32:
+        raise ValueError("Choose a key of 32 bytes")
+    return AES.new(key, AES.MODE_CBC, seed)
+
+
+def encrypt(plaintext_data, key, seed):
+    plaintext_data = pickle.dumps(plaintext_data, pickle.HIGHEST_PROTOCOL)  # whatever you give me I need to be able to restitute it
+    return b64encode(create_cipher(key, seed).encrypt(pad(plaintext_data)))
+
+
+def decrypt(encrypted_data, key, seed):
+    return pickle.loads(strip(create_cipher(key, seed).decrypt(b64decode(encrypted_data))))