class RevokedTokenModel(db.Model):
__tablename__ = 'revoked_tokens'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120))
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class PolicyPoolModel(db.Model):
policy = db.Column(db.Integer,
ForeignKey('policies.policy'),
primary_key=True)
timestamp = db.Column(db.Integer, primary_key=True)
pool_ = db.Column(JSON)
def __init__(self, policy: int, timestamp: int):
self.policy = policy
self.timestamp = timestamp
self.pool_ = []
def get_pool_hash(self):
print(type(self.pool))
return PolicyPoolModel.hash_util(self.pool)
@staticmethod
def hash_util(d: dict or list) -> int:
try:
assert type(d) == dict or type(d) == list
except AssertionError:
print(type(d), file=sys.stderr)
hashable = json.dumps(d)
hash_tmp = SHA256Hash().new(hashable.encode())
return Conversion.OS2IP(hash_tmp.digest())
@property
def pool(self) -> list:
res = list()
pool = json.loads(self.pool_)
for x in pool:
x = json.loads(x)
data = {"hash": PolicyPoolModel.hash_util(x), "proofs": x}
res.append(data)
return res
@pool.setter
def pool(self, proofs: dict):
self.append_to_pool(proofs)
def append_to_pool(self, proofs: dict):
tmp = json.loads(str(self.pool_))
tmp.append(json.dumps(proofs))
self.pool_ = json.dumps(tmp)
self.save_to_db()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class PolicyModel(db.Model):
__tablename__ = 'policies'
policy = db.Column(db.Integer, primary_key=True)
publication_interval = db.Column(db.Integer)
lifetime = db.Column(db.Integer)
description = db.Column(db.String)
keys = relationship("KeyModel")
pools = relationship("PolicyPoolModel")
def __init__(self, publication_interval, lifetime, description):
self.publication_interval = publication_interval
self.lifetime = lifetime
self.description = description if description is not None else "No description given"
def __repr__(self):
return "<Policy(policy='%s', description='%s')>" % (self.policy,
self.description)
def __str__(self):
return "Policy(policy='%s', description='%s')" % (self.policy,
self.description)
def get_key(self, timestamp: int) -> KeyModel:
"""
Find a policy key model based on the timestamp given.
:param timestamp: (int)
:return: (KeyModel) or None
"""
return self.__get_from_list(self.keys, timestamp)
def get_pool(self, timestamp: int) -> PolicyPoolModel:
pool = self.__get_from_list(self.pools, timestamp)
if pool is None:
pool = PolicyPoolModel(self.policy, timestamp)
pool.save_to_db()
self.save_to_db()
return pool
@staticmethod
def __get_from_list(ls, timestamp) -> db.Model:
for x in ls:
if x.timestamp == timestamp:
return x
return None
def save_to_db(self):
db.session.add(self)
db.session.commit()
class SigVarsModel(db.Model):
__tablename__ = 'sigvars'
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.Integer)
policy = db.Column(db.Integer)
u_ = db.Column(db.String)
d_ = db.Column(db.String)
s1_ = db.Column(db.String)
s2_ = db.Column(db.String)
user_id = db.Column(db.Integer, ForeignKey('users.id'))
def __init__(self, timestamp, policy, u, d, s1, s2, user_id):
"""
:param timestamp: POSIX timestamp
:param policy: integer referencing the policy chosen
:param u: Element.Integer mod q
:param d: Element.Integer mod q
:param s1: Element.Integer mod q
:param s2: Element.Integer mod q
:param user_id: integer representing the user in the CP's system database
"""
self.timestamp = timestamp
self.policy = policy
self.user_id = user_id
self.u_ = SigConversion.modint2strlist(u)
self.d_ = SigConversion.modint2strlist(d)
self.s1_ = SigConversion.modint2strlist(s1)
self.s2_ = SigConversion.modint2strlist(s2)
def __repr__(self):
return "<UserSigVars(user_id='%s', u='%s', d='%s', s1='%s', s2='%s')>" % \
(self.user_id, self.u, self.d, self.s1, self.s2)
@property
def u(self):
return SigConversion.strlist2modint(self.u_)
@property
def d(self):
return SigConversion.strlist2modint(self.d_)
@property
def s1(self):
return SigConversion.strlist2modint(self.s1_)
@property
def s2(self):
return SigConversion.strlist2modint(self.s2_)
@property
def get_timestamp(self):
return self.timestamp
def save_to_db(self):
db.session.add(self)
db.session.commit()
class KeyModel(db.Model):
timestamp = db.Column(db.Integer, primary_key=True)
policy = db.Column(db.Integer,
ForeignKey('policies.policy'),
primary_key=True)
signer_ = db.Column(db.String)
def __init__(self, timestamp, policy, signer):
self.timestamp = timestamp
self.policy = policy
self.signer_ = signer.encode()
def __repr__(self):
return "<Key(timestamp='%s', policy='%s', pub_key='%s')>" % (
self.timestamp, self.policy, self.pub_key)
@property
def signer(self):
return SignerBlindSignature().decode(self.signer_)
@property
def get_timestamp(self):
return self.timestamp
@property
def get_policy(self):
return self.policy
def get_public_key(self):
signer = self.signer
return signer.get_public_key()
def get_private_key(self):
sig = self.signer
return sig.get_private_key()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class UserModel(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
name = db.Column(db.String(1000), nullable=False)
sigvars = relationship('SigVarsModel')
def get_id(self):
return self.id
def __init__(self, name, email, password):
self.name = name
self.email = email
self.hash_password(password)
def __repr__(self):
return "<User(name='%s', email='%s')>" % (self.name, self.email)
def hash_password(self, password):
self.password = generate_password_hash(password, method='sha256')
def verify_password(self, password):
return check_password_hash(self.password, password)
def delete(self):
db.session.delete(self)
db.session.commit()
def get_sigvar(self, timestamp, policy):
for x in self.sigvars:
if x.timestamp == timestamp and x.policy == policy:
return x
return None
def save_to_db(self):
db.session.add(self)
db.session.commit()