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()
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(): # 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 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