def __init__(self, conf): self._init_keys(conf) config = cwconfig.instance_configuration(conf.get('cubicweb-instance')) repo = Repository(config, TasksManager(), vreg=None) portal = Portal(CubicWebSFTPRealm(repo, conf)) portal.registerChecker(CubicWebCredentialsChecker(repo)) self.portal = portal
def setUp(self): self.realm = Realm() portal = Portal(self.realm) portal.registerChecker(MockChecker()) self.authServer = userauth.SSHUserAuthServer() self.authServer.transport = FakeTransport(portal) self.authServer.serviceStarted()
def test_unencryptedConnectionWithoutPasswords(self): """ If the L{SSHUserAuthServer} is not advertising passwords, then an unencrypted connection should not cause any warnings or exceptions. This is a white box test. """ # create a Portal without password authentication portal = Portal(self.realm) portal.registerChecker(PrivateKeyChecker()) # no encryption clearAuthServer = userauth.SSHUserAuthServer() clearAuthServer.transport = FakeTransport(portal) clearAuthServer.transport.isEncrypted = lambda x: False clearAuthServer.serviceStarted() clearAuthServer.serviceStopped() self.assertEqual(clearAuthServer.supportedAuthentications, ['publickey']) # only encrypt incoming (the direction the password is sent) halfAuthServer = userauth.SSHUserAuthServer() halfAuthServer.transport = FakeTransport(portal) halfAuthServer.transport.isEncrypted = lambda x: x == 'in' halfAuthServer.serviceStarted() halfAuthServer.serviceStopped() self.assertEqual(clearAuthServer.supportedAuthentications, ['publickey'])
def main_ssh2http(): portal = Portal(ExampleRealm()) c_port = 5022 factory = SSH2HTTPConverterFactory(c_port) portal.registerChecker(factory) SSH2HTTPConverterFactory.portal = portal reactor.listenTCP(c_port, factory)
def createPortal(self, realmFactory=None): if realmFactory is None: realmFactory = SillyRealm r = realmFactory() p = Portal(r) p.registerChecker(AllowAnonymousAccess(), IAnonymous) return p
def PBServerFactoryFromTaskController(taskController): #### TODO: Real authentication here portal = Portal(IPythonRealm(taskController)) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "guest") portal.registerChecker(checker) return pb.PBServerFactory(portal)
def _get_portal(checker): ''' creates portal and adds realm and checker ''' portal = Portal(HoneyRealm()) portal.registerChecker(checker) return portal
def test_unencryptedConnectionWithoutPasswords(self): """ If the L{SSHUserAuthServer} is not advertising passwords, then an unencrypted connection should not cause any warnings or exceptions. This is a white box test. """ # create a Portal without password authentication portal = Portal(self.realm) portal.registerChecker(PrivateKeyChecker()) # no encryption clearAuthServer = userauth.SSHUserAuthServer() clearAuthServer.transport = FakeTransport(portal) clearAuthServer.transport.isEncrypted = lambda x: False clearAuthServer.serviceStarted() clearAuthServer.serviceStopped() self.assertEqual(clearAuthServer.supportedAuthentications, [b'publickey']) # only encrypt incoming (the direction the password is sent) halfAuthServer = userauth.SSHUserAuthServer() halfAuthServer.transport = FakeTransport(portal) halfAuthServer.transport.isEncrypted = lambda x: x == 'in' halfAuthServer.serviceStarted() halfAuthServer.serviceStopped() self.assertEqual(clearAuthServer.supportedAuthentications, [b'publickey'])
def __init__(self, conf): self._init_keys(conf) config = cwconfig.instance_configuration(conf.get('cubicweb-instance')) repo = Repository(config, TasksManager(), vreg=None) portal = Portal(CubicWebSFTPRealm(repo, conf)) portal.registerChecker(CubicWebCredentialsChecker(repo)) self.portal = portal
def setUp(self): super(RootTests, self).setUp() self.docroot = self.mktemp() os.mkdir(self.docroot) RootResource.CheckSACL = FakeCheckSACL(sacls={"calendar": ["dreid"]}) directory = XMLDirectoryService({"xmlFile" : xmlFile}) augment.AugmentService = augment.AugmentXMLDB( xmlFiles=(augmentsFile.path,) ) principals = DirectoryPrincipalProvisioningResource( "/principals/", directory ) root = RootResource(self.docroot, principalCollections=[principals]) root.putChild("principals", principals) portal = Portal(auth.DavRealm()) portal.registerChecker(directory) self.root = auth.AuthenticationWrapper( root, portal, credentialFactories=(basic.BasicCredentialFactory("Test realm"),), loginInterfaces=(auth.IPrincipal,)) self.site = server.Site(self.root)
def main_ssh2http(): portal = Portal(ExampleRealm()) c_port = 5022 factory = SSH2HTTPConverterFactory(c_port) portal.registerChecker(factory) SSH2HTTPConverterFactory.portal = portal reactor.listenTCP(c_port, factory)
def setUp(self): self.realm = Realm() portal = Portal(self.realm) portal.registerChecker(MockChecker()) self.authServer = userauth.SSHUserAuthServer() self.authServer.transport = FakeTransport(portal) self.authServer.serviceStarted()
def deploy(iface, port, dbLocation, dbType, dbUsername=None, dbPassword=None, ssl=False, sslRedirect=False, sslPrivate=None, sslCert=None, sslPort=None): if dbUsername and dbPassword: searchService = searchServices[dbType]( dbLocation, dbUsername, dbPassword) else: searchService = searchServices[dbType](dbLocation) portal = Portal(PublicHTMLRealm(searchService), [AllowAnonymousAccess()]) portal.registerChecker(QuasselChecker(searchService), IUsernameHashedPassword) portal.registerChecker(SessionChecker(), ISessionCredentials) application = service.Application("Querryl") site = server.Site(BasicWrapper(portal, [])) site.sessionFactory = LongSession if ssl: ctx = DefaultOpenSSLContextFactory(sslPrivate, sslCert) ssl_sv = internet.SSLServer(sslPort, site, ctx, interface=iface) ssl_sv.setServiceParent(application) if sslRedirect: site = server.Site(RedirectFromRequest(port=sslPort)) sv = internet.TCPServer(port, site, interface=iface) sv.setServiceParent(application) return sv
def portal(self): portal = Portal(self.realm()) for checker in self.auth_checkers(): portal.registerChecker(checker) if len(self.auth_checkers()) == 0: portal.registerChecker(checkers.AllowAnonymousAccess()) return portal
def listen(self, port): ''' Starts listening on the specified port. ''' portal = Portal(credentials.Realm()) portal.registerChecker(credentials.PasswordChecker(self.__passwd)) reactor.listenTCP(port, ServerProtocolFactory(portal, self.userlist))
def main(application=None): """ SMTP daemon for receiving DSN (Delivery Status Notification) :param application: optional Application instance (if used inside twistd) :type application: twisted.application.service.Application """ parser = argparse.ArgumentParser( description='Start the SMTPD process for CloudMailing.') parser.add_argument('-p', '--port', type=int, default=25, help='port number for SMTP (default: 25)') parser.add_argument('-u', '--uid', help='Change the UID of this process') parser.add_argument('-g', '--gid', help='Change the GID of this process') args = parser.parse_args() # Need to open TCP port early, before to switch user and configure log portal = Portal(SimpleRealm()) portal.registerChecker(AllowAnonymousAccess()) factory = ReturnPathSMTPFactory(portal) if application: smtpd = internet.TCPServer(args.port, factory) smtpd.setServiceParent(application) else: smtpd = reactor.listenTCP(args.port, factory) if args.uid or args.gid: uid = args.uid and pwd.getpwnam(args.uid).pw_uid or None gid = args.gid and grp.getgrnam(args.gid).gr_gid or None # for fname in os.listdir(settings.LOG_PATH): # fullname = os.path.join(settings.LOG_PATH, fname) # print fullname # if args.uid: # os.chown(fullname, args.uid, args.gid) switchUID(uid, gid) configure_logging("smtpd", settings.CONFIG_PATH, settings.LOG_PATH, settings.DEFAULT_LOG_FORMAT, False) ##Twisted logs observer = PythonLoggingObserver() observer.start() log = logging.getLogger("smtpd") log.info( "****************************************************************") log.info("Starting CloudMailing SMTPD version %s" % VERSION) log.info("Serial: %s" % settings.SERIAL) log.info("Twisted version %s", twisted.version.short()) log.info( "****************************************************************") Db.getInstance(settings.MASTER_DATABASE) log.info("CM SMTPD started on port %d", args.port)
def setupManhole(application, config): """Setup an SSH manhole for the API service. The manhole port is taken from the C{manhole-port} option in the config file. If this option is not provided the api port plus 100 is used. @param application: The fluidinfo API L{Application} object. @param config: The configuration object. """ servicePort = config.getint('service', 'port') if config.has_option('service', 'manhole-port'): manholePort = config.getint('service', 'manhole-port') else: manholePort = servicePort + 100 def getManhole(_): manhole = Manhole(globals()) ps1 = 'fluidinfo-api [%d] > ' % servicePort ps2 = '... '.rjust(len(ps1)) manhole.ps = (ps1, ps2) return manhole realm = TerminalRealm() realm.chainedProtocolFactory.protocolFactory = getManhole portal = Portal(realm) portal.registerChecker(SSHPublicKeyDatabase()) factory = ConchFactory(portal) manholeService = TCPServer(manholePort, factory, interface='127.0.0.1') manholeService.setServiceParent(application)
def makeService(config): components.registerAdapter( GitSession, GitAvatar, session.ISession) with open(config['conf']) as f: conf = yaml.load(f.read()) port = int(conf.get('port', 22)) host_key = conf.get('host_key') driver_key = conf.get('driver', 'example') log.msg('Using driver: \'%s\'' % driver_key) mgr = driver.DriverManager( namespace='gitserver.driver', name=driver_key, invoke_on_load=False ) portal = Portal(GitRealm(mgr)) portal.registerChecker(GitPublicKeyChecker(mgr)) # factory.SSHFactory takes no arguments, so unlike the # websocket server, we will assign portal on the class # rather than through the constructor. # TypeError: this constructor takes no arguments # is raised if we pass portal GitFactory(portal) GitFactory.portal = portal GitSession.driver_key = driver_key return internet.TCPServer(port, GitFactory(host_key=host_key))
def createPortal(self, realmFactory=None): if realmFactory is None: realmFactory = SillyRealm r = realmFactory() p = Portal(r) p.registerChecker(AllowAnonymousAccess(), IAnonymous) return p
def makeService(config): components.registerAdapter(GitSession, GitAvatar, session.ISession) with open(config['conf']) as f: conf = yaml.load(f.read()) port = int(conf.get('port', 22)) host_key = conf.get('host_key') driver_key = conf.get('driver', 'example') log.msg('Using driver: \'%s\'' % driver_key) mgr = driver.DriverManager(namespace='gitserver.driver', name=driver_key, invoke_on_load=False) portal = Portal(GitRealm(mgr)) portal.registerChecker(GitPublicKeyChecker(mgr)) # factory.SSHFactory takes no arguments, so unlike the # websocket server, we will assign portal on the class # rather than through the constructor. # TypeError: this constructor takes no arguments # is raised if we pass portal GitFactory(portal) GitFactory.portal = portal GitSession.driver_key = driver_key return internet.TCPServer(port, GitFactory(host_key=host_key))
def makeService(self, options): class LongSession(Session): sessionTimeout = 3600 if options['steamkey'] is None: raise ValueError('Must specify steam API key.') if options['strport'] is None: raise ValueError('Must specify strport description.') if options['dbdir'] is None: raise ValueError('Must specify database path.') steamAPI = API(key=options['steamkey']) store = Store(options['dbdir']) keyPath = FilePath(options['dbdir']).child('fernet.key') database = Database(store) loginRedirect = '/' portal = Portal(MapListRealm(database, options['bundle-path'], steamAPI, loginRedirect)) portal.registerChecker(PreauthenticatedChecker()) portal.registerChecker(AllowAnonymousAccess()) root = HTTPOpenIDAuthSessionWrapper(portal, [], loginRedirect, keyPath, database) site = Site(root) site.sessionFactory = LongSession return strports.service(options['strport'], site)
def create_portal(a): """I'm responsible for creating the authenticated portal""" realm = AggregatorRealm(a) portal = Portal(realm) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser(version.apiversion, a.getPassword()) portal.registerChecker(checker) return portal
def makeService(options): """ Makes a new swftp-ftp service. The only option is the config file location. The config file has the following options: - host - port - auth_url - num_persistent_connections - connection_timeout - welcome_message """ from twisted.protocols.ftp import FTPFactory from twisted.web.client import HTTPConnectionPool from twisted.cred.portal import Portal from swftp.ftp.server import SwiftFTPRealm from swftp.auth import SwiftBasedAuthDB from swftp.utils import print_runtime_info print('Starting SwFTP-ftp %s' % VERSION) c = get_config(options['config_file'], options) ftp_service = service.MultiService() # Add statsd service if c.get('ftp', 'log_statsd_host'): try: from swftp.statsd import makeService as makeStatsdService makeStatsdService( c.get('ftp', 'log_statsd_host'), c.getint('ftp', 'log_statsd_port'), sample_rate=c.getfloat('ftp', 'log_statsd_sample_rate'), prefix=c.get('ftp', 'log_statsd_metric_prefix') ).setServiceParent(ftp_service) except ImportError: log.err('Missing Statsd Module. Requires "txstatsd"') pool = HTTPConnectionPool(reactor, persistent=True) pool.maxPersistentPerHost = c.getint('ftp', 'num_persistent_connections') pool.cachedConnectionTimeout = c.getint('ftp', 'connection_timeout') authdb = SwiftBasedAuthDB(auth_url=c.get('ftp', 'auth_url'), verbose=c.getboolean('ftp', 'verbose')) ftpportal = Portal(SwiftFTPRealm()) ftpportal.registerChecker(authdb) ftpfactory = FTPFactory(ftpportal) ftpfactory.welcomeMessage = c.get('ftp', 'welcome_message') ftpfactory.allowAnonymous = False signal.signal(signal.SIGUSR1, print_runtime_info) signal.signal(signal.SIGUSR2, print_runtime_info) internet.TCPServer( c.getint('ftp', 'port'), ftpfactory, interface=c.get('ftp', 'host')).setServiceParent(ftp_service) return ftp_service
def adminWrapper(data): """Ties it together""" p = Portal(AdminRealm(data)) # found in twisted.cred.Portal p.registerChecker(AllowAnonymousAccess(), IAnonymous) p.registerChecker(data.players, IUsernamePassword) upw = guard.UsernamePasswordWrapper(p, callback=dumbRedirect) r = guard.SessionWrapper(upw) r.sessionLifetime = 12 * 3600 return r
class OpenRukoSSHServer(SSHFactory): def __init__(self, settings): self.settings = settings self.portal = Portal(OpenRukoRealm(settings)) self.portal.registerChecker(OpenRukoCredentialChecker(settings)) self.privateKeys = {'ssh-rsa': Key.fromFile(settings['private_key'])} self.publicKeys = {'ssh-rsa': Key.fromFile(settings['public_key'])}
class OpenRukoSSHServer(SSHFactory): def __init__(self, settings): self.settings = settings self.portal = Portal(OpenRukoRealm(settings)) self.portal.registerChecker(OpenRukoCredentialChecker(settings)) self.privateKeys = {'ssh-rsa': Key.fromFile(settings['gitmouth_private_key'])} self.publicKeys = {'ssh-rsa': Key.fromFile(settings['gitmouth_public_key'])}
def createDocumentRoot(self): docroot = self.mktemp() os.mkdir(docroot) userResource = TestDAVPrincipalResource("/principals/users/user01") userResource.writeDeadProperty(TwistedPasswordProperty("user01")) principalCollection = TestPrincipalsCollection( "/principals/", children={"users": TestPrincipalsCollection( "/principals/users/", children={"user01": userResource})}) rootResource = self.resource_class( docroot, principalCollections=(principalCollection,)) portal = Portal(DavRealm()) portal.registerChecker(TwistedPropertyChecker()) credentialFactories = (basic.BasicCredentialFactory(""),) loginInterfaces = (IPrincipal,) self.site = Site(AuthenticationWrapper( rootResource, portal, credentialFactories, credentialFactories, loginInterfaces )) rootResource.setAccessControlList(self.grant(element.All())) for name, acl in ( ("none" , self.grant()), ("read" , self.grant(element.Read())), ("read-write" , self.grant(element.Read(), element.Write())), ("unlock" , self.grant(element.Unlock())), ("all" , self.grant(element.All())), ): filename = os.path.join(docroot, name) if not os.path.isfile(filename): file(filename, "w").close() resource = self.resource_class(filename) resource.setAccessControlList(acl) for name, acl in ( ("nobind" , self.grant()), ("bind" , self.grant(element.Bind())), ("unbind" , self.grant(element.Bind(), element.Unbind())), ): dirname = os.path.join(docroot, name) if not os.path.isdir(dirname): os.mkdir(dirname) resource = self.resource_class(dirname) resource.setAccessControlList(acl) return docroot
def main(): from twisted.cred.portal import Portal from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("benchmark", "benchmark") portal.registerChecker(checker) reactor.listenTCP(8787, pb.PBServerFactory(portal)) reactor.run()
def StartServices(username,password): from md5 import md5 password = md5(password).digest() portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser(username,password) portal.registerChecker(checker) reactor.listenTCP(7001,pb.PBServerFactory(portal))
def createDocumentRoot(self): docroot = self.mktemp() os.mkdir(docroot) userResource = TestDAVPrincipalResource("/principals/users/user01") userResource.writeDeadProperty(TwistedPasswordProperty("user01")) principalCollection = TestPrincipalsCollection( "/principals/", children={"users": TestPrincipalsCollection( "/principals/users/", children={"user01": userResource})}) rootResource = self.resource_class( docroot, principalCollections=(principalCollection,)) portal = Portal(DavRealm()) portal.registerChecker(TwistedPropertyChecker()) credentialFactories = (basic.BasicCredentialFactory(""),) loginInterfaces = (IPrincipal,) self.site = Site(AuthenticationWrapper( rootResource, portal, credentialFactories, credentialFactories, loginInterfaces )) rootResource.setAccessControlList(self.grant(element.All())) for name, acl in ( ("none" , self.grant()), ("read" , self.grant(element.Read())), ("read-write" , self.grant(element.Read(), element.Write())), ("unlock" , self.grant(element.Unlock())), ("all" , self.grant(element.All())), ): filename = os.path.join(docroot, name) if not os.path.isfile(filename): file(filename, "w").close() resource = self.resource_class(filename) resource.setAccessControlList(acl) for name, acl in ( ("nobind" , self.grant()), ("bind" , self.grant(element.Bind())), ("unbind" , self.grant(element.Bind(), element.Unbind())), ): dirname = os.path.join(docroot, name) if not os.path.isdir(dirname): os.mkdir(dirname) resource = self.resource_class(dirname) resource.setAccessControlList(acl) return docroot
def adminWrapper(data): """Ties it together""" p = Portal(AdminRealm(data)) p.registerChecker(AllowAnonymousAccess(), IAnonymous) p.registerChecker(data.players, IUsernamePassword) upw = guard.UsernamePasswordWrapper(p, callback=dumbRedirect) r = guard.SessionWrapper(upw) r.sessionLifetime = 12 * 3600 return r
def main(): from twisted.internet import reactor from twisted.cred.portal import Portal from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "guest") portal.registerChecker(checker) reactor.listenTCP(pb.portno, pb.PBServerFactory(portal)) reactor.run()
def __init__(self, soledad_sessions, *args, **kw): LEAPIMAPServer.__init__(self, *args, **kw) realm = LocalSoledadIMAPRealm(soledad_sessions) portal = Portal(realm) checker = IMAPTokenChecker(soledad_sessions) self.checker = checker self.portal = portal portal.registerChecker(checker)
def StartServices(): #fire up the World Stuff portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() from md5 import md5 password = md5("daemon").digest() for x in range(0, 100): checker.addUser(str(x), password) portal.registerChecker(checker) reactor.listenTCP(7000, pb.PBServerFactory(portal))
def StartServices(): #fire up the World Stuff portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() from md5 import md5 password = md5("daemon").digest() for x in range(0,100): checker.addUser(str(x), password) portal.registerChecker(checker) reactor.listenTCP(7000,pb.PBServerFactory(portal))
def main(): from twisted.internet import reactor from twisted.cred.portal import Portal from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "guest") portal.registerChecker(checker) reactor.listenTCP(pb.portno, pb.PBServerFactory(portal)) reactor.run()
def __init__(self, account, *args, **kw): LEAPIMAPServer.__init__(self, *args, **kw) realm = TestRealm(account) portal = Portal(realm) checker = TestCredentialsChecker() self.checker = checker self.portal = portal portal.registerChecker(checker)
def __init__(self, soledad_sessions, *args, **kw): LEAPIMAPServer.__init__(self, *args, **kw) realm = LocalSoledadIMAPRealm(soledad_sessions) portal = Portal(realm) checker = IMAPTokenChecker(soledad_sessions) self.checker = checker self.portal = portal portal.registerChecker(checker)
def startService(self): Plugin.startService(self) if not self._inputs == []: portal = Portal(CollectorRealm(self)) portal.registerChecker(AllowAnonymousAccess()) factory = PBServerFactory(portal) self._listener = reactor.listenTCP(self._port, factory, interface=self._address) logger.info("[%s] listening for remote messages on %s:%i" % (self.name,self._address,self._port)) else: logger.info("[%s] no inputs configured" % self.name)
def __init__(self, account, *args, **kw): LEAPIMAPServer.__init__(self, *args, **kw) realm = TestRealm(account) portal = Portal(realm) checker = TestCredentialsChecker() self.checker = checker self.portal = portal portal.registerChecker(checker)
def setup(): from twisted.internet import reactor from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "password") portal.registerChecker(checker) reactor.listenTCP(7777, ConsoleSMTPFactory(portal))
def setServiceParent(self, parent): service.MultiService.setServiceParent(self, parent) portal = Portal(PbRealm(parent)) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "guest") portal.registerChecker(checker) s = strports.service("unix:%s" % self.socket, pb.PBServerFactory(portal)) s.setServiceParent(self)
class SSHFactory(factory.SSHFactory): def __init__(self, settings): self.settings = settings self.portal = Portal(Realm(settings)) self.portal.registerChecker(Checker(settings)) self.privateKeys = { 'ssh-rsa': Key.fromFile(settings['hadoukngit']['private_key']), } self.publicKeys = { 'ssh-rsa': Key.fromFile(settings['hadoukngit']['public_key']), }
def __init__(self, soledad_sessions, keymanager_sessions, sendmail_opts, encrypted_only=False): realm = LocalSMTPRealm( keymanager_sessions, soledad_sessions, sendmail_opts, encrypted_only) portal = Portal(realm) checker = SMTPTokenChecker(soledad_sessions) self.checker = checker self.portal = portal portal.registerChecker(checker)
def __init__(self, outgoing_sessions, soledad_sessions, encrypted_only=False): realm = LocalSMTPRealm(outgoing_sessions, encrypted_only) portal = Portal(realm) checker = SMTPTokenChecker(soledad_sessions) self.checker = checker self.portal = portal portal.registerChecker(checker)
class CleanerSite(Site, Loggable): def __init__(self, firewall): self.user = cattivo.config.get("cleaner", "user") self.passwd_file = cattivo.config.get("cleaner", "passwd-file") checker = FilePasswordDB(self.passwd_file) self.realm = CleanerRealm() self.portal = Portal(self.realm) self.portal.registerChecker(checker) self.firewall = firewall Site.__init__(self, CleanerResource(self.portal)) Loggable.__init__(self)
def __init__(self, soledad_sessions, keymanager_sessions, sendmail_opts, encrypted_only=False): realm = LocalSMTPRealm( keymanager_sessions, soledad_sessions, sendmail_opts, encrypted_only) portal = Portal(realm) checker = SMTPTokenChecker(soledad_sessions) self.checker = checker self.portal = portal portal.registerChecker(checker)
def StartServices(callback): global IMPCONNECTED_CALLBACK IMPCONNECTED_CALLBACK = callback #fire up the World Stuff portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() from md5 import md5 password = md5("imp").digest() for x in range(0, 100): checker.addUser(str(x), password) portal.registerChecker(checker) reactor.listenTCP(7005, pb.PBServerFactory(portal))
def __init__(self, port=8787): BaseService.__init__(self) boiler = None portal = Portal(PbRealm(boiler)) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "guest") portal.registerChecker(checker) service = strports.service("tcp:%d" % port, pb.PBServerFactory(portal)) service.setServiceParent(self)
def guardedWrapper(realm, checkers): ptl = Portal(realm) ptl.registerChecker(AllowAnonymousAccess(), IAnonymous) for checker in checkers: ptl.registerChecker(checker) # FIXME - this should be another wrapper, which returns a SessionWrapper, # which has persistentCookies set or not. for now, all cookies are # persistent for a week wrap = guard.SessionWrapper(ptl) wrap.persistentCookies = True wrap.sessionLifetime = 3600 * 24 * 7 return wrap
def __init__(self): super(SSHService, self).__init__() self._name = Config.ssh.name self._port = Config.ssh.port p = Portal(SSHRealm()) p.registerChecker(SSHService.honeytokendb) self._fService = factory.SSHFactory() self._fService.services[b'ssh-userauth'] = groveUserAuth self._limiter = Limiter(self._fService, Config.ssh.name, Config.ssh.connections_per_host) self._fService.portal = p # self.protocol = SSHProtocol # self._fService.protocol = self.protocol home = expanduser('~') # XXX: These paths should be configurable privateKeyPath = home + '/.ssh/id_honeygrove' publicKeyPath = home + '/.ssh/id_honeygrove.pub' # Generate RSA keys if they don't exist if not (exists(privateKeyPath) and exists(publicKeyPath)): key = keys.rsa.generate_private_key(public_exponent=65537, key_size=4096, backend=default_backend()) private_key = key.private_bytes( serialization.Encoding.PEM, serialization.PrivateFormat.TraditionalOpenSSL, serialization.NoEncryption()) public_key = key.public_key().public_bytes( serialization.Encoding.OpenSSH, serialization.PublicFormat.OpenSSH) # make .ssh directory, if it doesn't exist os.makedirs(dirname(publicKeyPath), exist_ok=True) with open(privateKeyPath, 'w') as f: f.write(private_key.decode()) with open(publicKeyPath, 'w') as f: f.write(public_key.decode()) self._fService.privateKeys = { b'ssh-rsa': keys.Key.fromFile(privateKeyPath) } self._fService.publicKeys = { b'ssh-rsa': keys.Key.fromFile(publicKeyPath) }
def __init__(self, port): realm = FTPRealm(get_poppy_root()) portal = Portal(realm) portal.registerChecker(PoppyAccessCheck()) factory = ftp.FTPFactory(portal) factory.tld = get_poppy_root() factory.protocol = ftp.FTP factory.welcomeMessage = "Launchpad upload server" factory.timeOut = config.poppy.idle_timeout self.ftpfactory = factory self.portno = port
def startService(self): Plugin.startService(self) if not self._inputs == []: portal = Portal(CollectorRealm(self)) portal.registerChecker(AllowAnonymousAccess()) factory = PBServerFactory(portal) self._listener = reactor.listenTCP(self._port, factory, interface=self._address) logger.info("[%s] listening for remote messages on %s:%i" % (self.name, self._address, self._port)) else: logger.info("[%s] no inputs configured" % self.name)
def main(): from twisted.application import internet from twisted.application import service portal = Portal(SimpleRealm()) checker = InMemoryUsernamePasswordDatabaseDontUse() checker.addUser("guest", "guest") portal.registerChecker(checker) app = service.Application("SES Relay SMTP Server") internet.TCPServer(8080, SESRelaySMTPFactory(portal)).setServiceParent(app) return app
def setUp(self): self.service_calls = [] self.encoder = pdu_encoding.PDUEncoder() self.smpp_config = SMPPServerConfig(msgHandler=self._serviceHandler, systems={'userA': {"max_bindings": 2}} ) portal = Portal(self.SmppRealm()) credential_checker = InMemoryUsernamePasswordDatabaseDontUse() credential_checker.addUser('userA', 'valid') portal.registerChecker(credential_checker) self.factory = SMPPServerFactory(self.smpp_config, auth_portal=portal) self.proto = self.factory.buildProtocol(('127.0.0.1', 0)) self.tr = proto_helpers.StringTransport() self.proto.makeConnection(self.tr)
def setUp(self): TestCase.setUp(self) gooduser = TestDAVPrincipalResource("/users/gooduser") gooduser.writeDeadProperty(TwistedPasswordProperty("goodpass")) baduser = TestDAVPrincipalResource("/users/baduser") baduser.writeDeadProperty(TwistedPasswordProperty("badpass")) rootresource = TestPrincipalsCollection( "/", { "users": TestResource("/users/", { "gooduser": gooduser, "baduser": baduser }) }) protected = TestResource("/protected", principalCollections=[rootresource]) protected.setAccessControlList( davxml.ACL( davxml.ACE(davxml.Principal(davxml.HRef("/users/gooduser")), davxml.Grant(davxml.Privilege(davxml.All())), davxml.Protected()))) rootresource.children["protected"] = protected portal = Portal(DavRealm()) portal.registerChecker(TwistedPropertyChecker()) credentialFactories = (basic.BasicCredentialFactory(""), ) loginInterfaces = (IPrincipal, ) self.rootresource = rootresource self.site = Site( AuthenticationWrapper( self.rootresource, portal, credentialFactories, credentialFactories, loginInterfaces, ))