pax_global_header00006660000000000000000000000064151003622350014507gustar00rootroot0000000000000052 comment=94fa1dfaa622cbac9a27f4d6413212a6ca93b015 unidns-0.0.4/000077500000000000000000000000001510036223500130105ustar00rootroot00000000000000unidns-0.0.4/.gitignore000066400000000000000000000060251510036223500150030ustar00rootroot00000000000000# ---> Python # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ cover/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder .pybuilder/ target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv # For a library or package, you might want to ignore these files since the code is # intended to run in multiple environments; otherwise, check them in: # .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock # pdm # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. #pdm.lock # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it # in version control. # https://pdm.fming.dev/#use-with-ide .pdm.toml # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ # pytype static type analyzer .pytype/ # Cython debug symbols cython_debug/ # PyCharm # JetBrains specific template is maintained in a separate JetBrains.gitignore that can # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ unidns-0.0.4/LICENSE000066400000000000000000000020561510036223500140200ustar00rootroot00000000000000MIT License Copyright (c) <2023> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. unidns-0.0.4/MANIFEST.in000066400000000000000000000000411510036223500145410ustar00rootroot00000000000000include LICENSE include README.mdunidns-0.0.4/Makefile000066400000000000000000000005631510036223500144540ustar00rootroot00000000000000clean: rm -f -r build/ rm -f -r dist/ rm -f -r *.egg-info find . -name '*.pyc' -exec rm -f {} + find . -name '*.pyo' -exec rm -f {} + find . -name '*~' -exec rm -f {} + publish: clean python3 setup.py sdist bdist_wheel python3 -m twine upload dist/* rebuild: clean python3 setup.py install build: python3 setup.py install install: python3 setup.py installunidns-0.0.4/README.md000066400000000000000000000000601510036223500142630ustar00rootroot00000000000000# unidns Rudimentary async DNS client in Pythonunidns-0.0.4/pyproject.toml000066400000000000000000000001301510036223500157160ustar00rootroot00000000000000[build-system] requires = ["setuptools>=61.0.0"] build-backend = "setuptools.build_meta"unidns-0.0.4/setup.py000066400000000000000000000023231510036223500145220ustar00rootroot00000000000000from setuptools import setup, find_packages import re VERSIONFILE="unidns/_version.py" verstrline = open(VERSIONFILE, "rt").read() VSRE = r"^__version__ = ['\"]([^'\"]*)['\"]" mo = re.search(VSRE, verstrline, re.M) if mo: verstr = mo.group(1) else: raise RuntimeError("Unable to find version string in %s." % (VERSIONFILE,)) setup( # Application name: name="unidns", # Version number (initial): version=verstr, # Application author details: author="Tamas Jos", author_email="info@skelsecprojects.com", # Packages packages=find_packages(exclude=["tests*"]), # Include additional files into the package include_package_data=True, # Details url="https://github.com/skelsec/unidns", zip_safe = True, # # license="LICENSE.txt", description="Rudimentary async DNS client in Python", long_description="Rudimentary async DNS client in Python", # long_description=open("README.txt").read(), python_requires='>=3.6', classifiers=( "Programming Language :: Python :: 3.6", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ), install_requires=[ 'asysocks>=0.2.18', ], entry_points={ 'console_scripts': [ 'unidns = unidns.examples.unidnsclient:main', ], } )unidns-0.0.4/unidns/000077500000000000000000000000001510036223500143105ustar00rootroot00000000000000unidns-0.0.4/unidns/__init__.py000066400000000000000000000000001510036223500164070ustar00rootroot00000000000000unidns-0.0.4/unidns/_version.py000066400000000000000000000001771510036223500165130ustar00rootroot00000000000000__version__ = "0.0.4" __banner__ = \ """ # unidns %s # Author: Tamas Jos @skelsec (info@skelsecprojects.com) """ % __version__unidns-0.0.4/unidns/client.py000066400000000000000000000216461510036223500161510ustar00rootroot00000000000000from unidns.protocol.structs import * from unidns.common.settings import DNSSettings from unidns.network.packetizer import DNSPacketizer from asysocks.unicomm.common.target import UniTarget, UniProto from asysocks.unicomm.client import UniClient from typing import Dict import asyncio import os import ipaddress import socket class DNSClient: def __init__(self, target:UniTarget, settings:DNSSettings = None): self.target = target if settings is None: settings = DNSSettings() self.connection_keepalive_time = settings.connection_keepalive_time self.query_timeout = settings.query_timeout self.cache = {} self.TID_lookup:Dict[bytes, asyncio.Future] = {} self.TID_lookup_packet:Dict[bytes, bytes] = {} self.connection = None self.__server_in_task = None async def __aenter__(self): return self async def __aexit__(self, exc_type, exc_val, exc_tb): if self.connection is not None: if asyncio.iscoroutinefunction(self.connection.close) is True: await self.connection.close() else: self.connection.close() self.connection = None if self.__server_in_task is not None: self.__server_in_task.cancel() for tid in self.TID_lookup: self.TID_lookup[tid].cancel() self.TID_lookup = {} async def __handle_server_in_udp(self): try: async for res in self.connection.read(with_addr = True): if res is None: break packetdata, addr = res if packetdata is None: break try: packet = DNSPacket.from_bytes(packetdata) await self.__process_packet(packet) except Exception as e: print("Error parsing packet:", e) finally: for tid in self.TID_lookup: self.TID_lookup[tid].cancel() try: if asyncio.iscoroutinefunction(self.connection.close): await self.connection.close() else: self.connection.close() except: pass self.connection = None async def __handle_server_in_tcp(self): try: async for packetdata in self.connection.read(): if packetdata is None: break packet = DNSPacket.from_bytes(packetdata) await self.__process_packet(packet) finally: for tid in self.TID_lookup: self.TID_lookup[tid].cancel() if self.connection is not None: await self.connection.close() self.connection = None async def __process_packet(self, packet:DNSPacket): if packet.TransactionID not in self.TID_lookup: #print("Unknown TID") return if packet.TransactionID in self.TID_lookup_packet: cachedata = self.TID_lookup_packet[packet.TransactionID] self.cache[cachedata] = packet del self.TID_lookup_packet[packet.TransactionID] self.TID_lookup[packet.TransactionID].set_result(packet) async def __server_request(self, question: DNSQuestion, with_recursion:bool = True): try: packet = DNSPacket(proto=socket.SOCK_DGRAM if self.target.protocol == UniProto.CLIENT_UDP else socket.SOCK_STREAM) packet.TransactionID = b'\x00\x00' packet.QR = DNSResponse.REQUEST packet.Rcode = DNSResponseCode.NOERR packet.FLAGS = DNSFlags.RD if with_recursion else DNSFlags(0) packet.Opcode = DNSOpcode.QUERY packet.Questions.append(question) cache_lookup_bytes = packet.to_bytes() if cache_lookup_bytes in self.cache: answer_future = asyncio.Future() answer_future.set_result(self.cache[cache_lookup_bytes]) return answer_future, None, None tid = os.urandom(2) self.TID_lookup_packet[tid] = cache_lookup_bytes packet.TransactionID = tid answer_future = asyncio.Future() self.TID_lookup[tid] = answer_future if self.connection is None: _, err = await self.__create_connection() if err is not None: return None, None, err await self.connection.write(packet.to_bytes()) return answer_future, packet.TransactionID, None except Exception as e: return None, None, e async def __create_connection(self): try: packetizer = DNSPacketizer() client = UniClient(self.target, packetizer) self.connection = await client.connect() if self.target.protocol == UniProto.CLIENT_TCP: self.__server_in_task = asyncio.create_task(self.__handle_server_in_tcp()) else: self.__server_in_task = asyncio.create_task(self.__handle_server_in_udp()) return True, None except Exception as e: return None, e async def query(self, name, qtype:str, with_recursion:bool = True): qtype = qtype.upper() if qtype == 'A': return await self.query_A(name) elif qtype == 'AAAA': return await self.query_AAAA(name) elif qtype == 'PTR': return await self.query_PTR(name) else: return None, Exception('Query type "%s" is not supported. Use A/AAAA/PTR') async def query_A(self, hostname:str, with_recursion:bool = True): tid = None try: question = DNSQuestion() question.QNAME = DNSName(str(hostname)) question.QTYPE = DNSType.A answer_future, tid, err = await self.__server_request(question, with_recursion=with_recursion) if err is not None: return None, err res = await asyncio.wait_for(answer_future, self.query_timeout) if res.Rcode != DNSResponseCode.NOERR: return None, Exception("DNS error: {}".format(res.Rcode)) for answer in res.Answers: if answer.TYPE == DNSType.A: return answer.ipaddress, None return None, Exception("No matching record found in response") except Exception as e: return None, e finally: if tid is not None and tid in self.TID_lookup: del self.TID_lookup[tid] async def query_AAAA(self, hostname:str, with_recursion:bool = True): tid = None try: question = DNSQuestion() question.QNAME = DNSName(str(hostname)) question.QTYPE = DNSType.AAAA answer_future, tid, err = await self.__server_request(question, with_recursion=with_recursion) if err is not None: return None, err res = await asyncio.wait_for(answer_future, self.query_timeout) if res.Rcode != DNSResponseCode.NOERR: return None, Exception("DNS error: {}".format(res.Rcode)) for answer in res.Answers: if answer.TYPE == DNSType.AAAA: return answer.ipaddress, None return None, Exception("No matching record found in response") except Exception as e: return None, e finally: if tid is not None and tid in self.TID_lookup: del self.TID_lookup[tid] async def query_PTR(self, ip:str or ipaddress.IPv4Address or ipaddress.IPv6Address, with_recursion:bool = True): tid = None try: if isinstance(ip, str): try: ip = ipaddress.ip_address(ip) except: raise Exception("Invalid IP address") question = DNSQuestion() question.QNAME = DNSName(str(ip.reverse_pointer)) question.QTYPE = DNSType.PTR answer_future, tid, err = await self.__server_request(question, with_recursion=with_recursion) if err is not None: return None, err res = await asyncio.wait_for(answer_future, self.query_timeout) if res.Rcode != DNSResponseCode.NOERR: return None, Exception("DNS error: {}".format(res.Rcode)) for answer in res.Answers: if answer.TYPE == DNSType.PTR: return answer.domainname, None return None, Exception("No matching record found in response") except Exception as e: return None, e finally: if tid is not None and tid in self.TID_lookup: del self.TID_lookup[tid] async def query_SOA(self, hostname:str, with_recursion:bool = True): tid = None try: question = DNSQuestion() question.QNAME = DNSName(str(hostname)) question.QTYPE = DNSType.SOA answer_future, tid, err = await self.__server_request(question, with_recursion=with_recursion) if err is not None: return None, err res = await asyncio.wait_for(answer_future, self.query_timeout) if res.Rcode != DNSResponseCode.NOERR: return None, Exception("DNS error: {}".format(res.Rcode)) for answer in res.Answers: if answer.TYPE == DNSType.SOA: return answer, None return None, Exception("No matching record found in response") except Exception as e: return None, e finally: if tid is not None and tid in self.TID_lookup: del self.TID_lookup[tid] if __name__ == "__main__": async def main(): for protocol in [UniProto.CLIENT_UDP, UniProto.CLIENT_TCP]: client = DNSClient(UniTarget("8.8.8.8", 53, protocol=protocol)) res = await client.query("google.com", "A") print(res) await asyncio.sleep(10) res = await client.query("google.com", "A") print(res) res = await client.query("index.hu", "A") print(res) await asyncio.sleep(10) res = await client.query("index.hu", "A") print(res) await asyncio.sleep(10) res = await client.query("444.hu", "A") print(res) await asyncio.sleep(10) res = await client.query("444.hu", "A") for protocol in [UniProto.CLIENT_UDP, UniProto.CLIENT_TCP]: client = DNSClient(UniTarget("8.8.8.8", 53, protocol=protocol)) res = await client.query("google.com", "A") print(res) res = await client.query("google.com", "A") print(res) res = await client.query("index.hu", "A") print(res) res = await client.query("index.hu", "A") print(res) res = await client.query("444.hu", "A") print(res) res = await client.query("444.hu", "A") asyncio.run(main()) unidns-0.0.4/unidns/common/000077500000000000000000000000001510036223500156005ustar00rootroot00000000000000unidns-0.0.4/unidns/common/__init__.py000066400000000000000000000000001510036223500176770ustar00rootroot00000000000000unidns-0.0.4/unidns/common/factory.py000066400000000000000000000014631510036223500176250ustar00rootroot00000000000000from asysocks.unicomm.common.target import UniTarget from unidns.client import DNSClient from unidns.common.settings import DNSSettings class DNSConnectionFactory: def __init__(self, target:UniTarget): self.target = target def get_client(self, settings:DNSSettings = None): return DNSClient(self.target, settings) async def test_connection(self, settings:DNSSettings = None): # must return True, None, None if connection is successful try: connection = self.get_client(settings) async with connection: _, err = await connection.query('google.com', 'A') if err is not None: raise err return True, None, None except Exception as e: return False, None, eunidns-0.0.4/unidns/common/settings.py000066400000000000000000000001711510036223500200110ustar00rootroot00000000000000 class DNSSettings: def __init__(self): self.query_timeout = 0.5 self.connection_keepalive_time = 10unidns-0.0.4/unidns/examples/000077500000000000000000000000001510036223500161265ustar00rootroot00000000000000unidns-0.0.4/unidns/examples/__init__.py000066400000000000000000000000001510036223500202250ustar00rootroot00000000000000unidns-0.0.4/unidns/examples/unidnsclient.py000066400000000000000000000026521510036223500212040ustar00rootroot00000000000000from unidns.client import DNSClient from asysocks.unicomm.common.target import UniTarget, UniProto import asyncio async def amain(host, port, domain, record_type, recursion = True): target = UniTarget(host, port, UniProto.CLIENT_TCP) client = DNSClient(target) response, error = await client.query(domain, record_type, recursion) if error is not None: print("Error: {}".format(error)) else: print(response) def main(): import argparse parser = argparse.ArgumentParser(description="Issue DNS queries to a specified DNS server.") parser.add_argument("-a", "--address", type=str, required=True, help="The IP address of the DNS server") parser.add_argument("-p", "--port", type=int, required=False, default = 53, help="The port number of the DNS server") parser.add_argument("-d", "--domain", type=str, required=True, help="The domain name for the DNS query") parser.add_argument("-t", "--type", type=str, choices=["A", "AAAA", "CNAME", "MX", "NS", "PTR", "SRV", "TXT"], default="A", help="The DNS record type for the query (default: A)") parser.add_argument("-r", "--recursion", action="store_true", help="Enable DNS recursion") args = parser.parse_args() asyncio.run(amain(args.address, args.port, args.domain, args.type, args.recursion)) if __name__ == '__main__': main()unidns-0.0.4/unidns/network/000077500000000000000000000000001510036223500160015ustar00rootroot00000000000000unidns-0.0.4/unidns/network/__init__.py000066400000000000000000000000001510036223500201000ustar00rootroot00000000000000unidns-0.0.4/unidns/network/packetizer.py000066400000000000000000000013011510036223500205070ustar00rootroot00000000000000from asysocks.unicomm.common.packetizers import Packetizer class DNSPacketizer(Packetizer): def __init__(self): Packetizer.__init__(self, 65535) self.in_buffer = b'' def process_buffer(self): packet_length = -1 while len(self.in_buffer) > 2: packet_length = int.from_bytes(self.in_buffer[:2], byteorder = 'big', signed=False) if len(self.in_buffer) < packet_length: break packet = self.in_buffer[2:packet_length+2] self.in_buffer = self.in_buffer[packet_length+2:] yield packet async def data_out(self, data): yield data async def data_in(self, data): if data is None: yield data self.in_buffer += data for packet in self.process_buffer(): yield packetunidns-0.0.4/unidns/protocol/000077500000000000000000000000001510036223500161515ustar00rootroot00000000000000unidns-0.0.4/unidns/protocol/__init__.py000066400000000000000000000000001510036223500202500ustar00rootroot00000000000000unidns-0.0.4/unidns/protocol/structs.py000066400000000000000000000673111510036223500202420ustar00rootroot00000000000000#https://www.ietf.org/rfc/rfc1035.txt import enum import io import asyncio import ipaddress import socket from typing import List class DNSResponseCode(enum.Enum): NOERR = 0 #No error condition FORMATERR = 1 #Format error - The name server was unable to interpret the query. SERVERERR = 2 #Server failure - The name server was unable to process this query due to a problem with the name server. NAMEERR = 3 #Name Error - Meaningful only for responses from an authoritative name server, this code signifies that the domain name referenced in the query does not exist. NOTIMPL = 4 #Not Implemented - The name server does not support the requested kind of query. REFUSED = 5 #Refused - The name server refuses to perform the specified operation for policy reasons. RESERVED6 = 6 RESERVED7 = 7 RESERVED8 = 8 RESERVED9 = 9 RESERVED10 = 10 RESERVED11 = 11 RESERVED12 = 12 RESERVED13 = 13 RESERVED14 = 14 RESERVED15 = 15 class DNSType(enum.Enum): UNKNOWN = 0 #not in RFC, used for internal purposes when dns packet is damaged A = 1 #a host address (IPv4) NS = 2 #an authoritative name server MD = 3 #a mail destination (Obsolete - use MX) MF = 4 #a mail forwarder (Obsolete - use MX) CNAME = 5 #the canonical name for an alias SOA = 6 #marks the start of a zone of authority MB = 7 #a mailbox domain name (EXPERIMENTAL) MG = 8 #a mail group member (EXPERIMENTAL) MR = 9 #a mail rename domain name (EXPERIMENTAL) NULL = 10 #a null RR (EXPERIMENTAL) WKS = 11 #a well known service description PTR = 12 #a domain name pointer HINFO = 13 #host information MINFO = 14 #mailbox or mail list information MX = 15 #mail exchange TXT = 16 #text strings RP = 17 #RFC 1183 Responsible Person Information about the responsible person(s) for the domain. Usually an email address with the @ replaced by a . AFSDB = 18 #RFC 1183 AFS database record Location of database servers of an AFS cell. This record is commonly used by AFS clients to contact AFS cells outside their local domain. A subtype of this record is used by the obsolete DCE/DFS file system. SIG = 24 #RFC 2535 Signature Signature record used in SIG(0) (RFC 2931) and TKEY (RFC 2930).[7] RFC 3755 designated RRSIG as the replacement for SIG for use within DNSSEC.[7] KEY = 25 #RFC 2535[3] and RFC 2930[4] Key record Used only for SIG(0) (RFC 2931) and TKEY (RFC 2930).[5] RFC 3445 eliminated their use for application keys and limited their use to DNSSEC.[6] RFC 3755 designates DNSKEY as the replacement within DNSSEC.[7] RFC 4025 designates IPSECKEY as the replacement for use with IPsec.[8] AAAA = 28 #RFC 3596[2] IPv6 address record Returns a 128-bit IPv6 address, most commonly used to map hostnames to an IP address of the host. LOC = 29 #RFC 1876 Location record Specifies a geographical location associated with a domain name SRV = 33 #RFC 2782 Service locator Generalized service location record, used for newer protocols instead of creating protocol-specific records such as MX. NAPTR = 35 #RFC 3403 Naming Authority Pointer Allows regular-expression-based rewriting of domain names which can then be used as URIs, further domain names to lookups, etc. KX = 36 #RFC 2230 Key Exchanger record Used with some cryptographic systems (not including DNSSEC) to identify a key management agent for the associated domain-name. Note that this has nothing to do with DNS Security. It is Informational status, rather than being on the IETF standards-track. It has always had limited deployment, but is still in use. CERT = 37 #RFC 4398 Certificate record Stores PKIX, SPKI, PGP, etc. DNAME = 39 #RFC 6672 Alias for a name and all its subnames, unlike CNAME, which is an alias for only the exact name. Like a CNAME record, the DNS lookup will continue by retrying the lookup with the new name. OPT = 41 #RFC 6891 Option This is a "pseudo DNS record type" needed to support EDNS APL = 42 #RFC 3123 Address Prefix List Specify lists of address ranges, e.g. in CIDR format, for various address families. Experimental. DS = 43 #RFC 4034 Delegation signer The record used to identify the DNSSEC signing key of a delegated zone SSHFP = 44 #RFC 4255 SSH Public Key Fingerprint Resource record for publishing SSH public host key fingerprints in the DNS System, in order to aid in verifying the authenticity of the host. RFC 6594 defines ECC SSH keys and SHA-256 hashes. See the IANA SSHFP RR parameters registry for details. IPSECKEY = 45 #RFC 4025 IPsec Key Key record that can be used with IPsec RRSIG = 46 #RFC 4034 DNSSEC signature Signature for a DNSSEC-secured record set. Uses the same format as the SIG record. NSEC = 47 #RFC 4034 Next Secure record Part of DNSSEC—used to prove a name does not exist. Uses the same format as the (obsolete) NXT record. DNSKEY = 48 #RFC 4034 DNS Key record The key record used in DNSSEC. Uses the same format as the KEY record. DHCID = 49 #RFC 4701 DHCP identifier Used in conjunction with the FQDN option to DHCP NSEC3 = 50 #RFC 5155 Next Secure record version 3 An extension to DNSSEC that allows proof of nonexistence for a name without permitting zonewalking NSEC3PARAM = 51 #RFC 5155 NSEC3 parameters Parameter record for use with NSEC3 TLSA = 52 #RFC 6698 TLSA certificate association A record for DANE. RFC 6698 defines "The TLSA DNS resource record is used to associate a TLS server certificate or public key with the domain name where the record is found, thus forming a 'TLSA certificate association'". HIP = 55 #RFC 8005 Host Identity Protocol Method of separating the end-point identifier and locator roles of IP addresses. CDS = 59 #RFC 7344 Child DS Child copy of DS record, for transfer to parent CDNSKEY = 60 #RFC 7344 Child DNSKEY Child copy of DNSKEY record, for transfer to parent OPENPGPKEY = 61 #RFC 7929 OpenPGP public key record A DNS-based Authentication of Named Entities (DANE) method for publishing and locating OpenPGP public keys in DNS for a specific email address using an OPENPGPKEY DNS resource record. TKEY = 249 #RFC 2930 Transaction Key record A method of providing keying material to be used with TSIG that is encrypted under the public key in an accompanying KEY RR.[10] TSIG = 250 #RFC 2845 Transaction Signature Can be used to authenticate dynamic updates as coming from an approved client, or to authenticate responses as coming from an approved recursive name server[11] similar to DNSSEC. IXFR = 251 #RFC 1996 Incremental Zone Transfer Requests a zone transfer of the given zone but only differences from a previous serial number. This request may be ignored and a full (AXFR) sent in response if the authoritative server is unable to fulfill the request due to configuration or lack of required deltas. AXFR = 252 #RFC 1035[1] Authoritative Zone Transfer Transfer entire zone file from the master name server to secondary name servers. ANY = 255 #ANYTHING URI = 256 #RFC 7553 Uniform Resource Identifier Can be used for publishing mappings from hostnames to URIs. CAA = 257 #RFC 6844 Certification Authority Authorization DNS Certification Authority Authorization, constraining acceptable CAs for a host/domain class DNSClass(enum.Enum): IN = 1 #the Internet CS = 2 #the CSNET class (Obsolete - used only for examples in some obsolete RFCs) CH = 3 #the CHAOS class HS = 4 #Hesiod [Dyer 87] ANY = 255 class DNSOpcode(enum.Enum): QUERY = 0 #a standard query () IQUERY = 1 #an inverse query () STATUS = 2 #a server status request () RESERVED3 = 3 RESERVED4 = 4 RESERVED5 = 5 RESERVED6 = 6 RESERVED7 = 7 RESERVED8 = 8 RESERVED9 = 9 RESERVED10 = 10 RESERVED11 = 11 RESERVED12 = 12 RESERVED13 = 13 RESERVED14 = 14 RESERVED15 = 15 #the upper bit is always zero and must never be set class DNSFlags(enum.IntFlag): AA = 0x0040 #Authoritative Answer TC = 0x0020 #TrunCation RD = 0x0010 #Recursion Desired RA = 0x0008 #Recursion Available RESERVED1 = 0x0004 RESERVED2 = 0x0002 RESERVED3 = 0x0001 class DNSResponse(enum.Enum): REQUEST = 0 #Query RESPONSE = 1 class DNSPacket(): def __init__(self, proto = socket.SOCK_STREAM): self.proto: socket.SocketKind = proto self.PACKETLEN: int = None #this is for TCP self.TransactionID: bytes = None self.QR: DNSResponse = None self.Opcode: DNSOpcode = None self.FLAGS: DNSFlags = None self.Rcode: DNSResponseCode = None self.QDCOUNT: int = None self.ANCOUNT: int = None self.NSCOUNT: int = None self.ARCOUNT: int = None self.Questions: List[DNSQuestion] = [] self.Answers = [] self.Authorities = [] self.Additionals = [] @staticmethod async def from_streamreader(reader, proto = socket.SOCK_DGRAM): if proto == socket.SOCK_DGRAM: data = await reader.read() return DNSPacket.from_bytes(data) else: plen_bytes = await reader.readexactly(2) plen = int.from_bytes(plen_bytes, byteorder = 'big', signed=False) data = await reader.readexactly(plen) return DNSPacket.from_bytes(plen_bytes + data, proto = proto) @staticmethod async def from_queue(in_q, prevdata, proto = socket.SOCK_DGRAM): if proto == socket.SOCK_DGRAM: data = await in_q.get() return DNSPacket.from_bytes(data) else: t, err = await in_q.get() if err is not None: raise err prevdata += t plen_bytes = prevdata[:2] plen = int.from_bytes(plen_bytes, byteorder = 'big', signed=False) return DNSPacket.from_bytes(plen_bytes + prevdata[2:2+plen], proto = proto), prevdata[plen:] @staticmethod def from_bytes(bbuff, proto = socket.SOCK_DGRAM): return DNSPacket.from_buffer(io.BytesIO(bbuff), proto) @staticmethod def from_buffer(buff, proto = socket.SOCK_DGRAM): packet = DNSPacket() packet.proto = proto if packet.proto == socket.SOCK_STREAM: packet.PACKETLEN = int.from_bytes(buff.read(2), byteorder = 'big', signed=False) buff = io.BytesIO(buff.read()) #need to repack this to a new buffer because the length field is not taken into account when calculating compressed DNSName packet.TransactionID = buff.read(2) temp = int.from_bytes(buff.read(2), byteorder = 'big', signed=False) packet.QR = DNSResponse(temp >> 15) packet.Opcode = DNSOpcode((temp & 0x7800) >> 11) packet.FLAGS = DNSFlags((temp >> 4) & 0x7F) packet.Rcode = DNSResponseCode(temp & 0xF) packet.QDCOUNT = int.from_bytes(buff.read(2), byteorder = 'big', signed=False) packet.ANCOUNT = int.from_bytes(buff.read(2), byteorder = 'big', signed=False) packet.NSCOUNT = int.from_bytes(buff.read(2), byteorder = 'big', signed=False) packet.ARCOUNT = int.from_bytes(buff.read(2), byteorder = 'big', signed=False) for i in range(0, packet.QDCOUNT): dnsq = DNSQuestion.from_buffer(buff) packet.Questions.append(dnsq) for i in range(0, packet.ANCOUNT): dnsr = DNSResourceParser.from_buffer(buff) packet.Answers.append(dnsr) for i in range(0, packet.NSCOUNT): dnsr = DNSResourceParser.from_buffer(buff) packet.Authorities.append(dnsr) for i in range(0, packet.ARCOUNT): dnsr = DNSResourceParser.from_buffer(buff) packet.Additionals.append(dnsr) return packet def __repr__(self): t = '== DNS Packet ==\r\n' t+= 'TransactionID: %s\r\n' % self.TransactionID.hex() t+= 'QR: %s\r\n' % self.QR.name t+= 'Opcode: %s\r\n' % self.Opcode.name t+= 'FLAGS: %s\r\n' % repr(self.FLAGS) t+= 'Rcode: %s\r\n' % self.Rcode.name t+= 'QDCOUNT: %s\r\n' % self.QDCOUNT t+= 'ANCOUNT: %s\r\n' % self.ANCOUNT t+= 'NSCOUNT: %s\r\n' % self.NSCOUNT t+= 'ARCOUNT: %s\r\n' % self.ARCOUNT if len(self.Questions) > 0: for question in self.Questions: t+= repr(question) if len(self.Answers) > 0: for answer in self.Answers: t+= repr(answer) if len(self.Authorities) > 0: for answer in self.Authorities: t+= repr(answer) if len(self.Additionals) > 0: for answer in self.Additionals: t+= repr(answer) return t def to_bytes(self): t = self.TransactionID a = self.Rcode.value a |= (self.FLAGS << 4 ) & 0x7F0 a |= (self.Opcode.value << 11) & 0x7800 a |= (self.QR.value << 15) & 0x8000 t += a.to_bytes(2, byteorder = 'big', signed = False) t += len(self.Questions).to_bytes(2, byteorder = 'big', signed=False) t += len(self.Answers).to_bytes(2, byteorder = 'big', signed=False) t += len(self.Authorities).to_bytes(2, byteorder = 'big', signed=False) t += len(self.Additionals).to_bytes(2, byteorder = 'big', signed=False) for q in self.Questions: t += q.to_bytes() for q in self.Answers: t += q.to_bytes() for q in self.Authorities: t += q.to_bytes() for q in self.Additionals: t += q.to_bytes() if self.proto == socket.SOCK_STREAM: self.PACKETLEN = len(t) t = self.PACKETLEN.to_bytes(2, byteorder = 'big', signed=False) + t return t @staticmethod def construct(TID, response, flags = 0, opcode = DNSOpcode.QUERY, rcode = DNSResponseCode.NOERR, questions= [], answers= [], authorities = [], additionals = [], proto = socket.SOCK_DGRAM): packet = DNSPacket() packet.proto = proto packet.TransactionID = TID packet.QR = response packet.Opcode = opcode packet.FLAGS = flags packet.Rcode = rcode packet.QDCOUNT = len(questions) packet.ANCOUNT = len(answers) packet.NSCOUNT = len(authorities) packet.ARCOUNT = len(additionals) packet.Questions = questions packet.Answers = answers packet.Authorities = authorities packet.Additionals = additionals return packet class DNSQuestion(): def __init__(self): self.QNAME:DNSName = None self.QTYPE:DNSType = None self.QCLASS:DNSClass = DNSClass.IN self.QU:bool = False #used in MDNS, tset it true for multicast @staticmethod def from_bytes(bbuff): return DNSQuestion.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): qst = DNSQuestion() qst.QNAME = DNSName.from_buffer(buff) qst.QTYPE = DNSType(int.from_bytes(buff.read(2), byteorder = 'big', signed = False)) temp = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) qst.QCLASS = DNSClass(temp & 0x7fff) qst.QU = bool((temp & 0x8000) >> 15) return qst def to_bytes(self): t = self.QNAME.to_bytes() t += self.QTYPE.value.to_bytes(2, byteorder = 'big', signed = False) a = self.QCLASS.value a |= int(self.QU) << 15 t += a.to_bytes(2, byteorder = 'big', signed = False) return t @staticmethod def construct(qname, qtype, qclass, qu = False): qst = DNSQuestion() qst.QNAME = DNSName.construct(qname) qst.QTYPE = qtype qst.QCLASS = qclass qst.QU = qu return qst def __repr__(self): t = '== DNSQuestion ==\r\n' t+= 'QNAME: %s\r\n' % self.QNAME.name t+= 'QTYPE: %s\r\n' % self.QTYPE.name t+= 'QCLASS: %s\r\n' % self.QCLASS.name t+= 'QU : %s\r\n' % self.QU return t class DNSOPT(): def __init__(self): self.Code:int = None self.Length:int = None self.Value:bytes = None #temp variable! self.size:int = None @staticmethod def from_bytes(buff): return DNSOPT.from_buffer(io.BytesIO(buff)) @staticmethod def from_buffer(buff): o = DNSOPT() o.Code = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.Length = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.Value = buff.read(o.Length) o.size = o.Length + 2 return o class DNSOPTResource(): #https://tools.ietf.org/html/rfc6891 Section 6.1.2. #Comments from the author: Seriosuly why did you re-invent the format???? def __init__(self): self.NAME:DNSName = None self.TYPE:DNSType = None self.UDPSIZE:int = None self.EXTRCODE:int = None self.VERSION:int = None self.DO:bool = None self.Z:int = None self.RDLENGTH:int = None self.RDATA:bytes = None self.options = [] @staticmethod def from_bytes(bbuff): return DNSOPTResource.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): rsc = DNSOPTResource() rsc.NAME = DNSName.from_buffer(buff) rsc.TYPE = DNSType(int.from_bytes(buff.read(2), byteorder = 'big', signed = False)) rsc.UDPSIZE = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) rsc.EXTRCODE = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rsc.VERSION = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) temp = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) rsc.DO = bool(temp & 0x8000) rsc.Z = temp & 0x7fff rsc.RDLENGTH = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) rsc.RDATA = buff.read(rsc.RDLENGTH) #TODO Further parsing the opt elements """ i = rsc.RDLENGTH if rsc.RDLENGTH > 0: opt = DNSOPT.from_bytes(rsc.RDATA) rsc.options.append(opt) """ return rsc def __repr__(self): t = '== DNSOPTResource ==\r\n' t+= 'NAME: %s\r\n' % self.NAME.name t+= 'TYPE: %s\r\n' % self.TYPE.name t+= 'UDPSIZE : %d\r\n' % self.UDPSIZE t+= 'EXTRCODE: %s\r\n' % self.EXTRCODE t+= 'VERSION: %s\r\n' % self.VERSION t+= 'DO: %s\r\n' % repr(self.DO) t+= 'RDLENGTH: %d\r\n' % self.RDLENGTH t+= 'RDATA: %s\r\n' % repr(self.RDATA) return t def to_bytes(self): t = self.NAME.to_bytes() t += self.TYPE.value.to_bytes(2, byteorder = 'big', signed = False) t += self.UDPSIZE.to_bytes(2, byteorder = 'big', signed = False) t += self.EXTRCODE.to_bytes(1, byteorder = 'big', signed = False) t += self.VERSION.to_bytes(1, byteorder = 'big', signed = False) a = self.Z a |= int(self.DO) << 15 t += a.to_bytes(2, byteorder = 'big', signed = False) t += self.RDLENGTH.to_bytes(2, byteorder = 'big', signed = False) t += self.RDATA return t class DNSResource(): def __init__(self): self.NAME:DNSName = None self.TYPE:DNSType = None self.CLASS:DNSClass = None self.CFLUSH:bool = None self.TTL:int = None self.RDLENGTH:int = None self.RDATA:bytes = None #this method will parse the Resource object until RDATA, which will be parsed by the object inheriting it def parse_header(self, buff): self.NAME = DNSName.from_buffer(buff) self.TYPE = DNSType(int.from_bytes(buff.read(2), byteorder = 'big', signed = False)) temp = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) self.CLASS = DNSClass(temp & 0x7fff) self.CFLUSH = bool((temp & 0x8000) >> 15) self.TTL = int.from_bytes(buff.read(4), byteorder = 'big', signed = False) self.RDLENGTH = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) #this is here to support proxying of packets pos = buff.tell() self.RDATA = buff.read(self.RDLENGTH) buff.seek(pos, io.SEEK_SET) return @staticmethod def from_bytes(bbuff): return DNSResource.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): res = DNSResource() res.parse_header(buff) res.RDATA = buff.read(res.RDLENGTH) return res def to_bytes(self): t = self.NAME.to_bytes() t += self.TYPE.value.to_bytes(2, byteorder = 'big', signed = False) a = self.CLASS.value a |= int(self.CFLUSH) << 15 t += a.to_bytes(2, byteorder = 'big', signed = False) t += self.TTL.to_bytes(4, byteorder = 'big', signed = False) t += self.RDLENGTH.to_bytes(2, byteorder = 'big', signed = False) t += self.RDATA return t def construct(self, rname, rtype, rdata, ttl = 30, rclass = DNSClass.IN, cflush = False): res = DNSResource() res.NAME = DNSName.construct(rname) res.TYPE = rtype res.CLASS = rclass res.CFLUSH = cflush res.TTL = ttl res.RDATA = rdata return res def __repr__(self): t = '== DNSResource ==\r\n' t+= 'NAME: %s\r\n' % self.NAME.name t+= 'TYPE: %s\r\n' % self.TYPE.name t+= 'CLASS : %s\r\n' % self.CLASS.name t+= 'CFLUSH: %s\r\n' % self.CFLUSH t+= 'TTL: %s\r\n' % self.TTL t+= 'RDLENGTH: %s\r\n' % self.RDLENGTH t+= 'RDATA: %s\r\n' % repr(self.RDATA) return t #the logic here is: all resource types contain different data in the RDATA filed #we describe the custom data for each and every different type #and define a new object inheriting for the base object class DNSAResource(DNSResource): def __init__(self): DNSResource.__init__(self) self.ipaddress:ipaddress.IPv4Address = None @staticmethod def from_bytes(bbuff): return DNSAResource.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): res = DNSAResource() res.parse_header(buff) res.ipaddress = ipaddress.IPv4Address(buff.read(res.RDLENGTH)) return res @staticmethod def construct(rname, ipv4, ttl = 3000, rclass = DNSClass.IN, cflush = False): res = DNSAResource() res.NAME = DNSName.construct(rname) res.TYPE = DNSType.A res.CLASS = rclass res.CFLUSH = cflush res.TTL = ttl res.ipaddress = ipv4 res.RDATA = res.ipaddress.packed res.RDLENGTH = len(res.RDATA) #should be 4 return res def __repr__(self): t = '=== DNS A ===\r\n' t += DNSResource.__repr__(self) t += 'IP address: %s\r\n' % str(self.ipaddress) return t class DNSAAAAResource(DNSResource): def __init__(self): DNSResource.__init__(self) self.ipaddress:ipaddress.IPv6Address = None @staticmethod def from_bytes(bbuff): return DNSAAAAResource.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): res = DNSAAAAResource() res.parse_header(buff) res.ipaddress = ipaddress.IPv6Address(buff.read(res.RDLENGTH)) return res @staticmethod def construct(rname, ipv6, ttl = 3000, rclass = DNSClass.IN, cflush = False): res = DNSAAAAResource() res.NAME = DNSName.construct(rname) res.TYPE = DNSType.AAAA res.CLASS = rclass res.CFLUSH = cflush res.TTL = ttl res.ipaddress = ipv6 res.RDATA = res.ipaddress.packed res.RDLENGTH = len(res.RDATA) #should be 16 return res def __repr__(self): t = '=== DNS AAAA ===\r\n' t += DNSResource.__repr__(self) t += 'IP address: %s\r\n' % str(self.ipaddress) return t class DNSPTRResource(DNSResource): def __init__(self): DNSResource.__init__(self) self.domainname:DNSName = None @staticmethod def from_bytes(bbuff): return DNSPTRResource.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): res = DNSPTRResource() res.parse_header(buff) res.domainname = DNSName.from_buffer(buff) return res @staticmethod def construct(rname, domainname, ttl = 3000, rclass = DNSClass.IN, cflush = False): res = DNSPTRResource() res.NAME = DNSName.construct(rname) res.TYPE = DNSType.PTR res.CLASS = rclass res.CFLUSH = cflush res.TTL = ttl res.domainname = domainname res.RDATA = DNSName.construct(res.domainname) res.RDLENGTH = len(res.RDATA) #should be 16 return res def __repr__(self): t = '=== DNS PTR ===\r\n' t += DNSResource.__repr__(self) t += 'PTR name: %s\r\n' % str(self.domainname) return t class DNSSRVResource(DNSResource): def __init__(self): DNSResource.__init__(self) self.Service = None self.Proto = None self.Name = None self.Priority = None self.Weight = None self.Port = None self.Target = None #_Service._Proto.Name TTL Class SRV Priority Weight Port Target @staticmethod def from_bytes(bbuff): return DNSSRVResource.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): res = DNSSRVResource() res.parse_header(buff) try: if res.NAME.name.count('.') == 4: res.Service, res.Proto, res.Name, tld = res.NAME.name.split('.') print(res.Service, res.Proto, res.Name, tld) else: res.Service = res.NAME.name except Exception as e: print(res.NAME.name) raise(e) res.Priority = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) res.Weight = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) res.Port = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) res.Target = DNSName.from_buffer(buff) return res def __repr__(self): t = '=== DNS SRV ===\r\n' t += DNSResource.__repr__(self) t += 'Priority: %s\r\n' % str(self.Priority) t += 'Weight: %s\r\n' % str(self.Weight) t += 'Port: %s\r\n' % str(self.Port) t += 'Target: %s\r\n' % str(self.Target) return t class DNSSOAResource(DNSResource): def __init__(self): DNSResource.__init__(self) self.MNAME = None self.RNAME = None self.SERIAL = None self.REFRESH = None self.RETRY = None self.EXPIRE = None self.MINIMUM = None @staticmethod def from_bytes(bbuff): return DNSSOAResource.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): res = DNSSOAResource() res.parse_header(buff) res.MNAME = DNSName.from_buffer(buff) res.RNAME = DNSName.from_buffer(buff) res.SERIAL = int.from_bytes(buff.read(4), byteorder = 'big', signed = False) res.REFRESH = int.from_bytes(buff.read(4), byteorder = 'big', signed = False) res.RETRY = int.from_bytes(buff.read(4), byteorder = 'big', signed = False) res.EXPIRE = int.from_bytes(buff.read(4), byteorder = 'big', signed = False) res.MINIMUM = int.from_bytes(buff.read(4), byteorder = 'big', signed = False) return res class DNSResourceParser: @staticmethod def from_bytes(bbuff): return DNSResourceParser.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): pos = buff.tell() resname = DNSName.from_buffer(buff) restype = DNSType(int.from_bytes(buff.read(2), byteorder = 'big', signed = False)) #Extended dns? if restype == DNSType.OPT: buff.seek(pos, io.SEEK_SET) return DNSOPTResource.from_buffer(buff) #nope. else: #rewinding the buffer buff.seek(pos, io.SEEK_SET) #now parse for various types if restype == DNSType.A: rsc = DNSAResource.from_buffer(buff) elif restype == DNSType.AAAA: rsc = DNSAAAAResource.from_buffer(buff) elif restype == DNSType.PTR: rsc = DNSPTRResource.from_buffer(buff) elif restype == DNSType.SRV: rsc = DNSSRVResource.from_buffer(buff) elif restype == DNSType.SOA: rsc = DNSSOAResource.from_buffer(buff) #catch-all for not fully implemented or unknown types #feel free to expand the if-else statement above... else: rsc = DNSResource.from_buffer(buff) return rsc class DNSName(): def __init__(self, name:str = ''): self.name = name #variables below are for parsing only self.compressed = False self.compressed_pos = None self.compressed_done = False @staticmethod def from_bytes(bbuff): return DNSName.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): dnsname = DNSName() dnsname.parse(buff) return dnsname def parse(self, data, rec = False): #this code is ugly :( if self.compressed_done: return temp = data.read(1)[0] if not self.compressed: self.compressed = (temp & 0xC0) >> 6 == 0x3 if self.compressed: data.seek(-1, io.SEEK_CUR) self.compressed_pos = data.tell() temp = int.from_bytes(data.read(2), byteorder = 'big', signed = False) ptr = temp & 0x3fff data.seek(ptr, io.SEEK_SET) self.parse(data, rec) data.seek(self.compressed_pos + 2, io.SEEK_SET) self.compressed_done = True return length = temp if length == 0: return if length < 63: if rec: self.name += '.' + data.read(length).decode() else: self.name += data.read(length).decode() self.parse(data, True) @staticmethod def construct(name): dnsname = DNSName() dnsname.name = name return dnsname def to_bytes(self): #not using compression here! implement yourself and do a PR please #will give you chokolate t = b'' for label in self.name.split('.'): t += len(label).to_bytes(1, byteorder = 'big', signed = False) t += label.encode() if self.name.endswith('.') is False: t += b'\x00' return t def __repr__(self): return self.name """ def decode_NS(self, encoded_name): #encoded http://www.ietf.org/rfc/rfc1001.txt transform = [((i - 0x41)& 0x0F) for i in encoded_name] i = 0 while i < len(transform): self.QNAME += chr(transform[i] << 4 | transform[i+1] ) i+=2 """