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()