isl-tool 1.1.0__py3-none-any.whl

isl_tool/__init__.py

@@ -0,0 +1,7 @@
+"""Information Security Lab Tool (ETH Zürich)"""
+
+__version__ = "1.1.0"
+
+from .lib import API, APIError
+
+__all__ = ["API", "APIError", "__version__"]

isl_tool/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

isl_tool/cli.py

@@ -0,0 +1,355 @@
+import argparse
+import errno
+import os
+import sys
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import urljoin, urlsplit
+
+from . import __version__, colors, oidc
+from .lib import API
+
+PORTS = [53682, 53683, 53684, 53685]
+
+GITLAB = "https://gitlab.ethz.ch"
+CLIENT_ID = "d23d5238b28b43203b4430eaa42de7caea7ed6b8cdf9021787417ae6576cfdbe"
+
+api = API("https://isl-2026-1.inf.ethz.ch")
+
+
+def main():
+    program = argparse.ArgumentParser(
+        prog="isl-tool", description="Information Security Lab Tool (ETH Zürich)"
+    )
+    program.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=__version__,
+        help="output the version number",
+    )
+    commands = program.add_subparsers(title="commands", metavar="command")
+
+    def add_command(name, description, action):
+        command = commands.add_parser(name, help=description, description=description)
+        command.set_defaults(action=action)
+        return command
+
+    add_command(
+        "login", "authenticate for access to student environment", lambda args: login()
+    )
+
+    command = add_command(
+        "submit",
+        "submit solution for grading",
+        lambda args: submit(args.exercise, args.file),
+    )
+    command.add_argument("exercise", help="name of exercise to be submitted")
+    command.add_argument("file", help="file containing solution to exercise")
+
+    add_command(
+        "results",
+        "list the current grading results for your submissions",
+        lambda args: results(),
+    )
+
+    command = add_command(
+        "submission",
+        "show the submission file considered for the grading result of an exercise",
+        lambda args: submission(args.exercise),
+    )
+    command.add_argument("exercise", help="name of exercise")
+
+    # Equivalent of the help command commander adds implicitly
+    command = add_command(
+        "help",
+        "display help for command",
+        lambda args: commands.choices.get(args.command, program).print_help(),
+    )
+    command.add_argument("command", nargs="?", help="command to display help for")
+
+    args = program.parse_args()
+    if not hasattr(args, "action"):
+        program.print_help(sys.stderr)
+        sys.exit(1)
+    try:
+        args.action(args)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+def auth_token_path():
+    return str(Path.home() / ".isl-auth-token")
+
+
+def auth_token():
+    try:
+        with open(auth_token_path(), encoding="utf-8") as f:
+            return f.read().strip()
+    except OSError as e:
+        print(
+            colors.red(f"Error: unable to retrieve authentication token: {e}"),
+            file=sys.stderr,
+        )
+        print(file=sys.stderr)
+        print("Have you logged in using `isl-tool login` yet?", file=sys.stderr)
+        sys.exit(1)
+
+
+def write_stdout(data):
+    sys.stdout.write(data)
+    sys.stdout.flush()
+
+
+class CallbackServer(ThreadingHTTPServer):
+    # On Windows, SO_REUSEADDR allows binding a port that is already in use, which would defeat the port fallback
+    allow_reuse_address = os.name != "nt"
+    # Let handle_request() return regularly so that the login loop can check whether the callback was handled
+    timeout = 0.5
+
+
+def listen_on_first_available_port(handler, ports):
+    for port in ports:
+        try:
+            return CallbackServer(("127.0.0.1", port), handler), port
+        except OSError as err:
+            if err.errno != errno.EADDRINUSE:
+                raise
+    raise RuntimeError("No available callback port")
+
+
+def obtain_id_token():
+    config = oidc.discovery(GITLAB, CLIENT_ID)
+
+    code_verifier = oidc.random_pkce_code_verifier()
+    state = oidc.random_state()
+    nonce = oidc.random_nonce()
+
+    redirect_uri = None
+    # (id_token, error) of the first handled callback
+    outcome = []
+
+    class CallbackHandler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            url = urljoin(redirect_uri, self.path)
+
+            if urlsplit(url).path != "/callback":
+                return self.respond(404)
+
+            try:
+                tokens = oidc.authorization_code_grant(
+                    config,
+                    url,
+                    pkce_code_verifier=code_verifier,
+                    expected_state=state,
+                    expected_nonce=nonce,
+                )
+
+                self.respond(200, "Login successful. You can close this tab.")
+                outcome.append((tokens["id_token"], None))
+            except Exception as err:
+                self.respond(400, "Login failed.")
+                outcome.append((None, err))
+
+        def respond(self, status, body=""):
+            data = body.encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Length", str(len(data)))
+            self.end_headers()
+            self.wfile.write(data)
+
+        def log_message(self, format, *args):
+            pass
+
+    server, port = listen_on_first_available_port(CallbackHandler, PORTS)
+    try:
+        redirect_uri = f"http://127.0.0.1:{port}/callback"
+        auth_url = oidc.build_authorization_url(
+            config,
+            {
+                "redirect_uri": redirect_uri,
+                "scope": "openid profile email",
+                "code_challenge": oidc.calculate_pkce_code_challenge(code_verifier),
+                "code_challenge_method": "S256",
+                "state": state,
+                "nonce": nonce,
+            },
+        )
+
+        print(f"Listening on {redirect_uri}")
+        print("Opening browser for login...")
+
+        try:
+            opened = webbrowser.open(auth_url)
+        except webbrowser.Error:
+            opened = False
+        if not opened:
+            print(f"Open this URL:\n{auth_url}")
+
+        while not outcome:
+            server.handle_request()
+    finally:
+        server.server_close()
+
+    id_token, error = outcome[0]
+    if error is not None:
+        raise error
+    return id_token
+
+
+def login():
+    try:
+        id_token = obtain_id_token()
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        token = api.login(id_token)
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)
+        return
+
+    try:
+        path = auth_token_path()
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(token)
+        print(colors.green("Login successful!"))
+        print(colors.gray(f"Authentication token stored at {path}"))
+    except OSError as e:
+        print(
+            f"Error: failed to write authentication token to home directory: {e}",
+            file=sys.stderr,
+        )
+
+
+def status():
+    # Request container status from the API
+    try:
+        status = api.status(auth_token())
+
+        # Print the status
+        text = status["status"]
+        if text == "running":
+            text = colors.green(text)
+        elif text == "stopped":
+            text = colors.yellow(text)
+        elif text == "uninitialised":
+            text = colors.gray(text)
+        else:
+            text = colors.red(text)
+        print(f"Status:\t{text}")
+
+        # Print connection information
+        if status["status"] == "running":
+            print()
+            print(
+                f"Your container is available at {status['host']} on port {status['port']}."
+            )
+            print(
+                "You can connect to it using: "
+                + colors.yellow(f"ssh student@{status['host']} -p {status['port']}")
+            )
+
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)
+
+
+def reset():
+    # Request container reset from the API
+    try:
+        status = api.reset(auth_token())
+
+        # Print login credentials
+        print(colors.green("Successfully reset container!"))
+        print()
+        print("Username:\t" + colors.yellow("student"))
+        print("Password:\t" + colors.yellow(f"{status['password']}"))
+        print(
+            colors.italic(
+                "Take note of this password! You will need to reset your container to reset it!"
+            )
+        )
+        print()
+
+        # Print connection information
+        print(
+            f"Your container is available at {status['host']} on port {status['port']}."
+        )
+        print(
+            "You can connect to it using: "
+            + colors.yellow(f"ssh student@{status['host']} -p {status['port']}")
+        )
+
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)
+
+
+def start():
+    # Request container start from the API
+    try:
+        api.start(auth_token())
+    except Exception as err:
+        if str(err) == "container does not exist":
+            print("Container does not exist yet, resetting...")
+            print()
+            reset()
+        else:
+            print(colors.red(f"Error: {err}"), file=sys.stderr)
+
+
+def stop():
+    # Request container stop from the API
+    try:
+        api.stop(auth_token())
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)
+
+
+def submit(exercise, solution):
+    # Read solution file
+    try:
+        with open(solution, "rb") as f:
+            data = f.read()
+    except OSError as err:
+        print(colors.red(f"Error reading solution file: {err}"), file=sys.stderr)
+        return
+
+    # Submit solution for grading
+    try:
+        api.grade_exercise(
+            auth_token(), exercise, data.decode("utf-8", errors="replace"), write_stdout
+        )
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)
+
+
+def results():
+    # Request grader results from the API
+    try:
+        results = api.results(auth_token())
+        if not results:
+            print("No submissions yet.")
+        else:
+            for exercise, score in results.items():
+                text = colors.gray("no submission")
+                if score is not None:
+                    text = f"{score['received_points']}/{score['max_points']} points"
+                    text = (
+                        colors.green(text)
+                        if score["received_points"] == score["max_points"]
+                        else colors.yellow(text)
+                    )
+                print(f"{exercise}: {text}")
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)
+
+
+def submission(exercise):
+    # Request grader submission from the API
+    try:
+        write_stdout(api.submission(auth_token(), exercise))
+    except Exception as err:
+        print(colors.red(f"Error: {err}"), file=sys.stderr)

isl_tool/colors.py

@@ -0,0 +1,36 @@
+"""ANSI text styles, covering the subset of the `colors` npm package used by the Node.js version of isl-tool."""
+
+import os
+import sys
+
+if sys.platform == "win32":
+    from colorama import just_fix_windows_console
+
+    just_fix_windows_console()
+
+
+def supports_color():
+    if os.environ.get("FORCE_COLOR"):
+        return os.environ["FORCE_COLOR"] != "0"
+    if "NO_COLOR" in os.environ or os.environ.get("TERM") == "dumb":
+        return False
+    return sys.stdout.isatty()
+
+
+enabled = supports_color()
+
+
+def style(open_code, close_code):
+    def apply(text):
+        if not enabled or not text:
+            return text
+        return f"\x1b[{open_code}m{text}\x1b[{close_code}m"
+
+    return apply
+
+
+red = style(31, 39)
+green = style(32, 39)
+yellow = style(33, 39)
+gray = style(90, 39)
+italic = style(3, 23)

isl_tool/lib.py

@@ -0,0 +1,166 @@
+from http import HTTPStatus
+from urllib.parse import urljoin, urlsplit, urlunsplit
+
+import requests
+from websockets.exceptions import ConnectionClosed, InvalidStatus
+from websockets.sync.client import connect
+
+
+class APIError(Exception):
+    pass
+
+
+def status_text(status):
+    try:
+        return HTTPStatus(status).phrase
+    except ValueError:
+        return ""
+
+
+def decode(data):
+    return data.decode("utf-8", errors="replace")
+
+
+def api_error(err):
+    response = err.response
+    if response is not None and response.status_code == HTTPStatus.UNAUTHORIZED:
+        return APIError("unauthorized request")
+    elif response is not None and response.status_code == HTTPStatus.FORBIDDEN:
+        return APIError("unauthorized user")
+    elif response is not None and response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+        return APIError("too many requests (you have exceeded your rate limit)")
+    elif response is not None:
+        msg = f"request failed with status: {response.status_code} {status_text(response.status_code)}"
+        if response.content:
+            msg += "\n" + decode(response.content)
+        return APIError(msg)
+    else:
+        return APIError(f"request failed: {type(err).__name__}")
+
+
+def ws_response_error(status, body):
+    # Prefer the message sent by the server (e.g. submission limit reached)
+    if body.strip():
+        return APIError(body.strip())
+    elif status == HTTPStatus.UNAUTHORIZED:
+        return APIError("unauthorized request")
+    elif status == HTTPStatus.FORBIDDEN:
+        return APIError("unauthorized user")
+    elif status == HTTPStatus.TOO_MANY_REQUESTS:
+        return APIError("too many requests (you have exceeded your rate limit)")
+    elif status == HTTPStatus.NOT_FOUND:
+        return APIError("invalid exercise name")
+    return APIError(f"request failed with status: {status} {status_text(status)}")
+
+
+class API:
+    def __init__(self, base_url):
+        self.base_url = base_url
+
+    def _get(self, path, token):
+        response = requests.get(
+            urljoin(self.base_url, path), headers={"Authorization": f"Bearer {token}"}
+        )
+        response.raise_for_status()
+        return response
+
+    def login(self, auth_token):
+        try:
+            return decode(self._get("auth", auth_token).content)
+        except requests.RequestException as err:
+            if (
+                err.response is not None
+                and err.response.status_code == HTTPStatus.UNAUTHORIZED
+            ):
+                raise APIError("invalid credentials") from err
+            else:
+                raise api_error(err) from err
+
+    def status(self, token):
+        try:
+            return self._get("env/status", token).json()
+        except requests.RequestException as err:
+            raise api_error(err) from err
+
+    def reset(self, token):
+        try:
+            return self._get("env/reset", token).json()
+        except requests.RequestException as err:
+            raise api_error(err) from err
+
+    def start(self, token):
+        try:
+            self._get("env/start", token)
+        except requests.RequestException as err:
+            if (
+                err.response is not None
+                and err.response.status_code == HTTPStatus.NOT_FOUND
+            ):
+                raise APIError("container does not exist") from err
+            else:
+                raise api_error(err) from err
+
+    def stop(self, token):
+        try:
+            self._get("env/stop", token)
+        except requests.RequestException as err:
+            if (
+                err.response is not None
+                and err.response.status_code == HTTPStatus.NOT_FOUND
+            ):
+                raise APIError("container does not exist") from err
+            else:
+                raise api_error(err) from err
+
+    def grade_exercise(
+        self, token, exercise, solution, output_callback=lambda data: None
+    ):
+        url = urlsplit(urljoin(self.base_url, f"grader/submit/{exercise}"))
+        if url.scheme == "https":
+            url = url._replace(scheme="wss")
+        elif url.scheme == "http":
+            url = url._replace(scheme="ws")
+        else:
+            raise APIError(f"unsupported protocol in base URL: {url.scheme}:")
+        try:
+            # No keepalive pings: the grader stops reading (and thus answering pings) while grading
+            with connect(
+                urlunsplit(url),
+                additional_headers={"Authorization": f"Bearer {token}"},
+                ping_interval=None,
+                max_size=None,
+            ) as ws:
+                ws.send(solution)
+                while True:
+                    try:
+                        data = ws.recv()
+                    except ConnectionClosed as err:
+                        # The grader closes the TCP connection without a close frame once it is done,
+                        # so only a closure caused by an actual error (e.g. a reset) is a failure
+                        if err.__cause__ is not None:
+                            raise err.__cause__
+                        return
+                    output_callback(data if isinstance(data, str) else decode(data))
+        except InvalidStatus as err:
+            # Server rejected the upgrade (e.g. 403/429): use the body so its message isn't lost
+            raise ws_response_error(
+                err.response.status_code, decode(err.response.body or b"")
+            ) from err
+
+    def results(self, token):
+        try:
+            return self._get("grader/results", token).json()
+        except requests.RequestException as err:
+            raise api_error(err) from err
+
+    def submission(self, token, exercise):
+        try:
+            return decode(self._get(f"grader/submission/{exercise}", token).content)
+        except requests.RequestException as err:
+            if (
+                err.response is not None
+                and err.response.status_code == HTTPStatus.NOT_FOUND
+            ):
+                raise APIError("no submission or invalid exercise name") from err
+            else:
+                raise api_error(err) from err

isl_tool/oidc.py

@@ -0,0 +1,198 @@
+"""Minimal OpenID Connect client for the authorization code flow with PKCE (public client).
+
+Implements the subset of the `openid-client` npm package used by the Node.js version of isl-tool.
+As with `openid-client` (unless non-repudiation checks are enabled), the ID Token's signature is
+not verified because it is received directly from the token endpoint over TLS. Its claims are.
+"""
+
+import base64
+import hashlib
+import json
+import secrets
+import time
+from urllib.parse import parse_qs, parse_qsl, urlencode, urlsplit, urlunsplit
+
+import requests
+
+TIMEOUT = 30
+CLOCK_TOLERANCE = 30
+
+
+class OIDCError(Exception):
+    pass
+
+
+class Configuration:
+    def __init__(self, server_metadata, client_id):
+        self.server_metadata = server_metadata
+        self.client_id = client_id
+
+    def endpoint(self, name):
+        url = self.server_metadata.get(name)
+        if not isinstance(url, str):
+            raise OIDCError(f"authorization server metadata does not contain {name}")
+        return url
+
+
+def normalize_issuer(issuer):
+    return issuer.rstrip("/")
+
+
+def discovery(server, client_id):
+    response = requests.get(
+        f"{normalize_issuer(server)}/.well-known/openid-configuration",
+        headers={"Accept": "application/json"},
+        timeout=TIMEOUT,
+    )
+    response.raise_for_status()
+    metadata = response.json()
+    issuer = metadata.get("issuer") if isinstance(metadata, dict) else None
+    if not isinstance(issuer, str) or normalize_issuer(issuer) != normalize_issuer(
+        server
+    ):
+        raise OIDCError(
+            '"issuer" in authorization server metadata does not match the expected value'
+        )
+    return Configuration(metadata, client_id)
+
+
+def random_pkce_code_verifier():
+    return secrets.token_urlsafe(32)
+
+
+def random_state():
+    return secrets.token_urlsafe(32)
+
+
+def random_nonce():
+    return secrets.token_urlsafe(32)
+
+
+def calculate_pkce_code_challenge(code_verifier):
+    digest = hashlib.sha256(code_verifier.encode("ascii")).digest()
+    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+
+
+def build_authorization_url(config, parameters):
+    url = urlsplit(config.endpoint("authorization_endpoint"))
+    query = parse_qsl(url.query)
+    query.append(("client_id", config.client_id))
+    query.append(("response_type", "code"))
+    query.extend(parameters.items())
+    return urlunsplit(url._replace(query=urlencode(query)))
+
+
+def authorization_code_grant(
+    config, current_url, pkce_code_verifier, expected_state, expected_nonce
+):
+    url = urlsplit(current_url)
+    params = parse_qs(url.query, keep_blank_values=True)
+
+    def param(name):
+        values = params.get(name, [])
+        if len(values) > 1:
+            raise OIDCError(f'"{name}" parameter must be provided only once')
+        return values[0] if values else None
+
+    # Validate the authorization response
+    iss = param("iss")
+    if iss is None and config.server_metadata.get(
+        "authorization_response_iss_parameter_supported"
+    ):
+        raise OIDCError('response parameter "iss" (issuer) missing')
+    if iss is not None and iss != config.server_metadata["issuer"]:
+        raise OIDCError('unexpected "iss" (issuer) response parameter value')
+    state = param("state")
+    if state is None:
+        raise OIDCError('response parameter "state" missing')
+    if state != expected_state:
+        raise OIDCError('unexpected "state" response parameter value')
+    error = param("error")
+    if error is not None:
+        description = param("error_description")
+        raise OIDCError(
+            f"authorization response from the server is an error: {error}"
+            + (f" ({description})" if description else "")
+        )
+    if param("id_token") is not None or param("token") is not None:
+        raise OIDCError("implicit and hybrid flows are not supported")
+    code = param("code")
+    if not code:
+        raise OIDCError('response parameter "code" missing')
+
+    # Exchange the authorization code at the token endpoint
+    response = requests.post(
+        config.endpoint("token_endpoint"),
+        data={
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": urlunsplit(url._replace(query="", fragment="")),
+            "code_verifier": pkce_code_verifier,
+            "client_id": config.client_id,
+        },
+        headers={"Accept": "application/json"},
+        timeout=TIMEOUT,
+    )
+    try:
+        tokens = response.json()
+    except ValueError:
+        tokens = None
+    if response.status_code != 200:
+        if isinstance(tokens, dict) and isinstance(tokens.get("error"), str):
+            description = tokens.get("error_description")
+            raise OIDCError(
+                f"server responded with an error in the response body: {tokens['error']}"
+                + (f" ({description})" if description else "")
+            )
+        raise OIDCError(
+            f"unexpected token endpoint response status code: {response.status_code}"
+        )
+    if not isinstance(tokens, dict):
+        raise OIDCError("token endpoint response body must be a JSON object")
+    for name in ("access_token", "token_type", "id_token"):
+        if not isinstance(tokens.get(name), str):
+            raise OIDCError(
+                f'token endpoint response body "{name}" property must be a string'
+            )
+
+    validate_id_token_claims(
+        config, decode_jwt_claims(tokens["id_token"]), expected_nonce
+    )
+    return tokens
+
+
+def decode_jwt_claims(jwt):
+    try:
+        _, payload, _ = jwt.split(".")
+        claims = json.loads(
+            base64.urlsafe_b64decode(payload + "=" * (-len(payload) % 4))
+        )
+    except ValueError as err:
+        raise OIDCError("failed to parse the ID Token") from err
+    if not isinstance(claims, dict):
+        raise OIDCError("ID Token claims set must be a JSON object")
+    return claims
+
+
+def validate_id_token_claims(config, claims, expected_nonce):
+    for claim in ("aud", "exp", "iat", "iss", "sub"):
+        if claim not in claims:
+            raise OIDCError(f'ID Token "{claim}" claim missing')
+    if claims["iss"] != config.server_metadata["issuer"]:
+        raise OIDCError('unexpected ID Token "iss" (issuer) claim value')
+    audience = claims["aud"] if isinstance(claims["aud"], list) else [claims["aud"]]
+    if config.client_id not in audience:
+        raise OIDCError('unexpected ID Token "aud" (audience) claim value')
+    if (len(audience) > 1 or "azp" in claims) and claims.get("azp") != config.client_id:
+        raise OIDCError('unexpected ID Token "azp" (authorized party) claim value')
+    if (
+        not isinstance(claims["exp"], (int, float))
+        or claims["exp"] <= time.time() - CLOCK_TOLERANCE
+    ):
+        raise OIDCError(
+            'unexpected ID Token "exp" (expiration time) claim value, expiration is past current timestamp'
+        )
+    if not isinstance(claims["iat"], (int, float)):
+        raise OIDCError('ID Token "iat" (issued at) claim must be a number')
+    if claims.get("nonce") != expected_nonce:
+        raise OIDCError('unexpected ID Token "nonce" claim value')

isl_tool-1.1.0.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: isl-tool
+Version: 1.1.0
+Summary: Information Security Lab Tool (ETH Zürich)
+Author: csrrw
+Requires-Python: >=3.9
+Requires-Dist: colorama>=0.4.6; sys_platform == 'win32'
+Requires-Dist: requests>=2.27
+Requires-Dist: websockets>=15.0
+Description-Content-Type: text/markdown
+
+# isl-tool
+
+Information Security Lab Tool (ETH Zürich). Python port of the `isl-tool` npm
+package.
+
+## Usage
+
+Requires Python >= 3.9. Similar to `npx isl-tool@latest`, the tool can be run
+without installing it, always using the most recent version, with
+[uv](https://docs.astral.sh/uv/) or [pipx](https://pipx.pypa.io/):
+
+```shell
+uvx isl-tool@latest --help
+pipx run --no-cache isl-tool --help
+```
+
+Alternatively, install it with `pip install isl-tool` and invoke `isl-tool` (or
+`python -m isl_tool`).
+
+On first use, authenticate using the `login` command. This opens a browser for
+logging in with ETH GitLab and stores the issued token in `~/.isl-auth-token`,
+which subsequent commands use to authenticate.
+
+```shell
+isl-tool login
+isl-tool submit <exercise> <file>
+isl-tool results
+isl-tool submission <exercise>
+```
+
+## Publishing
+
+Increment the version number in `src/isl_tool/__init__.py`, then build and upload the package:
+
+```shell
+python -m pip install --upgrade build twine
+python -m build
+python -m twine upload dist/*
+```

isl_tool-1.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+isl_tool/__init__.py,sha256=7jxAOct8cgvgy9haLPqYpQ0hA5V3KW1LMlvy5gqD6cQ,151
+isl_tool/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+isl_tool/cli.py,sha256=q0CotZFIXF38As9FCycNmb1FBMX9z0VWKyIUZQ0gJ5Q,10740
+isl_tool/colors.py,sha256=jG0V4z9Ud7Kdqsfj3Oc5oXwL-C5fIHKTEPmdH0h0r7w,811
+isl_tool/lib.py,sha256=4xNrxl_6NmKKuvcu4zsYwQ_AKJ68-vU3O10HgZ8lI-w,6120
+isl_tool/oidc.py,sha256=eQ2yB3JIrf4VwLE5NL6PZLi-qccGd7C09N9j107zIc0,7125
+isl_tool-1.1.0.dist-info/METADATA,sha256=IEMPqW5QszVijqenBF_LJrY0xmU0OQO6wUO-H9wTv5E,1336
+isl_tool-1.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+isl_tool-1.1.0.dist-info/entry_points.txt,sha256=Oj28HN2vu5VR7SS1fO7Un2OAOZ1Cu1EIgJ3pfbxgv7c,47
+isl_tool-1.1.0.dist-info/RECORD,,

isl_tool-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

isl_tool-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+isl-tool = isl_tool.cli:main