dpyproxy 2.2.0__py3-none-any.whl

util/DnsReachabilityCollector.py

@@ -0,0 +1,160 @@
+# Determines and outputs the reachability of all DNS servers and circumvention methods's
+# specified in DnsModeDeterminator.py
+import logging
+import os
+
+# hack to add parent to pythonpath
+import sys
+import time
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
+from modules.dns.DnsModeDeterminator import DnsModeDeterminator
+
+TIMEOUT = 5
+CENSORED_DOMAIN = "www.google.dj"
+MIN_RETRIES = 3
+MAX_RETRIES = 20
+ADD_SNI = True
+RESTRICT_ADVERTISED = True
+BLOCK_PAGE_IPS = False
+
+# wikipedia ranges https://wikitech.wikimedia.org/wiki/IP_and_AS_allocations
+WIKIMEDIA_RANGES = [
+    "185.15.56.0/22",
+    "91.198.174.0/24",
+    "195.200.68.0/24",
+    "193.46.90.0/24",
+    "198.35.26.0/23",
+    "208.80.152.0/22",
+    "103.102.166.0/24",
+]
+
+# https://www.gstatic.com/ipranges/goog.json
+GOOGLE_RANGES = [
+    "8.8.4.0/24",
+    "8.8.8.0/24",
+    "8.34.208.0/20",
+    "8.35.192.0/20",
+    "23.236.48.0/20",
+    "23.251.128.0/19",
+    "34.0.0.0/15",
+    "34.2.0.0/16",
+    "34.3.0.0/23",
+    "34.3.3.0/24",
+    "34.3.4.0/24",
+    "34.3.8.0/21",
+    "34.3.16.0/20",
+    "34.3.32.0/19",
+    "34.3.64.0/18",
+    "34.4.0.0/14",
+    "34.8.0.0/13",
+    "34.16.0.0/12",
+    "34.32.0.0/11",
+    "34.64.0.0/10",
+    "34.128.0.0/10",
+    "35.184.0.0/13",
+    "35.192.0.0/14",
+    "35.196.0.0/15",
+    "35.198.0.0/16",
+    "35.199.0.0/17",
+    "35.199.128.0/18",
+    "35.200.0.0/13",
+    "35.208.0.0/12",
+    "35.224.0.0/12",
+    "35.240.0.0/13",
+    "57.140.192.0/18",
+    "64.15.112.0/20",
+    "64.233.160.0/19",
+    "66.22.228.0/23",
+    "66.102.0.0/20",
+    "66.249.64.0/19",
+    "70.32.128.0/19",
+    "72.14.192.0/18",
+    "74.114.24.0/21",
+    "74.125.0.0/16",
+    "104.154.0.0/15",
+    "104.196.0.0/14",
+    "104.237.160.0/19",
+    "107.167.160.0/19",
+    "107.178.192.0/18",
+    "108.59.80.0/20",
+    "108.170.192.0/18",
+    "108.177.0.0/17",
+    "130.211.0.0/16",
+    "136.22.160.0/20",
+    "136.22.176.0/21",
+    "136.22.184.0/23",
+    "136.22.186.0/24",
+    "136.124.0.0/15",
+    "142.250.0.0/15",
+    "146.148.0.0/17",
+    "152.65.208.0/22",
+    "152.65.214.0/23",
+    "152.65.218.0/23",
+    "152.65.222.0/23",
+    "152.65.224.0/19",
+    "162.120.128.0/17",
+    "162.216.148.0/22",
+    "162.222.176.0/21",
+    "172.110.32.0/21",
+    "172.217.0.0/16",
+    "172.253.0.0/16",
+    "173.194.0.0/16",
+    "173.255.112.0/20",
+    "192.104.160.0/23",
+    "192.158.28.0/22",
+    "192.178.0.0/15",
+    "193.186.4.0/24",
+    "199.36.154.0/23",
+    "199.36.156.0/24",
+    "199.192.112.0/22",
+    "199.223.232.0/21",
+    "207.223.160.0/20",
+    "208.65.152.0/22",
+    "208.68.108.0/22",
+    "208.81.188.0/22",
+    "208.117.224.0/19",
+    "209.85.128.0/17",
+    "216.58.192.0/19",
+    "216.73.80.0/20",
+    "216.239.32.0/19",
+    "216.252.220.0/22",
+]
+
+IRAN_BLOCK_PAGES = ["10.10.34.34", "10.10.34.35", "10.10.34.36"]
+
+
+def main():
+    print(",".join(GOOGLE_RANGES))
+    return
+    logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
+
+    _det = DnsModeDeterminator(
+        timeout=TIMEOUT,
+        censored_domain=CENSORED_DOMAIN,
+        compare_ip_ranges=GOOGLE_RANGES,
+        block_page_ips=BLOCK_PAGE_IPS,
+        restrict_advertised=RESTRICT_ADVERTISED,
+    )
+
+    print("Generating working resolvers... might take a while!")
+    _time = time.time()
+
+    for resolver in [
+        x for x in _det.generate_working_resolver(min_retries=MIN_RETRIES, max_retries=MAX_RETRIES, add_sni=ADD_SNI)
+    ]:
+        print(resolver)
+
+    print(f"Time taken: {format_time(time.time() - _time)}")
+
+
+def format_time(unix_timestamp: float) -> str:
+    """
+    Formats unix timestamp to hh:mm:ss format
+    """
+    return time.strftime("%H:%M:%S", time.gmtime(unix_timestamp))
+
+
+if __name__ == "__main__":
+    main()

util/DnsResolversDomainResolver.py

@@ -0,0 +1,36 @@
+import os
+
+# hack to add parent to pythonpath
+import sys
+
+from dns.message import make_query
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
+from enumerators.DnsProxyMode import DnsProxyMode
+from enumerators.DnsResolvers import DnsResolvers
+from network.DomainResolver import DomainResolver
+from network.NetworkAddress import NetworkAddress
+from util.Util import parse_all_ips
+
+TIMEOUT = 5
+
+
+def main():
+    local_address = NetworkAddress("127.0.0.53", 53)
+    local_resolver = DomainResolver(DnsProxyMode.UDP, local_address, TIMEOUT, "")
+    for resolver in DnsResolvers:
+        if resolver.hostname == "":
+            continue  # No need to test Gcore
+
+        message = make_query(resolver.hostname, "A")
+        try:
+            answer = local_resolver.resolve_udp_static(message, resolver=local_address, timeout=TIMEOUT)
+            resolved_ips = parse_all_ips(answer)
+            if resolver.value not in resolved_ips:
+                print(f"Ip mismatch between {resolver} and {resolved_ips}")
+        except Exception as e:
+            print(f"Could not determine IP of {resolver} due to {e}")
+
+
+main()

util/Util.py

@@ -0,0 +1,62 @@
+import logging
+import socket
+
+import dns
+from dns.rdatatype import RdataType
+
+
+def is_valid_ipv4_address(ip_address: str) -> bool:
+    """
+    Returns whether the given string is a valid ipv4 address.
+    :param ip_address: String to check for ipv4 validity
+    :return: Whether the given string is a valid ip address
+    """
+    try:
+        socket.inet_aton(ip_address)
+        return True
+    except socket.error:
+        return False
+
+
+def parse_all_ips(answer: dns.message.Message) -> list[str]:
+    resolved_ips = []
+    _name = ""
+    _rdclass = ""
+    _rdtype = ""
+
+    try:
+        _name = answer.question[0].name
+        _rdclass = answer.question[0].rdclass
+        _rdtype = answer.question[0].rdtype
+
+        for record in answer.find_rrset(answer.answer, _name, _rdclass, _rdtype):
+            try:
+                ip = record.address
+                resolved_ips += [ip]
+            except Exception as e:
+                logging.error(f"Could not extract IP from DNS response with exception {e}:\n{record}")
+                continue
+    except Exception as e:
+        if answer is not None:
+            try:
+                # Try CNAME backup
+                cname = answer.find_rrset(answer.answer, _name, _rdclass, RdataType.CNAME)
+                _name = str(cname[0])
+
+                for record in answer.find_rrset(answer.answer, _name, _rdclass, _rdtype):
+                    try:
+                        ip = record.address
+                        resolved_ips += [ip]
+                    except Exception as e:
+                        logging.error(f"Could not extract IP from DNS response with exception {e}:\n{record}")
+                        continue
+            except Exception as e:
+                logging.error(
+                    f"Could not extract IP from DNS response with exception {e}:\n{_name}, {_rdclass}, {_rdtype}; "
+                    f"{answer.answer}"
+                )
+        else:
+            logging.error(
+                f"Could not extract IP from DNS response with exception {e}:\n{_name}, {_rdclass}, {_rdtype}; None"
+            )
+    return resolved_ips

util/constants.py

@@ -0,0 +1,8 @@
+TLS_1_0_HEADER = b"\x16\x03\x01"
+TLS_1_1_HEADER = b"\x16\x03\x02"
+TLS_1_2_HEADER = b"\x16\x03\x03"
+
+SOCKSv4_HEADER = b"\x04"
+SOCKSv5_HEADER = b"\x05"
+
+STANDARD_SOCKET_RECEIVE_SIZE = 4096