onionshare_cli 2.3__py3-none-any.whl

onionshare_cli/web/web.py

@@ -0,0 +1,424 @@
+# -*- coding: utf-8 -*-
+"""
+OnionShare | https://onionshare.org/
+
+Copyright (C) 2014-2020 Micah Lee, et al. <micah@micahflee.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import hmac
+import logging
+import os
+import queue
+import socket
+import sys
+import tempfile
+import requests
+from distutils.version import LooseVersion as Version
+from urllib.request import urlopen
+
+import flask
+from flask import (
+    Flask,
+    request,
+    render_template,
+    abort,
+    make_response,
+    send_file,
+    __version__ as flask_version,
+)
+from flask_httpauth import HTTPBasicAuth
+from flask_socketio import SocketIO
+
+from .share_mode import ShareModeWeb
+from .receive_mode import ReceiveModeWeb, ReceiveModeWSGIMiddleware, ReceiveModeRequest
+from .website_mode import WebsiteModeWeb
+from .chat_mode import ChatModeWeb
+
+# Stub out flask's show_server_banner function, to avoiding showing warnings that
+# are not applicable to OnionShare
+def stubbed_show_server_banner(env, debug, app_import_path, eager_loading):
+    pass
+
+
+try:
+    flask.cli.show_server_banner = stubbed_show_server_banner
+except:
+    pass
+
+
+class Web:
+    """
+    The Web object is the OnionShare web server, powered by flask
+    """
+
+    REQUEST_LOAD = 0
+    REQUEST_STARTED = 1
+    REQUEST_PROGRESS = 2
+    REQUEST_CANCELED = 3
+    REQUEST_RATE_LIMIT = 4
+    REQUEST_UPLOAD_FILE_RENAMED = 5
+    REQUEST_UPLOAD_SET_DIR = 6
+    REQUEST_UPLOAD_FINISHED = 7
+    REQUEST_UPLOAD_CANCELED = 8
+    REQUEST_INDIVIDUAL_FILE_STARTED = 9
+    REQUEST_INDIVIDUAL_FILE_PROGRESS = 10
+    REQUEST_INDIVIDUAL_FILE_CANCELED = 11
+    REQUEST_ERROR_DATA_DIR_CANNOT_CREATE = 12
+    REQUEST_OTHER = 13
+    REQUEST_INVALID_PASSWORD = 14
+
+    def __init__(self, common, is_gui, mode_settings, mode="share"):
+        self.common = common
+        self.common.log("Web", "__init__", f"is_gui={is_gui}, mode={mode}")
+
+        self.settings = mode_settings
+
+        # The flask app
+        self.app = Flask(
+            __name__,
+            static_folder=self.common.get_resource_path("static"),
+            static_url_path=f"/static_{self.common.random_string(16)}",  # randomize static_url_path to avoid making /static unusable
+            template_folder=self.common.get_resource_path("templates"),
+        )
+        self.app.secret_key = self.common.random_string(8)
+        self.generate_static_url_path()
+        self.auth = HTTPBasicAuth()
+        self.auth.error_handler(self.error401)
+
+        # Verbose mode?
+        if self.common.verbose:
+            self.verbose_mode()
+
+        # Are we running in GUI mode?
+        self.is_gui = is_gui
+
+        # If the user stops the server while a transfer is in progress, it should
+        # immediately stop the transfer. In order to make it thread-safe, stop_q
+        # is a queue. If anything is in it, then the user stopped the server
+        self.stop_q = queue.Queue()
+
+        # Are we using receive mode?
+        self.mode = mode
+        if self.mode == "receive":
+            # Use custom WSGI middleware, to modify environ
+            self.app.wsgi_app = ReceiveModeWSGIMiddleware(self.app.wsgi_app, self)
+            # Use a custom Request class to track upload progress
+            self.app.request_class = ReceiveModeRequest
+
+        # Starting in Flask 0.11, render_template_string autoescapes template variables
+        # by default. To prevent content injection through template variables in
+        # earlier versions of Flask, we force autoescaping in the Jinja2 template
+        # engine if we detect a Flask version with insecure default behavior.
+        if Version(flask_version) < Version("0.11"):
+            # Monkey-patch in the fix from https://github.com/pallets/flask/commit/99c99c4c16b1327288fd76c44bc8635a1de452bc
+            Flask.select_jinja_autoescape = self._safe_select_jinja_autoescape
+
+        self.security_headers = [
+            ("X-Frame-Options", "DENY"),
+            ("X-Xss-Protection", "1; mode=block"),
+            ("X-Content-Type-Options", "nosniff"),
+            ("Referrer-Policy", "no-referrer"),
+            ("Server", "OnionShare"),
+        ]
+
+        self.q = queue.Queue()
+        self.password = None
+
+        self.reset_invalid_passwords()
+
+        self.done = False
+
+        # shutting down the server only works within the context of flask, so the easiest way to do it is over http
+        self.shutdown_password = self.common.random_string(16)
+
+        # Keep track if the server is running
+        self.running = False
+
+        # Define the web app routes
+        self.define_common_routes()
+
+        # Create the mode web object, which defines its own routes
+        self.share_mode = None
+        self.receive_mode = None
+        self.website_mode = None
+        self.chat_mode = None
+        if self.mode == "share":
+            self.share_mode = ShareModeWeb(self.common, self)
+        elif self.mode == "receive":
+            self.receive_mode = ReceiveModeWeb(self.common, self)
+        elif self.mode == "website":
+            self.website_mode = WebsiteModeWeb(self.common, self)
+        elif self.mode == "chat":
+            self.socketio = SocketIO()
+            self.socketio.init_app(self.app)
+            self.chat_mode = ChatModeWeb(self.common, self)
+
+    def get_mode(self):
+        if self.mode == "share":
+            return self.share_mode
+        elif self.mode == "receive":
+            return self.receive_mode
+        elif self.mode == "website":
+            return self.website_mode
+        elif self.mode == "chat":
+            return self.chat_mode
+        else:
+            return None
+
+    def generate_static_url_path(self):
+        # The static URL path has a 128-bit random number in it to avoid having name
+        # collisions with files that might be getting shared
+        self.static_url_path = f"/static_{self.common.random_string(16)}"
+        self.common.log(
+            "Web",
+            "generate_static_url_path",
+            f"new static_url_path is {self.static_url_path}",
+        )
+
+        # Update the flask route to handle the new static URL path
+        self.app.static_url_path = self.static_url_path
+        self.app.add_url_rule(
+            self.static_url_path + "/<path:filename>",
+            endpoint="static",
+            view_func=self.app.send_static_file,
+        )
+
+    def define_common_routes(self):
+        """
+        Common web app routes between all modes.
+        """
+
+        @self.auth.get_password
+        def get_pw(username):
+            if username == "onionshare":
+                return self.password
+            else:
+                return None
+
+        @self.app.before_request
+        def conditional_auth_check():
+            # Allow static files without basic authentication
+            if request.path.startswith(self.static_url_path + "/"):
+                return None
+
+            # If public mode is disabled, require authentication
+            if not self.settings.get("general", "public"):
+
+                @self.auth.login_required
+                def _check_login():
+                    return None
+
+                return _check_login()
+
+        @self.app.errorhandler(404)
+        def not_found(e):
+            mode = self.get_mode()
+            history_id = mode.cur_history_id
+            mode.cur_history_id += 1
+            return self.error404(history_id)
+
+        @self.app.route("/<password_candidate>/shutdown")
+        def shutdown(password_candidate):
+            """
+            Stop the flask web server, from the context of an http request.
+            """
+            if password_candidate == self.shutdown_password:
+                self.force_shutdown()
+                return ""
+            abort(404)
+
+        if self.mode != "website":
+
+            @self.app.route("/favicon.ico")
+            def favicon():
+                return send_file(
+                    f"{self.common.get_resource_path('static')}/img/favicon.ico"
+                )
+
+    def error401(self):
+        auth = request.authorization
+        if auth:
+            if (
+                auth["username"] == "onionshare"
+                and auth["password"] not in self.invalid_passwords
+            ):
+                print(f"Invalid password guess: {auth['password']}")
+                self.add_request(Web.REQUEST_INVALID_PASSWORD, data=auth["password"])
+
+                self.invalid_passwords.append(auth["password"])
+                self.invalid_passwords_count += 1
+
+                if self.invalid_passwords_count == 20:
+                    self.add_request(Web.REQUEST_RATE_LIMIT)
+                    self.force_shutdown()
+                    print(
+                        "Someone has made too many wrong attempts to guess your password, so OnionShare has stopped the server. Start sharing again and send the recipient a new address to share."
+                    )
+
+        r = make_response(
+            render_template("401.html", static_url_path=self.static_url_path), 401
+        )
+        return self.add_security_headers(r)
+
+    def error403(self):
+        self.add_request(Web.REQUEST_OTHER, request.path)
+        r = make_response(
+            render_template("403.html", static_url_path=self.static_url_path), 403
+        )
+        return self.add_security_headers(r)
+
+    def error404(self, history_id):
+        self.add_request(
+            self.REQUEST_INDIVIDUAL_FILE_STARTED,
+            request.path,
+            {"id": history_id, "status_code": 404},
+        )
+
+        self.add_request(Web.REQUEST_OTHER, request.path)
+        r = make_response(
+            render_template("404.html", static_url_path=self.static_url_path), 404
+        )
+        return self.add_security_headers(r)
+
+    def error405(self, history_id):
+        self.add_request(
+            self.REQUEST_INDIVIDUAL_FILE_STARTED,
+            request.path,
+            {"id": history_id, "status_code": 405},
+        )
+
+        self.add_request(Web.REQUEST_OTHER, request.path)
+        r = make_response(
+            render_template("405.html", static_url_path=self.static_url_path), 405
+        )
+        return self.add_security_headers(r)
+
+    def add_security_headers(self, r):
+        """
+        Add security headers to a request
+        """
+        for header, value in self.security_headers:
+            r.headers.set(header, value)
+        # Set a CSP header unless in website mode and the user has disabled it
+        if not self.settings.get("website", "disable_csp") or self.mode != "website":
+            r.headers.set(
+                "Content-Security-Policy",
+                "default-src 'self'; style-src 'self'; script-src 'self'; img-src 'self' data:;",
+            )
+        return r
+
+    def _safe_select_jinja_autoescape(self, filename):
+        if filename is None:
+            return True
+        return filename.endswith((".html", ".htm", ".xml", ".xhtml"))
+
+    def add_request(self, request_type, path=None, data=None):
+        """
+        Add a request to the queue, to communicate with the GUI.
+        """
+        self.q.put({"type": request_type, "path": path, "data": data})
+
+    def generate_password(self, saved_password=None):
+        self.common.log("Web", "generate_password", f"saved_password={saved_password}")
+        if saved_password != None and saved_password != "":
+            self.password = saved_password
+            self.common.log(
+                "Web",
+                "generate_password",
+                f'saved_password sent, so password is: "{self.password}"',
+            )
+        else:
+            self.password = self.common.build_password()
+            self.common.log(
+                "Web", "generate_password", f'built random password: "{self.password}"'
+            )
+
+    def verbose_mode(self):
+        """
+        Turn on verbose mode, which will log flask errors to a file.
+        """
+        flask_log_filename = os.path.join(self.common.build_data_dir(), "flask.log")
+        log_handler = logging.FileHandler(flask_log_filename)
+        log_handler.setLevel(logging.WARNING)
+        self.app.logger.addHandler(log_handler)
+
+    def reset_invalid_passwords(self):
+        self.invalid_passwords_count = 0
+        self.invalid_passwords = []
+
+    def force_shutdown(self):
+        """
+        Stop the flask web server, from the context of the flask app.
+        """
+        # Shutdown the flask service
+        try:
+            func = request.environ.get("werkzeug.server.shutdown")
+            if func is None:
+                raise RuntimeError("Not running with the Werkzeug Server")
+            func()
+        except:
+            pass
+        self.running = False
+
+    def start(self, port):
+        """
+        Start the flask web server.
+        """
+        self.common.log("Web", "start", f"port={port}")
+
+        # Make sure the stop_q is empty when starting a new server
+        while not self.stop_q.empty():
+            try:
+                self.stop_q.get(block=False)
+            except queue.Empty:
+                pass
+
+        # In Whonix, listen on 0.0.0.0 instead of 127.0.0.1 (#220)
+        if os.path.exists("/usr/share/anon-ws-base-files/workstation"):
+            host = "0.0.0.0"
+        else:
+            host = "127.0.0.1"
+
+        self.running = True
+        if self.mode == "chat":
+            self.socketio.run(self.app, host=host, port=port)
+        else:
+            self.app.run(host=host, port=port, threaded=True)
+
+    def stop(self, port):
+        """
+        Stop the flask web server by loading /shutdown.
+        """
+        self.common.log("Web", "stop", "stopping server")
+
+        # Let the mode know that the user stopped the server
+        self.stop_q.put(True)
+
+        # To stop flask, load http://shutdown:[shutdown_password]@127.0.0.1/[shutdown_password]/shutdown
+        # (We're putting the shutdown_password in the path as well to make routing simpler)
+        if self.running:
+            if self.password:
+                requests.get(
+                    f"http://127.0.0.1:{port}/{self.shutdown_password}/shutdown",
+                    auth=requests.auth.HTTPBasicAuth("onionshare", self.password),
+                )
+            else:
+                requests.get(
+                    f"http://127.0.0.1:{port}/{self.shutdown_password}/shutdown"
+                )
+
+        # Reset any password that was in use
+        self.password = None

onionshare_cli/web/website_mode.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""
+OnionShare | https://onionshare.org/
+
+Copyright (C) 2014-2020 Micah Lee, et al. <micah@micahflee.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import os
+import sys
+import tempfile
+import mimetypes
+from flask import Response, request, render_template, make_response
+
+from .send_base_mode import SendBaseModeWeb
+
+
+class WebsiteModeWeb(SendBaseModeWeb):
+    """
+    All of the web logic for website mode
+    """
+
+    def init(self):
+        pass
+
+    def define_routes(self):
+        """
+        The web app routes for sharing a website
+        """
+
+        @self.web.app.route("/", defaults={"path": ""})
+        @self.web.app.route("/<path:path>")
+        def path_public(path):
+            return path_logic(path)
+
+        def path_logic(path=""):
+            """
+            Render the onionshare website.
+            """
+            return self.render_logic(path)
+
+    def directory_listing_template(
+        self, path, files, dirs, breadcrumbs, breadcrumbs_leaf
+    ):
+        return make_response(
+            render_template(
+                "listing.html",
+                path=path,
+                files=files,
+                dirs=dirs,
+                breadcrumbs=breadcrumbs,
+                breadcrumbs_leaf=breadcrumbs_leaf,
+                static_url_path=self.web.static_url_path,
+            )
+        )
+
+    def set_file_info_custom(self, filenames, processed_size_callback):
+        self.common.log("WebsiteModeWeb", "set_file_info_custom")
+        self.web.cancel_compression = True
+
+    def render_logic(self, path=""):
+        # Strip trailing slash
+        path = path.rstrip("/")
+
+        if path in self.files:
+            filesystem_path = self.files[path]
+
+            # If it's a directory
+            if os.path.isdir(filesystem_path):
+                # Is there an index.html?
+                index_path = os.path.join(path, "index.html")
+                if index_path in self.files:
+                    # Render it
+                    return self.stream_individual_file(self.files[index_path])
+
+                else:
+                    # Otherwise, render directory listing
+                    filenames = []
+                    for filename in os.listdir(filesystem_path):
+                        filenames.append(filename)
+                    filenames.sort()
+                    return self.directory_listing(filenames, path, filesystem_path)
+
+            # If it's a file
+            elif os.path.isfile(filesystem_path):
+                return self.stream_individual_file(filesystem_path)
+
+            # If it's not a directory or file, throw a 404
+            else:
+                history_id = self.cur_history_id
+                self.cur_history_id += 1
+                return self.web.error404(history_id)
+        else:
+            # Special case loading /
+
+            if path == "":
+                index_path = "index.html"
+                if index_path in self.files:
+                    # Render it
+                    return self.stream_individual_file(self.files[index_path])
+                else:
+                    # Root directory listing
+                    filenames = list(self.root_files)
+                    filenames.sort()
+                    return self.directory_listing(filenames, path)
+
+            else:
+                # If the path isn't found, throw a 404
+                history_id = self.cur_history_id
+                self.cur_history_id += 1
+                return self.web.error404(history_id)

onionshare_cli-2.3.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: onionshare-cli
+Version: 2.3
+Summary: OnionShare lets you securely and anonymously send and receive files. It works by starting a web server, making it accessible as a Tor onion service, and generating an unguessable web address so others can download files from you, or upload files to you. It does _not_ require setting up a separate server or using a third party file-sharing service.
+License: GPLv3+
+Author: Micah Lee
+Author-email: micah@micahflee.com
+Requires-Python: >=3.6,<4.0
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Communications :: File Sharing
+Classifier: Topic :: Security :: Cryptography
+Requires-Dist: click
+Requires-Dist: eventlet
+Requires-Dist: flask
+Requires-Dist: flask-httpauth
+Requires-Dist: flask-socketio
+Requires-Dist: psutil
+Requires-Dist: pycryptodome
+Requires-Dist: pysocks
+Requires-Dist: requests
+Requires-Dist: setuptools
+Requires-Dist: stem
+Requires-Dist: unidecode
+Requires-Dist: urllib3

onionshare_cli-2.3.dist-info/RECORD

@@ -0,0 +1,45 @@
+onionshare_cli/__init__.py,sha256=npQuu3Xxee-4ijr7zi1b66EYwTpyuMNiuefzjIkAWl4,18804
+onionshare_cli/common.py,sha256=3e1Bg-0r8c_5u-JAbo9-lHKdLSU36kV_Qz-Nk48YhSM,10060
+onionshare_cli/mode_settings.py,sha256=BvvxSULagqvXw5Oq7tS_FcDsya-u2A_o1vZdy2YxPao,5116
+onionshare_cli/onion.py,sha256=lEMd-A1j8cAIWXWgbSMIpDomxWBYbaOb0ZQi-ONQ2SA,32727
+onionshare_cli/onionshare.py,sha256=seCR03hDR7KqLN-6hoYAfgm8Hjuq125JL0-r2If4SQ8,3315
+onionshare_cli/resources/static/css/style.css,sha256=Z44manZ4K00GW02pTzsLo_2dNdVEjUSF7n8y9SlYgDs,6088
+onionshare_cli/resources/static/img/ajax.gif,sha256=Ha41spwCqc39DjUUk6Hq5TTRassrOGLVqzHPsjOzIGI,847
+onionshare_cli/resources/static/img/favicon.ico,sha256=cAwV8YHCn_s0fcb8ouC5lx6VH2KJuw1kCR9xqB_rWTs,4286
+onionshare_cli/resources/static/img/logo.png,sha256=O4s9U1wJZLPpAELaR2d4AxHJqGloQn86PXmLCEyy1Fw,3824
+onionshare_cli/resources/static/img/logo_large.png,sha256=1peNnDBnxFy12It3htQ2J04a5LG8o_r_c6Ec4UntESg,9663
+onionshare_cli/resources/static/img/web_file.png,sha256=5aW8bPAwB4OUlWPxYrSKnJm12T2AYar9Pa7bljyQT80,251
+onionshare_cli/resources/static/img/web_folder.png,sha256=DCCm4ZCoz-6vruLkpH2sva9fQG2Ii8_wRDeCl7BrBu8,338
+onionshare_cli/resources/static/js/chat.js,sha256=ZD7usLa7CCqqEcr4v9qEUgeFUy-7QyG8ln0WG6kI7XY,5268
+onionshare_cli/resources/static/js/jquery-3.5.1.min.js,sha256=9_aliU8dGd2tb6OSsuzixeV4y_faTqgFtohetphbbj0,89476
+onionshare_cli/resources/static/js/receive.js,sha256=C_ln2d6LbDhxpzpwcB0epsHe9QgujjcurI2RsxlD0E4,4288
+onionshare_cli/resources/static/js/send.js,sha256=UWSMC0fMDCeTrimcKT6VWY0-wD8M6q-eXoG5QYr9YAk,2664
+onionshare_cli/resources/static/js/socket.io.min.js,sha256=l7bJqGGRCT1WkgISTZPrdFddUwh8hFB7IBHngxng0L8,65070
+onionshare_cli/resources/templates/401.html,sha256=51DfjrgIGCzw8hnLWWKVz-y5dgw6smCsN5437j4T1Gw,645
+onionshare_cli/resources/templates/403.html,sha256=CnsDbx5EDpjq5Ddc1ilmhfRx5jknn5VtGiZRp9ehdcw,668
+onionshare_cli/resources/templates/404.html,sha256=-0MM_80rlHpOelimpW-EF8Pw0XvWa9LHqn8K_3etczk,623
+onionshare_cli/resources/templates/405.html,sha256=Pg8QOVGj-HHLed9q-ge44cSzA6T9Mms063F5Whj36Zk,641
+onionshare_cli/resources/templates/chat.html,sha256=_LrnX5JHCdxjbzNVJ8N71B5HkCHGKjoYyc_GS-baitI,1304
+onionshare_cli/resources/templates/denied.html,sha256=Y70lVlbafNsWfgfGebqjzAskFV4jikVsVY_gVe_Onec,230
+onionshare_cli/resources/templates/listing.html,sha256=h2rgL10VULEI0GKzv3WX6HNCWkkzRPLIoOVA6T9m7os,1535
+onionshare_cli/resources/templates/receive.html,sha256=-Mdic8baaqPj4fgaBfyHpiBOy0RQHd_vwCm_XZyMejc,1698
+onionshare_cli/resources/templates/send.html,sha256=KFNDRwHyLQVi069ijW7srJDfr7mrVP0wu9XCsfVbdlk,2267
+onionshare_cli/resources/templates/thankyou.html,sha256=u2m-FWbDTpMrbN8DdPs4x7gPGpO3Bvdawv35y7iT_us,852
+onionshare_cli/resources/torrc_template,sha256=jx9N1CvSf9CcTo0O-ox9ZFLx4S_NLmfXBGFwd0enfxU,209
+onionshare_cli/resources/torrc_template-meek_lite_amazon,sha256=8tV9kh1WY9plp8KwMyC8ScUIaYHB8ns5OSZdQnkpbYk,146
+onionshare_cli/resources/torrc_template-meek_lite_azure,sha256=8lqaQdoAlzZDrkwW46q0PDB9bcxqQxEGFNvAt2dG40s,137
+onionshare_cli/resources/torrc_template-obfs4,sha256=7RNprD5Cll7CpBIc8lmcwGra94r6nuzwBe5hi7mYgm4,4165
+onionshare_cli/resources/version.txt,sha256=h3GmwEF0t_cZ697KXbhzBKcqEYpWKaXizp731iFYtyg,3
+onionshare_cli/resources/wordlist.txt,sha256=bVV_BpOVj7XmULaLW-5YXrgs9NoyllUFx4npJHQ7xSI,62144
+onionshare_cli/settings.py,sha256=j70KcNnSnMVnnh3xW1Fx1B1na-ZXnNngC1y2ckeM5p0,7284
+onionshare_cli/web/__init__.py,sha256=5Ddm6klCmorvGir6AYMdzT6f5Ams-KFk4d4HOR4-ujE,769
+onionshare_cli/web/chat_mode.py,sha256=5mWshE7qcjUWu8tRFn2IHM5UrOhwjOxq_QcL68O6OWg,5865
+onionshare_cli/web/receive_mode.py,sha256=mf1B1hmp-RooyPERiXxW1ke8euWW4PpLlhJshY3rk9s,17150
+onionshare_cli/web/send_base_mode.py,sha256=ur3tDU4pzqIznc7FK3Wb4g2IhLNIkOWNRAa2LGOygv0,12158
+onionshare_cli/web/share_mode.py,sha256=OFockAvg6-GC3J1sM2u5bT8LAxb7rdMVd8rv9ppbXW8,15990
+onionshare_cli/web/web.py,sha256=N1MXmWTaZpGxvb1U7jQgXq7DNDlxP3eJqV9O4wwoSHI,14861
+onionshare_cli/web/website_mode.py,sha256=S6xjL-18hJfz7KVt3SZ0eRD26LE_0rbOCIbg8FUJY68,4071
+onionshare_cli-2.3.dist-info/entry_points.txt,sha256=jqtxfoRDQXNWkup_DHJbmTimeFUz34p0m840rRqcu3I,54
+onionshare_cli-2.3.dist-info/WHEEL,sha256=SrtnPGVTMeYWttls9xnWA01eUhCZ3ufFdJUYb1J3r-U,83
+onionshare_cli-2.3.dist-info/METADATA,sha256=FJEkBq3LGkXz__l0E-tmmIj0NijZ8xQyia3Qr5ZBkoE,1482
+onionshare_cli-2.3.dist-info/RECORD,,

onionshare_cli-2.3.dist-info/WHEEL

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

onionshare_cli-2.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+onionshare-cli=onionshare_cli:main
+