Comrad/komrade/backend/crypt0.py

"""
Storage for both keys and data
"""
import os,sys; sys.path.append(os.path.abspath(os.path.join(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')),'..')))
from komrade import *
from simplekv.fs import FilesystemStore
from simplekv.memory.redisstore import RedisStore
import redis
import hashlib,os
import zlib
from pythemis.exception import ThemisError



LOG_GET_SET = 0





class Crypt(Logger):
    def __init__(self,
            name=None,
            fn=None,
            use_secret=CRYPT_USE_SECRET,
            path_secret=PATH_CRYPT_SECRET,
            encrypt_values=False,
            encryptor_func=None,
            decryptor_func=None):
        
        # defaults
        if not name and fn: name=os.path.basename(fn).replace('.','_')
        self.name,self.fn=name,fn

        
        # use secret? for salting
        if use_secret and path_secret:
            if not os.path.exists(path_secret):
                self.secret = get_random_binary_id()
                from komrade.backend.keymaker import make_key_discreet
                self.log('shhh! creating secret:',make_key_discreet(self.secret))
                with open(path_secret,'wb') as of:
                    of.write(self.secret)
            else:
                with open(path_secret,'rb') as f:
                    self.secret = f.read()
        else:
            self.secret = b''
        self.encrypt_values = encrypt_values
        if self.secret and encrypt_values and (not encryptor_func or not decryptor_func):
            from komrade.backend.keymaker import KomradeSymmetricKeyWithPassphrase
            self.key = KomradeSymmetricKeyWithPassphrase(
                passphrase=self.secret
            )
            encryptor_func = self.key.encrypt
            decryptor_func = self.key.decrypt
        self.encryptor_func=encryptor_func
        self.decryptor_func=decryptor_func
        
        self.store = FilesystemStore(self.fn)
        # self.store = RedisStore(redis.StrictRedis())


    def log(self,*x):
        if LOG_GET_SET:
            super().log(*x)
        
    def hash(self,binary_data):
        return hasher(binary_data,self.secret)

    def force_binary(self,k_b):
        if k_b is None: return None
        if type(k_b)==str: k_b=k_b.encode()
        if type(k_b)!=bytes: k_b=k_b.decode()
        return k_b

    def package_key(self,k,prefix=''):
        if not k: return b''
        k_b = self.force_binary(k)
        k_b2 = self.force_binary(prefix) + k_b
        return k_b2

    def package_val(self,k,encrypt=None):
        if encrypt is None: encrypt=self.encrypt_values
        k_b = self.force_binary(k)
        if encrypt:
            try:
                k_b = self.encryptor_func(k_b)
            except ThemisError as e:
                self.log('!! ENCRYPTION ERROR:',e)
        return k_b

    def unpackage_val(self,k_b,encrypt=None):
        if encrypt is None: encrypt=self.encrypt_values
        if encrypt:
            try:
                k_b = self.decryptor_func(k_b)
            except ThemisError as e:
                self.log('!! DECRYPTION ERROR:',e)
        return k_b

    def has(self,k,prefix=''):
        return bool(self.get(k,prefix=prefix))


    def set(self,k,v,prefix='',override=False,encrypt=True):
        if self.has(k,prefix=prefix) and not override:
            self.log(f"I'm afraid I can't let you do that, overwrite someone's data!\n\nat {prefix}{k} = {v}")
            return False #(False,None,None)
        
        k_b=self.package_key(k,prefix=prefix)
        k_b_hash = self.hash(k_b)
        v_b=self.package_val(v,encrypt = (self.encrypt_values and encrypt))
        if not override:
            self.log(f'''Crypt.set(\n\t{k_b}\n\n\t{k_b_hash}\n\n\t{v_b}\n)''')
        self.store.put(k_b_hash,v_b)
        return True

    def exists(self,k,prefix=''):
        return self.has(k,prefix=prefix)

    def key2hash(self,k,prefix=''):
        return self.hash(
            self.package_key(
                prefix + k
            )
        )

    def delete(self,k,prefix=''):
        k_b=self.package_key(k,prefix=prefix)
        k_b_hash = self.hash(k_b)
        r=self.store.delete(k_b_hash)
        return r
        

    def get(self,k,prefix=''):
        k_b=self.package_key(k,prefix=prefix)
        k_b_hash = self.hash(k_b)
        try:
            v=self.store.get(k_b_hash)
        except KeyError:
            return None
        v_b=self.unpackage_val(v)
        return v_b


class KeyCrypt(Crypt):
    def __init__(self):
        return super().__init__(name=PATH_CRYPT_CA_KEYS.replace('.','_'))


class DataCrypt(Crypt):
    def __init__(self):
        return super().__init__(name=PATH_CRYPT_CA_DATA.replace('.','_'))



class CryptList(Crypt):  # like inbox
    def __init__(self,
            crypt,
            keyname,
            prefix='',
            encryptor_func=lambda x: x,
            decryptor_func=lambda x: x):
        
        self.crypt=crypt
        self.keyname=keyname
        self.prefix=prefix
        self.encryptor_func=encryptor_func
        self.decryptor_func=decryptor_func

    def __repr__(self):
        return f"""
(CryptList)
val_b_encr = {self.val_b_encr}
val_b = {self.val_b}
values = {self.values}
        """
    
    @property
    def val_b_encr(self):
        res = self.crypt.get(
            self.keyname,
            prefix=self.prefix
        )
        self.log('res from crypt:',res)
        return res
    
    @property
    def val_b(self):
        val_b_encr=self.val_b_encr
        if not val_b_encr: return None
        return self.decryptor_func(val_b_encr)
    
    @property
    def values(self):
        if not hasattr(self,'_values') or not self._values:    
            val_b=self.val_b
            if not val_b: return []
            self._values = pickle.loads(val_b)
        return self._values

    def prepend(self,x_l):
        return self.append(x_l,insert=0)

    def append(self,x_l,insert=None):
        if type(x_l)!=list: x_l=[x_l]
        val_l = self.values
        self.log('val_l =',val_l)
        x_l = [x for x in x_l if not x in set(val_l)]
        # print('val_l =',val_l)
        for x in x_l:
            if insert is not None:
                val_l.insert(insert,x)
            else:
                val_l.append(x)
            # print('val_l2 =',val_l)
        return self.set(val_l)

    def set(self,val_l):
        self._values = val_l

        val_b = pickle.dumps(val_l)
        val_b_encr = self.encryptor_func(val_b)
        return self.crypt.set(
            self.keyname,
            val_b_encr,
            prefix=self.prefix,
            override=True
        )

    def remove(self,l):
        if type(l)!=list: l=[l]
        lset=set(l)
        values = [x for x in self.values if x not in lset]
        return self.set(values)




# !!!!
# @TODO: CAUSING PROBLEMS
# !!!

class CryptListRedis(Logger):
    def __init__(self,keyname,prefix='',**y):
        self.redis = redis.StrictRedis()
        # self.store = RedisStore(self.redis)
        self.keyname=b64enc_s(prefix)+b64enc_s(keyname)
        self.log('loading CryptList',keyname,prefix,self.keyname)

    def package_val(self,val):
        if type(val)==bytes: val=val.decode()
        # return b64enc_s(val)
        return val

    def unpackage_val(self,val):
        if type(val)==str: val=val.encode()
        # return b64dec(val)
        return val

    def append(self,val):
        self.log('<--val',val)
        if type(val)==list: return [self.append(x) for x in val]
        val_x = self.package_val(val)
        res = self.redis.rpush(self.keyname,val_x)
        self.log('-->',res)
        return res

    def prepend(self,val):
        self.log('<--val',val)
        if type(val)==list: return [self.prepend(x) for x in val]
        val_x = self.package_val(val)
        res = self.redis.lpush(self.keyname,val_x)
        self.log('-->',res)
        return res

    @property
    def values(self):    
        l = self.redis.lrange(self.keyname, 0, -1 )
        vals = [self.unpackage_val(x) for x in l]
        self.log('-->',vals)
        return vals

    def remove(self,val):
        self.log('<--',val)
        if type(val)==list: return [self.remove(x) for x in val]
        val_x = self.package_val(val)
        res = self.redis.lrem(self.keyname, 0, val_x)
        self.log('-->',res)
        return res



if __name__=='__main__':
    crypt = Crypt('testt')

    from komrade import KomradeSymmetricKeyWithPassphrase
    key = KomradeSymmetricKeyWithPassphrase()


    crypt_list = CryptListRedis(
        keyname='MyInbox2',
        # crypt=crypt
    )

    print(crypt_list.values)

    # print(crypt_list.remove('cool thing 0'))

    # print(crypt_list.append('cool thing 1'))
    
    print(crypt_list.append('#1 baby'))
    print(crypt_list.append('cool thing 0'))
    print(crypt_list.prepend('#0 baby'))

    # print(crypt_list.remove('cool thing 0'))

    print(crypt_list.values)