def worker(modo):
"""Realiza el trabajo"""
global equipos
for equipo in equipos:
if modo == 'ping':
host = ping(equipo, count=4, interval=1, timeout=2)
if host.is_alive:
print(
f'Host:{host.address} RTT_min:{host.min_rtt} RTT_prom:{host.avg_rtt} RTT_max:{host.max_rtt} P_enviados:{host.packets_sent} P_recibidos:{host.packets_received} P_perdidos:{host.packet_loss}'
)
else:
print(f'Host:{host.address} no responde!')
if modo == 'traceroute':
hops = traceroute(equipo,
count=3,
interval=0.05,
timeout=1,
max_hops=30,
fast_mode=True)
print('_' * 20)
print(f'Host:{equipo}')
print('Distancia (ttl) Address RTT_prom')
last_distance = 0
for hop in hops:
if last_distance + 1 != hop.distance:
print(f'* * * * * *')
print(f'{hop.distance} {hop.address} {hop.avg_rtt} ms')
last_distance = hop.distance
print('Traza completa')
def check_device_status(self, address):
"""
Returns True if host (str) responds to a ping request.
Remember that a host may not respond to a ping (ICMP) request even if the host name is valid.
"""
host = ping(address, count=1, interval=0.2)
return host.is_alive
def ping_host(hostname):
if os.geteuid() == 0:
host = ping(hostname, count=3, privileged=True)
return {
'anchor': hostname.split('.')[0],
'min_rtt': host.min_rtt,
'max_rtt': host.max_rtt,
'jitter': host.jitter,
'packet_loss': host.packet_loss
}
else:
p = subprocess.Popen(shlex.split(f'ping -c3 {hostname}'),
stdout=subprocess.PIPE)
output = p.stdout.read()
for line in output.decode('utf-8').split('\n'):
if 'packets transmitted' in line:
transmitted = line
if line.startswith('rtt min'):
rtt = line
packet_loss = float(transmitted.split(',')[2].split('%')[0].strip())
min_rtt, _, max_rtt, jitter = map(
float,
rtt.split('=')[1].strip().split(' ')[0].split('/'))
return {
'anchor': hostname.split('.')[0],
'min_rtt': min_rtt,
'max_rtt': max_rtt,
'jitter': jitter,
'packet_loss': packet_loss
}
def __init__(self, source_host, port=50000, target=None):
"""
Creates a metasploit class to connect and use metasploit functionality.
Args:
source_host (str): the host that uses metasploit.
port (int): on which port the msfrpc listens to.
target (str): target host to perform actions.
Raises:
MsfrpcdConnectionError: in case metasploit connection attempt has failed.
InvalidHostName: in case the provided target host name is invalid.
"""
self._source_host = source_host
try:
if target:
self._target_host = socket.gethostbyname(target)
is_target_reachable = ping(address=self._target_host, privileged=False).is_alive
if not is_target_reachable:
raise HostIsUnreachable(source_host=self._source_host, target_host=self._target_host)
except socket.gaierror:
raise InvalidHostName(invalid_host=target)
try:
self._metasploit = Metasploit(server=source_host, port=port)
except ConnectionError:
raise MsfrpcdConnectionError(host=source_host, port=port)
async def main():
try:
jar = aiohttp.CookieJar(unsafe=True)
nodes_ssh_dict: dict = {}
async for apic in FABRICS:
async with ClientSession(cookie_jar=jar) as session:
tasks = []
url = API % apic
await apic_login(session, url)
await verify_apic_faults(session, url)
impacted_devices = await verify_devices(session, url)
async for node in AsyncIterator(impacted_devices):
ssh_info = await get_ssh_ip(session, url, node)
nodes_ssh_dict.update(ssh_info)
async for node in AsyncIterator(nodes_ssh_dict):
if 'mgmtRsOoBStNode' in nodes_ssh_dict[node].keys():
node_ip = nodes_ssh_dict[node]['mgmtRsOoBStNode']
elif 'mgmtRsOoBStNode' not in nodes_ssh_dict[node].keys():
node_ip = nodes_ssh_dict[node]['mgmtRsInBStNode']
host = ping(node_ip, count=5, interval=0.2, privileged=False)
if host.is_alive:
log.info(f'Attempting SSH connection to {node} '
f'at oobMgmt {host.address}')
power_on_hrs = await query_nxos_switches(node, host.address)
# print(power_on_hrs)
else:
log.error(f'{node} is unreachable via SSH '
f'on {host.address}. Unable to verify.')
except Exception as e:
print(str(e), 'Exception happened on main')
def tn_connect(ip_remote, ftp_ip, ftp_local):
"""Connect via telnet"""
if ftp_local:
for ip_local in ips_local:
host = ping(ip_remote, count=2, interval=0.1, source=ip_local)
if host.is_alive:
ftp_path = ip_local
break
else:
ftp_path = f'{ftp_ip}/FTP'
with telnetlib.Telnet(ip_remote, 23) as tn:
tn.read_until(b'Login:'******'admin\n\r')
tn.read_until(b'Password:'******'admin\n\r')
tn.write(b'sys ver\n\r')
time.sleep(3)
result = tn.read_very_eager().decode('utf-8')
pattern = re.compile(r'SN:(\d+)')
if pattern.search(result):
sn = pattern.search(result).group(1)
if sn in licenses:
ftp_file = licenses[sn].name
ftp_command = f'license --install=ftp://anonymous:anonymous@{ftp_path}/{ftp_file}\n\r'
tn.write(ftp_command.encode('utf-8'))
time.sleep(3)
tn.write(b'co sa; rest y\n\r')
#result = tn.read_very_eager().decode('utf-8')
#print(result)
else:
print(f'ERROR: The license not found.')
def alive(address):
try:
if icmplib.ping(address):
return "%s is alive!" % address
except:
pass
return "%s is dead!" % address
def main():
# Довольно громоздкий вызов получается имхо, поэтому я параметры в словарик вытащил
# Они всё равно не меняются сейчас
ping_parameters = {
'address': config.SERVER_TO_PING,
'interval': config.INTERVAL_BETWEEN_PINGS,
'count': 1,
'timeout': config.TIMEOUT_SECONDS
}
progress = PingProgress(config.TIMEOUTS_BEFORE_FAILURE,
config.TIMEOUTS_BEFORE_SUCCESS)
progress.on_network_up = on_network_up
while True:
try:
ping_result = icmplib.ping(**ping_parameters)
if not ping_result.is_alive:
progress.fail()
print('Хост недоступен')
if ping_result.received_packets == 0:
progress.fail()
# print('Fail')
else:
progress.success()
# print('Success')
except KeyboardInterrupt:
print('Ctrl-C')
break
def isOnline(self):
"""sends every 0.5s a ping to check if host is up. Returns after first received ping."""
host = ping(self.ip,
interval=0.5,
timeout=self.ping_timeout,
privileged=False)
return host.is_alive
def ping_discovery(net=0):
"""
Função que realiza descoberta de hosts onlines na rede utilizando ping. Por padrão utiliza rede vinculada ao
hostname da máquina onde o script está sendo rodado com a máscara /24. Por exemplo, se o seu ip é 192.168.10.10,
a rede a ser utilizada no scan será 192.168.10.0/24
:param net: Opcional, Rede a ser escaneada. Se não especificado será utilizada rede do gateway padrão
:return: Lista com os endereços que responderam o ping.
"""
# if __name__ == '__main__':
target = net
try:
nethosts = ip_network(target).hosts()
iponline = []
for ip in nethosts:
ipstr = str(ip)
pingresult = ping(ipstr)
if pingresult.is_alive:
iponline.append(pingresult.address)
return iponline
except KeyboardInterrupt:
print(
'\nO usuário preferiu interromper a execução, portanto o retorno será 0'
)
return 0
except:
print("Tente digitar a rede no formato 172.16.0.0/24")
def newClient():
nonlocal threadPingData
# starting the fake client and connecting to the server
f_client = socket.socket()
# f_client.settimeout(1)
hostip = socket.gethostbyname(socket.gethostname())
f_client.connect((hostip, 54321))
# saving response
response = f_client.recv(1024).decode()
pingData = str(response).split(",", 3)
pingData = ping(pingData[0], int(pingData[1]), int(pingData[2]),
int(pingData[3]))
with lock:
# saving the ping data for later processing
threadPingData.append(pingData)
time.sleep(2)
# telling the client to stop the attack
f_client.sendall("n".encode('ascii', 'strict'))
if len(threadPingData) == 2:
sys.exit()
def alive(address): try: if icmplib.ping(address): return "%s is alive!" % address except: pass return "%s is dead!" % address
async def on_message(message):
global bot_busy
if not bot_busy:
if message.author != client.user:
if message.content.startswith("$ctp"):
bot_busy = True
async with message.channel.typing():
await message.channel.send("{} requested command!".format(
message.author))
await message.channel.send(
"Checking if Tsu can play! Please wait...")
# Capture initial time when starting timer. NOTE: time.perf.counter() returns time in seconds. So
# simply multiply by 1000 to get milliseconds! \o/
timer_init = time.perf_counter()
# icmplib.ping(address, count=4, interval=1, timeout=2)
ping_object = icmplib.ping("8.8.8.8", 10, 1, 2)
prep_str = "Max: %d ms\nMin: %d ms\nDropped Packets: %d\nAverage Latency: %d ms" % (
ping_object.max_rtt, ping_object.min_rtt,
ping_object.packet_loss, ping_object.avg_rtt)
await message.channel.send(prep_str)
# Calculate the duration of the timer.
time_passed_ms = round((time.perf_counter() - timer_init),
2)
await message.channel.send(
"Command processed in: {} seconds.".format(
time_passed_ms))
else:
await message.channel.send("Sorry, {}! Bot busy: {}".format(
message.author, bot_busy))
def deepScan():
prefixoIP = str(file.get("Rede", "prefixip"))
faixaDeIp = str(file.get("Rede", "faixaip"))
ipStart = input("Digite o IP inicial: ")
ipEnd = input("Digite o IP Final: ")
if ((int(ipStart) <= 0) or (int(ipEnd) > 254)):
print("IP inválido!")
else:
for cont in ipEnd:
cont = int(cont) + 1
hostRemoto = ping(prefixoIP + '.' + faixaDeIp + '.' + str(cont),
count=2,
interval=1)
print(prefixoIP + faixaDeIp + str(cont))
if hostRemoto.is_alive == True:
print("Online!")
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as scan:
try:
temposocket = file.get("Rede", "timesocket")
socket.setdefaulttimeout(float(temposocket))
scan.connect((ip, 5900))
print("VNC Ok")
scan.close()
finally:
menu.opcoes()
def check_alive(self):
ping_res = ping('www.starlink.com', count=3, interval=0.1, timeout=1)
#ping_res = ping(self.data["host"], count=3, interval=0.1, timeout=1)
self.data["is_alive"] = ping_res.is_alive
if ping_res.is_alive:
self.data['last_seen_alive'] = datetime.now().strftime("%H:%M:%S")
return ping_res.is_alive
def PingNetwork(Endereco):
hos = ping(Endereco, count=32, interval=0.5, timeout=1)
print(f"IP:{hos.address}")
print(f"Min:{hos.min_rtt}ms")
print(f"Med:{hos.avg_rtt}ms")
print(f"Max:{hos.max_rtt}ms")
print(f"Enviados:{hos.packets_sent}")
print(f"Recebido:{hos.packets_received}")
print(f"Perda:{hos.packet_loss}")
print(f"Host:{hos.is_alive}")
print(xy.strftime("%X"))
print(xy.strftime("%x"))
Result = {
"Domain": Endereco,
"Ip": hos.address,
"Ping-Min": hos.min_rtt,
"Ping-Avg": hos.avg_rtt,
"Ping-Max": hos.max_rtt,
"PacketsSent": hos.packets_sent,
"PacketsReceived": hos.packets_received,
"Loss": hos.packet_loss,
"Accessible host": hos.is_alive,
"Date": xy.strftime("%x"),
"hora": xy.strftime("%X")
}
with open('return/Ping.json', 'w') as json_file:
json.dump(Result, json_file, indent=4)
json_file.close()
return "Network Ok 01"
def latency(dest):
"""Calculate the internet latency stats based on ICMP.
This method uses icmp echo request/response and calculate the average rtt, packet loss and jitter.
Args:
dest (string): hostname or IP address
"""
PING_REQUESTS.inc()
try:
with PING_FAILURES.count_exceptions():
LOGGER.debug("PING - destination: " + str(dest))
host = ping(str(dest), count=2, interval=0.5)
PING_LATENCY.observe(host.avg_rtt / 1000)
PING_PACKET_LOSS.inc(host.packet_loss)
PING_JITTER.set((host.max_rtt - host.min_rtt) / 1000)
LOGGER.debug("PING - max_rtt: " + str(host.max_rtt))
LOGGER.debug("PING - min_rtt: " + str(host.min_rtt))
LOGGER.debug("PING - avg_rtt: " + str(host.avg_rtt))
LOGGER.debug("PING - packet_loss: " + str(host.packet_loss))
UP.set(1)
except Exception as e:
LOGGER.error("Could not process ICMP Echo requests: %s", e)
UP.set(0)
def ping_retry(addr: str, ttl: int) -> bool:
if ttl <= 0:
return False
if not ping(addr, count=1).is_alive:
return ping_retry(addr, ttl - 1)
return True
def fnTestConnectivity(siteAddress):
objHost = ping(address=siteAddress, count=1)
if objHost.is_alive:
return "Address {}, ({}), can be reached".format(
siteAddress, objHost.address)
else:
return "No connection to {}".format(siteAddress)
def pinging(adres): #metoda pingowanie adresu ip
global name_text
tab_ip = {
"192.168.1.1": "serwer1",
"192.168.1.2": "serwer2",
"192.168.1.3":
"serwer3", #slownik zawierajacy adresy IP przypisanych do serwerów lub innych urządzeń sieciowych
"192.168.1.4": "serwer4",
"192.168.1.5": "serwer5",
"192.168.1.6": "serwer6",
}
host = ping(adres, count=1) #ping 1 raz wysłanie 1 pakietu
if host.packet_loss: #jezeli brak odpowiedzi to jest wykonywana kolejna linia kodu
host = ping(adres, count=5) #ping 5 razy wysłanie 5 pakietów
if host.packet_loss > 0.5: #jezeli jest wiecej niz połowa (w procentach liczone) utracona to jest wykonywana kolejna linia kodu
# name_text = tab_ip[adres] # przypisanie do zmiennej wartosci o kluczu krórym jest adres ip a vartosc to nazwa serwera
warnings.append(Host(adres, tab_ip[adres]))
def do_ping_icmplib(dst):
host = ping(dst, count=5, interval=0.2)
if host.is_alive:
print(f"{Fore.GREEN}pinging {dst}, avg rtt is {host.avg_rtt}")
print(
f"sent {host.packets_sent} packets, packet loss is {host.packet_loss} {Fore.RESET}"
)
else:
print(f"{Fore.GREEN}pinging {dst}, host is down {Fore.RESET}")
async def check_ping(addr, count=10):
host = ping(addr, count=count, interval=0.2, timeout=2)
k = 0.8
if host.transmitted_packets == 0:
return False
elif host.received_packets == 0:
return False
elif host.received_packets / host.transmitted_packets < k:
return False
else:
return True
def ping(address):
host = ping(address, count=1)
is_alive = False
ping = -1
if host.is_alive:
is_alive = True
ping = utils.format.format_output(round(host.avg_rtt))
return {"is_alive": is_alive, "ping": ping}
def pingThread(self):
logger.info('Thread started')
while True:
host = ping(self.addr, count=1, interval=1, timeout=2)
if host.is_alive:
self.data['status'] = True
self.data['data'] = host
else:
self.data['status'] = False
self.data['msg'] = 'Device seems down'
logger.warning('Cannot ping through {}'.format(self.addr))
time.sleep(self.interval)
def ping(self, addr):
if len(addr.strip()) == 0:
return "pong"
addr = addr.split(" ")[0].strip()
try:
result = icmplib.ping(addr)
if not result:
return "Request timed out"
else:
return "%1.2fms" % (result * 1000)
except:
return None
def ping(self, addr):
if len(addr.strip()) == 0:
return "pong"
addr = addr.split(" ")[0].strip()
try:
result = icmplib.ping(addr)
if not result:
return "Request timed out"
else:
return "%1.2fms" % (result * 1000)
except:
return None
def rede():
if sys.platform != "linux":
print("\33[33m"+"Este módulo só funciona em "+"\33[34m"+"Linux."+"\33[31m"+" Saindo...")
time.sleep(3)
sys.exit()
info = configparser.ConfigParser()
info.read("Configs/Configs.ini")
qtd = info.get('Rede','pings')
prefixo = info.get('Rede','prefixip')
faixa = info.get('Rede','faixaip')
mostraoff = info.get('Outros','showoffline')
intervalo = info.get('Rede','timeout')
faixadeip = int(input("Faixa de IP: "))
ip = int(input("IP inicial: "+prefixo+"."+str(faixadeip)+"."))
if (ip < 1):
print("\33[33m"+"\nEndereço IP inválido!.")
ipfinal = int(input("IP final: "+prefixo+"."+str(faixadeip)+"."))
if ipfinal > 254:
print("Endereço IP inválido!")
print("\33[33m"+"O IP final não deve ser maior que 254, portanto, o programa verificará até o 254.")
if ip > ipfinal:
print("\33[31m"+"O IP inicial não pode ser maior que o final.")
rede()
print("\n")
print("\33[5m"+"Varrendo rede..."+"\33[0m")
print("\n")
user = getpass.getuser()
if user != "root":
print("**********************************************************************")
print("* Você não tem privilégios suficientes para isto, execute como sudo. *")
print("**********************************************************************")
menu.opcoes()
for cont in range(ip, ipfinal+1):
host = ping(prefixo+'.'+str(faixadeip)+'.'+str(cont), count=int(qtd), interval=float(intervalo))
if host.is_alive == True:
print("\33[0m")
print("*"*32)
print("* "+"\33[36m"+prefixo+"."+str(faixadeip)+"."+str(cont)+"\33[32m"+" ✔️ Host online *")
else:
if (mostraoff == "true"):
print("\33[37m"+prefixo+"."+str(faixadeip)+"."+str(cont)+"\33[31m"+" ❌️ Host offline")
elif (mostraoff == "false"):
pass
elif ((mostraoff != "true") and (mostraoff != "false")):
print("Valor incorreto na configuração")
menu.opcoes()
if os.path.exists("echo.txt"):
os.remove("echo.txt")
menu.opcoes()
def do_GET(self):
if None != re.search('/api/ping/*', self.path):
ipaddr = "" + self.path.split('/')[-1]
print(self.path.split('/'))
#This URL will trigger our sample function and send what it returns back to the browser
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(
str(ping(
ipaddr, count=3, interval=0.2,
timeout=1).avg_rtt).encode()) #call sample function here
return
if None != re.search('/api/isalive/*', self.path):
ipaddr = "" + self.path.split('/')[-1]
print(self.path.split('/'))
#This URL will trigger our sample function and send what it returns back to the browser
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(
str(ping(
ipaddr, count=3, interval=0.2,
timeout=1).is_alive).encode()) #call sample function here
return
if None != re.search('/api/mult/*', self.path):
num1 = float(self.path.split('/')[-1])
num2 = float(self.path.split('/')[-2])
#This URL will trigger our sample function and send what it returns back to the browser
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(str(num1 *
num2).encode()) #call sample function here
return
else:
#serve files, and directory listings by following self.path from
#current working directory
http.server.SimpleHTTPRequestHandler.do_GET(self)
def fnTestRoute(siteAddress):
objHost = ping(address=siteAddress, count=1)
objRoute = traceroute(address=siteAddress)
if objHost.is_alive:
print('Distance (ttl) Address Average round-trip time')
intDistance = 0
for hop in objRoute:
if intDistance + 1 != hop.distance:
print(f"{intDistance + 1} Hop ({hop.address}) isn't responding")
print(f'{hop.distance} {hop.address} {hop.avg_rtt} ms')
intDistance = hop.distance
else:
print(f"No connection to {siteAddress}")
def run_ping():
now = dt.datetime.now()
y = now.strftime('%Y')
m = now.strftime('%m')
d = now.strftime('%d')
# 監視対象ノードリストを取得しノードごとのフォルダを作成
nodes = config.get('settings', 'nodes')
with open(nodes) as n:
row = csv.reader(n)
header = next(row) # header行をスキップ
for row in csv.reader(n):
folder = path + '/' + row[0]
if not os.path.isdir(folder):
os.makedirs(folder)
file = folder + '/' + row[
0] + '_' + y + m + d + '.csv' # 日毎のcsvファイルを作成
# pingのオプション設定取得
pc = config.getint('ping_options', 'p_count')
pi = config.getint('ping_options', 'p_interval')
pt = config.getint('ping_options', 'p_timeout')
node = ping(row[1], count=pc, interval=pi, timeout=pt,
id=PID) # ping実行
t = dt.datetime.now().strftime('%H:%M:%S')
# 結果の書き込み
with open(file, 'a') as f:
w = csv.writer(f)
if node.is_alive: # ping成功
w.writerow([t, 'OK'])
else: # ping失敗
tc = config.getint('tracert_options', 't_count')
ti = config.getfloat('tracert_options', 't_interval')
tt = config.getint('tracert_options', 't_timeout')
tm = config.getint('tracert_options', 't_hops')
tf = config.get('tracert_options', 'fast_mode')
hops = traceroute(row[1],
count=tc,
interval=ti,
timeout=tt,
id=PID,
max_hops=tm,
fast_mode=tf)
w.writerow([t, 'NG', hops])
send_mail(row[0], file)
def check_link_quality(self):
""" Actually determine the quality of the link """
res = ping(self.data['host'], count=10, interval=0.1, timeout=0.5)
# packet_loss is a percent
self.data['packet_loss'] = int(round(res.packet_loss, 2) * 100)
# link quality is judged to be the maximum distance from average
# on the min or max rtt time. Basically, closer numbers to the average
# are better, because they indicate less jitter. Units are in ms.
min_diff = res.avg_rtt - res.min_rtt
max_diff = res.max_rtt - res.avg_rtt
self.data["link_quality"] = 100 - int(round(max(min_diff, max_diff),
0))
return self.data["link_quality"]
def check_ping(hostname, x):
global up, responses
try:
data = threading.local()
data.response = ping(hostname, count=1, timeout=2)
if data.response.is_alive:
responses[x - 1] = colored(f"{hostname} is up", "green")
up += 1
else:
responses[x - 1] = colored(f"{hostname} is down", "red")
except KeyboardInterrupt:
quit("Stopping...")
def ping(address): return icmplib.ping(address)
