def main(): # Instantiate a dummy authorizer for managing 'virtual' users authorizer = ftpserver.DummyAuthorizer() # Define a new user having full r/w permissions and a read-only # anonymous user authorizer.add_user('user', '12345', os.getcwd(), perm='elradfmwM') authorizer.add_anonymous(os.getcwd()) # Instantiate FTP handler class handler = ftpserver.FTPHandler handler.authorizer = authorizer # Define a customized banner (string returned when client connects) handler.banner = "pyftpdlib %s based ftpd ready." % ftpserver.__ver__ # Specify a masquerade address and the range of ports to use for # passive connections. Decomment in case you're behind a NAT. #handler.masquerade_address = '151.25.42.11' #handler.passive_ports = range(60000, 65535) # Instantiate FTP server class and listen on 0.0.0.0:21 address = ('', 21) ftpd = ftpserver.FTPServer(address, handler) # set a limit for connections ftpd.max_cons = 256 ftpd.max_cons_per_ip = 5 # start ftp server ftpd.serve_forever()
def setUp(self): self.port = random.choice(range(9000, 11000)) authorizer = ftpserver.DummyAuthorizer() self.dir = tempfile.mkdtemp() self.user = '******' self.password = '******' ftpserver.log = lambda x: None ftpserver.logline = lambda x: None authorizer.add_user(self.user, self.password, self.dir, perm='elradfmw') address = ('127.0.0.1', self.port) ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer self.ftpd = ftpserver.FTPServer(address, ftp_handler) class RunServer(Thread): def run(self): try: self.ftpd.serve_forever() except Exception: pass s = RunServer() s.ftpd = self.ftpd s.start()
def __init__(self, conn, server, config, db_file): ftpserver.FTPHandler.__init__(self, conn, server) self.config = config = textual.utf8(config) self.ip = inet.get_ip(conn.getpeername()) self.db_file = db_file self.config_ip = config_reader.get_config_ip(self.ip, config) if not self.config_ip: conn.send( 'Please add your device %s to ftp_collector in LogInspect to send logs.\n' % self.ip) self.close() return self.profiles = config['client_map'][self.config_ip] # TODO use hashed password in config file self.authorizer = ftpserver.DummyAuthorizer() for user, profile in self.profiles.iteritems(): password = profile['password'] permission = profile['permission'] basedir = config['basedir'].replace('$LOGINSPECT_HOME', homing.LOGINSPECT_HOME) home = profile['home'].lstrip('/') # let home not be absolute path user_home = os.path.join(basedir, home) disk.prepare_path(user_home + '/') self.authorizer.add_user(user, password, user_home, permission)
def __init__(self, conn, server, config, db_file, parser_name_only): ftpserver.FTPHandler.__init__(self, conn, server) self.config = config = textual.utf8(config) self.ip = inet.get_ip(conn.getpeername()) self.db_file = db_file self.parser_name_only = parser_name_only self.config_ip = config_reader.get_config_ip(self.ip, config) if not self.config_ip: conn.send("Please add your device %s to ftp_collector in LogInspect to send logs.\n" % self.ip) self.close() return self.profiles = config["client_map"][self.config_ip] self.authorizer = ftpserver.DummyAuthorizer() for user, profile in self.profiles.iteritems(): password = outself.get_decrypted_password(profile["password"]) permission = profile["permission"] basedir = config["basedir"].replace("$LOGINSPECT_HOME", homing.LOGINSPECT_HOME) home = profile["home"].lstrip("/") # let home not be absolute path user_home = os.path.join(basedir, home) disk.prepare_path(user_home + "/") self.authorizer.add_user(user, password, user_home, permission)
def mainfunc(): global authorizer global ttl user = [] __user_table = {} addr = ("", 21) ttl = 60 ftpserver.log = standard_logger ftpserver.logline = line_logger authorizer = ftpserver.DummyAuthorizer() conf = ConfigParser.ConfigParser() conf.read(currdir + currname + ".conf") sections = conf.sections() global f1, f2 for i in sections: if i != '!ftpd': if not os.path.isdir(conf.get(i, 'dir')): print('No such directory: "%s"' % conf.get(i, 'dir')) continue else: user.append(i) if i == '!ftpd': addr = (conf.get('!ftpd', 'host'), int(conf.get('!ftpd', 'port'))) ttl = int(conf.get('!ftpd', 'ttl')) _servername = conf.get('!ftpd', 'servername') sys.stdout.write("Server Name: %s\n" % _servername) sys.stdout.flush() _maxcon = int(conf.get('!ftpd', 'maxconnect')) _maxconperu = int(conf.get('!ftpd', 'maxconperuser')) f1 = open(conf.get('!ftpd', 'logfile'), 'a') f2 = open(conf.get('!ftpd', 'lineslogfile'), 'a') if ttl == 0: ttl = 60 for i in user: __dir = conf.get(i, 'dir') __password = conf.get(i, 'password') __power = conf.get(i, 'access') __dir = os.path.realpath(__dir) authorizer._check_permissions(i, __power) dic = { 'pwd': str(__password), 'home': __dir, 'perm': __power, 'operms': {}, 'msg_login': str("Login successful."), 'msg_quit': str("Goodbye.") } __user_table[i] = dic authorizer.user_table = __user_table ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer ftp_handler.banner = _servername ftpd = ftpserver.FTPServer(addr, ftp_handler) ftpd.max_cons = _maxcon ftpd.max_cons_per_ip = _maxconperu UpConf().start() line_logger('~~~~~~~~~Serve forever......') ftpd.serve_forever()
def ftpServer(ftpHost, ftpPort, ftpLogin, ftpPasswd, ftpPath, ftpPerm): from pyftpdlib import ftpserver authorizer = ftpserver.DummyAuthorizer() authorizer.add_user(ftpLogin, ftpPasswd, ftpPath, ftpPerm) handler = ftpserver.FTPHandler handler.authorizer = authorizer address = (ftpHost, ftpPort) ftpd = ftpserver.FTPServer(address, handler) ftpd.serve_forever()
def ftp_server(ftp_dir, user, password): """Start a local ftp server.""" authorizer = ftpserver.DummyAuthorizer() authorizer.add_user(user, password, ftp_dir, "elradfmw", "hi!", "bye") authorizer.add_anonymous(ftp_dir) handler = ftpserver.FTPHandler handler.authorizer = authorizer address = "127.0.0.1", 2121 # use 2121 to avoid security policies conflict ftpd = ftpserver.FTPServer(address, handler) ftpd.serve_forever()
def main(): authorizer = ftpserver.DummyAuthorizer() authorizer.add_user('user', '12345', '.', perm='elradfmw') authorizer.add_anonymous('.') ftp_handler = TLS_FTPHandler ftp_handler.certfile = CERTFILE ftp_handler.authorizer = authorizer # requires SSL for both control and data channel #ftp_handler.tls_control_required = True #ftp_handler.tls_data_required = True ftpd = ftpserver.FTPServer(('', 8021), ftp_handler) ftpd.serve_forever()
def run(self): try: authorizer = ftpserver.DummyAuthorizer() authorizer.add_user('anonymous', '',self.Path,perm="elradfmw") handler = ftpserver.FTPHandler handler.authorizer = authorizer address = (self.localIP, 54221) self.ftpd = ftpserver.FTPServer(address, handler) self.ftpd.serve_forever() print('ftp started') except BaseException,e: print(str(e))
def serve_fs(fs, addr, port): """ Creates a basic anonymous FTP server serving the given FS on the given address/port combo. """ from pyftpdlib.contrib.authorizers import UnixAuthorizer ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = ftpserver.DummyAuthorizer() ftp_handler.authorizer.add_anonymous('/') ftp_handler.abstracted_fs = FTPFSFactory(fs) s = ftpserver.FTPServer((addr, port), ftp_handler) s.serve_forever()
def setUpClass(cls): cls.pid = os.fork() if cls.pid == 0: uri = urlparse(cls.uri) authorizer = ftpserver.DummyAuthorizer() authorizer.add_user(uri.username, uri.password, sample_root, perm="elradfmw") handler = ftpserver.FTPHandler handler.authorizer = authorizer ftpd = ftpserver.FTPServer((uri.hostname, uri.port), handler) ftpd.serve_forever() time.sleep(0.5) # give time for the FTP server to launch TestBase.setUpClass() cls.transporter = transporter.Transporter(cls.uri)
def startFTPServer(): """ Starts an FTP server so that the encoders, ui, and server can swap files back and forth """ homeDir = os.path.join(os.path.expanduser("~"), 'master') if not os.path.exists(homeDir): os.makedirs(self.homeDir) print homeDir auth = ftpserver.DummyAuthorizer() auth.add_user(ftp_user, ftp_pass, homeDir, perm='elrwda') handler = ftpserver.FTPHandler handler.authorizer = auth address = ("0.0.0.0", ftp_port) ftpd = ftpserver.FTPServer(address, handler) ftpd.serve_forever()
def main(): authorizer = ftpserver.DummyAuthorizer() authorizer.add_user('user', '12345', os.getcwd(), perm='elradfmw') authorizer.add_anonymous(os.getcwd()) dtp_handler = ftpserver.ThrottledDTPHandler dtp_handler.read_limit = 30720 # 30 Kb/sec (30 * 1024) dtp_handler.write_limit = 30720 # 30 Kb/sec (30 * 1024) ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer # have the ftp handler use the alternative dtp handler class ftp_handler.dtp_handler = dtp_handler ftpd = ftpserver.FTPServer(('', 21), ftp_handler) ftpd.serve_forever()
def __init__(self, homedir, user=G.FTP_USER, password=G.FTP_PASSWORD, port=G.FTP_PORT, db_host=G.DB_HOST): """ Initialize FTP settings """ logger.debug("* Starting Incoming FTP Server") self.user = user self.password = password # Instantiate a dummy authorizer for managing 'virtual' users authorizer = ftpserver.DummyAuthorizer() # Ensure our root directory exists if not os.path.exists(homedir): os.makedirs(homedir) # create upload directory if it doesn't exist if not os.path.exists(os.path.join(homedir,'upload')): os.makedirs(os.path.join(homedir,'upload')) # Define a new user having full r/w permissions and a read-only # anonymous user authorizer.add_user(user, password=password, homedir=homedir, perm='elradfmw') # Instantiate FTP handler class handler = JobHandler handler.authorizer = authorizer # TODO: check if this works # create connection to our db handler.datastore = DatastoreSamples(db_host) # Define a customized banner (string returned when client connects) handler.banner = "LO-PHI FTP Server at your service!" # Instantiate FTP server class and listen to 0.0.0.0:21 address = ('', port) self.server = ftpserver.FTPServer(address, handler) # set a limit for connections self.server.max_cons = 256 self.server.max_cons_per_ip = 5
def __init__(self, conn, server, config): ftpserver.FTPHandler.__init__(self, conn, server) self.ip = inet.get_ip(conn.getpeername()) logging.warn( 'FileInspect FTP Server; Connection attempted from IP %r' % self.ip) self.authorizer = ftpserver.DummyAuthorizer() user = config['username'] password = config['password'] basedir = config['basedir'].replace('$LOGINSPECT_HOME', homing.LOGINSPECT_HOME) permission = config['permission'] self.authorizer.add_user(user, password, basedir, permission)
def runpool(number_of_processes): # create a single server object -- children will each inherit a copy authorizer = ftpserver.DummyAuthorizer() authorizer.add_user('user', password="******", homedir=os.getcwd() + "/REV", perm='elradfmw') # handler = YourHandler # If we use our logic handler = ftpserver.FTPHandler handler.tcp_no_delay = True handler.authorizer = authorizer address = ('192.168.203.167', 21) server = ftpserver.FTPServer(address, handler) # create child processes to act as workers for i in range(number_of_processes-1): Process(target=serve_forever, args=(server,)).start() # main process also acts as a worker serve_forever(server)
def __init__(self, eframe, ftp_dir): self.__eframe = eframe authorizer = ftpserver.DummyAuthorizer() authorizer.add_user(self.__eframe.ftp_username, self.__eframe.ftp_password, ftp_dir, perm="elr") ftp_handler = EFrameFTPHandler ftp_handler.authorizer = authorizer ftp_handler.abstracted_fs = EFrameAbstractedFS self.__ftpd = ftpserver.FTPServer(("0.0.0.0", self.__eframe.ftp_port), ftp_handler) self.__ftp_thread = threading.Thread(target=self.__ftpd.serve_forever) self.__ftp_thread.setDaemon(True) ftpserver.log = self.nolog ftpserver.logline = self.nolog self.__ftp_thread.start()
def start_server (host, port): def line_logger(msg): if "kill" in msg: raise KeyboardInterrupt() try: from pyftpdlib import ftpserver except ImportError: pytest.skip("pyftpdlib is not available") return authorizer = ftpserver.DummyAuthorizer() datadir = os.path.join(os.path.dirname(__file__), 'data') authorizer.add_anonymous(datadir) # Instantiate FTP handler class ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer ftp_handler.timeout = TIMEOUT ftpserver.logline = line_logger # Define a customized banner (string returned when client connects) ftp_handler.banner = "pyftpdlib %s based ftpd ready." % ftpserver.__ver__ # Instantiate FTP server class and listen to host:port address = (host, port) server = ftpserver.FTPServer(address, ftp_handler) port = server.address[1] t = threading.Thread(None, server.serve_forever) t.start() # wait for server to start up tries = 0 while tries < 5: tries += 1 try: ftp = FTP() ftp.connect(host, port, TIMEOUT) ftp.login() ftp.close() break except: time.sleep(0.5) return port
def main(): parser = create_option_parser(usage='%prog [options]') parser.add_option( "--ftp_host", nargs=1, dest="ftp_host", help= "Server host or IP address to bind on. Only change if running in an isolated network!", default='localhost') parser.add_option("--ftp_port", nargs=1, dest="ftp_port", help="Server port to bind on.", default=2121) options = parser.parse_args()[0] authorizer = ftpserver.DummyAuthorizer() authorizer.add_anonymous('/', perm=('r', 'w')) address = (options.ftp_host, options.ftp_port) if options.ftp_host != 'localhost': import warnings warnings.warn( 'Running aksyftpd on non-local address %s' % options.ftp_host, RuntimeWarning) sampler = Devices.get_instance(options.sampler_type, options.connector) try: ftp_handler = ftpserver.FTPHandler ftp_handler.authorizer = authorizer ftp_handler.banner = "aksyftpd (pyftpd version %s) ready." % ftpserver.__ver__ ftp_handler.abstracted_fs = AksyFtpFS(sampler) ftpd = ftpserver.FTPServer(address, ftp_handler) ftpd.max_cons = 256 ftpd.max_cons_per_ip = ftpd.max_cons ftpd.serve_forever() finally: sampler.close()
def listen(db, config, updater): repo = config["repo"] localfile = get_downloaded_file(db, repo) if localfile: logging.warn("file already downloaded at %r", localfile) return localfile channel = config["upload_channel"] username = channel["username"] password = channel["password"] home = channel["home"].replace("$LOGINSPECT_HOME", homing.LOGINSPECT_HOME).replace("$repo", repo) disk.prepare_path(home + '/') address = ('0.0.0.0', channel["port"]) authorizer = ftpserver.DummyAuthorizer() authorizer.add_user(username, password, home, "elradfmwM") FTPHandler.authorizer = authorizer ftpd = ftpserver.FTPServer(address, lambda conn, server: FTPHandler(conn, server, db, repo)) logging.warn("ftp server starting at %r", address) ftpd.serve_forever() return DOWNLOADED_FILE
def __init__(self): object.__init__(self) from optparse import OptionParser parser = OptionParser() parser.add_option("--secure", default=False, action="store_true", help="Require explicit TLS on command and data connections") parser.add_option("--port", default=1337, action="store", type="int", help="Set the {0} FTP port".format(self.__program__)) options, posargs = parser.parse_args() #print options, posargs from config import Config config = Config() from pyftpdlib import ftpserver if options.secure: from pyftpdlib.contrib.handlers import TLS_FTPHandler as handler handler.tls_control_required = True handler.certfile = "wotevs.pem" else: handler = ftpserver.FTPHandler handler.banner = "{0} ready".format(self.__title__) from filesys import LanshareFS LanshareFS.shares = config.shares handler.abstracted_fs = LanshareFS authorizer = ftpserver.DummyAuthorizer() authorizer.add_anonymous(homedir=None) handler.authorizer = authorizer import socket server = ftpserver.FTPServer(("0.0.0.0", options.port), handler) print "FTP server listening on {0}".format(server.socket.getsockname()) self.server = server self.config = config self.port = options.port
os.popen('TASKKILL /PID ' + str(self.ftp_server.pid) + ' /F') else: os.system('kill ' + str(self.ftp_server.pid)) shutil.rmtree(self.temp_dir) self.fs.close() def check(self, p): check_path = self.temp_dir.rstrip(os.sep) + os.sep + p return os.path.exists(check_path.encode('utf-8')) if __name__ == "__main__": # Run an ftp server that exposes a given directory import sys authorizer = ftpserver.DummyAuthorizer() authorizer.add_user("user", "12345", sys.argv[1], perm="elradfmw") authorizer.add_anonymous(sys.argv[1]) def nolog(*args): pass ftpserver.log = nolog ftpserver.logline = nolog handler = ftpserver.FTPHandler handler.authorizer = authorizer address = ("127.0.0.1", int(sys.argv[2])) #print address ftpd = ftpserver.FTPServer(address, handler)