def __init__(self):
self.check_sysstat_version()
self.IP = get_ip()
self.thread_pool = cfg.getServer(
'threadPool') if cfg.getServer('threadPool') >= 0 else 0
self._msg = {
'port': [],
'pid': [],
'isRun': [],
'startTime': []
} # port、pid、status、startTime
self.is_system = cfg.getMonitor(
'isMonSystem') # Whether to monitor the server system
self.error_times = cfg.getMonitor('errorTimes')
self.sleepTime = cfg.getMonitor('sleepTime')
self.maxCPU = cfg.getMonitor('maxCPU')
self.CPUDuration = cfg.getMonitor('CPUDuration')
self.isCPUAlert = cfg.getMonitor('isCPUAlert')
self.minMem = cfg.getMonitor('minMem')
self.isMemAlert = cfg.getMonitor('isMemAlert')
self.isPidAlert = cfg.getMonitor('isPidAlert')
self.errorTimesOfPid = cfg.getMonitor('errorTimesOfPid')
self.frequencyFGC = cfg.getMonitor('frequencyFGC')
self.isJvmAlert = cfg.getMonitor('isJvmAlert')
self.echo = cfg.getMonitor('echo')
self.isDiskAlert = cfg.getMonitor('isDiskAlert')
self.maxDiskUsage = cfg.getMonitor('maxDiskUsage') / 100
self.isTCP = cfg.getMonitor('isTCP')
self.timeSetting = cfg.getMonitor('timeSetting')
system_interval = cfg.getMonitor('system_interval')
port_interval = cfg.getMonitor('port_interval')
self.system_interval = max(
system_interval,
1) # If the set value is less than 1, the default is 1
self.port_interval = max(
port_interval,
1) # If the set value is less than 1, the default is 1
self.system_interval = self.system_interval - 1.1 # Program running time
self.system_interval = max(self.system_interval, 0)
self.port_interval = self.port_interval - 1.03 # Program running time
self.port_interval = max(self.port_interval, 0)
self.system_version = '' # system version
self.cpu_info = ''
self.cpu_usage = 0.0 # CPU usage
self.cpu_cores = 0 # number of CPU core
self.mem_usage = 0.0 # memory usage
self.total_mem = 0 # totel memory, unit: G
self.total_mem_100 = 0 # total memory, unit: 100*G
self.nic = '' # network card
self.all_disk = [] # disk number
self.total_disk = 1 # total disk size, unit: M
self.total_disk_h = 0 # total disk size, unit:T or G
self.network_speed = cfg.getServer('nicSpeed') # bandwidth
self.get_system_version()
self.get_cpu_cores()
self.get_total_mem()
self.get_system_nic()
self.get_disks()
self.get_system_net_speed()
self.get_total_disk_size()
self.monitor_task = queue.Queue() # FIFO queue
# thread pool, +2 is the need for monitoring system and registration service
self.executor = ThreadPoolExecutor(self.thread_pool + 2)
self.client = influxdb.InfluxDBClient(
cfg.getInflux('host'), cfg.getInflux('port'),
cfg.getInflux('username'), cfg.getInflux('password'),
cfg.getInflux('database')) # influxdb connection
self.FGC = {} # full gc times
self.FGC_time = {} # full gc time
self.last_cpu_io = [] # recently cpu usage
self.is_java = {} # whether is java, 0 or 1
self.monitor()
robot_id = sys.argv[1]
if not common.check_id(robot_id):
common.print_error('please check the robot id')
exit(3)
j = 2
for i in range(2, len(sys.argv)):
if '-j' in sys.argv[i]:
j = int(sys.argv[i][2:])
break
if not common.build_project(True, j):
common.print_error('build error, please check code')
exit(4)
args = common.parse_argv(sys.argv)
ip_address = common.get_ip(robot_id)
if not common.check_net(ip_address):
common.print_error('can not connect to host, please check network')
exit(6)
ssh_client = ssh_connection.ssh_connection(ip_address, config.ssh_port,
config.username,
config.password)
if not common.compress_files(ssh_client):
common.print_error('compress files error, please check')
exit(5)
ssh_client.upload(config.project_dir + '/bin/' + config.compress_file_name,
config.remote_dir + config.compress_file_name)
def __init__(self, ctl_domain, clientpri, clientpri_sha1, serverpub,
clientpub_sha1, req_num, remote_host, remote_port, dns_servers,
debug_ip, swapcount, ptexec, obfs_level, ipv6, not_upnp):
self.req_num = req_num
self.remote_host = remote_host
self.dns_servers = dns_servers
random.shuffle(self.dns_servers)
self.dns_count = 0
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.swapcount = swapcount
self.ctl_domain = ctl_domain
if ipv6 == "":
self.ip = get_ip(debug_ip)
self.ipv6 = ipv6
self.ptexec = ptexec
self.obfs_level = obfs_level
# shared properties, used in ServerReceiver
self.remote_port = remote_port
self.serverpub = serverpub
self.clientpri = clientpri
self.clientpri_sha1 = clientpri_sha1
self.clientpub_sha1 = clientpub_sha1
self.clientreceivers_dict = dict()
self.main_pw = (''.join(rng.choice(ascii_letters) for _ in range(16)))\
.encode('ASCII')
# DEBUG:
#self.main_pw = b"bbbbbbbbbbbbbbbb"
# each dict maps client connection id to the max index received
# by the corresponding serverreceiver
self.serverreceivers_pool = [None] * self.req_num
# each entry as dict: conn_id -> queue, each queue is (index, data)
# pairs
self.server_send_buf_pool = [{}] * self.req_num
self.server_recv_max_idx = [{}] * self.req_num
# end of shared properties
self.ready = None # used to store the next ServerReceiver to use
# lock the method to request connections
self.check = threading.Event()
self.check.set()
req = threading.Thread(target=self.reqconn)
req.setDaemon(True)
if not not_upnp:
self.upnp_start()
# obfs4 = level 1 and 2, meek (GAE) = level 3
if 1 <= self.obfs_level <= 2:
self.certs_send = None
self.certs_random = ''.join(rng.choice(ascii_letters)
for _ in range(40))
self.certcheck = threading.Event()
self.certcheck.clear()
pt = threading.Thread(target=self.ptinit)
pt.setDaemon(True)
pt.start()
self.certcheck.wait(1000)
elif self.obfs_level == 3:
pt = threading.Thread(target=self.meekinit)
pt.setDaemon(True)
pt.start()
req.start()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author: leeyoshinari
import os
import time
import asyncio
import traceback
from aiohttp import web
from common import get_ip
from logger import logger, cfg
from performance_monitor import PerMon, port_to_pid
permon = PerMon()
HOST = cfg.getServer('host') if cfg.getServer('host') else get_ip()
async def index(request):
"""
Home, basic data can be displayed by visiting http://ip:port
:param request:
:return:
"""
return web.Response(
body=
f'The server system version is {permon.system_version}, {permon.cpu_info}, total memory is {permon.total_mem}G, '
f'the network card is {permon.nic}, bandwidth is {permon.network_speed}Mb/s, {len(permon.all_disk)} disks, '
f'total size of disks is {permon.total_disk_h}, disks number is {"、".join(permon.all_disk)}. '
f'If you need to stop the monitoring client, please visit http://{HOST}:{cfg.getServer("port")}/stop'
)
def __init__(self, ctl_domain, localcert, localcert_sha1, remotecert,
localpub, required, remote_host, remote_port, dns_servers,
debug_ip, swapcount, ptexec, obfs_level, ipv6, not_upnp):
self.remotepub = remotecert
self.localcert = localcert
self.localcert_sha1 = localcert_sha1
self.authdata = localpub
self.required = required
self.remote_host = remote_host
self.remote_port = remote_port
self.dns_servers = dns_servers
random.shuffle(self.dns_servers)
self.dns_count = 0
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.swapcount = swapcount
self.ctl_domain = ctl_domain
if ipv6 == "":
self.ip = get_ip(debug_ip)
self.ipv6 = ipv6
self.ptexec = ptexec
self.obfs_level = obfs_level
self.clientreceivers = {}
self.ready = None
self.recvs = [] # For serverreceivers
self.str = (''.join(rng.choice(ascii_letters) for _ in range(16)))\
.encode('ASCII')
self.check = threading.Event()
self.check.set()
req = threading.Thread(target=self.reqconn)
req.setDaemon(True)
# Try to map ports via UPnP
if not not_upnp:
try:
u = miniupnpc.UPnP()
u.discoverdelay = 200
logging.info("Scanning for UPnP devices")
if u.discover() > 0:
logging.info("Device discovered")
u.selectigd()
if self.ipv6 == "" and self.ip != struct.unpack("!I", socket.inet_aton(u.externalipaddress()))[0]:
logging.warning(
"Mismatched external address, more than one layers of NAT? UPnP may not work.")
r = u.getspecificportmapping(remote_port, 'TCP')
if r is None:
b = u.addportmapping(remote_port, 'TCP', u.lanaddr,
remote_port, 'ArkC Client port %u' % remote_port, '')
if b:
logging.info("Port mapping succeed")
atexit.register(self.exit_handler, upnp_obj=u)
elif r[0] == u.lanaddr and r[1] == remote_port:
logging.info("Port mapping already existed.")
else:
logging.error("Remote port occupied in UPnP mapping")
# TODO: implement the following function
# eport = eport + 1
# logging.warning("Original remote port used, switched to " + str(eport))
# r = u.getspecificportmapping(eport, 'TCP')
else:
logging.error("No UPnP devices discovered")
except Exception:
logging.error("Error arose when initializing UPnP")
# obfs4 = level 1 and 2, meek (GAE) = level 3
if 1 <= self.obfs_level <= 2:
self.certs_send = None
self.certs_random = ''.join(rng.choice(ascii_letters)
for _ in range(40))
self.certcheck = threading.Event()
self.certcheck.clear()
pt = threading.Thread(target=self.ptinit)
pt.setDaemon(True)
pt.start()
self.certcheck.wait(1000)
elif self.obfs_level == 3:
pt = threading.Thread(target=self.meekinit)
pt.setDaemon(True)
pt.start()
req.start()
def __init__(self):
self.IP = get_ip()
self.thread_pool = cfg.getServer(
'threadPool') if cfg.getServer('threadPool') >= 0 else 0
self._msg = {
'port': [],
'pid': [],
'isRun': [],
'startTime': []
} # 端口号、进程号、监控状态、开始监控时间
self.is_system = cfg.getMonitor('isMonSystem') # 是否监控服务器的资源
self.error_duration = cfg.getMonitor('errorDuration') # 执行命令失败次数
self.sleepTime = cfg.getMonitor('sleepTime')
self.maxCPU = cfg.getMonitor('maxCPU')
self.CPUDuration = cfg.getMonitor('CPUDuration')
self.isCPUAlert = cfg.getMonitor('isCPUAlert')
self.minMem = cfg.getMonitor('minMem')
self.isMemAlert = cfg.getMonitor('isMemAlert')
self.frequencyFGC = cfg.getMonitor('frequencyFGC')
self.isJvmAlert = cfg.getMonitor('isJvmAlert')
self.echo = cfg.getMonitor('echo')
self.isDiskAlert = cfg.getMonitor('isDiskAlert')
self.maxDiskUsage = cfg.getMonitor('maxDiskUsage') / 100
self.isTCP = cfg.getMonitor('isTCP')
self.timeSetting = cfg.getMonitor('timeSetting')
system_interval = cfg.getMonitor('system_interval') # 每次执行监控命令的时间间隔
port_interval = cfg.getMonitor('port_interval') # 每次执行监控命令的时间间隔
self.system_interval = max(system_interval, 1) # 设置的值如果小于1，则默认为1
self.port_interval = max(port_interval, 1)
self.system_interval = self.system_interval - 1.1 # 程序运行、写库时间
self.system_interval = max(self.system_interval, 0)
self.port_interval = self.port_interval - 0.02 # 0.02为程序运行、写库时间
self.system_version = '' # 系统版本
self.cpu_info = ''
self.cpu_cores = 0 # CPU核数
self.total_mem = 0 # 总内存，单位G
self.total_mem_100 = 0 # 总内存，单位100*G，主要用于求内存占比，减少运算量
self.nic = '' # 系统正在使用的网卡
self.all_disk = [] # 磁盘号
self.total_disk = 1 # 磁盘总大小，单位M
self.total_disk_h = 0 # 磁盘总大小，以人可读的方式展示，单位T或G
self.network_speed = 1 # 服务器网卡带宽
self.get_system_version()
self.get_cpu_cores()
self.get_total_mem()
self.get_system_nic()
self.get_disks()
self.get_system_net_speed()
self.get_total_disk_size()
self.monitor_task = queue.Queue() # 创建一个FIFO队列
self.executor = ThreadPoolExecutor(self.thread_pool +
1) # 创建线程池, +1是需要监控系统
self.client = influxdb.InfluxDBClient(
cfg.getInflux('host'), cfg.getInflux('port'),
cfg.getInflux('username'), cfg.getInflux('password'),
cfg.getInflux('database')) # 创建数据库连接
self.FGC = {} # 每个端口的full gc次数
self.FGC_time = {} # 每个端口每次full gc的时间
self.last_cpu_io = [] # 最近一段时间的cpu的值，约100s
self.is_java = {} # 监控的端口是否是java服务，0 or 1
self.monitor()
def __init__(self, ctl_domain, clientpri, clientpri_sha1, serverpub,
clientpub_sha1, req_num, remote_host, remote_port,
dns_servers, debug_ip, swapcount, ptexec, obfs_level, ipv6,
not_upnp):
self.req_num = req_num
self.remote_host = remote_host
self.dns_servers = dns_servers
random.shuffle(self.dns_servers)
self.dns_count = 0
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.swapcount = swapcount
self.ctl_domain = ctl_domain
if ipv6 == "":
self.ip = get_ip(debug_ip)
self.ipv6 = ipv6
self.ptexec = ptexec
self.obfs_level = obfs_level
# shared properties, used in ServerReceiver
self.remote_port = remote_port
self.serverpub = serverpub
self.clientpri = clientpri
self.clientpri_sha1 = clientpri_sha1
self.clientpub_sha1 = clientpub_sha1
self.clientreceivers_dict = dict()
self.main_pw = (''.join(rng.choice(ascii_letters) for _ in range(16)))\
.encode('ASCII')
# DEBUG:
#self.main_pw = b"bbbbbbbbbbbbbbbb"
# each dict maps client connection id to the max index received
# by the corresponding serverreceiver
self.serverreceivers_pool = [None] * self.req_num
# each entry as dict: conn_id -> queue, each queue is (index, data)
# pairs
self.server_send_buf_pool = [{}] * self.req_num
self.server_recv_max_idx = [{}] * self.req_num
# end of shared properties
self.ready = None # used to store the next ServerReceiver to use
# lock the method to request connections
self.check = threading.Event()
self.check.set()
req = threading.Thread(target=self.reqconn)
req.setDaemon(True)
if not not_upnp:
self.upnp_start()
# obfs4 = level 1 and 2, meek (GAE) = level 3
if 1 <= self.obfs_level <= 2:
self.certs_send = None
self.certs_random = ''.join(
rng.choice(ascii_letters) for _ in range(40))
self.certcheck = threading.Event()
self.certcheck.clear()
pt = threading.Thread(target=self.ptinit)
pt.setDaemon(True)
pt.start()
self.certcheck.wait(1000)
elif self.obfs_level == 3:
pt = threading.Thread(target=self.meekinit)
pt.setDaemon(True)
pt.start()
req.start()
def on_connect(self):
self.emit('login', {'ip': get_ip(), 'id': 1, 'channel': 'login'})
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author: leeyoshinari
import os
import time
import asyncio
import traceback
from aiohttp import web
from common import get_ip
from logger import logger, cfg
from performance_monitor import PerMon, port_to_pid
permon = PerMon()
HOST = get_ip()
async def index(request):
"""
首页，浏览器访问 http://ip:port 即可显示服务器基本资源
:param request:
:return:
"""
return web.Response(
body=
f'当前服务器系统版本为{permon.system_version}，{permon.cpu_info}，总内存为{permon.total_mem}G，使用的网卡为{permon.nic}，系统带宽为{permon.network_speed}Mb/s，共有{len(permon.all_disk)}个磁盘，磁盘总大小为{permon.total_disk_h}，磁盘号分别为{"、".join(permon.all_disk)}。'
)
async def run_monitor(request):
"""
common.print_error('no enough arguments')
common.print_info('./set_wifi.py id ssid pswd ip netmask gateway')
exit(2)
robot_id = sys.argv[1]
ssid = sys.argv[2]
pswd = sys.argv[3]
ip = sys.argv[4]
netmask_str = sys.argv[5]
netmasks = netmask_str.split('.')
netmask = 0
for n in netmasks:
netmask = netmask + number_of_1(n)
gateway = sys.argv[6]
ip_address = common.get_ip(config.conf_file, robot_id)
cmd1 = '''
sed -i '/ssid=/cssid={sid}' {file};
sed -i '/psk=/cpsk={psk}' {file};
sed -i '/address1=/caddress1={adr}' {file};
'''.format(sid=ssid, psk=pswd, adr=ip, file=config.wan_file)
cmd2 = '''
sed -i '/address1=/caddress1={adr}' {file};
'''.format(adr=ip, file=config.lan_file)
ssh_client = SSH.SSH(ip_address, config.username, config.password)
shell = ssh_client.create_shell()
shell.exec_command(cmd1)
shell.exec_command(cmd2)
shell.exec_command('poweroff')
def main(
hosts: str = typer.Option(...,
'-ip',
help="IP地址(范围), 如: 192.168.0.1-192.168.0.100"),
ports: str = typer.Option(
"1-1024",
'-p',
help=
"待扫描端口号, 支持端口号范围, 支持单个端口号, 连续端口号(用'-'连接, 如: '3000-4000'), 不连续端口号(用','连接, 如: '22,3389,3306,27017')"
),
concurrent_num: int = typer.Option(32, '-n', help="并发数量. 默认32"),
concurrent_type: ConcurrentType = typer.Option(
ConcurrentType.THREADING,
'-m',
case_sensitive=False,
help=f"并发类型. 默认: {ConcurrentType.THREADING}"),
test_type: TestType = typer.Option(TestType.TCP,
'-f',
case_sensitive=False,
help=f"测试类型. 默认: {TestType.TCP}"),
saved_file: str = typer.Option(None,
'-w',
case_sensitive=False,
help="保存文件"),
verbose: bool = typer.Option(None, '-v', is_eager=True, help="打印扫描器运行耗时"),
):
"""
基于多进程或多线程模型的端口主机扫描器
"""
Executor = ThreadPoolExecutor
if concurrent_type == ConcurrentType.MULTIPROCESSING:
Executor = ProcessPoolExecutor
concurrent_num = multiprocessing.cpu_count()
_is_saved = False
if saved_file:
try:
makedirs(saved_file)
f = open(saved_file, "w", encoding='utf-8')
f.write("[")
_is_saved = True
except OSError as e:
logger.error(e)
sys.exit(1)
tic = time.perf_counter()
with Executor(concurrent_num) as exec:
tasks = {}
for host in get_ip(hosts):
if test_type == TestType.PING:
future = exec.submit(ping, host)
tasks.update({future: {'host': host, 'type': test_type}})
else:
for port in get_port(ports):
future = exec.submit(scan, host, port)
tasks.update({future: {'host': host, 'type': test_type}})
for future in concurrent.futures.as_completed(tasks):
host, test_type = tasks[future]['host'], tasks[future]['type']
result = future.result()
if test_type == TestType.PING:
logger.info('\n'.join(result))
elif result['open']:
logger.info(result)
if _is_saved:
out = json.dumps(
{
'host': host,
"concurrent_num": concurrent_num,
"concurrent_type": concurrent_type,
"test_type": test_type,
"verbose": verbose,
"info": result
},
ensure_ascii=False)
f.write(out + ',')
toc = time.perf_counter()
if _is_saved:
f.seek(f.tell() - 1)
f.write("]")
if verbose:
logger.info(f"\nTime elapse(s): {toc - tic:.6f}")
if _is_saved:
f.close()
logger.info(f"\nThe result saved in file: {saved_file}")
