class NoteRecord(Record):
__tablename__ = 'note_records'
id = db.Column(db.Integer, db.ForeignKey('records.id'), primary_key=True)
note_type = db.Column(db.String(64))
fields = db.Column(JSONType)
__mapper_args__ = {'polymorphic_identity': 'note_records'}
def __init__(self, name, note_type=None):
self.name = name
if not note_type:
self.note_type = "Blank"
self.fields = {}
else:
assert note_type in NOTE_FIELDS
self.note_type = note_type
try:
self.fields = json.loads(NOTE_FIELDS[note_type])
except Exception as e:
print(e)
def __repr__(self):
return '<NoteRecord %r>' % self.name
class UserPreferences(BaseTable):
__tablename__ = 'user_preferences'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(64))
phone_number = db.Column(db.String(64))
password_hint = db.Column(db.String(128))
#language
#timezone
#trusted_users
def __init__(self,
first_name=None,
last_name=None,
phone_number=None,
password_hint=None):
self.first_name = first_name
self.last_name = last_name
self.phone_number = phone_number
self.password_hint = password_hint
def __repr__(self):
return '<UserPreferences %r>' % (self.id)
class PasswordItem(BaseTable):
__tablename__ = 'passwords'
digest_key = db.Column(db.String(64))
salt = db.Column(db.String(32))
length = db.Column(db.Integer)
#encryption
#history
flags = db.Column(ScalarListType())
class ServicePasswordRules(db.Model):
service_id = db.Column(db.Integer, primary_key=True)
symbols = db.Column(db.Boolean, default=True)
alphabet = db.Column(db.String(32), default='')
min_password_length = db.Column(db.Integer, default=8)
max_password_length = db.Column(db.Integer, default=None)
min_required_uppercase = db.Column(db.Integer, default=None)
min_required_numbers = db.Column(db.Integer, default=None)
min_required_special_chars = db.Column(db.Integer, default=None)
class Record(BaseTable):
__tablename__ = 'records'
name = db.Column(db.String(128), unique=True, nullable=False)
description = db.Column(db.String(200))
starred = db.Column(db.Boolean, default=False)
reprompt = db.Column(db.Boolean, default=False)
color = db.Column(db.String(36))
notes = db.Column(db.String(128))
details = db.Column(JSONType())
attachments = db.Column(ScalarListType())
history = db.Column(ScalarListType())
type = db.Column(db.String(50))
__mapper_args__ = {
'polymorphic_identity':'records',
'polymorphic_on': type
}
def _get_name(self):
return self.name
def _get_description(self):
return self.description
def _get_starred(self):
return self.starred
def _get_reprompt(self):
return self.reprompt
def _get_color(self):
return self.color
def _get_notes(self):
return self.notes
def _get_flags(self):
pass
def _get_tags(self):
pass
def _get_attachments(self):
pass
def _get_history(self):
pass
def change_description(self):
pass
def change_color(self):
pass
class User(UserMixin, BaseTable):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False, index=True)
password_hash = db.Column(String(128))
#device = db.Column(db.Integer, ForeignKey('device.id'), nullable=False)
#preferences
#history
def __init__(self, username, email, password):
self.username = username
self.email = email
self._set_password(password)
def _set_password(self, plaintext):
self.password_hash = generate_password_hash(plaintext)
def is_correct_password(self, plaintext):
return check_password_hash(self.password_hash, plaintext)
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
def __repr__(self):
return '<User %r>' % (self.username)
class WalletRecord(Record):
__tablename__ = 'wallet_records'
id = db.Column(db.Integer, db.ForeignKey('records.id'), primary_key=True)
card_type = db.Column(db.String(128))
card_number = db.Column(db.Integer, nullable=False)
name_on_card = db.Column(db.String(128), nullable=False)
expiration_date = db.Column(db.String(5), nullable=False)
cvc_code = db.Column(db.Integer, nullable=False)
zip_code = db.Column(db.Integer, nullable=False)
__mapper_args__ = {'polymorphic_identity': 'wallet_records'}
def __init__(self, name, card_number, name_on_card, expiration_date, cvc_code, zip_code, description=None, notes=None):
self.name = name
self.card_number = card_number
self.name_on_card = name_on_card
self.expiration_date = expiration_date
self.cvc_code = cvc_code
self.zip_code = zip_code
self.description = description
self.notes = notes
def __repr__(self):
return '<WalletRecord %r>' % self.card_name
class Device(BaseTable):
__tablename__ = 'device'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
make = db.Column(db.String(120))
model = db.Column(db.String(120))
client_name = db.Column(db.String(120))
#client_version
os_name = db.Column(db.String(120))
#os_version
last_auth_ip = db.Column(IPAddressType)
#user_agent
def __init__(self,
name=None,
make=None,
model=None,
client_name=None,
os_name=None,
user_agent=None):
self.name = name
self.make = make
self.model = model
self.client_name = client_name
self.os_name = os_name
self.user_agent = user_agent
def __repr__(self):
return '<Device %r>' % (self.name)
class Vault(BaseTable):
src = db.Column(db.String(255))
secret_key = db.Column(db.Unicode(255))
token = db.Column(EncryptedType(db.Unicode, secret_key, AesEngine,
'pkcs5'))
def __init__(self, token=None, src='http://127.0.0.1:5000/'):
self.src = src
self.token = token
#self.cert = cert
#self.access_key
#self.secret_key
#self.expiration_time
@staticmethod
def create(filename, password):
pass
def write_to_file(self, filename, password):
pass
class Flag(db.Model):
__tablename__ = 'flags'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), unique=True, nullable=False)
description = db.Column(db.String(200), unique=True, nullable=False)
def __init__(self, name, description):
self.name = name
self.description = description
@property
def serialize(self):
return {
'id': id,
'name': name
}
def __repr__(self):
return '<Flag %r>' % self.name
class TrustedUser(BaseTable):
__tablename__ = 'trusted_user'
username = db.Column(db.String(64), unique=True)
email = db.Column(db.String(64), unique=True, nullable=False)
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(64))
permissions = db.Column(ScalarListType())
def __init__(self,
username=None,
email=None,
first_name=None,
last_name=None,
permissions=None):
self.username = username
self.email = email
self.first_name = first_name
self.last_name = last_name
self.permissions = permissions
def __repr__(self):
return '<TrustedUser %r>' % (self.username)
class PasswordRecord(Record):
__tablename__ = 'password_records'
id = db.Column(db.Integer, db.ForeignKey('records.id'), primary_key=True)
service_name = db.Column(db.String(128))
service_url = db.Column(db.String(128))
service_domain = db.Column(db.String(64))
email = db.Column(db.String(128))
username = db.Column(db.String(128))
password = db.Column(db.String(128))
__mapper_args__ = {'polymorphic_identity': 'password_records'}
def __init__(self, name=None, service_name=None, service_url=None, service_domain=None, username=None, password=None, email=None, notes=None, description=None, reprompt=None):
self.name = name
self.service_name = service_name
self.service_url = service_url
self.service_domain = service_domain
self.username = username
self.password = password
self.email = email
self.description = description
self.notes = notes
self.reprompt = reprompt
def _get_service_name(self):
return self.service_name
def _get_service_domain(self):
return self.service_domain
def _get_service(self):
pass
def _get_username(self):
return self.username
def _get_email(self):
return self.email
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def delete(self):
db.session.delete(self)
db.session.commit()
def save(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return '<PasswordRecord %r>' % self.name
class FileRecord(Record):
__tablename__ = 'file_records'
id = db.Column(db.Integer, db.ForeignKey('records.id'), primary_key=True)
encrypted_filename = db.Column(db.String(128))
unencrypted_filename = db.Column(db.String(128))
extension = db.Column(db.String(6))
encrypted_content = db.Column(db.LargeBinary)
file_path = db.Column(db.String(128))
parent_id = db.Column(db.Integer, default=None)
unencrypted_file_size = db.Column(db.Integer)
__mapper_args__ = {'polymorphic_identity': 'file_records'}
def __init__(self, name=None, encrypted_filename=None, unencrypted_filename=None, unencrypted_content=None, file_path=None, description=None, notes=None):
self.name = name
self.encrypted_filename = encrypted_filename
self.file_path = file_path
self.description = description
self.notes = notes
self.unencrypted_file_size = os.path.getsize(unencrypted_filename) if unencrypted_filename else None
encrypt_file(in_filename=unencrypted_filename, out_filename=encrypted_filename)
def allowed_filename(self, filename):
return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
def set_extension(self, filename):
pass
def decrypt(self, in_filename=None, out_filename=None):
if not in_filename:
in_filename = self.encrypted_filename
if not out_filename:
out_filename = self.unencrypted_filename
decrypt_file(in_filename, out_filename)
def __repr__(self):
return '<FileRecord %r>' % self.encrypted_filename
class Service(db.Model):
__tablename__ = 'services'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
service_name = db.Column(db.String(32), unique=True, nullable=False)
domain_name = db.Column(db.String(32), unique=True, nullable=False)
length = db.Column(db.Integer, default=8)
symbols = db.Column(db.Boolean, default=True)
alphabet = db.Column(db.String(32), default='')
equiv_domains = db.Column(ScalarListType())
def __init__(self, name, length=8, symbols=True, alphabet=''):
self.name = name
self.length = length
self.symbols = symbols
self.alphabet = alphabet
def get_alphabet(self):
if self.alphabet:
return self.alphabet
alpha = ('abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
'0123456789')
if self.symbols:
alpha += '!@#$%^&*()-_'
return alpha
def get_password(self, plaintext):
return get_password_wrapper(plaintext, self.name, self.length,
self.get_alphabet())
def generate_password(self, plaintext):
pass
@classmethod
def search(cls, query):
return cls.select().where(cls.name**('%%%s%%' % query))
class Tag(db.Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), unique=True, nullable=False)
password_record_id = db.Column(db.Integer,db.ForeignKey('password_records.id'))
wallet_record_id = db.Column(db.Integer,db.ForeignKey('wallet_records.id'))
file_record_id = db.Column(db.Integer,db.ForeignKey('file_records.id'))
note_record_id = db.Column(db.Integer,db.ForeignKey('note_records.id'))
def __init__(self, name=None):
self.name = name
@property
def serialize(self):
return {
'id': self.id,
'name': self.name
}
def __repr__(self):
return '<Tag %r>' % self.name
from flask import jsonify
from flask_sqlalchemy import SQLAlchemy
#from sqlalchemy import event
from sqlalchemy.orm import relationship, backref
#from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.ext.declarative import declarative_base, declared_attr
from sqlalchemy_utils import JSONType, ScalarListType
from passbook.features.orm import db
from passbook.util.security import encrypt_file, decrypt_file
from passbook.models import NOTE_FIELDS
from passbook.models.base import BaseTable
Base = declarative_base()
tag_table = db.Table('tags', Base.metadata, db.Column('password_record_id', db.Integer, db.ForeignKey('password_records.id')),
db.Column('wallet_record_id', db.Integer, db.ForeignKey('wallet_records.id')),
db.Column('file_record_id', db.Integer, db.ForeignKey('file_records.id')),
db.Column('note_record_id', db.Integer, db.ForeignKey('note_records.id'))
)
class Record(BaseTable):
__tablename__ = 'records'
name = db.Column(db.String(128), unique=True, nullable=False)
description = db.Column(db.String(200))
starred = db.Column(db.Boolean, default=False)
reprompt = db.Column(db.Boolean, default=False)
color = db.Column(db.String(36))
notes = db.Column(db.String(128))
class BaseTable(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_on = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
last_updated = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
last_accessed = db.Column(db.DateTime)
version = db.Column(db.Integer, default=1)
def save(self):
db.session.add(self)
db.session.commit()
def update(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
self.save()
def update_credentials(self):
self.last_updated = datetime.utcnow()
self.version += 1
@classmethod
def get_all(cls_):
return cls_.query.all()
@classmethod
def find(cls_, **kwargs):
query = db.session.query(cls_)
if kwargs is not None:
for k, v in kwargs.items():
if isinstance(v, list):
query = query.filter(getattr(cls_, k).in_(v))
else:
query = query.filter(getattr(cls_, k) == v)
return query
@classmethod
def find_first(cls_, **kwargs):
return cls_.find(**kwargs).first()
@classmethod
def delete(cls_, args):
query = db.session.query(cls_)
for k, v in args.items():
query = query.filter(getattr(cls_, k) == v)
query.delete()
def encrypt(self):
pass
def decrypt(self):
pass
def as_dict(self):
fields = {}
for col in self.__table__.columns:
fields[col.name] = getattr(self, col.name)
return fields
def import_from_json(self):
pass
def export_to_json(self):
pass
def log(self, message, level=None):
level = logging.INFO if not level else level
app.logger.log(msg=message, level=level)
