def get_server_name_ip(server):
if re.compile("^\d+.\d+.\d+.\d+$").findall(server) or re.compile("^([^\.]+\.(?:[^\.]+\.)?(?:\w+)?)$").findall(server):
server_ip = server
server_name = None
else:
server_ip = None
server_name = server.upper()
if not server_ip: server_ip = NetBIOS().queryName(server_name)[0]
if not server_name: server_name = NetBIOS().queryIPForName(server_ip)[0]
return server_name, server_ip
def get_server_name_ip(server):
import re
if re.compile("^\d+.\d+.\d+.\d+$").findall(server):
server_ip = server
server_name = None
else:
server_ip = None
server_name = server.upper()
if not server_ip: server_ip = NetBIOS().queryName(server_name)[0]
if not server_name: server_name = NetBIOS().queryIPForName(server_ip)[0]
return server_name, server_ip
def dowload_latest_image(sysConf):
serverIP = sysConf.imgServer['IP']
netbios = NetBIOS()
serverName = netbios.queryIPForName(serverIP)
conn = SMBConnection(sysConf.imgServer['USER'],
sysConf.imgServer['PASSWORD'],
my_name="BMC_Tester",
remote_name=serverName[0],
domain="COMPAL")
if (False == conn.connect(serverIP)):
return None
platformImage = "BMC/Daily_Build/" + sysConf.platform
path = conn.listPath(sysConf.imgServer['ROOT'], platformImage)
sortedFile = sorted(path, key=attrgetter('create_time'))
lastFile = sortedFile[len(sortedFile) - 1]
imagePath = os.getcwd() + "/download"
if not os.path.exists(imagePath):
os.mkdir(imagePath)
image = open(imagePath + "/" + lastFile.filename, "wb")
print("\tDownloading %s to %s ....." %
(lastFile.filename, imagePath + "/" + lastFile.filename))
conn.retrieveFile(sysConf.imgServer['ROOT'],
platformImage + "/" + lastFile.filename, image)
image.close()
return lastFile.filename
def _test_connectivity(self, param):
config = self.get_config()
ip = config['ip']
port = int(param.get('port', 137))
timeout = int(param.get('timeout', 30))
action_result = ActionResult(dict(param))
self.add_action_result(action_result)
self.save_progress("Looking up IP : {0} to test connectivity".format(ip))
nb = NetBIOS()
hosts = nb.queryIPForName(ip, port, timeout)
if hosts is None:
self.save_progress("Request timed out")
self.save_progress("Test Connectivity Failed")
return action_result.set_status(phantom.APP_ERROR)
if hosts:
self.save_progress("Got {0} hosts".format(len(hosts)))
self.save_progress("Test Connectivity Passed")
return action_result.set_status(phantom.APP_SUCCESS)
self.save_progress("Lookup did not return any results, but connectivity passed")
return action_result.set_status(phantom.APP_SUCCESS)
def get_server_name_ip(server):
if re.compile("^\d+.\d+.\d+.\d+$").findall(server) or re.compile("^([^\.]+\.(?:[^\.]+\.)?(?:\w+)?)$").findall(server):
server_ip = server
server_name = None
else:
server_ip = None
server_name = server.upper()
if not server_ip: server_ip = NetBIOS(broadcast=False).queryName(server_name, timeout=5)
if isinstance(server_ip, (list, tuple)) and len(server_ip) > 0: server_ip = server_ip[0]
if not server_ip: server_ip = ''
if not server_name: server_name = NetBIOS(broadcast=False).queryIPForName(server_ip, timeout=5)
if isinstance(server_name, (list, tuple)) and len(server_name) > 0: server_name = server_name[0]
if not server_name: server_name = ''
return server_name, server_ip
def run(self):
print "Starting thread for " + self.ip
net = NetBIOS()
net_name = str(net.queryIPForName(self.ip)).strip("['").strip("']")
net.close()
conn = SMBConnection(self.user,
self.pwd,
'cobwebs',
net_name,
domain=self.domain,
use_ntlm_v2=False)
if conn.connect(self.ip, port=139, timeout=10):
print(
"Connecting to %s was successful! How about a nice game of spidering %s%s?"
% (self.ip, self.share, self.subfolder))
else:
print("Connection error: %s" % (self.ip))
if self.recursive > 0:
recurse(conn, self.ip, self.share, self.subfolder, self.pattern,
int(self.recursive))
else:
filelist = conn.listPath(self.share, self.subfolder)
dir_list(filelist, self.ip, self.subfolder, self.pattern)
conn.close()
print "Exiting thread for " + self.ip
def performTest(self):
if(not self.smb):
randomUser = ''.join(random.choice(string.ascii_lowercase) for _ in range(12))
randomPass = ''.join(random.choice(string.ascii_lowercase) for _ in range(12))
print("%sPerforming test request to benchmark failed attempt...%s" % (Y,W))
if(not self.ntlm):
self.test_response = self.performRequest(randomUser, randomPass)
else:
self.test_response = self.performNTLMRequest(randomUser, randomPass)
self.test_hexDigest = self.getHashFromResponse(self.test_response)
if(self.test_response.status_code == 400):
print("%sTest request returned status code " % (R) + str(self.test_response.status_code) + "%s" % (W))
if(input("Are you sure you want to continue? (y/N) ") != 'y'):
sys.exit("Unsatisfactory HTTP response code.")
else:
print("%sTest request did not return 400, moving on.%s\n" % (G,W))
else:
print("%sAttempting to reach machine for SMB login...%s" % (Y,W))
n = NetBIOS()
ip = n.queryIPForName(self.ip)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((self.ip, 445))
s.shutdown(2)
print("%sMachine is available on port 445, moving on.%s\n" % (G,W))
except:
print("%sCan't reach machine on port 445" % (R) + str(self.test_response.status_code) + "%s" % (W))
if(input("Are you sure you want to continue? (y/N) ") != 'y'):
sys.exit("Double check IP and port 445 open.")
return False
def authenticate(self):
from smb.SMBConnection import SMBConnection
# There will be some mechanism to capture userID, password, client_machine_name, server_name and server_ip
# client_machine_name can be an arbitary ASCII string
# server_name should match the remote machine name, or else the connection will be rejected
#userID = 'xatportantier'
userID = 'guest'
#password = '******'
password = ''
client_machine_name = 'fmp'
server_ip = '192.1.3.120'
server_name = 'Server72'
server_name = ''
from nmb.NetBIOS import NetBIOS
nb = NetBIOS(broadcast=True, listen_port=0)
#print('ip', nb.queryName(server_name, port=445))
#print('name', nb.queryIPForName(server_ip))
conn = SMBConnection(userID, password, client_machine_name, server_name, use_ntlm_v2=True, is_direct_tcp=False)
from pprint import pprint
for a in [ 'capabilities', 'domain', 'host_type', 'log', 'my_name', 'remote_name', 'security_mode', 'uid', 'username' ]:
print(a, getattr(conn, a))
#print('cap', conn.capabilities)
#print('domain', conn.domain)
print('auth', conn.connect(server_ip, 139))
def connect(self):
inventory = Inventory()
address = self.hostname
if inventory.has_option(self.hostname, 'address'):
address = inventory.get(self.hostname, 'address')
ip = None
nb_name = None
try:
socket.inet_aton(address)
ip = address
except OSError as e:
nb_name = address
nb = NetBIOS()
if ip is not None and nb_name is None:
# need to look up the hostname
logger.debug('Looking up NetBIOS name from IP ' + ip)
nb_names = nb.queryIPForName(ip)
if nb_names is None or len(nb_names) < 1:
raise RuntimeError('Cannot connect to host ' + self.hostname +
'; looking up NetBIOS name failed')
nb_name = nb_names[0]
elif ip is None and nb_name is not None:
# not a IPv4 address, need to look up the ip
nb_name = address
logger.debug('Looking up NetBIOS IP from name ' + nb_name)
ips = nb.queryName(nb_name)
if ips is None or len(ips) < 1:
raise RuntimeError('Cannot connect to host ' + self.hostname +
'; looking up NetBIOS IP failed')
ip = ips[0]
nb.close()
if inventory.has_option(self.hostname,
'username') and inventory.has_option(
self.hostname, 'password'):
username = inventory.get(self.hostname, 'username')
password = inventory.get(self.hostname, 'password')
client_machine_name = ''.join(
random.choice(string.ascii_letters + string.digits)
for _ in range(15))
logger.debug('Using client name of ' + client_machine_name)
logger.info('Connecting to ' + nb_name + ' as ' + username +
' for host ' + self.hostname)
self.connection = SMBHost(username,
password,
client_machine_name,
nb_name,
use_ntlm_v2=True,
sign_options=SMBHost.SIGN_WHEN_SUPPORTED
) #, is_direct_tcp=True)
if not self.connection.connect(ip):
raise RuntimeError('Cannot connect to host ' + self.hostname +
'; connecting via SMB failed')
else:
raise RuntimeError('No method of authenticating with host ' +
self.hostname + ' found')
print(str(self.connection.listPath('ADMIN$', '\\')))
def getServerName(IP):
try:
server = NetBIOS()
servername = server.queryIPForName(IP)
return servername[0]
except:
print(Fore.RED+"You need to porvide the remote computer or server name")
exit(0)
def ip2hostname(ip):
nb = NetBIOS(broadcast=True, listen_port=0)
try:
hostname = nb.queryIPForName(str(ip), port=137, timeout=10)
hostname = hostname[0]
except:
print 'hostname get fail please use -n'
exit(0)
return str(hostname)
def get_netbios_name(remote_addr):
nb = NetBIOS()
names = nb.queryIPForName(remote_addr)
nb.close()
if len(names) == 0:
raise NameError('No NetBIOS name found for {}'.format(remote_addr))
elif len(names) > 1:
logging.warn('More than one NetBIOS name for {}'.format(remote_addr))
return names[0]
def get_netbios_name(remote_addr, timeout=DEFAULT_TIMEOUT):
nb = NetBIOS()
names = nb.queryIPForName(remote_addr, timeout=timeout)
nb.close()
if names is None or len(names) == 0:
raise NameError('No NetBIOS name found for {}'.format(remote_addr))
elif len(names) > 1:
logging.warn('More than one NetBIOS name for {}'.format(remote_addr))
return names[0]
def getBIOSName(timeout=30):
try:
bios = NetBIOS()
srv_name = bios.queryIPForName('172.25.73.100', timeout=timeout)
except:
print("Looking up timeout, check remote_smb_ip again!!", sys.stderr)
finally:
bios.close()
return srv_name
def getBIOSName(remote_smb_ip, timeout=30):
try:
bios = NetBIOS()
srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
except:
print(sys.stderr, "Looking up timeout, check remote_smb_ip again!!")
finally:
bios.close()
return srv_name
def getBIOSName(remote_smb_ip, timeout=5):
try:
bios = NetBIOS()
srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
except:
print 'getBIOSName: timeout too short?'
finally:
bios.close()
#print 'bios name = ' + srv_name[0]
return srv_name[0]
def getServerName(self, remote_smb_ip, timeout=30):
bios = NetBIOS()
srv_name = None
try:
srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
except:
log.err(
"Couldn't find SMB server name, check remote_smb_ip again!!")
finally:
bios.close()
return srv_name
def reverse_host(host, timeout=1, save=True):
n = NetBIOS()
try:
host.hostname = n.queryIPForName(host.ip_address, timeout=timeout)[0]
except:
pass
n.close()
host.reverse_latest_time = timezone.datetime.now()
if save:
host.save()
return host
def get_netbios_name(hostname):
if hostname in ["127.0.0.1", "localhost"]:
return "localhost"
n = NetBIOS()
resp = n.queryIPForName(hostname)
if resp:
return resp[0]
else:
# Default to first part of hostname
# eg: smbsrv01.example.com -> smbsrv01
dns_name = socket.gethostbyaddr(hostname)[0] # "nslookup"
return dns_name.split(".")[0]
def get_BIOSName(self, host, timeout=30):
try:
bios = NetBIOS()
srv_name = bios.queryIPForName(host, timeout=timeout)
except Exception as e:
logger.error("Looking up timeout, check remote_smb_ip again. %s" %
str(e))
finally:
bios.close()
return srv_name
def clean_up(ip, share, subfolder, user, pwd, domain):
net = NetBIOS()
net_name = str(net.queryIPForName(ip)).strip("['").strip("']")
net.close()
conn = SMBConnection(user, pwd, 'cobwebs', net_name, domain=domain, use_ntlm_v2=True, is_direct_tcp=True)
if conn.connect(ip, port=445, timeout=10):
print(Fore.GREEN+"[+] Connection to %s Successful! Cleaning up SCF's Now!" % ip + Style.RESET_ALL)
else:
print(Fore.RED+"[!] Connection to %s Failed!" % ip + Style.RESET_ALL)
delete_file(conn, ip, subfolder, share)
conn.close()
def getBIOSName(remote_smb_ip, timeout=30):
# 通过IP地址，查找smb服务器的名称
srv_name = None
bios = NetBIOS()
try:
srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
except:
print "查找samba服务器的名称时超时。"
finally:
bios.close()
return srv_name
def __resolve__(self, server:str): # str | None
# If no valid IP adres, try to obtain it
# First as netBIOS on LAN
nb = NetBIOS(broadcast=True, listen_port=0)
# Send a query on the network and hopes that if machine matching the name will reply with its IP address.
res = nb.queryName(server, ip='', port=NETBIOS_PORT, timeout=NETBIOS_TIMEOUT)
if isinstance(res, list) and len(res) > 0 and isinstance(res[0], str) and self.isIP4(res[0]):
return res[0]
# Try to DNS resolve
try:
return socket.gethostbyname(server)
except socket.gaierror as sge:
# Nope, didn't work
return None
def getBIOSName(remote_smb_ip, timeout=5):
# Devuelvo el nombre NetBios de una máquina remota
from nmb.NetBIOS import NetBIOS
Aux = 'ERROR'
try:
bios = NetBIOS()
srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
Aux = srv_name[0]
except:
print 'No es posible conocer el nombre NETBIOS del servidor ' + remote_smb_ip + ' en el tiempo ' + str(
timeout)
finally:
bios.close()
return Aux
def __init__(self, session, iface, plugin_path):
Screen.__init__(self, session)
self.skin_path = plugin_path
self.session = session
self.iface = iface or 'eth0'
for service in eNetworkManager.getInstance().getServices():
key = self.getServiceIF(service)
if key:
self.iface = key
break
self.networklist = []
self.expanded = []
self.cache_ttl = 604800 #Seconds cache is considered valid, 7 Days should be ok
self.cache_file = eEnv.resolve(
"${sysconfdir}/enigma2/networkbrowser.cache"
) #Path to cache directory
self._nrthreads = 0
self._netbios = NetBIOS(broadcast=False)
self._ipv4 = iNetworkInfo.getConfiguredInterfaces()[self.iface].ipv4
self._myhostname = self._lookupHostname(self._ipv4.address, local=True)
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Mounts"))
self["key_yellow"] = StaticText(_("Rescan"))
self["key_blue"] = StaticText(_("Expert"))
self["infotext"] = StaticText(_("Press OK to mount!"))
self["shortcuts"] = ActionMap(
["ShortcutActions", "WizardActions"], {
"ok": self.go,
"back": self.close,
"red": self.close,
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
})
self.list = []
self.statuslist = []
self.listindex = 0
self["list"] = List(self.list)
self["list"].onSelectionChanged.append(self._onSelectionChanged)
self.onLayoutFinish.append(self.startRun)
self.onShown.append(self.setWindowTitle)
self.onClose.append(self.cleanup)
self.Timer = eTimer()
self.Timer_conn = self.Timer.timeout.connect(self.TimerFire)
def getBIOSName(self, remote_smb_ip, timeout=5): # unused if dynamic IP
# ip -> smb name
try:
self.error = None
bios = NetBIOS()
srv_name = bios.queryIPForName(remote_smb_ip, timeout=timeout)
return srv_name[0]
except Exception as e:
if self.print_errors:
print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
type(e).__name__, e)
else:
self.error = 'Error on line {}'.format(
sys.exc_info()[-1].tb_lineno) + str(
type(e).__name__) + str(e)
return None
def getIP(self):
# smb name -> ip
try:
self.error = None
bios = NetBIOS()
ip = bios.queryName(self.smb_name)
return ip[0]
except Exception as e:
if self.print_errors:
print('Error on line {}'.format(sys.exc_info()[-1].tb_lineno),
type(e).__name__, e)
else:
self.error = 'Error on line {}'.format(
sys.exc_info()[-1].tb_lineno) + str(
type(e).__name__) + str(e)
return None
def get_name(target, timeout=5):
logger.blue('Getting NetBIOS Name for {}'.format(logger.BLUE(target)))
logger.verbose('Timeout for NetBIOS resolution: '+str(timeout))
bios = NetBIOS()
try:
tmpnetbios_name = bios.queryIPForName(target, timeout=timeout)
netbios_name = str(tmpnetbios_name[0])
except:
netbios_name = None
bios.close()
if netbios_name == None:
logger.red_indent('Failed to get NetBIOS Name')
return None
else:
logger.green_indent('Got NetBIOS Name: {}'.format(
logger.GREEN(netbios_name)))
return str(netbios_name)
def get_name(target, timeout=2):
logger.live_info('[{}]:\tATTEMPTING NETBIOS NAME'.format(logger.BLUE(target)))
# logger.verbose('Timeout for NetBIOS resolution: '+str(timeout))
logger.verbose('[{}]:\tNETBIOS TIMEOUT: {}'.format(logger.YELLOW(target),logger.YELLOW(str(timeout))))
bios = NetBIOS()
try:
tmpnetbios_name = bios.queryIPForName(target, timeout=timeout)
netbios_name = str(tmpnetbios_name[0])
except:
netbios_name = None
bios.close()
if netbios_name == None:
logger.live_bad('[{}]:\tNETBIOS NAME: {}'.format(logger.RED(target),logger.RED('FAILED')))
return None
else:
logger.green('[{}]:\tNETBIOS NAME: {}'.format(logger.GREEN(target),logger.GREEN(netbios_name)))
return str(netbios_name)
def run(options):
ip = options['ip']
port = options['port']
username = options['username']
password = options['password']
test = random.choice(config.SMB_FILES)
expected = test['checksum']
try:
n = NetBIOS()
hostname = n.queryIPForName(ip)[0]
n.close()
conn = SMBConnection(username, password, '', hostname, config.DOMAIN)
conn.connect(ip, port)
t = tempfile.TemporaryFile()
conn.retrieveFile(test['sharename'], test['path'], t)
except (SMBTimeout, socket.timeout):
logger.debug('Timeout')
return False
except NotReadyError:
logger.debug(ERROR_STRINGS['NotReadyError'] % (username, password))
return False
except (NotConnectedError, UnsupportedFeature, ProtocolError, OperationFailure) as e:
name = e.__class__.__name__
if name in ERROR_STRINGS:
logger.debug(ERROR_STRINGS[name] % e)
else:
logger.debug('%s: %s' % (name, e))
return False
sha1 = hashlib.sha1()
t.seek(0)
sha1.update(t.read())
t.close()
checksum = sha1.hexdigest()
if checksum == expected:
return True
else:
logger.debug('Check failed: output: %s | expected: %s' % (checksum, expected))
return False
