xtlsapi-ipblacklist 3.3.2__py3-none-any.whl

tests/conftest.py

@@ -0,0 +1,14 @@
+import sys
+import pytest
+
+
+# each test runs on cwd to its temp dir
+@pytest.fixture(autouse=True)
+def go_to_tmpdir(request):
+    # Get the fixture dynamically by its name.
+    tmpdir = request.getfixturevalue("tmpdir")
+    # ensure local test created packages can be imported
+    sys.path.insert(0, str(tmpdir))
+    # Chdir only for the duration of the test.
+    with tmpdir.as_cwd():
+        yield

tests/test_base.py

@@ -0,0 +1,5 @@
+from xtlsapi.base import NAME
+
+
+def test_base():
+    assert NAME == "xtlsapi"

tests/test_block_ips.py

@@ -0,0 +1,9 @@
+import pytest
+from unittest.mock import patch
+from xtlsapi import XrayClient
+
+def test_stats_online_ip_list():
+    xray = XrayClient("127.0.0.1", 53357)
+    with patch.object(xray, 'stats_online_ip_list', return_value={'212.58.119.246': 1763418412}):
+        result = xray.stats_online_ip_list("1")
+        assert result == {'212.58.119.246': 1763418412}

tests/test_stats_online_ip_list.py

@@ -0,0 +1,14 @@
+import pytest
+from unittest.mock import patch
+from xtlsapi import XrayClient
+from xtlsapi.xray_api.app.router.command import command_pb2
+
+
+def test_stats_online_ip_list():
+    xray = XrayClient("127.0.0.1", 53357)
+    with patch.object(xray, 'block_ips', return_value=command_pb2.AddRuleResponse()):
+        xray.block_ips(
+            ips=["103.23.202.74"],
+            inbound_tag="vless-in"
+        )
+        assert xray

xtlsapi/VERSION

@@ -0,0 +1 @@
+3.3.0

xtlsapi/__init__.py

@@ -0,0 +1,4 @@
+from xtlsapi.client.XrayClient import XrayClient
+from xtlsapi.client.SingboxClient import SingboxClient
+import xtlsapi.exceptions
+from xtlsapi.ext import utils

xtlsapi/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for xtlsapi."""
+
+from .cli import main  # pragma: no cover
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

xtlsapi/api_services/__init__.py

@@ -0,0 +1,8 @@
+from .stats import StatsAPIService
+from .handler import HandlerAPIService
+from .logger import LoggerAPIService
+from .router import RouterAPIService
+
+
+class APIService(StatsAPIService, HandlerAPIService, LoggerAPIService, RouterAPIService):
+    pass

xtlsapi/api_services/_base.py

@@ -0,0 +1,12 @@
+from xtlsapi.xray_api.app.log.command import config_pb2_grpc as logger_pb2_grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2_grpc as stats_pb2_grpc
+from xtlsapi.xray_api.app.proxyman.command import command_pb2_grpc as handler_pb2_grpc
+from xtlsapi.xray_api.app.router.command import command_pb2_grpc as router_pb2_grpc
+
+
+class BaseService:
+    def __init__(self):
+        self.stats_stub = stats_pb2_grpc.StatsServiceStub(self._channel)
+        self.logger_stub = logger_pb2_grpc.LoggerServiceStub(self._channel)
+        self.handler_stub = handler_pb2_grpc.HandlerServiceStub(self._channel)
+        self.routing_stub = router_pb2_grpc.RoutingServiceStub(self._channel)

xtlsapi/api_services/handler/__init__.py

@@ -0,0 +1,6 @@
+from .add_client import AddClient
+from .remove_client import RemoveClient
+
+
+class HandlerAPIService(AddClient, RemoveClient):
+    pass

xtlsapi/api_services/handler/add_client.py

@@ -0,0 +1,66 @@
+from grpc._channel import _InactiveRpcError
+
+from xtlsapi.xray_api.common.protocol import user_pb2
+from xtlsapi.xray_api.app.proxyman.command import command_pb2
+from xtlsapi.ext import utils
+from .._base import BaseService
+from xtlsapi import exceptions
+
+
+class AddClient(BaseService):
+    def add_client(self, inbound_tag, user_id_or_password, email,protocol='vless', level=None, alter_id=None,flow=None,cipher=None):
+        try:
+            if protocol=='vmess':
+                from xtlsapi.xray_api.proxy.vmess import account_pb2
+                account=account_pb2.Account(id=user_id_or_password)
+            elif protocol=='vless':
+                from xtlsapi.xray_api.proxy.vless import account_pb2
+                account=account_pb2.Account(id=user_id_or_password,flow=flow,encryption="none")
+            elif protocol=='trojan':
+                from xtlsapi.xray_api.proxy.trojan import config_pb2
+                account=config_pb2.Account(password=user_id_or_password,flow=flow)
+            elif protocol=='shadowsocks':
+                from xtlsapi.xray_api.proxy.shadowsocks import config_pb2
+                cipher_map={'aes_128_gcm':config_pb2.CipherType.AES_128_GCM,
+                            'aes_256_gcm':config_pb2.CipherType.AES_256_GCM,
+                            'chacha20_poly1305':config_pb2.CipherType.CHACHA20_POLY1305,
+                            'xchacha20_poly1305':config_pb2.CipherType.XCHACHA20_POLY1305,
+                            None:config_pb2.CipherType.NONE                            
+                            }
+                account=config_pb2.Account(password=user_id_or_password,cipher_type=cipher_map.get(cipher,cipher_map[None]))
+            # elif protocol=='shadowsocks_2022':
+                # from xtlsapi.xray_api.proxy.shadowsocks import config_pb2
+                # cipher_map={'aes_128_gcm':config_pb2.CipherType.AES_128_GCM,
+                #             'aes_256_gcm':config_pb2.CipherType.AES_256_GCM,
+                #             'chacha20_poly1305':config_pb2.CipherType.CHACHA20_POLY1305,
+                #             'xchacha20_poly1305':config_pb2.CipherType.XCHACHA20_POLY1305,
+                #             None:config_pb2.CipherType.NONE                            
+                #             }
+                # account=config_pb2.Account(password=user_id_or_password,cipher_type=cipher_map.get(cipher,cipher_map[None])
+                # raise Exception("not implemented ")
+            else:
+                raise Exception("not implemented "+protocol )
+            
+            self.handler_stub.AlterInbound(
+                command_pb2.AlterInboundRequest(
+                    tag=inbound_tag,
+                    operation=utils.to_typed_message(
+                        command_pb2.AddUserOperation(
+                            user=user_pb2.User(
+                                email=email,
+                                level=level,
+                                account=utils.to_typed_message(account),
+                            )
+                        )
+                    ),
+                )
+            )
+            return user_id_or_password
+        except _InactiveRpcError as e:
+            details = e.details()
+            if details.endswith(f"User {email} already exists."):
+                raise exceptions.EmailAlreadyExists(details, email)
+            elif details.endswith(f"handler not found: {inbound_tag}"):
+                raise exceptions.InboundNotFound(details, inbound_tag)
+            else:
+                raise exceptions.XRayException(details)

xtlsapi/api_services/handler/remove_client.py

@@ -0,0 +1,27 @@
+from grpc._channel import _InactiveRpcError
+from xtlsapi.ext import utils
+from xtlsapi import exceptions
+from xtlsapi.xray_api.app.proxyman.command import command_pb2
+
+from .._base import BaseService
+
+
+class RemoveClient(BaseService):
+    def remove_client(self, inbound_tag, email):
+        try:
+            self.handler_stub.AlterInbound(
+                command_pb2.AlterInboundRequest(
+                    tag=inbound_tag,
+                    operation=utils.to_typed_message(
+                        command_pb2.RemoveUserOperation(email=email)
+                    ),
+                )
+            )
+        except _InactiveRpcError as e:
+            details = e.details()
+            if details.endswith(f"User {email} not found."):
+                raise exceptions.EmailNotFound(details, email)
+            elif details.endswith(f"handler not found: {inbound_tag}"):
+                raise exceptions.InboundNotFound(details, inbound_tag)
+            else:
+                raise exceptions.XRayException(details)

xtlsapi/api_services/logger/__init__.py

@@ -0,0 +1,5 @@
+from .restart_logger import RestartLogger
+
+
+class LoggerAPIService(RestartLogger):
+    pass

xtlsapi/api_services/logger/restart_logger.py

@@ -0,0 +1,17 @@
+from grpc._channel import _InactiveRpcError
+
+from xtlsapi import exceptions
+from xtlsapi.xray_api.app.log.command import config_pb2
+
+from .._base import BaseService
+
+
+class RestartLogger(BaseService):
+    def restart_logger(self):
+        try:
+            self.logger_stub.RestartLogger(
+                config_pb2.RestartLoggerRequest()
+            )
+        except _InactiveRpcError as e:
+            details = e.details()
+            raise exceptions.XRayException(details)

xtlsapi/api_services/router/__init__.py

@@ -0,0 +1,7 @@
+from .block_ips import RouterBlockIps
+
+
+class RouterAPIService(
+    RouterBlockIps,
+):
+    pass

xtlsapi/api_services/router/block_ips.py

@@ -0,0 +1,60 @@
+import grpc
+import ipaddress
+
+from xtlsapi.api_services._base import BaseService
+from xtlsapi.xray_api.app.router.command import command_pb2
+from xtlsapi.xray_api.common.serial import typed_message_pb2
+from xtlsapi.xray_api.app.router import config_pb2
+
+
+class RouterBlockIps(BaseService):
+
+    def block_ips(
+        self,
+        ips: list[str],
+        inbound_tag: str,
+        rule_tag: str = "sourceIpBlock",
+        outbound_tag: str = "blocked",
+    ):
+        try:
+            self.routing_stub.RemoveRule(
+                command_pb2.RemoveRuleRequest(ruleTag=rule_tag)
+            )
+
+            if not ips:
+                return None
+
+            rule = config_pb2.RoutingRule()
+            rule.rule_tag = rule_tag
+            rule.inbound_tag.extend([inbound_tag] if inbound_tag else [])
+            rule.tag = outbound_tag
+
+            for ip in ips:
+                net = ipaddress.ip_network(ip, strict=False)
+
+                cidr = config_pb2.CIDR()
+                cidr.ip = net.network_address.packed
+                cidr.prefix = net.prefixlen
+
+                geo = config_pb2.GeoIP()
+                geo.cidr.append(cidr)
+
+                rule.source_geoip.append(geo)
+
+            config = config_pb2.Config()
+            config.rule.append(rule)
+
+            typed_msg = typed_message_pb2.TypedMessage(
+                type="xray.app.router.Config",
+                value=config.SerializeToString(),
+            )
+
+            return self.routing_stub.AddRule(
+                command_pb2.AddRuleRequest(
+                    config=typed_msg,
+                    shouldAppend=True,
+                )
+            )
+
+        except grpc.RpcError as e:
+            raise e

xtlsapi/api_services/stats/__init__.py

@@ -0,0 +1,22 @@
+from .get_client_upload_traffic import GetClientUploadTraffic
+from .get_client_download_traffic import GetClientDownloadTraffic
+from .get_inbound_upload_traffic import GetInboundUploadTraffic
+from .get_inbound_download_traffic import GetInboundDownloadTraffic
+from .get_total_upload_traffic import GetTotalUploadTraffic
+from .get_total_download_traffic import GetTotalDownloadTraffic
+from .get_statsquery import StatsQuery
+from .get_statsonline import StatsOnline
+from .get_stats_online_ip_list import StatsOnlineIpList
+
+class StatsAPIService(
+    GetClientUploadTraffic,
+    GetClientDownloadTraffic,
+    GetInboundUploadTraffic,
+    GetInboundDownloadTraffic,
+    GetTotalUploadTraffic,
+    GetTotalDownloadTraffic,
+    StatsQuery,
+    StatsOnline,
+    StatsOnlineIpList
+):
+    pass

xtlsapi/api_services/stats/get_client_download_traffic.py

@@ -0,0 +1,17 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+
+from .._base import BaseService
+
+
+class GetClientDownloadTraffic(BaseService):
+    def get_client_download_traffic(self, email, reset=False):
+        try:
+            return self.stats_stub.GetStats(
+                command_pb2.GetStatsRequest(
+                    name=f"user>>>{email}>>>traffic>>>downlink", reset=reset
+                )
+            ).stat.value
+        except grpc.RpcError:
+            # raise
+            return None

xtlsapi/api_services/stats/get_client_upload_traffic.py

@@ -0,0 +1,15 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+from .._base import BaseService
+
+
+class GetClientUploadTraffic(BaseService):
+    def get_client_upload_traffic(self, email, reset=False):
+        try:
+            return self.stats_stub.GetStats(
+                command_pb2.GetStatsRequest(
+                    name=f"user>>>{email}>>>traffic>>>uplink", reset=reset
+                )
+            ).stat.value
+        except grpc.RpcError:
+            return None

xtlsapi/api_services/stats/get_inbound_download_traffic.py

@@ -0,0 +1,16 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+from .._base import BaseService
+
+
+class GetInboundDownloadTraffic(BaseService):
+    def get_inbound_download_traffic(self, tag, reset=False):
+        try:
+            return self.stats_stub.GetStats(
+                command_pb2.GetStatsRequest(
+                    name=f"inbound>>>{tag}>>>traffic>>>downlink", reset=reset
+                )
+            ).stat.value
+        except grpc.RpcError:
+            # raise
+            return None

xtlsapi/api_services/stats/get_inbound_upload_traffic.py

@@ -0,0 +1,16 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+from .._base import BaseService
+
+
+class GetInboundUploadTraffic(BaseService):
+    def get_inbound_upload_traffic(self, tag, reset=False):
+        try:
+            return self.stats_stub.GetStats(
+                command_pb2.GetStatsRequest(
+                    name=f"inbound>>>{tag}>>>traffic>>>uplink", reset=reset
+                )
+            ).stat.value
+        except grpc.RpcError:
+            # raise
+            return None

xtlsapi/api_services/stats/get_stats_online_ip_list.py

@@ -0,0 +1,28 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+
+from .._base import BaseService
+
+
+class StatsOnlineIpList(BaseService):
+    def stats_online_ip_list(self, user, reset=False) -> dict:
+	"""
+	Returns a dictionary of online IPs for the given user.
+
+	Args:
+	    user: The email of the user to query.
+
+	Returns:
+	    A dictionary mapping IP addresses to last cleanup time of expired ip's.
+	"""
+
+        try:
+            return self.stats_stub.GetStatsOnlineIpList(
+                command_pb2.GetStatsRequest(
+                    name=f"user>>>{user}>>>online",
+                    reset=reset
+                )
+            ).ips
+        except grpc.RpcError:
+            raise
+            return None

xtlsapi/api_services/stats/get_statsonline.py

@@ -0,0 +1,18 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+
+from .._base import BaseService
+
+
+class StatsOnline(BaseService):
+    def stats_online(self, user,reset=False):
+        try:
+            return self.stats_stub.GetStatsOnline(
+                command_pb2.GetStatsRequest(
+                    name=f"user>>>{user}>>>online",
+                    reset=reset
+                )
+            ).stat.value
+        except grpc.RpcError:
+            raise
+            return None

xtlsapi/api_services/stats/get_statsquery.py

@@ -0,0 +1,17 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+
+from .._base import BaseService
+
+
+class StatsQuery(BaseService):
+    def stats_query(self, pattern,reset=False):
+        try:
+            return self.stats_stub.QueryStats(
+                command_pb2.QueryStatsRequest(
+                    pattern=pattern,reset=reset
+                )
+            ).stat
+        except grpc.RpcError:
+            raise
+            return None

xtlsapi/api_services/stats/get_total_download_traffic.py

@@ -0,0 +1,17 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+from .._base import BaseService
+
+
+class GetTotalDownloadTraffic(BaseService):
+    def get_total_download_traffic(self, reset=False):
+        raise Exception('Not Implemented')
+        try:
+            return self.stats_stub.GetStats(
+                command_pb2.GetStatsRequest(
+                    name=f"outbound>>>statout>>>traffic>>>downlink", reset=reset
+                )
+            ).stat.value
+        except grpc.RpcError:
+            # raise
+            return None

xtlsapi/api_services/stats/get_total_upload_traffic.py

@@ -0,0 +1,16 @@
+import grpc
+from xtlsapi.xray_api.app.stats.command import command_pb2
+from .._base import BaseService
+
+
+class GetTotalUploadTraffic(BaseService):
+    def get_total_upload_traffic(self, reset=False):
+        raise Exception('Not Implemented')
+        try:
+            return self.stats_stub.GetStats(
+                command_pb2.GetStatsRequest(
+                    name=f"outbound>>>direct>>>traffic>>>uplink", reset=reset
+                )
+            ).stat.value
+        except grpc.RpcError:
+            return None

xtlsapi/base.py

@@ -0,0 +1,17 @@
+"""
+xtlsapi base module.
+
+This is the principal module of the xtlsapi project.
+here you put your main classes and objects.
+
+Be creative! do whatever you want!
+
+If you want to replace this with a Flask application run:
+
+    $ make init
+
+and then choose `flask` as template.
+"""
+
+# example constant variable
+NAME = "xtlsapi"

xtlsapi/cli.py

@@ -0,0 +1,28 @@
+"""CLI interface for xtlsapi project.
+
+Be creative! do whatever you want!
+
+- Install click or typer and create a CLI app
+- Use builtin argparse
+- Start a web application
+- Import things from your .base module
+"""
+
+
+def main():  # pragma: no cover
+    """
+    The main function executes on commands:
+    `python -m xtlsapi` and `$ xtlsapi `.
+
+    This is your program's entry point.
+
+    You can change this function to do whatever you want.
+    Examples:
+        * Run a test suite
+        * Run a server
+        * Do some other stuff
+        * Run a command line application (Click, Typer, ArgParse)
+        * List all available tasks
+        * Run an application (Flask, FastAPI, Django, etc.)
+    """
+    print("This will do something")

xtlsapi/client/SingboxClient.py

@@ -0,0 +1,11 @@
+from grpc import insecure_channel as grpc_insecure_channel
+
+from xtlsapi.singbox_api_services import APIService
+
+
+class SingboxClient(APIService):
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
+        self._channel = grpc_insecure_channel(f'{host}:{port}')
+        super().__init__()

xtlsapi/client/XrayClient.py

@@ -0,0 +1,11 @@
+from grpc import insecure_channel as grpc_insecure_channel
+
+from xtlsapi.api_services import APIService
+
+
+class XrayClient(APIService):
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
+        self._channel = grpc_insecure_channel(f'{host}:{port}')
+        super().__init__()

xtlsapi/client/__init__.py

@@ -0,0 +1 @@
+from .XrayClient import XrayClient

xtlsapi/exceptions/__init__.py

@@ -0,0 +1,4 @@
+from ._base import XRayException
+from .email_not_found import EmailNotFound
+from .inbound_not_found import InboundNotFound
+from .email_already_exists import EmailAlreadyExists

xtlsapi/exceptions/_base.py

@@ -0,0 +1,3 @@
+class XRayException(Exception):
+    def __init__(self, details):
+        self.details = details

xtlsapi/exceptions/email_already_exists.py

@@ -0,0 +1,7 @@
+from ._base import XRayException
+
+
+class EmailAlreadyExists(XRayException):
+    def __init__(self, details, email):
+        self.email = email
+        super().__init__(details)

xtlsapi/exceptions/email_not_found.py

@@ -0,0 +1,7 @@
+from ._base import XRayException
+
+
+class EmailNotFound(XRayException):
+    def __init__(self, details, email):
+        self.email = email
+        super().__init__(details)

xtlsapi/exceptions/inbound_not_found.py

@@ -0,0 +1,7 @@
+from ._base import XRayException
+
+
+class InboundNotFound(XRayException):
+    def __init__(self, details, inbound_tag):
+        self.inbound_tag = inbound_tag
+        super().__init__(details)

xtlsapi/ext/utils.py

@@ -0,0 +1,49 @@
+import uuid
+import math
+import socket
+import secrets
+
+from xtlsapi.xray_api.common.serial import typed_message_pb2
+
+
+def to_typed_message(message):
+    return typed_message_pb2.TypedMessage(
+        type=message.DESCRIPTOR.full_name, value=message.SerializeToString()
+    )
+
+
+def ip2bytes(ip: str):
+    return bytes([int(i) for i in ip.split('.')])
+
+
+def generate_random_tag():
+    return secrets.token_urlsafe()
+
+
+def generate_random_name(hex_count=8):
+    return f"{secrets.token_hex(hex_count)}"
+
+
+def generate_random_user_id():
+    return uuid.uuid4().hex
+
+
+def generate_random_email(tld='vump.com', hex_count=8):
+    return f"{generate_random_name(hex_count)}@{tld}"
+
+
+def generate_random_port():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as tcp:
+        tcp.bind(('', 0))
+        addr, port = tcp.getsockname()
+    return port
+
+
+def human_readable_bytes(size_bytes):
+    if not size_bytes:
+        return "0 B"
+    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_name[i]}"