def main(args=None):
ap = argparse.ArgumentParser()
ap.add_argument(
"-p",
"--port",
type=int,
default=21,
help="FTP server port (default: %(default)s)",
)
ap.add_argument(
"-u",
"--user",
default="joedoe",
help="User account name (default: %(default)s)",
)
ap.add_argument(
"-P",
"--password",
default="abc123",
help="User account password (default: %(default)s)",
)
ap.add_argument(
"-c",
"--certfile",
default="keycert.pem",
help="Certificate/Keyfile (default: %(default)s)",
)
ap.add_argument("-s",
"--tls",
action="store_true",
help="Enable and require TLS")
ap.add_argument(
"-w",
"--writable",
action="store_true",
help="Allow authenticated users to write to FTP root directory",
)
ap.add_argument("-v",
"--verbose",
action="store_true",
help="Enable verbose (debug) output")
ap.add_argument("rootdir",
nargs='?',
default=os.getcwd(),
help="FTP root directory (default: current working dir)")
args = ap.parse_args(args)
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
perm = args.writable and "elradfmwMT" or "elr"
authorizer = DummyAuthorizer()
authorizer.add_user(args.user, args.password, args.rootdir, perm=perm)
authorizer.add_anonymous(args.rootdir, perm="elr")
if args.tls:
handler = TLS_FTPHandler
handler.certfile = args.certfile
# requires SSL for both control and data channel
handler.tls_control_required = True
handler.tls_data_required = True
else:
handler = FTPHandler
handler.authorizer = authorizer
server = FTPServer(("", args.port), handler)
server.serve_forever()
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from pyftpdlib.authorizers import DummyAuthorizer
from pyftpdlib.handlers import FTPHandler
from pyftpdlib.servers import FTPServer
yonetici = DummyAuthorizer()
yonetici.add_anonymous("C:/sunucu", perm="elradfmw")
yonetici.add_user("minnela", "italy", "C:/sunucu", perm="elradfmw")
yonetici.add_user("sixfinger",
"Angela Fortunata",
"C:/sunucu",
perm="elradfmw")
print("bitti")
# In[ ]:
handler = FTPHandler
handler.authorizer = yonetici
server = FTPServer(("127.0.0.1", 1200), handler)
server.serve_forever()
print("bitti")
# In[ ]:
def user():
author = DummyAuthorizer()
return author
def main():
"""
main
"""
parser = argparse.ArgumentParser("Simple ftp server")
parser.add_argument('-c',
action='store',
dest='cfg_name',
default="/etc/pyftpd.yaml",
help="YAML filename")
options = parser.parse_args()
if not os.path.isfile(options.cfg_name):
print("Error! Configuration file %s is not exit..." % options.cfg_name)
sys.exit(0)
stream = open(options.cfg_name, 'r')
cfg = yaml.load(stream)
ftp_cfg = cfg['server']
open_logfile(ftp_cfg['log_dir'])
logging.info("log dir : %s" % ftp_cfg['log_dir'])
home_dir = get_dir(ftp_cfg['incoming_dir'])
logging.info("home dir : %s" % home_dir)
authorizer = DummyAuthorizer()
authorizer.add_user(ftp_cfg['username'],
ftp_cfg['password'],
home_dir,
perm="elradfmw")
#authorizer.add_anonymous("/home/nobody")
handler = MyHandler # FTPHandler is the default handler
handler.authorizer = authorizer
handler.target_dir = get_dir(cfg['post-processing']['target_dir'])
# enable for docker case
handler.permit_foreign_addresses = True
try:
listening_port = os.environ["PYFTPD_PORT"]
listening_port = eval(listening_port)
except KeyError:
listening_port = ftp_cfg['port_number']
logging.info("Listening port : %d" % listening_port)
print("Listening port : %d" % listening_port)
try:
passive_ports = os.environ["PYFTPD_PASSIVE_PORT"]
print("Passive port : %s" % passive_ports)
p_ports = passive_ports.split('-')
if len(p_ports) == 2:
handler.passive_ports = range(eval(p_ports[0]), eval(p_ports[1]))
logging.info("Passive mode : %s" % passive_port)
except:
logging.info("Active mode")
pass
server = FTPServer((ftp_cfg['ip_address'], listening_port), handler)
server.serve_forever()
def main():
"""Start a stand alone anonymous FTP server."""
usage = "python -m pyftpdlib.ftpserver [options]"
parser = optparse.OptionParser(usage=usage,
description=main.__doc__,
formatter=CustomizedOptionFormatter())
parser.add_option('-i',
'--interface',
default=None,
metavar="ADDRESS",
help="specify the interface to run on (default all "
"interfaces)")
parser.add_option('-p',
'--port',
type="int",
default=2121,
metavar="PORT",
help="specify port number to run on (default 21)")
parser.add_option('-w',
'--write',
action="store_true",
default=False,
help="grants write access for the anonymous user "
"(default read-only)")
parser.add_option('-d',
'--directory',
default=getcwdu(),
metavar="FOLDER",
help="specify the directory to share (default current "
"directory)")
parser.add_option('-n',
'--nat-address',
default=None,
metavar="ADDRESS",
help="the NAT address to use for passive connections")
parser.add_option('-r',
'--range',
default=None,
metavar="FROM-TO",
help="the range of TCP ports to use for passive "
"connections (e.g. -r 8000-9000)")
parser.add_option('-v',
'--version',
action='store_true',
help="print pyftpdlib version and exit")
parser.add_option('-V',
'--verbose',
action='store_true',
help="activate a more verbose logging")
options, args = parser.parse_args()
if options.version:
sys.exit("pyftpdlib %s" % __ver__)
if options.verbose:
import logging
import pyftpdlib.log
pyftpdlib.log.LEVEL = logging.DEBUG
passive_ports = None
if options.range:
try:
start, stop = options.range.split('-')
start = int(start)
stop = int(stop)
except ValueError:
parser.error('invalid argument passed to -r option')
else:
passive_ports = list(range(start, stop + 1))
# On recent Windows versions, if address is not specified and IPv6
# is installed the socket will listen on IPv6 by default; in this
# case we force IPv4 instead.
if os.name in ('nt', 'ce') and not options.interface:
options.interface = '0.0.0.0'
authorizer = DummyAuthorizer()
perm = options.write and "elradfmwM" or "elr"
authorizer.add_anonymous(options.directory, perm=perm)
handler = FTPHandler
handler.authorizer = authorizer
handler.masquerade_address = options.nat_address
handler.passive_ports = passive_ports
ftpd = FTPServer((options.interface, options.port), FTPHandler)
try:
ftpd.serve_forever()
finally:
ftpd.close_all()
def setup_authorization(config):
authorizer = DummyAuthorizer()
authorizer.add_user(config.ftpserver.username, config.ftpserver.password, config.incoming_directory, perm='lrwe')
authorizer.add_anonymous(config.artifacts_directory)
AppRepoFtpHandler.authorizer = authorizer
def run_ftp_server(para=None):
# 初始化参数
server_ip = gol.get_value('ftp_ip')
server_port = gol.get_value('ftp_port')
server_model = gol.get_value('ftp_model')
masquerade_ip = gol.get_value('ftp_masquerade_ip')
passive_ports = gol.get_value('ftp_passive_ports')
max_cons = gol.get_value('ftp_max_cons')
max_cons_per_ip = gol.get_value('ftp_max_cons_per_ip')
# FTP日志
logger = logging.getLogger()
logger.setLevel(logging.INFO)
log_handler = TimedRotatingFileHandler(filename='app_ftpserver.log',
when='d',
interval=1,
backupCount=7)
formatter = logging.Formatter('[%(asctime)s-%(levelname)s] - %(message)s')
log_handler.setFormatter(formatter)
logger.addHandler(log_handler)
#实例化虚拟用户，这是FTP验证首要条件
authorizer = DummyAuthorizer()
#添加用户
for i in ['update','pdf','equip']:
user = gol.get_value('%s_user' %i)
passwd = gol.get_value('%s_passwd' % i)
path = gol.get_value('%s_path' % i)
perm = gol.get_value('%s_perm' % i)
# 添加用户权限和路径，括号内的参数是(用户名， 密码， 用户目录， 权限)
authorizer.add_user(user, passwd, path, perm=perm)
# 匿名账户
# authorizer.add_anonymous("D:/")
#初始化ftp句柄
handler = MyHandler
handler.authorizer = authorizer
handler.max_login_attempts=20
# 如果你在NAT之后，就用这个指定被动连接的参数
if not masquerade_ip:
logger.info("FTP服务：主动模式！")
else:
handler.masquerade_address = masquerade_ip
handler.passive_ports = [int(i) for i in passive_ports]
logger.info("FTP服务：被动模式！端口号：%s" %handler.passive_ports)
# handler.passive_ports =range(10000,10005)
#是否启用FXP特性，也就是文件交换协议，从此FTP服务器到另外的FTP服务器，默认False
# handler.permit_foreign_addresses=True
# 上传下载速度限制
# dtp_handler = ThrottledDTPHandler
# dtp_handler.read_limit = 30720 # 30 Kb/sec (30 * 1024)
# dtp_handler.write_limit = 30720 # 30 Kb/sec (30 * 1024)
# handler.dtp_handler = dtp_handler
address = (server_ip,server_port)
if server_model:
server = ThreadedFTPServer(address, handler)
else:
server = FTPServer(address, handler)
server.max_cons = int(max_cons) # 给链接设置限制
server.max_cons_per_ip = int(max_cons_per_ip)
#开始服务
server.serve_forever()
def server():
print("Enter intrface you wanna use::")
#Check for the available network interfaces
intr = netifaces.interfaces()
a = 1
print "{:<8} {:<20}".format('$$Key', '$$Interface')
for i in intr:
print "{:<8} {:<20}".format(str(a), str(i))
#print (str(a)+'.'+' '+str(i))
a = a + 1
facech = raw_input("Enter :: ")
facech = int(facech)
facech = facech - 1
strintr = intr[facech]
#User chooses the interface he/she wants to work with
intrip = netifaces.ifaddresses(strintr)[2][0]['addr']
print('My system ip of intrfce:: ' + strintr + ' is :: ' + intrip + ' ')
authorizer = DummyAuthorizer()
# Define a new user having full r/w permissions and a read-only
"""
Read permissions:
- "e" = change directory (CWD command)
- "l" = list files (LIST, NLST, STAT, MLSD, MLST, SIZE, MDTM commands)
- "r" = retrieve file from the server (RETR command)
Write permissions:
- "a" = append data to an existing file (APPE command)
- "d" = delete file or directory (DELE, RMD commands)
- "f" = rename file or directory (RNFR, RNTO commands)
- "m" = create directory (MKD command)
- "w" = store a file to the server (STOR, STOU commands)
- "M" = change file mode (SITE CHMOD command
"""
read_permissions = "elr"
write_permissions = "adfmwM"
authorizer.add_user('akash', 'root123', '.', perm=str(write_permissions))
authorizer.add_anonymous(os.getcwd())
# Instantiate FTP handler class
handler = MyHandler
handler.authorizer = authorizer
handler.abstracted_fs = UnixFilesystem
handler.use_sendfile = True
# Define a customized banner (string returned when client connects)
handler.banner = "||cONMan is ready||."
# Instantiate FTP server class and listen on X.X.X.X:2121
address = (intrip, 2121)
server = FTPServer(address, handler)
# set a limit for connections
server.max_cons = 256
server.max_cons_per_ip = 5
#enable logging
#logging.basicConfig(filename='log/server_log.log', level=logging.DEBUG)
# start ftp server
server.serve_forever()
def start_transd(type1,ip,port,local):
global tftpSer
global ftpSer
global httpSer
global socketSer
global conSer
global SOC_S
print(type1,ip,port,local)
if type1 == "tftp":
tftpSer = tftp.TftpServer(local)
tftpSer.listen(ip,int(port))
elif type1 == "ftp":
# Instantiate a dummy authorizer for managing 'virtual' users
authorizer = DummyAuthorizer()
# Define a new user having full r/w permissions
authorizer.add_user('user_name', 'pass_word','./', perm='elradfmwM',msg_login='******',msg_quit='bye')
# Define a read-only anonymous user
authorizer.add_anonymous(local)
# Instantiate FTP handler class
handler = FTPHandler
handler.authorizer = authorizer
handler.max_login_attempts = 3
handler.permit_foreign_addresses = True
handler.tcp_no_delay = True
# Define a customized banner (string returned when client connects)
handler.banner = "Welcome to my FTP."
# Instantiate FTP server class and listen on 127.0.0.1:21
address = (ip, int(port))
ftpSer = FTPServer(address, handler)
# set a limit for connections
ftpSer.max_cons = 128
ftpSer.max_cons_per_ip = 2
absfs = AbstractedFS(unicode(local),handler)
#absfs.cwd = u"/bbb/ss/"
# start ftp server
ftpSer.serve_forever()
elif type1 == "http":
HandlerClass = SimpleHTTPRequestHandler
ServerClass = BaseHTTPServer.HTTPServer
Protocol = "HTTP/1.0"
server_address = (ip,int(port))
HandlerClass.protocol_version = Protocol
httpSer = ServerClass(server_address, HandlerClass)
sa = httpSer.socket.getsockname()
print "Serving HTTP on", sa[0], "port", sa[1], "..."
httpSer.serve_forever()
elif type1 == "socket":
#tcp
socketSer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
bi = socketSer.bind((ip,int(port)))
socketSer.listen(2)
conSer,addr = socketSer.accept()
while SOC_S == True:
try:
conSer.send("hi")
rcv = conSer.recv(10240)
print(rcv)
#time.sleep(3)
except Exception, e:
conSer.close()
print("s1 error")
break
print("socket close")
conSer.close()
def str2int(str):
num = str.split("*")
return int(num[0]) * int(num[1])
def start_server(author):
handler = FTPHandler
handler.authorizer = author
handler.passive_ports = range(2000, 2333)
dtp_handler = ThrottledDTPHandler
dtp_handler.read_limit = str2int(up)
dtp_handler.write_limit = str2int(down)
handler.dtp_handler = dtp_handler
ip_addr = get_ipaddr()
server = FTPServer((ip_addr, 21), handler)
server.max_cons = 150
server.max_cons_per_ip = 15
server.serve_forever()
if __name__ == "__main__":
get_conf()
for i, v in enumerate(user_list):
print(v)
# print(up, down, log_path, ip)
log_set()
authorizer = DummyAuthorizer() # 实例化虚拟用户
add_users(authorizer)
start_server(authorizer)
class OVSFTPHandler(FTPHandler):
authorizer = DummyAuthorizer()
authorizer.add_anonymous("/tmp")
def main():
example_text = "example:\n" \
" {0} -u user -p password\n" \
" {0} -u user -p password --readonly\n" \
" {0} -u user -p password --dir /tmp\n".format(__file__)
parser = argparse.ArgumentParser(
prog="ftp_server",
description=
"FTP server for file sharing over internet or local network",
epilog=example_text,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("--tls", action="store_true")
parser.add_argument("-u", "--user", type=str, default="user")
parser.add_argument("-p",
"--password",
type=str,
default=generate_password(strength=20))
parser.add_argument("-r", "--readonly", action="store_true")
parser.add_argument("-d", "--dir", type=Path, default=Path().cwd())
parser.add_argument("-g", "--use_global", action="store_true")
parser.add_argument("--ip", type=str, default=get_hostname())
parser.add_argument("--port", type=int, default=60000)
parser.add_argument("--port_range", default=range(60001, 60101))
args = parser.parse_args()
perm_read = "elr"
perm_write = "adfmw"
permissions = perm_read + perm_write
if args.readonly:
permissions = perm_read
authorizer = DummyAuthorizer()
authorizer.add_user(args.user,
args.password,
str(args.dir),
perm=permissions)
if args.tls:
handler = TLS_FTPHandler
temp_dir = Path(__file__).absolute().parent / "temp"
temp_dir.mkdir(exist_ok=True)
cert_file = temp_dir / "cert_file.crt"
key_file = temp_dir / "key_file.key"
create_self_signed_cert(cert_file, key_file)
handler.certfile = str(cert_file.absolute())
handler.keyfile = str(key_file.absolute())
handler.tls_control_required = True
handler.tls_data_required = True
handler.ssl_protocol = SSL.TLSv1_2_METHOD
else:
handler = FTPHandler
handler.passive_ports = args.port_range
handler.authorizer = authorizer
if "Linux" in platform.system():
handler.use_sendfile = True
server = FTPServer((get_local_ip(), args.port), handler)
print("\n\n\n\n")
print(f"Local address: ftp://{get_local_ip()}:{args.port}")
if args.use_global:
print(f"Global address: ftp://{get_global_ip()}:{args.port}")
print(f"User: {args.user}")
print(f"Password: {args.password}")
print()
server.serve_forever()
#!/usr/bin/env python
#-*- coding: utf-8 -*-
from pyftpdlib.authorizers import DummyAuthorizer #izmantotā bibliotēka
from pyftpdlib.handlers import FTPHandler #izmantotā bibliotēka
from pyftpdlib.servers import FTPServer #izmantotā bibliotēka
authorizer = DummyAuthorizer() #norāda klasi lietotājiem
authorizer.add_user("rus_sud", "12345", "/home/russud/ftp",
perm="elradfmw") #definē lietotāju
authorizer.add_anonymous("/home/russud",
perm="elradfmw") #nenoteikts lietotājs
handler = FTPHandler #norāda autorizācijas veidu
handler.authorizer = authorizer
server = FTPServer(("127.0.0.1", 1026), handler) #definē serveri
server.serve_forever() #nozimē ka var atbildēt uz vairākiem pieprasijumiem
def setSharedDirectory(self, path):
if not path_exists(path):
raise FileNotFoundError
self.authorizer = DummyAuthorizer()
self.authorizer.add_anonymous(path)
self.ftp_handler.authorizer = self.authorizer
def init_ftp_server():
authorizer = DummyAuthorizer()
"""
读权限:
- "e" = 改变文件目录
- "l" = 列出文件 (LIST, NLST, STAT, MLSD, MLST, SIZE, MDTM commands)
- "r" = 从服务器接收文件 (RETR command)
写权限:
- "a" = 文件上传 (APPE command)
- "d" = 删除文件 (DELE, RMD commands)
- "f" = 文件重命名 (RNFR, RNTO commands)
- "m" = 创建文件 (MKD command)
- "w" = 写权限 (STOR, STOU commands)
- "M" = 文件传输模式 (SITE CHMOD command)
"""
if enable_anonymous:
# 添加匿名用户
authorizer.add_anonymous(anonymous_path)
# 读取配置中用户并授权
for user in user_list:
name,passwd,permit,homedir= user
try:
authorizer.add_user(name, passwd, homedir, perm=permit)
except:
print("配置文件错误请检查是否正确匹配了相应的用户名、密码、权限、路径")
print(user)
dtp_handler = ThrottledDTPHandler
# 上传速度 下载速度
dtp_handler.read_limit = max_download
dtp_handler.write_limit = max_upload
# Instantiate FTP handler class
handler = FTPHandler
handler.authorizer = authorizer
# 是否开启记录
if enable_logging:
logging.basicConfig(filename='pyftp.log', level=logging.INFO)
# 登录时候显示的标题
handler.banner = welcom_banner
handler.masquerade_address = masquerade_address
# 主动模式和被动模式
handler.passive_ports = range(passive_ports[0], passive_ports[1])
# 监听的ip和端口
address = (ip, port)
server = FTPServer(address, handler)
# 设置最大连接数
server.max_cons = max_cons
server.max_cons_per_ip = max_pre_ip
# 开启ftp
try:
server.serve_forever()
except KeyboardInterrupt:
return
def init_ftp_server():
authorizer = DummyAuthorizer()
"""
读权限:
- "e" = 改变文件目录
- "l" = 列出文件 (LIST, NLST, STAT, MLSD, MLST, SIZE, MDTM commands)
- "r" = 从服务器接收文件 (RETR command)
写权限:
- "a" = 文件上传 (APPE command)
- "d" = 删除文件 (DELE, RMD commands)
- "f" = 文件重命名 (RNFR, RNTO commands)
- "m" = 创建文件 (MKD command)
- "w" = 写权限 (STOR, STOU commands)
- "M" = 文件传输模式 (SITE CHMOD command)
"""
if enable_anonymous:
# 添加匿名用户
authorizer.add_anonymous(anonymous_path)
# 读取配置中的用户并授权
for user in user_list:
name, passwd, permit, homedir = user
try:
authorizer.add_user(username=name,
password=passwd,
perm=permit,
homedir=homedir)
except Exception as e:
print("baseftp.ini error, please check the form of datas.")
print(user)
print(e)
dtp_handler = ThrottledDTPHandler
# 上传速度 下载速度
dtp_handler.read_limit = max_download
dtp_handler.write_limit = max_upload
# Instantiate FTP handler class
handler = FTPHandler
handler.authorizer = authorizer
# 是否开启记录
if enable_logging:
logging.basicConfig(filename="pyftp.log", level=logging.INFO)
# 登录时显示的标题
handler.banner = welcome_banner
handler.masquerade_address = masquerade_address
# 主动模式和被动模式
handler.passive_ports = range(passive_ports[0], passive_ports[1])
# 监听的ip和端口
address = (ip, port)
server = FTPServer(address, handler)
# 设置最大连接数
server.max_cons = max_cons
server.max_cons_per_ip = max_pre_ip
# 开启ftp
server.serve_forever()
PORT_RECV = 3000
PORT_SEND = 3010
PORT_FTP = 3020
IP_ADDRESS = '192.168.43.221'
MAX_BUFFER = 2048
serverRecv.bind((IP_ADDRESS, PORT_RECV))
serverSend.bind((IP_ADDRESS, PORT_SEND))
serverRecv.listen(1000)
serverSend.listen(1000)
listClients = []
publicGroups = ['public']
listusersftp = DummyAuthorizer()
#-----------Free Function
def randstring():
all_char = string.ascii_letters + string.digits
random = "".join(choice(all_char) for x in range(30))
return random
#-----------Free Function done
def runFTP():
try:
handler = FTPHandler
#!/usr/bin/python3
# coding: utf-8
>>> from pyftpdlib.authorizers import DummyAuthorizer
>>> from pyftpdlib.handlers import FTPHandler
>>> from pyftpdlib.servers import FTPServer
>>>
>>> authorizer = DummyAuthorizer()
>>> authorizer.add_user("user", "12345", "/home/giampaolo", perm="elradfmwMT")
>>> authorizer.add_anonymous("/home/nobody")
>>>
>>> handler = FTPHandler
>>> handler.authorizer = authorizer
>>>
>>> server = FTPServer(("127.0.0.1", 21), handler)
>>> server.serve_forever()
参考资料：http://www.jb51.net/article/110901.htm
FTP服务的主动模式和被动模式
在开始之前，先聊一下FTP的主动模式和被动模式，两者的区别 ， 用两张图来表示可能会更加清晰一些：
主动模式：
主动模式工作过程：
1.
客户端以随机非特权端口N，就是大于1024的端口，对server端21端口发起连接
2.
客户端开始监听
N + 1
端口；
3.
def authorizer_server(self, path=None):
self.authorizer = DummyAuthorizer()
if path is not None:
self.default_path = path
self.authorizer.add_user(self.username, self.password,
self.default_path, self.permission_attr)
parser.add_argument('-lh', '--addr', help='Listening address', default='')
parser.add_argument('-lp',
'--port',
help='Listening port',
type=int,
default=21)
parser.add_argument('-p',
'--path',
help='Exposed local path',
default='./')
parser.add_argument('-b',
'--banner',
help='Exposed FTP banner',
default='FTPd 1.99')
args = parser.parse_args()
authorizer = DummyAuthorizer()
authorizer.add_user(args.username,
args.password,
args.path,
perm='elradfmw')
handler = FTPHandler
handler.authorizer = authorizer
handler.banner = args.banner
handler.passive_ports = range(60000, 65535)
address = (args.addr, args.port)
server = FTPServer(address, handler)
server.max_cons = 256
server.max_cons_per_ip = 5
server.serve_forever()
def __init__(self):
self.authorizer = DummyAuthorizer()
self.handler = FTPHandler
self.handler.timeout = None
