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)
