class ftp_server(object):
# Create Random Username and Password
def __init__(self, Dir='/tmp', Port=2121):
self.Dir = Dir
self.Port = Port
# Get Local Server Address
self.Addr = _get_local_ip()
def _run_server(self):
# Create Dummy Authorizer, with the random user/pass
self.authorizer = DummyAuthorizer()
self.authorizer.add_user(self.User,
self.Pass,
self.Dir,
perm='elradfmw')
self.handler = FTPHandler
self.handler.authorizer = self.authorizer
# Instantiate the FTP Server
self.SRV = ThreadedFTPServer(('0.0.0.0', self.Port), self.handler)
self.SRV.serve_forever()
def start(self):
# Random user/pass
self.User = _random_string()
self.Pass = _random_string()
# Start separate process calling Run Server function
self.srv = multiprocessing.Process(target=self._run_server)
self.srv.start()
def stop(self):
# Close all connections immediately
self.srv.kill()
def run(self):
with self._lock:
# Instantiate a dummy authorizer for managing 'virtual' users
authorizer = DummyAuthorizer()
# Define a new user having full r/w permissions and a read-only anonymous user
authorizer.add_user(self._user, self._pwd, self._path, perm='elradfmwMT')
# Instantiate FTP handler class
handler = FTPHandler
handler.authorizer = authorizer
# Define a customized banner (string returned when client connects)
handler.banner = "pyftpdlib based ftpd ready."
# Instantiate FTP server class and listen on 0.0.0.0:self._port
address = ('0.0.0.0', int(self._port))
try:
self._server = ThreadedFTPServer(address, handler)
except Exception as e:
logging.error(f"Exception while start PyFtpServer: {e}")
if self._server is not None:
# set a limit for connections
self._server.max_cons = 256
self._server.max_cons_per_ip = 5
# start ftp server
self._server.serve_forever()
def main():
authorizer = DummyAuthorizer()
authorizer.add_user("user", "12345", ".")
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer(("", 2121), handler)
server.serve_forever()
def main():
authorizer = DummyAuthorizer()
authorizer.add_user(USER, PWD, ftp_root, perm='elradfmw')
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer((ftp_address, ftp_port), handler)
server.serve_forever()
def __init__(self, parent, host, user, passwd, home_dir, log):
# pull settings
self.parent = parent
self.home_dir = unicode(home_dir)
host = host.split(':')
host[1] = int(host[1])
# create authorizer
authorizer = HumbleAuthorizer()
authorizer.add_user(user, passwd, home_dir, perm="elradfmw")
# create filesystem
#virtual_fs = VirtualFS
filesystem = HumbleAbstractedFS
filesystem.parent = self
# create handler
handler = HumbleFTPHandler
handler.parent = self
handler.logger = log
handler.authorizer = authorizer
handler.passive_ports = range(60000, 65535)
handler.abstracted_fs = filesystem # virtual_fs # real_fs
# setup virtual fs
# real_fs = HumbleAbstractedFS(self.home_dir, handler)
# real_fs.parent = self
# virtual_fs.structure = {'workspace': real_fs}
# init self
self.logger = log
FTPServer.__init__(self, host, handler)
self.max_cons = 256
self.max_cons_per_ip = 5
class ftp_server:
def __init__(self):
authorizer = DummyAuthorizer()
authorizer.add_user('user', '12345', 'collected/', perm='elradfmwMT')
authorizer.add_anonymous("collected/", perm='elradfmwMT')
self.handler = MyHandler
self.handler.authorizer = authorizer
self.obj = ThreadedFTPServer(("0.0.0.0", 21), self.handler)
self.filename = ""
# set a limit for connections
#self.max_cons = 256
#self.max_cons_per_ip = 5
def get_filename(self):
global filename
return filename
def _run_server(self):
self.obj.serve_forever()
def start(self):
srv = threading.Thread(target=self._run_server)
srv.deamon = True
srv.start()
def stop(self):
self.obj.close_all()
def ftpserver(self):
# 实例化虚拟用户，这是FTP验证首要条件
authorizer = DummyAuthorizer()
# 添加用户权限和路径，括号内的参数是(用户名， 密码， 用户目录， 权限)
authorizer.add_user(self.var_username.get(),
self.var_passwd.get(),
self.var_path.get(),
perm="elradfmwMT")
# 添加匿名用户，任何人都可以访问，否则需要输入用户名和密码才能访问
# 匿名用户只需要配置路径
authorizer.add_anonymous(self.var_path.get(), msg_login="******")
# 初始化ftp句柄
handler = FTPHandler
handler.authorizer = authorizer
# 监听ip和端口
self.server = ThreadedFTPServer(
(self.var_address.get(), self.var_port.get()), handler)
# 开始服务
self.server.serve_forever()
def run_pot(self):
# Get config
config = configparser.ConfigParser()
config.read('./ftp/config.ini')
section = 'DEFAULT'
FTP_PORT = config[section]['ftp_port']
FTP_USER = config[section]['ftp_user']
FTP_PASSWORD = config[section]['ftp_password']
FTP_DIR = config[section]['ftp_directory']
####################
print("Starting FTP honeypot on port ", FTP_PORT, '...', sep='')
authorizer = DummyAuthorizer()
authorizer.add_user(FTP_USER, FTP_PASSWORD, FTP_DIR, perm="elradfmw")
authorizer.add_anonymous(FTP_DIR, perm="elr")
handler = FTPHandler
handler.authorizer = authorizer
#handler.log_prefix = 'XXX [%(username)s]@%(remote_ip)s'
handler.banner = "Welcome to the FTP Server :)"
logging.basicConfig(filename='./ftp/logs/ftp.log', level=logging.DEBUG)
server = ThreadedFTPServer(('127.0.0.1', FTP_PORT), handler)
server.max_cons = 10
server.max_cons_per_ip = 5
self.is_running = True
print('FTP server started')
server_thread = threading.Thread(target=server.serve_forever,
daemon=True)
server_thread.start()
def start_ftp_server(self):
if not self.dry_run and self.args.local_ftp_server:
self.ftp_server = None
try:
handler = FTPHandler
authorizer = DummyAuthorizer()
if(self.args.ftp_username and self.args.ftp_username != ""):
authorizer.add_user(self.args.ftp_username, self.args.ftp_password, self.ftp_output_path, perm='elradfmwMT')
else:
authorizer.add_anonymous(self.ftp_output_path, perm='elradfmwMT')
handler.authorizer = authorizer
self.ftp_server = ThreadedFTPServer((self.args.local_ftp_interface, self.args.local_ftp_port), handler)
self.ftp_server.serve_forever(blocking=False)
if self.args.local_ftp_interface == "":
print("Started local FTP server: ::%s" % (self.args.local_ftp_port))
else:
print("Started local FTP server: %s:%s" % (self.args.local_ftp_interface, self.args.local_ftp_port))
except:
if self.args.local_ftp_interface == "":
print("Failed to start local FTP server on: ::%s" % (self.args.local_ftp_port))
else:
print("Failed to start local FTP server on: %s:%s" % (self.args.local_ftp_interface, self.args.local_ftp_port))
exit()
def start_ftp(masquerade_address, listen_address, port, log_level, internal,
passive_ports):
LogLevel = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
if log_level in LogLevel:
for lev in LogLevel:
if log_level == lev:
level = lev
else:
print "wrong loglevel parameter: %s" % log_level
exit(1)
authorizer = ObsAuthorizer()
authorizer.internal = internal
handler = FTPHandler
handler.passive_ports = passive_ports
handler.permit_foreign_addresses = True
if handler.masquerade_address != "":
handler.masquerade_address = masquerade_address
handler.authorizer = authorizer
handler.abstracted_fs = AbstrFileToObs
handler.banner = 'obs ftpd ready.'
address = (listen_address, port)
set_logger(level)
server_muti = ThreadedFTPServer(address, handler)
server_muti.serve_forever()
def main():
authorizer = DummyAuthorizer()
authorizer.add_user('user', '12345', '.')
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer(('', 2121), handler)
server.serve_forever()
def start(self):
self.authorizer = DummyAuthorizer()
if self.config.get('usessl') == 'Yes':
self.logger.debug('Using SSL socket.')
keyfile_path = 'privkey.pem'
self.handler = TLS_FakeFTPHandler
self.handler.certfile = keyfile_path
else:
self.handler = FakeFTPHandler
self.handler.ftproot_path = self.ftproot_path
self.handler.abstracted_fs = FakeFS
self.handler.authorizer = self.authorizer
self.handler.passive_ports = self.expand_ports(self.config.get('pasvports', '60000-60010'))
self.server = ThreadedFTPServer((self.local_ip, int(self.config['port'])), self.handler)
# Override pyftpdlib logger name
logging.getLogger('pyftpdlib').name = self.name
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
def main():
authorizer = DummyAuthorizer()
authorizer.add_user('user', '12345', '.')
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer(('', 2121), handler)
server.serve_forever()
class Server(threading.Thread): def __init__(self, ip, path, users, port, password): super(Server, self).__init__() self.ip = ip self.path = path self.users = users self.port = port self.auth = DummyAuthorizer() self.handler = CustomFTP(self.auth, self.port, path, password) # self.handler.authorizer = self.auth print 'starting server on port %d' % (self.port) [self.add_user(self.path, u, password) for u in self.users] def start_thread(self): self.start() return self def add_user(self, path, user, password): pathn = os.path.join(path, str(self.port)) if not os.path.exists(pathn): os.mkdir(pathn) self.auth.add_user(user, password, pathn, perm="elr") # elradfmw def run(self): self.server = ThreadedFTPServer((self.ip, self.port), self.handler) self.server.serve_forever()
class FTPServer:
server = None
def __init__(self, user):
authorizer = DummyAuthorizer()
authorizer.add_user(user.username,
user.password,
user.dir_,
perm=user.permissions)
handler = FTPHandler
handler.authorizer = authorizer
address = (str(ip_retriever.get_ip_address()), 2121)
self.server = ThreadedFTPServer(address, handler)
self.server.max_cons = 10
self.server.max_cons_per_ip = 5
print('\nServer Address: ftp://{}:{}\n'.format(address[0], address[1]))
def start_server(self):
self.server.serve_forever()
def setUp(self) -> None:
self.fake = Faker()
self.fake.add_provider(FakeCamera)
self.temp_folder = tempfile.mkdtemp()
self.temp_upload_file_path = None
self.ftp_auth = DummyAuthorizer()
self.ftp_auth.add_user('test', 'test', self.temp_folder, 'elrmw')
self.ftp_handler = FTPHandler
self.ftp_handler.authorizer = self.ftp_auth
self.ftp_server = None
while not self.ftp_server:
self.ftp_port = random.randint(50000, 60000)
try:
self.ftp_server = ThreadedFTPServer(
('localhost', self.ftp_port), self.ftp_handler)
except Exception as exc:
print('{} error creating FTP server: {}; retrying...'.format(
type(exc), exc))
self.ftp_server = None
self.ftp_thread = Thread(target=self.ftp_server.serve_forever)
self.ftp_thread.start()
logging.getLogger('').setLevel(logging.DEBUG)
def __init__(self, ip="127.0.0.1", port=9090, config_file="server.json"):
"""
Initmethod initializes ftp server
"""
with open(config_file, "r") as f:
self.config = json.load(f)
# Logic for authentication
authorizer = DummyAuthorizer()
for path, details in self.config.items():
authorizer.add_user(
details['user'],
details["password"],
homedir=path,
perm="elradfmw" if details["read_only"] else "elr",
)
handler = FTPHandler
handler.authorizer = authorizer
handler.on_disconnect = self.genAndDump # Refresh DB on close
handler.on_login = self.on_login
# Configure ip, port & Authentication for server
self.server = ThreadedFTPServer((ip, port), handler)
def __init__(self):
authorizer = DummyAuthorizer()
authorizer.add_user('user', '12345', 'collected/', perm='elradfmwMT')
authorizer.add_anonymous("collected/", perm='elradfmwMT')
self.handler = MyHandler
self.handler.authorizer = authorizer
self.obj = ThreadedFTPServer(("0.0.0.0", 21), self.handler)
self.filename = ""
def main():
authorizer = DummyAuthorizer()
authorizer.add_user('1', '1', '/')
handler = EncodedHandler
handler.authorizer = authorizer
server = ThreadedFTPServer(('', 21), handler)
server.serve_forever()
def main():
authorizer = DummyAuthorizer()
# authorizer.add_user('user', '12345', '.')
authorizer.add_anonymous(os.getcwd(),perm='elradfmw')
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer(('0.0.0.0', 21), handler)
server.serve_forever()
def runFTP():
try:
handler = FTPHandler
handler.authorizer = listusersftp
serverFTP = ThreadedFTPServer((IP_ADDRESS, PORT_FTP), handler)
serverFTP.serve_forever()
except:
print("FTP cannot Run")
return
class ServeurFTP(Thread):
port = "12345"
server = None
handler = None
authorizer = None
repertory = "./fichiers"
# daemon = False
# threadftp = None
def __init__(self, port):
Thread.__init__(self)
self.daemon = True
self.port = port
def isin(self, file):
retour = False
Rfile = file.split('/')
if len(Rfile) > 0:
file = Rfile[-1]
files = os.listdir(self.repertory)
if file in files:
retour = True
return retour
def run(self=object):
print("# FTPD Forever: demarrage")
# Thread.run(self)
config_logging(0)
self.authorizer = DummyAuthorizer()
self.authorizer.add_anonymous(self.repertory, perm='elradfmwM')
# handler = CustomFtpHandler
self.handler = FTPHandler
self.handler.authorizer = self.authorizer
address = ('0.0.0.0', self.port)
# self.server = FTPServer(address, self.handler)
self.server = ThreadedFTPServer(address, self.handler)
self.server.serve_forever(timeout=1, blocking=True, handle_exit=False)
# self.server.serve_forever(timeout=1, blocking=True, handle_exit=False)
# self.server.serve_forever(timeout=None, blocking=True, handle_exit=False)
print("# FTPD Forever: sortie fonction run")
@classmethod
def stop(self):
print("# Fermeture du service FTP")
self.handler.close()
self.server = None
def __init__(self):
super().__init__()
authorizer = DummyAuthorizer()
authorizer.add_user("ons", "ons", "./ftp", perm="elradfmw")
handler = FTPHandler
handler.authorizer = authorizer
handler.abstracted_fs = UnixFilesystem
self.server = ThreadedFTPServer(
(settings.FTP_HOST, str(settings.FTP_PORT)), handler)
def main():
authorizer = DummyAuthorizer()
authorizer.add_anonymous('.', perm='elradfmwM')
handler = FTPHandler
handler.authorizer = authorizer
handler.banner = "Connected"
server = ThreadedFTPServer(('127.0.0.1', 3001), handler)
server.serve_forever()
def __init__(self, port=('', FTP_SERVER_PORT)):
self.auth = DummyAuthorizer()
self.handler = FTPServerWrapper.TestHandler
self.handler.authorizer = self.auth
self.server = ThreadedFTPServer(port, self.handler)
self.port = port
self.users = []
self.t = FTPServerWrapper.FTPServerRunner(self.server)
self.t.start()
def main():
authorizer = DummyAuthorizer()
authorizer.add_user(
'ftpuser', 'pass', homedir=r'C:\Temp\TMP\DFS\Dnode2',
perm='elradfmw') # set username, password & homedirectory for the user
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer((host, port),
handler) # Bind the host:port for FTP services
print("Starting FTP Server on port:", port)
server.serve_forever() # Start FTP server
class FTPServerThread(threading.Thread):
def __init__(self, addr, homedir, *args, **kwargs):
super(FTPServerThread, self).__init__(*args, **kwargs)
authorizer = DummyAuthorizer()
authorizer.add_anonymous(homedir, perm='elradfmwM')
handler = FTPHandler
handler.authorizer = authorizer
self.ftpserver = ThreadedFTPServer(addr, handler)
def run(self):
self.ftpserver.serve_forever()
def ftpServer(user, psw, port=2121, write=True):
authorizer = DummyAuthorizer()
if write == True:
authorizer.add_user(user, psw , '.', perm='elradfmwM')
else:
authorizer.add_user(user, psw , '.')
# authorizer.add_anonymous(os.getcwd())
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer(('0.0.0.0', port), handler)
server.serve_forever()
def main():
authorizer = DummyAuthorizer()
authorizer.add_user("usr", "pw", "./dummyAWG", perm="elradfmw")
authorizer.add_anonymous("./dummyAWG")
#logging.basicConfig(filename='./logs/pyftpd.log', level=logging.INFO)
handler = MyHandler
handler.authorizer = authorizer
server = ThreadedFTPServer((HOST, PORT), handler)
server.serve_forever()
def main():
authorizer = DummyAuthorizer()
authorizer.add_anonymous(os.getcwd())
for user, password, path, permission in USER_PASS_PATH_PERM:
authorizer.add_user(user, password, path, perm=permission)
handler = FTPHandler
handler.authorizer = authorizer
handler.passive_ports = range(8000, 9000)
server = ThreadedFTPServer(('', PORT), handler)
server.serve_forever()
def serve_fs(fs, addr, port):
"""
Creates a basic anonymous FTP server serving the given FS on the given address/port
combo.
"""
ftp_handler = FTPFSHandler
ftp_handler.authorizer = DummyAuthorizer()
ftp_handler.use_sendfile = False
ftp_handler.authorizer.add_anonymous('/', perm='elrdmw')
ftp_handler.abstracted_fs = FTPFSFactory(fs)
s = ThreadedFTPServer((addr, port), ftp_handler)
s.serve_forever()
def main():
authorizer = DummyAuthorizer()
authorizer.add_anonymous(os.getcwd())
for user, password, path, permission in USER_PASS_PATH_PERM:
authorizer.add_user(user, password, path, perm=permission)
handler = FTPHandler
handler.authorizer = authorizer
handler.passive_ports = range(8000, 9000)
server = ThreadedFTPServer(('', PORT), handler)
server.serve_forever()
def main():
# Creates authorization for anonymous users
# and gives them Read/Write access to the server
authorizer = DummyAuthorizer()
authorizer.add_anonymous('.', perm='elradfmwM')
# Using the default pyftpdlib handler to handle
# requests sent to the server
handler = FTPHandler
handler.authorizer = authorizer
server = ThreadedFTPServer(('127.0.0.1', 1026), handler)
server.serve_forever()
def _run_server(self):
# Create Dummy Authorizer, with the random user/pass
self.authorizer = DummyAuthorizer()
self.authorizer.add_user(self.User,
self.Pass,
self.Dir,
perm='elradfmw')
self.handler = FTPHandler
self.handler.authorizer = self.authorizer
# Instantiate the FTP Server
self.SRV = ThreadedFTPServer(('0.0.0.0', self.Port), self.handler)
self.SRV.serve_forever()
class FTP_SERVER:
def __init__(self):
path = os.getcwd()
if path.startswith('C'):
os.chdir('\\')
else:
os.chdir('C:')
self.hose_name = socket.gethostname()
self.ip = socket.gethostbyname(self.hose_name)
self.port = '21'
self.root_dir = 'C:'
self.server_address = '\EWTSS'
self.log_address = 'EWTSS\log\change_log_name.txt'
self.log_time = 'EWTSS\log\change_log_time.txt'
self.log_folder = 'EWTSS\log'
self.server = ThreadedFTPServer
self.changes_cheker = Checker(self.server_address, self.log_address,
self.log_time)
def log_generator(self):
if os.path.exists(self.log_folder):
server_logger = Server_Logger(self.server_address,
self.log_address, self.log_time)
else:
try:
os.makedirs(self.log_folder)
server_logger = Server_Logger(self.server_address,
self.log_address)
except Exception as e:
print(e)
def start(self):
try:
answer = pyautogui.confirm('Server will start on :: ' + self.ip,
"FTP Server", ("Start", "Stop"))
if answer == "Start":
self.log_generator()
try:
self.changes_cheker.start()
except Exception as e:
print(e, ":: Starting Thread")
authorizer = DummyAuthorizer()
authorizer.add_user('EWTSS_FTP_USER', 'EWTSS', '.')
handler = FTPHandler
handler.authorizer = authorizer
self.server = ThreadedFTPServer((self.ip, self.port), handler)
self.server.serve_forever()
except Exception as e:
pyautogui.alert(text=str(e),
title=str(type(e).__name__),
button='Exit')
def onClick(self):
print('start')
user = self.lineEditUser.text()
passw = self.lineEditPassword.text()
self.authorizer.add_user(user, passw, '.', perm='elrw')
self.address = ('127.0.0.1', 2100)
self.server = ThreadedFTPServer(self.address, self.handler)
QMessageBox.information(self, "FTP Server started",
"FTP Server started")
self.start()
def start_server(self):
port_no = 0
msg = "Please type a port number between 1025 and 65533 inclusive."
try:
port_no = int(self.listen_port.get())
if port_no < LOWEST_PORT_NO or port_no > HIGHEST_PORT_NO:
msg += " Port {0} is not valid.".format(port_no)
raise Exception(msg)
except:
mbox.showinfo(message=msg)
return
self.address = (self.listen_ip.get(), port_no)
self.server = ThreadedFTPServer(self.address, self.handler)
self.server.max_cons = 256
self.server.max_cons_per_ip = 5
self.share_dir(self.root_dir_tree['Local'])
self.start_button.state(['disabled'])
self.stop_button.state(['!disabled'])
self.share_button.state(['disabled'])
self.current_state.set("RUNNING")
threading.Thread(target=self.server.serve_forever).start()
def __init__(self, ftpaddr, ftpport, ftphome, rpcaddr, rpcport):
self.ftpaddr = ftpaddr
self.ftpport = ftpport
self.ftphome = ftphome
self.rpcaddr = rpcaddr
self.rpcport = rpcport
logger.info("--- xagent startup ---")
XOR.File.mkpath(self.ftphome)
authorizer = DummyAuthorizer()
authorizer.add_anonymous(self.ftphome, perm='elradfmwM')
handler = FTPHandler
handler.authorizer = authorizer
handler.banner = "xagent ftp server ready"
self.ftpserver = ThreadedFTPServer((self.ftpaddr, self.ftpport), handler)
self.rpcserver = XOR.Net.XMLRPCServer(addr=(self.rpcaddr, self.rpcport), logRequests=True, allow_none=True, encoding="UTF-8")
self.rpcserver.reg_function(XOR.OS.runex, "os.")
self.rpcserver.reg_function(XOR.OS.type, "os.")
self.rpcserver.reg_function(XOR.Zip.extract, "zip.")
self.rpcserver.reg_function(XOR.File.remove, "file.")
self.rpcserver.reg_function(self.reg_package)
self.rpcserver.reg_function(self.shutdown)
self.rpcserver.reg_function(self.set_logger)
self.rpcserver.reg_function(self.del_logger)
self.rpcserver.reg_function(self.get_ftphomedir)
self.rpcserver.register_introspection_functions()
self.rpcserver.register_multicall_functions()
def start(self):
self.authorizer = DummyAuthorizer()
if self.config.get('usessl') == 'Yes':
self.logger.debug('Using SSL socket.')
keyfile_path = 'privkey.pem'
self.handler = TLS_FakeFTPHandler
self.handler.certfile = keyfile_path
else:
self.handler = FakeFTPHandler
self.handler.ftproot_path = self.ftproot_path
self.handler.abstracted_fs = FakeFS
self.handler.authorizer = self.authorizer
self.handler.passive_ports = self.expand_ports(self.config.get('pasvports', '60000-60010'))
self.server = ThreadedFTPServer((self.local_ip, int(self.config['port'])), self.handler)
# Override pyftpdlib logger name
logging.getLogger('pyftpdlib').name = self.name
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
def main(username, password, base_dir):
# Instantiate a dummy authorizer for managing 'virtual' users
authorizer = DummyAuthorizer()
# Define a new user having full r/w permissions
authorizer.add_user(username, password, base_dir, perm='elradfmwM')
# Instantiate FTP handler class
handler = FTPHandler
handler.authorizer = authorizer
# Define a customized banner (string returned when client connects)
handler.banner = "pyftpdlib based ftpd ready."
# Instantiate FTP server class and listen on 0.0.0.0:2121
address = ('0.0.0.0', 2121)
server = ThreadedFTPServer(address, handler)
# set a limit for connections
server.max_cons = 256
server.max_cons_per_ip = 5
# start ftp server
server.serve_forever()
def main(user,password,ftppath=".",port=21):
#新建一个用户组
authorizer = DummyAuthorizer()
#将用户名，密码，用户访问指定目录，权限 添加到里面，当目录用"."表示.py文件当前所在的目录
authorizer.add_user(user, password, ftppath, perm="elr") #elr只读,perm="elradfmw",windows 路径用 /
# authorizer.add_user(user, password, ftppath, perm="elradfmw") #全部权限elradfmw
#这个是添加匿名用户,任何人都可以访问，如果去掉的话，需要输入用户名和密码，可以自己尝试
authorizer.add_anonymous(ftppath) #windows 路径用 /
#下载速度限制
# dtp_handler = ThrottledDTPHandler
# dtp_handler.read_limit = 30720 # 30 Kb/sec (30 * 1024)
# dtp_handler.write_limit = 30720 # 30 Kb/sec (30 * 1024)
#头部
handler = FTPHandler
handler.authorizer = authorizer
handler.banner = "pyftpdlib based ftpd ready."
#ssl 认证
handler.tls_control_required = True
handler.tls_data_required = True
#开启服务器
ip = socket.gethostbyname(socket.gethostname()) # 获取本机ip地址
# server = FTPServer((ip, 21), handler) #ip、端口、协议
server = ThreadedFTPServer((ip, port), handler) # 多线程
# server = MultiprocessFTPServer((ip, 21), handler) #多进程，多进程,3.x貌似去掉了
#连接数
server.max_cons = 48 #ip连接总数
server.max_cons_per_ip = 3 #每个ip连接总数
server.serve_forever() #一直打开
def start_using(self):
"""Increment use_count. If the FTP server is currently not running, start it in a new thread."""
self.use_count += 1
if self._server is None:
from cloudalpha.managers.ftp.ftp_server.file_system_adapter import FileSystemAdapter
from cloudalpha.managers.ftp.ftp_server.adapted_ftp_handler import AdaptedFTPHandler
# Get FileSystemAdapter
fs_adapter = FileSystemAdapter
# Initiate the FTP Handler class
handler = AdaptedFTPHandler
handler.authorizer = self._authorizer
handler.abstracted_fs = fs_adapter
handler.banner = "CloudAlpha FTP manager ready."
# Initiate and start the server
self._server = Server(("0.0.0.0", self._port), handler)
self._server.max_cons = self._server.max_cons_per_ip = 256
self._thread = FTPServerThread(self._server)
self._thread.start()
def start(self):
self.authorizer = DummyAuthorizer()
if self.config.get('usessl') == 'Yes':
self.logger.debug('Using SSL socket.')
keyfile_path = 'listeners/ssl_utils/privkey.pem'
keyfile_path = ListenerBase.abs_config_path(keyfile_path)
if keyfile_path is None:
self.logger.error('Could not locate %s', keyfile_path)
sys.exit(1)
self.handler = TLS_FakeFTPHandler
self.handler.certfile = keyfile_path
else:
self.handler = FakeFTPHandler
self.handler.banner = self.genBanner()
self.handler.ftproot_path = self.ftproot_path
self.handler.abstracted_fs = FakeFS
self.handler.authorizer = self.authorizer
self.handler.passive_ports = self.expand_ports(self.config.get('pasvports', '60000-60010'))
self.server = ThreadedFTPServer((self.local_ip, int(self.config['port'])), self.handler)
# Override pyftpdlib logger name
logging.getLogger('pyftpdlib').name = self.name
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
class FTPListener():
def __init__(self, config, name = 'FTPListener', logging_level = logging.INFO):
self.logger = logging.getLogger(name)
self.logger.setLevel(logging_level)
self.config = config
self.name = name
self.local_ip = '0.0.0.0'
self.server = None
self.logger.info('Starting...')
self.logger.debug('Initialized with config:')
for key, value in config.iteritems():
self.logger.debug(' %10s: %s', key, value)
# Initialize webroot directory
self.ftproot_path = self.config.get('ftproot','defaultFiles')
def expand_ports(self, ports_list):
ports = []
for i in ports_list.split(','):
if '-' not in i:
ports.append(int(i))
else:
l,h = map(int, i.split('-'))
ports+= range(l,h+1)
return ports
def start(self):
self.authorizer = DummyAuthorizer()
if self.config.get('usessl') == 'Yes':
self.logger.debug('Using SSL socket.')
keyfile_path = 'privkey.pem'
self.handler = TLS_FakeFTPHandler
self.handler.certfile = keyfile_path
else:
self.handler = FakeFTPHandler
self.handler.ftproot_path = self.ftproot_path
self.handler.abstracted_fs = FakeFS
self.handler.authorizer = self.authorizer
self.handler.passive_ports = self.expand_ports(self.config.get('pasvports', '60000-60010'))
self.server = ThreadedFTPServer((self.local_ip, int(self.config['port'])), self.handler)
# Override pyftpdlib logger name
logging.getLogger('pyftpdlib').name = self.name
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
def stop(self):
self.logger.debug('Stopping...')
if self.server:
self.server.close_all()
class FTPListener(object):
def taste(self, data, dport):
# See RFC5797 for full command list. Many of these commands are not likely
# to be used but are included in case malware uses FTP in unexpected ways
base_ftp_commands = [
'abor', 'acct', 'allo', 'appe', 'cwd', 'dele', 'help', 'list', 'mode',
'nlst', 'noop', 'pass', 'pasv', 'port', 'quit', 'rein', 'rest', 'retr',
'rnfr', 'rnto', 'site', 'stat', 'stor', 'stru', 'type', 'user'
]
opt_ftp_commands = [
'cdup', 'mkd', 'pwd', 'rmd', 'smnt', 'stou', 'syst'
]
confidence = 1 if dport == 21 else 0
data = data.lstrip().lower()
for command in base_ftp_commands + opt_ftp_commands:
if data.startswith(command):
return confidence + 1
return confidence
def __init__(self,
config,
name='FTPListener',
logging_level=logging.INFO,
running_listeners=None,
diverter=None
):
self.logger = logging.getLogger(name)
self.logger.setLevel(logging_level)
self.config = config
self.name = name
self.local_ip = config.get('ipaddr')
self.server = None
self.running_listeners = running_listeners
self.diverter = diverter
self.name = 'FTP'
self.port = self.config.get('port', 21)
self.logger.debug('Starting...')
self.logger.debug('Initialized with config:')
for key, value in config.iteritems():
self.logger.debug(' %10s: %s', key, value)
# Initialize ftproot directory
path = self.config.get('ftproot','defaultFiles')
self.ftproot_path = ListenerBase.abs_config_path(path)
if self.ftproot_path is None:
self.logger.error('Could not locate ftproot directory: %s', path)
sys.exit(1)
def expand_ports(self, ports_list):
ports = []
for i in ports_list.split(','):
if '-' not in i:
ports.append(int(i))
else:
l,h = map(int, i.split('-'))
ports+= range(l,h+1)
return ports
def start(self):
self.authorizer = DummyAuthorizer()
if self.config.get('usessl') == 'Yes':
self.logger.debug('Using SSL socket.')
keyfile_path = 'listeners/ssl_utils/privkey.pem'
keyfile_path = ListenerBase.abs_config_path(keyfile_path)
if keyfile_path is None:
self.logger.error('Could not locate %s', keyfile_path)
sys.exit(1)
self.handler = TLS_FakeFTPHandler
self.handler.certfile = keyfile_path
else:
self.handler = FakeFTPHandler
self.handler.banner = self.genBanner()
self.handler.ftproot_path = self.ftproot_path
self.handler.abstracted_fs = FakeFS
self.handler.authorizer = self.authorizer
self.handler.passive_ports = self.expand_ports(self.config.get('pasvports', '60000-60010'))
self.server = ThreadedFTPServer((self.local_ip, int(self.config['port'])), self.handler)
# Override pyftpdlib logger name
logging.getLogger('pyftpdlib').name = self.name
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
def stop(self):
self.logger.debug('Stopping...')
if self.server:
self.server.close_all()
def genBanner(self):
bannerfactory = BannerFactory.BannerFactory()
return bannerfactory.genBanner(self.config, BANNERS)
class FTPServerApp(tkinter.Frame):
root_dir = dict()
root_dir_tree = dict()
dir_tree_frame = dict()
def __init__(self, master=None):
tkinter.Frame.__init__(self, master)
self.grid(row=0, column=0)
# Main Frame
master.minsize(480,640)
self.local_ip_addr = socket.gethostbyname(socket.getfqdn())
self.local_port = int(LOWEST_PORT_NO)
master.title("FTP Server by TP031319 at %s" % (self.local_ip_addr,))
self.authorizer = DummyAuthorizer()
self.initialise()
self.create_server_control_frame(rw=0, cl=0)
self.create_input_frame(rw=0, cl=3)
self.create_state_frame(rw=1, cl=0)
self.create_dir_frame(rw=4, cl=0)
self.create_dir_tree_frame(rw=7, cl=0, tit="Local")
self.create_browse_button(rw=5, cl=4)
self.create_share_button(rw=5, cl=5)
self.create_stderr_frame(rw=12, cl=0)
self.handler = FTPHandler
self.handler.authorizer = self.authorizer
self.handler.banner = "FTP Server ver %s is ready" % VERSION #does this work in Python3?
def create_server_control_frame(self, rw, cl):
# Server Control Frame
self.server_control_frame = ttk.Frame(self, relief=constants.SOLID, borderwidth=1)
self.server_control_frame.grid(row=rw, column=cl, columnspan=4, sticky=constants.W,
pady=4, padx=5)
ttk.Label(self.server_control_frame, text="Server Control ").grid(row=rw, column=cl)
self.start_button = ttk.Button(self.server_control_frame, text="Start",
command=self.start_server)
self.start_button.grid(row=rw, column=cl+1)
self.stop_button = ttk.Button(self.server_control_frame, text="Stop", state=['disabled'],
command=self.stop_server)
self.stop_button.grid(row=rw, column=cl+2)
def create_state_frame(self, rw, cl):
# State Frame
state_frame = ttk.Frame(self, relief=constants.SOLID, borderwidth=1)
state_frame.grid(row=rw, column=cl, columnspan=3, sticky=constants.W, pady=4, padx=5)
ttk.Label(state_frame, text="Server State").grid(row=rw, column=cl)
state_value = ttk.Label(state_frame, textvariable=self.current_state, foreground='blue')
state_value.grid(row=rw, column=cl+1)
def create_input_frame(self, rw, cl):
self.input_frame = ttk.Frame(self, relief=constants.SOLID, borderwidth=1)
self.input_frame.grid(row=rw, column=cl, columnspan=3, sticky=constants.W, pady=4, padx=5)
port_input_label = ttk.Label(self.input_frame,
text="Server Port ({0}~{1})".format(LOWEST_PORT_NO, HIGHEST_PORT_NO))
port_input_label.grid(row=rw, column=cl+1, sticky=constants.W)
self.listen_port_input = ttk.Entry(self.input_frame, width=8, textvariable=self.listen_port)
self.listen_port_input.grid(row=rw+1, column=cl+1)
def create_dir_frame(self, rw, cl):
self.dir_frame = ttk.Frame(self, relief=constants.SOLID, borderwidth=1)
self.dir_frame.grid(row=rw, column=cl, columnspan=3, sticky=constants.W, pady=4, padx=5)
ttk.Label(self.dir_frame, text="Shared Directory").grid(row=rw, column=cl,
sticky=constants.W)
self.root_dir_input = ttk.Entry(self.dir_frame, width=64,
textvariable=self.root_dir['Local'])
self.root_dir_input.grid(row=rw+1, column=cl)
def create_browse_button(self, rw, cl):
self.browse_button = ttk.Button(self.dir_frame, text="Browse",
command=partial(self.select_dir, self.root_dir_tree['Local']))
self.browse_button.grid(row=rw, column=cl)
def create_share_button(self, rw, cl):
self.share_button = ttk.Button(self.dir_frame, text="Share",
command=partial(self.share_dir, self.root_dir_tree['Local']))
self.share_button.grid(row=rw, column=cl)
def create_dir_tree_frame(self, rw, cl, tit):
self.dir_tree_frame[tit] = ttk.Frame(self, relief=constants.SOLID, borderwidth=1)
self.root_dir_tree[tit] = RootTree(self, columns=('fullpath','type','size'),
displaycolumns='size', root_dir=self.root_dir[tit],
conn=self.ftp_conn if tit=='Remote' else None)
self.root_dir_tree[tit].heading('#0', text='Directory', anchor=constants.W)
self.root_dir_tree[tit].heading('size', text='Size', anchor=constants.W)
self.root_dir_tree[tit].column('#0', stretch=0, minwidth=200, width=440)
self.root_dir_tree[tit].column('size', stretch=1, minwidth=40, width=80)
self.dir_tree_frame[tit].grid(row=rw, column=cl, sticky=constants.W, pady=4, padx=5)
ttk.Label(self.dir_tree_frame[tit], text=tit).grid(row=rw, column=cl, sticky=constants.W)
self.root_dir_tree[tit].grid(in_=self.dir_tree_frame[tit], row=rw+1, column=cl,
sticky=constants.NSEW)
yScrollBar = ttk.Scrollbar(self.dir_tree_frame[tit], orient=constants.VERTICAL,
command=self.root_dir_tree[tit].yview)
xScrollBar = ttk.Scrollbar(self.dir_tree_frame[tit], orient=constants.HORIZONTAL,
command=self.root_dir_tree[tit].xview)
self.root_dir_tree[tit]['yscroll'] = yScrollBar.set
self.root_dir_tree[tit]['xscroll'] = xScrollBar.set
yScrollBar.grid(row=rw, column=cl+2, rowspan=3, sticky=constants.NS)
xScrollBar.grid(row=rw+3, column=cl, rowspan=1, sticky=constants.EW)
# set frame resizing priorities
self.dir_tree_frame[tit].rowconfigure(0, weight=1)
self.dir_tree_frame[tit].columnconfigure(0, weight=1)
def create_stderr_frame(self, rw, cl):
self.stderr_frame = ttk.Frame(self, relief=constants.SOLID, borderwidth=1)
self.stderr_frame.grid(row=rw, column=cl)
self.old_stderr = sys.stderr
self.err = tkinter.Text(self, width=64, height=12, wrap='none')
self.err.grid(row=rw+1, column=cl, pady=4, padx=5)
sys.stderr = StdoutRedirector(self.err)
def initialise(self):
# Initial values
self.username = tkinter.StringVar()
self.username.set("user")
self.password = tkinter.StringVar()
self.password.set("passwd")
self.listen_ip = tkinter.StringVar()
self.listen_ip.set(self.local_ip_addr)
self.listen_port = tkinter.StringVar()
self.listen_port.set(self.local_port)
self.root_dir['Local'] = tkinter.StringVar()
self.root_dir['Local'].set(os.getcwd() + os.sep)
self.current_state = tkinter.StringVar()
self.current_state.set("NOT RUNNING")
self.root_dir['Remote'] = tkinter.StringVar()
self.root_dir['Remote'].set(os.sep)
# This can be set up only once and saved in a database
self.authorizer.add_user(self.username.get(), self.password.get(),
self.root_dir['Local'].get(), 'elradfmw')
def start_server(self):
port_no = 0
msg = "Please type a port number between 1025 and 65533 inclusive."
try:
port_no = int(self.listen_port.get())
if port_no < LOWEST_PORT_NO or port_no > HIGHEST_PORT_NO:
msg += " Port {0} is not valid.".format(port_no)
raise Exception(msg)
except:
mbox.showinfo(message=msg)
return
self.address = (self.listen_ip.get(), port_no)
self.server = ThreadedFTPServer(self.address, self.handler)
self.server.max_cons = 256
self.server.max_cons_per_ip = 5
self.share_dir(self.root_dir_tree['Local'])
self.start_button.state(['disabled'])
self.stop_button.state(['!disabled'])
self.share_button.state(['disabled'])
self.current_state.set("RUNNING")
threading.Thread(target=self.server.serve_forever).start()
def stop_server(self):
self.server.close_all()
self.start_button.state(['!disabled'])
self.stop_button.state(['disabled'])
self.share_button.state(['!disabled'])
self.current_state.set("NOT RUNNING")
def select_dir(self, dir_tree_view):
if isinstance(dir_tree_view, RootTree):
children = dir_tree_view.get_children('')
if children:
dir_tree_view.delete(children)
old_dir_tree_view_root_dir = dir_tree_view.root_directory.get()
dir_tree_view.root_directory.set(filedialog.askdirectory().replace("/" , str(os.sep)))
if not dir_tree_view.root_directory.get():
dir_tree_view.root_directory.set(old_dir_tree_view_root_dir)
def share_dir(self, dir_tree_view):
if isinstance(dir_tree_view, RootTree):
try:
os.chdir(self.root_dir['Local'].get())
dir_tree_view.root_directory = self.root_dir['Local']
# No need to reconnect because this is only for local dir
dir_tree_view.populate_parent()
# Open up the directory for transferring out/receiving in files
# For use with WindowsAuthorizer or UnixAuthorizer:
# For simplicity's sake, update the homedir everytime Share button is pressed
# self.authorizer.override_user(self.username.get(),
# homedir=self.root_dir['Local'].get())
# For now the workaround:
self.authorizer.remove_user(self.username.get())
self.authorizer.add_user(self.username.get(), self.password.get(),
self.root_dir['Local'].get(), 'elradfmw')
except FileNotFoundError:
mbox.showinfo(message="Invalid Directory!")
def run(self): self.server = ThreadedFTPServer((self.ip, self.port), self.handler) self.server.serve_forever()
class DeployAgent(object):
def __init__(self, ftpaddr, ftpport, ftphome, rpcaddr, rpcport):
self.ftpaddr = ftpaddr
self.ftpport = ftpport
self.ftphome = ftphome
self.rpcaddr = rpcaddr
self.rpcport = rpcport
logger.info("--- xagent startup ---")
XOR.File.mkpath(self.ftphome)
authorizer = DummyAuthorizer()
authorizer.add_anonymous(self.ftphome, perm='elradfmwM')
handler = FTPHandler
handler.authorizer = authorizer
handler.banner = "xagent ftp server ready"
self.ftpserver = ThreadedFTPServer((self.ftpaddr, self.ftpport), handler)
self.rpcserver = XOR.Net.XMLRPCServer(addr=(self.rpcaddr, self.rpcport), logRequests=True, allow_none=True, encoding="UTF-8")
self.rpcserver.reg_function(XOR.OS.runex, "os.")
self.rpcserver.reg_function(XOR.OS.type, "os.")
self.rpcserver.reg_function(XOR.Zip.extract, "zip.")
self.rpcserver.reg_function(XOR.File.remove, "file.")
self.rpcserver.reg_function(self.reg_package)
self.rpcserver.reg_function(self.shutdown)
self.rpcserver.reg_function(self.set_logger)
self.rpcserver.reg_function(self.del_logger)
self.rpcserver.reg_function(self.get_ftphomedir)
self.rpcserver.register_introspection_functions()
self.rpcserver.register_multicall_functions()
def startup(self):
self.ftpthread = threading.Thread(target=lambda:self.ftpserver.serve_forever())
self.ftpthread.daemon = True
self.ftpthread.start()
self.rpcthread = threading.Thread(target=lambda:self.rpcserver.serve_forever())
self.rpcthread.daemon = True
self.rpcthread.start()
def shutdown(self):
self.ftpserver.close_all()
self.rpcserver.shutdown()
def join(self):
self.ftpthread.join()
self.rpcthread.join()
def set_logger(self, logurl):
logger.info("set httphandler: %s", logurl)
if hasattr(self, "httphandler"):
self.del_logger()
match = re.match("http://(.*:\d{1,5})/(.*)", logurl)
host = match.group(1)
path = "/%s" % match.group(2)
logger.info("log host: %s", host)
logger.info("log path: %s", path)
self.httphandler = logging.handlers.HTTPHandler(host, path, "POST")
self.httphandler.setLevel(logging.DEBUG)
logger.info("set httphandler: %s", logurl)
rootlogger.addHandler(self.httphandler)
def del_logger(self):
logger.info("delete logging httphandler: %s" % self.httphandler)
rootlogger.removeHandler(self.httphandler)
def reg_package(self, name, path=[], clss=[]):
found = imp.find_module( name, path )
imp.load_module(name, *found)
self.rpcserver.reg_module(sys.modules[name], clss, "%s." % name)
def get_ftphomedir(self):
return self.ftphome
@staticmethod
def parse_args():
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('--host', action='store', default="0.0.0.0")
parser.add_argument('--rpcport', action='store', type=int, default=3333)
parser.add_argument('--ftpport', action='store', type=int, default=6121)
parser.add_argument('--ftpusername', action='store', default="xor")
parser.add_argument('--ftppassword', action='store', default="xor")
parser.add_argument('--ftphomedir', action='store', default= os.path.join( os.path.dirname(bindir), "dist" ))
args = parser.parse_known_args()
return vars(args[0])
return options
options = parse_options(argv[1:])
path = options.root_path if options.root_path else '.'
authorizer = DummyAuthorizer()
authorizer.add_user('john', 'john', path, perm='elradfmwM')
authorizer.add_anonymous(path)
handler = FTPHandler
handler.authorizer = authorizer
handler.banner = "pyftpdlib based ftpd ready."
logging.basicConfig(stream=stdout)
address = ('127.0.0.1', options.port)
server = ThreadedFTPServer(address, handler)
server.max_cons = 256
server.max_cons_per_ip = 5
def start_server():
global server
server.serve_forever()
def main():
global server
t = Thread(target=start_server)
t.start()
sleep(3)
server.close_all()
class FTPServer:
"""A singleton FTP server which each user has access to a distinct
cloudalpha.file_system_view.FileSystemView instance.
"""
_instance = None
_port = None
_server = None
_thread = None
_authorizer = DummyAuthorizer()
_file_system_views = {}
use_count = 0
def __new__(cls, *args, **kwargs):
"""Return the singleton instance."""
if not cls._instance:
cls._instance = super(FTPServer, cls).__new__(cls, *args, **kwargs)
cls._instance._port = FTPSettings.ftp_server_port
return cls._instance
def user_exists(self, username):
"""Return a boolean value indicating if the specified username exists."""
return username in self._file_system_views
def add_user(self, username, password, file_system_view):
"""Add a new user with the given username and password, associated
to the specified cloudalpha.file_system_view.FileSystemView instance."""
self._file_system_views[username] = file_system_view
self._authorizer.add_user(username, password, "/", perm="elradfmw")
def remove_user(self, username):
"""Remove the user corresponding to the given username."""
self._authorizer.remove_user(username)
del self._file_system_views[username]
def get_file_system_view(self, username):
"""Get the cloudalpha.file_system_view.FileSystemView instance
corresponding to the given username."""
return self._file_system_views[username]
def start_using(self):
"""Increment use_count. If the FTP server is currently not running, start it in a new thread."""
self.use_count += 1
if self._server is None:
from cloudalpha.managers.ftp.ftp_server.file_system_adapter import FileSystemAdapter
from cloudalpha.managers.ftp.ftp_server.adapted_ftp_handler import AdaptedFTPHandler
# Get FileSystemAdapter
fs_adapter = FileSystemAdapter
# Initiate the FTP Handler class
handler = AdaptedFTPHandler
handler.authorizer = self._authorizer
handler.abstracted_fs = fs_adapter
handler.banner = "CloudAlpha FTP manager ready."
# Initiate and start the server
self._server = Server(("0.0.0.0", self._port), handler)
self._server.max_cons = self._server.max_cons_per_ip = 256
self._thread = FTPServerThread(self._server)
self._thread.start()
def stop_using(self):
"""If the FTP server is currently running, decrement use_count. If
the new value of use_count is zero, stop the server."""
if self._server is not None:
self.use_count -= 1
if self.use_count < 1:
self._server.stop()
return True
