def main():
"""Create a configured wsgi app"""
settings = {}
debug = os.environ.get('DEBUG', True)
settings['reload_all'] = debug
settings['debug_all'] = debug
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get(
'AUTH_PASSWORD', manager.encode('secret'))
if not os.environ.get('TESTING', False):
# only bind the session if we are not testing
engine = sa.create_engine(DATABASE_URL)
DBSession.configure(bind=engine)
# add a secret value for auth tkt signing
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'itsaseekrit')
# configuration setup
config = Configurator(
settings=settings,
authentication_policy=AuthTktAuthenticationPolicy(
secret=auth_secret,
hashalg='sha512'
),
authorization_policy=ACLAuthorizationPolicy(),
)
config.include('pyramid_tm')
config.include('pyramid_jinja2')
config.add_route('home', '/')
config.add_route('add', '/add')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_static_view('static', os.path.join(HERE, 'static'))
config.scan()
app = config.make_wsgi_app()
return app
def main(argv=None):
if len(argv) != 3:
print "Usage: create_user.py <username> <password>"
sys.exit(1)
session = dbsession()
username = argv[1]
password = argv[2]
manager = BCRYPTPasswordManager()
hashed_password = manager.encode(password)
user = User()
user.username = username
user.password = hashed_password
user.active_ind = True
try:
session.add(user)
session.commit()
print "User {0} created.".format(username)
except:
print "Error adding user."
session.rollback()
session.close()
sys.exit(1)
session.close()
sys.exit(0)
def main():
"""Create a configured wsgi app"""
settings = {}
settings['reload_all'] = os.environ.get('DEBUG', True)
settings['debug_all'] = os.environ.get('DEBUG', True)
settings['db'] = os.environ.get(
'DATABASE_URL', 'dbname=learning_journal user=efrain-petercamacho')
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get('AUTH_PASSWORD',
manager.encode('secret'))
secret = os.environ.get('JOURNAL_SESSION_SECRET', 'itsaseekrit')
session_factory = SignedCookieSessionFactory(secret)
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'anotherseekrit')
# configuration setup
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=AuthTktAuthenticationPolicy(secret=auth_secret,
hashalg='sha512'),
authorization_policy=ACLAuthorizationPolicy(),
)
jinja2.filters.FILTERS['markdown'] = markd
config.include('pyramid_jinja2')
config.add_static_view('static', os.path.join(here, 'static'))
config.add_route('home', '/')
config.add_route('add', '/add')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('details', '/details/{id}')
config.add_route('editor', '/editor/{id}')
config.add_route('delete', '/delte/{id}')
config.scan()
app = config.make_wsgi_app()
return app
def test_shorthash(self):
manager = BCRYPTPasswordManager()
def match(hash):
return True
manager.match = match
short_hash = manager.encode(self.snowpass)[:28]
assert_true(manager.match(short_hash))
manager.check(short_hash, self.snowpass)
def main(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
@forbidden_view_config(renderer='templates/forbidden.jinja2')
def forbidden(request):
return {}
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
auth_secret = os.environ.get('TASTEBUDDIES_AUTH_SECRET', 'tastynoms')
authn_policy = AuthTktAuthenticationPolicy(
secret=auth_secret,
hashalg='sha512',
callback=groupfinder,
)
authz_policy = ACLAuthorizationPolicy()
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get(
'AUTH_PASSWORD', manager.encode('secret')
)
config = Configurator(
settings=settings,
authentication_policy=authn_policy,
authorization_policy=authz_policy,
)
config.include('pyramid_jinja2')
config.include('pyramid_tm')
config.add_static_view('static', 'static', cache_max_age=3600)
config.add_route('home', '/')
config.add_route('user_create', '/create_user')
config.add_route('user_login', '/login')
config.add_route('verify', '/verify', factory=Root)
config.add_route('send_email', '/send_email', factory=Root)
config.add_route('logout', '/logout', factory=Root)
config.add_route('profile_edit', '/profile/edit/{username}',
factory=Root)
config.add_route('group_create', '/group/create_group',
factory=Root)
config.add_route('group_edit', '/group/edit/{group_name}',
factory=Root)
config.add_route('profile_detail', '/profile/{username}',
factory=UserFactory, traverse='/{username}')
config.add_route('group_detail', '/group/{group_name}',
factory=Root)
config.scan()
return config.make_wsgi_app()
def _makeOne(self, email, password, id=False):
m = BPM()
hashed = m.encode(password)
if id:
return self._getTargetClass()(id=id, email=email, password=hashed)
return self._getTargetClass()(
email=email,
password=hashed,
)
def _set_password(self, raw_password):
""" Encrypt the password.
Encrypt `raw_password` with bcrypt and set it as the account
password.
:param raw_password: the unencrypted user password
:type username: unicode
:return: the bcrypt encrypted password
:rtype: unicode
"""
bcrypt = BCRYPTPasswordManager()
self._password = unicode(bcrypt.encode(raw_password, rounds=12))
def _initTestingDB(makeuser=False):
engine = create_engine('sqlite://')
Base.metadata.create_all(engine)
DBSession.configure(bind=engine)
if makeuser:
m = BPM()
hashed = m.encode(u'1234567')
with transaction.manager:
user = User(email=u'*****@*****.**',
password=hashed,
)
DBSession.add(user)
return DBSession
def new(cls, username=None, password=None, session=DBSession):
"""Stores password in database already hashed"""
manager = BCRYPTPasswordManager()
if not (username and password):
raise ValueError("Username and password needed")
hashed = unicode(manager.encode(password))
try:
instance = cls(username=username, password=hashed)
session.add(instance)
session.flush()
except IntegrityError:
raise ValueError("Username already in use")
return instance
def auth_req(request):
manager = BCRYPTPasswordManager()
settings = {
'auth.username': '******',
'auth.password': manager.encode('secret'),
}
testing.setUp(settings=settings)
req = testing.DummyRequest()
def cleanup():
testing.tearDown()
request.addfinalizer(cleanup)
return req
def _initTestingDB(makeuser=False):
engine = create_engine('sqlite://')
Base.metadata.create_all(engine)
DBSession.configure(bind=engine)
if makeuser:
m = BPM()
hashed = m.encode(u'1234567')
with transaction.manager:
user = User(
email=u'*****@*****.**',
password=hashed,
)
DBSession.add(user)
return DBSession
def auth_req(request):
manager = BCRYPTPasswordManager()
settings = {
'auth.username': '******',
'auth.password': manager.encode('secret'),
}
testing.setUp(settings=settings)
req = testing.DummyRequest()
def cleanup():
testing.tearDown()
request.addfinalizer(cleanup)
return req
def create_user(cls, username, password, first="", last="",
dflt_medium=1, timezone='America/Los_Angeles',
session=None):
"""Instantiates a new user, and writes it to the database.
User must supply a username and password.
"""
if session is None:
session = DBSession
manager = BCRYPTPasswordManager()
hashed = manager.encode(password)
instance = cls(first=first, last=last, username=username,
password=hashed, dflt_medium=dflt_medium,
timezone=timezone)
session.add(instance)
session.flush()
return instance
def main():
"""Create a configured wsgi app."""
settings = {}
settings['reload_all'] = os.environ.get('DEBUG', True)
settings['debug_all'] = os.environ.get('DEBUG', True)
# settings['db'] = os.environ.get(
# 'DATABASE_URL', 'dbname=learning-journal user=mark'
# )
settings['sqlalchemy.url'] = os.environ.get(
# must be rfc1738 URL
'DATABASE_URL', 'postgresql://mark:@localhost:5432/learning-journal'
)
engine = sa.engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
# Add authentication setting configuration
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get(
'AUTH_PASSWORD', manager.encode('secret'))
# secret value for session signing:
secret = os.environ.get('JOURNAL_SESSION_SECRET', 'itsaseekrit')
session_factory = SignedCookieSessionFactory(secret)
# add a secret value for auth tkt signing
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'anotherseekrit')
# configuration setup
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=AuthTktAuthenticationPolicy(
secret=auth_secret,
hashalg='sha512'
),
authorization_policy=ACLAuthorizationPolicy(),
)
config.include('pyramid_jinja2')
config.include('pyramid_tm')
config.add_static_view('static', os.path.join(here, 'static'))
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('detail', '/detail/{id:\d+}')
config.add_route('edit', '/edit')
config.add_route('new', '/new')
config.scan()
app = config.make_wsgi_app()
return app
def main(argv=sys.argv):
manager = BCRYPTPasswordManager()
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
if 'DATABASE_URL' in os.environ:
settings['sqlalchemy.url'] = os.environ['DATABASE_URL']
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
password = manager.encode(u'admin')
admin = User(name=u'admin', password=password)
DBSession.add(admin)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
if 'DATABASE_URL' in os.environ:
settings['sqlalchemy.url'] = os.environ['DATABASE_URL']
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
manager = Manager()
password = manager.encode(u'admin')
admin = User(username=u'admin', hashed_password=password)
DBSession.add(admin)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
manager = BCRYPTPasswordManager()
pw = getpass.getpass('Admin password: '******'admin', email='*****@*****.**', password=hashed)
DBSession.add(admin)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
manager = Manager()
password = manager.encode('admin')
DBSession.add(Entry(title=u'title', body=u'body'))
DBSession.add(User(username=u'admin', password=password))
def main():
"""Create a configured wsgi app"""
settings = {}
settings['reload_all'] = os.environ.get('DEBUG', True)
settings['debug_all'] = os.environ.get('DEBUG', True)
settings['sqlalchemy.url'] = os.environ.get(
'DATABASE_URL',
'postgresql://roberthaskell:@localhost:5432/learning_journal' #'dbname=learning_journal user=cewing'
)
engine = sa.engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get('AUTH_PASSWORD',
manager.encode('secret'))
# secret value for session signing:
secret = os.environ.get('JOURNAL_SESSION_SECRET', 'itsaseekrit')
session_factory = SignedCookieSessionFactory(secret)
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'anotherseekrit')
# configuration setup
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=AuthTktAuthenticationPolicy(secret=auth_secret,
hashalg='sha512'),
authorization_policy=ACLAuthorizationPolicy(),
)
jinja2.filters.FILTERS['markdown'] = markd
config.include('pyramid_tm')
config.include('pyramid_jinja2')
config.add_static_view('static', os.path.join(here, 'static'))
config.add_route('home', '/')
config.add_route('add', '/add')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('details', '/details/{id}')
config.add_route('editor', '/editor/{id}')
config.add_route('delete', '/delete/{id}')
config.add_route('tweet', '/tweet')
config.scan()
app = config.make_wsgi_app()
return app
def main():
# Create a configured wsgi app
settings = {}
debug = os.environ.get('DEBUG', True)
settings['reload_all'] = debug
settings['debug_all'] = debug
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get(
'AUTH_PASSWORD', manager.encode('secret')
)
if not os.environ.get("TESTING", False):
# only bind the session if it isn't already bound, while testing
engine = sa.create_engine(DATABASE_URL)
DBSession.configure(bind=engine)
# add a secret value for auth tkt signing
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'itsaseekrit')
# and add a new value to the constructor for our Configurator:
config = Configurator(
settings=settings,
authentication_policy=AuthTktAuthenticationPolicy(
secret=auth_secret,
hashalg='sha512',
),
authorization_policy=ACLAuthorizationPolicy(),
)
# we want to use the transaction management provided by pyramid-tm
config.include("pyramid_tm")
config.include("pyramid_jinja2")
config.add_static_view('static', os.path.join(HERE, 'static'))
config.add_route('home', '/')
config.add_route('detail', '/detail/{id}')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('edit', '/edit/{entry_id}')
config.add_route('create', '/create')
config.scan()
app = config.make_wsgi_app()
return app
def auth_req(request):
manager = BCRYPTPasswordManager()
settings = {
'auth.username': '******',
# Password encryption
'auth.password': manager.encode('secret'),
}
testing.setUp(settings=settings)
req = testing.DummyRequest()
print
print "check fixture:"
print settings['auth.password']
def cleanup():
testing.tearDown()
request.addfinalizer(cleanup)
return req
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
m = BPM()
a_email = raw_input('Enter email for admin account: ')
a_pw = getpass('Enter password for admin account: ')
a_hashed = m.encode(a_pw)
with transaction.manager:
admin = User(
email=a_email,
password=a_hashed,
)
DBSession.add(admin)
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
m = BPM()
a_email = raw_input('Enter email for admin account: ')
a_pw = getpass('Enter password for admin account: ')
a_hashed = m.encode(a_pw)
with transaction.manager:
admin = User(
email=a_email,
password=a_hashed,
)
DBSession.add(admin)
def edit_user(request):
user = request.context
if request.method == 'POST':
user.username = request.authenticated_userid
password = request.params.get('password')
manager = BCRYPTPasswordManager()
hashed = manager.encode(password)
user.password = hashed
user.first_name = request.params.get('first_name')
user.last_name = request.params.get('last_name')
default_medium = request.params.get('default_medium').lower()
if default_medium == 'email':
user.dflt_medium = 1
if default_medium == 'text':
user.dflt_medium = 2
else:
raise ValueError()
user.timezone = request.params.get('timezone')
return HTTPFound(request.route_url('list'))
else:
return {'user': user}
def main():
"""Create a configured wsgi app"""
settings = {}
settings['reload_all'] = os.environ.get('DEBUG', True)
settings['debug_all'] = os.environ.get('DEBUG', True)
settings['sqlalchemy.url'] = os.environ.get('DATABASE_URL',
'postgresql:///whiteknight')
engine = sa.engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
settings['auth.username'] = os.environ.get('AUTH_USERNAME', 'admin')
manager = BCRYPTPasswordManager()
settings['auth.password'] = os.environ.get('AUTH_PASSWORD',
manager.encode('secret'))
secret = os.environ.get('JOURNAL_SESSION_SECRET', 'itsaseekrit')
session_factory = SignedCookieSessionFactory(secret)
auth_secret = os.environ.get('JOURNAL_AUTH_SECRET', 'anotherseekrit')
config = Configurator(
settings=settings,
session_factory=session_factory,
authentication_policy=AuthTktAuthenticationPolicy(secret=auth_secret,
hashalg='sha512',
debug=True),
authorization_policy=ACLAuthorizationPolicy(),
)
config.add_static_view('static', os.path.join(here, 'static'))
config.include('pyramid_jinja2')
config.include('pyramid_tm')
config.add_route('home', '/')
config.add_route('login', '/login')
config.add_route('logout', '/logout')
config.add_route('feed', '/feed')
config.add_route('scrape', '/scrape')
config.add_route('scrape_twitter', '/scrape_twitter')
config.add_route('tweet', '/tweet/{id}')
config.add_route('edit_comment', '/edit_comment/{id}')
config.add_route('remove_one', '/remove_one/{id}')
config.add_route('delete_all', '/delete_all')
config.scan()
app = config.make_wsgi_app()
return app
def user_create_view(request):
username = request.authenticated_userid
if request.method == 'POST':
try:
manager = BCRYPTPasswordManager()
username = request.params.get('username')
password = request.params.get('password')
hashed = manager.encode(password)
email = request.params.get('email')
user = User.add(
username=username,
password=hashed,
email=email,
)
Criteria.add(user=user)
headers = remember(request, username)
return HTTPFound(request.route_url('send_email'), headers=headers)
except:
return {}
return {'username': username}
from cryptacular.bcrypt import BCRYPTPasswordManager
manager = BCRYPTPasswordManager()
hashed = manager.encode('password')
assert manager.check(hashed, 'password')
def auth_env(good_login_params):
"""Set username and password into os environment."""
from cryptacular.bcrypt import BCRYPTPasswordManager
manager = BCRYPTPasswordManager()
os.environ['AUTH_USERNAME'] = good_login_params['username']
os.environ['AUTH_PASSWORD'] = manager.encode(good_login_params['password'])
def setPassword(self, new_password):
crypto_manager = BCRYPTPasswordManager()
self.password_hash = crypto_manager.encode(new_password)
def by_name_and_password(cls, name, password):
manager = BCRYPTPasswordManager()
return User.by_name_and_hash(name, manager.encode(password))
def cryptacular():
manager = BCRYPTPasswordManager()
hashed = manager.encode('password')
if manager.check(hashed, 'password'):
print(hashed)
def _makeOne(self, email, password, group, id=False):
m = BPM()
hashed = m.encode(password)
if id:
return self._getTargetClass()(id=id, email=email, password=hashed, group=group)
return self._getTargetClass()(email=email, password=hashed, group=group)
def credentials(self, value):
manager = BCRYPTPasswordManager()
self._credentials = manager.encode(value, rounds=14)
class TestBCRYPTPasswordManager(object):
snowpass = "******"
def setup(self):
self.manager = BCRYPTPasswordManager()
@raises(TypeError)
def test_None1(self):
self.manager.encode(None)
@raises(TypeError)
def test_None2(self):
self.manager.check(None, 'xyzzy')
@raises(TypeError)
def test_None3(self):
hash = self.manager.encode('xyzzy')
self.manager.check(hash, None)
def test_badhash(self):
eq_(self.manager.check('$p5k2$400$ZxK4ZBJCfQg=$kBpklVI9kA13kP32HMZL0rloQ1M=', self.snowpass), False)
@raises(ValueError)
def test_shorthash(self):
manager = BCRYPTPasswordManager()
def match(hash):
return True
manager.match = match
short_hash = manager.encode(self.snowpass)[:28]
assert_true(manager.match(short_hash))
manager.check(short_hash, self.snowpass)
@raises(ValueError)
def test_too_few_rounds(self):
self.manager.encode(self.snowpass, rounds=1)
@raises(ValueError)
def test_too_many_rounds(self):
self.manager.encode(self.snowpass, rounds=100)
def test_emptypass(self):
self.manager.encode('')
def test_general(self):
manager = self.manager
hash = manager.encode(self.snowpass)
eq_(manager.match(hash), True)
eq_(len(hash), 60)
assert_true(manager.check(hash, self.snowpass))
password = "******"
hash = manager.encode(password)
assert_true(manager.check(hash, password))
assert_true(manager.check(unicode(hash), password))
assert_false(manager.check(password, password))
assert_not_equal(manager.encode(password), manager.encode(password))
hash = manager.encode(password, rounds=4)
assert_true(manager.check(hash, password))
@raises(ValueError)
def test_fail_1(self):
def return_none(*args): return None
bcrypt = BCRYPTPasswordManager()
bcrypt.crypt_gensalt_rn = return_none
bcrypt.encode('foo')
@raises(ValueError)
def test_fail_2(self):
def return_none(*args): return None
bcrypt = BCRYPTPasswordManager()
bcrypt.crypt_rn = return_none
bcrypt.encode('foo')
@raises(ValueError)
def test_fail_3(self):
def return_none(*args): return None
bcrypt = BCRYPTPasswordManager()
pw = bcrypt.encode('foobar')
bcrypt.crypt_rn = return_none
bcrypt.check(pw, 'foo')
def hashBcrypt(password, salt='', n=12):
import cryptacular.bcrypt
from cryptacular.bcrypt import BCRYPTPasswordManager
manager = BCRYPTPasswordManager()
hashed = manager.encode(password)
return hashed
def credentials(self, value):
manager = BCRYPTPasswordManager()
self._credentials = manager.encode(value, rounds=14)
def password(self, value):
manager = BCRYPTPasswordManager()
self._password = manager.encode(value)
db_session.add(group)
group = UserGroup(name='registered_bot', description='The owner of the webpage, has all permissions granted.')
db_session.add(group)
group = UserGroup(name='anonymous_user', description='An unregistered user, which can create/read/edit a very limited number of items.')
db_session.add(group)
group = UserGroup(name='banned', description='A banned user, or ip address.')
db_session.add(group)
db_session.commit()
db_session.flush()
#List of registered users at start
user = RegisteredUser(email='*****@*****.**',
email_verified=True,
email_validation_token = 'abc123',
password_hash = crypto_manager.encode('Testing1!'),
accepted_terms_and_conditions = True,
group_id = 1,
display_name="Dante")
db_session.add(user)
db_session.commit()
user = RegisteredUser(email='*****@*****.**',
email_verified=True,
email_validation_token = 'djfixnd2dd3d',
password_hash = crypto_manager.encode('Testing1!'),
accepted_terms_and_conditions = True,
group_id = 2,
display_name="Kali")
db_session.add(user)
db_session.commit()
def __init__(self, login, fullname, password):
self.login = login
self.fullname = fullname
pwd_manager = BCRYPTPasswordManager()
self.password = pwd_manager.encode(password)
