py10x-universe 0.1.3__py3-none-any.whl

core_10x/vault/security_keys_old.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import os
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+from cryptography.hazmat.primitives.serialization import (
+    load_pem_private_key,
+    load_pem_public_key,
+)
+
+from core_10x.global_cache import cache
+
+# fmt: off
+ROOT                = '.xx'
+PUBLIC_EXP          = 65537
+KEY_SIZE            = 2048
+PRIVATE_KEY_FILE    = 'private.pem'
+PUBLIC_KEY_FILE     = 'public.pem'
+ENCODING            = 'utf-8'
+# fmt: on
+
+
+class SecKeys:
+    @classmethod
+    @cache
+    def home_dir(cls) -> str:
+        dir = f'{os.path.expanduser("~")}/{ROOT}'
+        if os.path.exists(dir):
+            assert os.path.isdir(dir), f'{dir} is not a directory'
+        else:
+            os.mkdir(dir)
+
+        return dir
+
+    @classmethod
+    def generate_keys(cls, pwd=None) -> tuple:
+        private_key = rsa.generate_private_key(public_exponent=PUBLIC_EXP, key_size=KEY_SIZE, backend=default_backend())
+        public_key = private_key.public_key()
+
+        if pwd:
+            format = serialization.PrivateFormat.PKCS8
+            algo = serialization.BestAvailableEncryption(bytes(pwd, encoding=ENCODING))
+        else:
+            format = serialization.PrivateFormat.TraditionalOpenSSL
+            algo = serialization.NoEncryption()
+
+        private_key_pem = private_key.private_bytes(encoding=serialization.Encoding.PEM, format=format, encryption_algorithm=algo)
+        public_key_pem = public_key.public_bytes(encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo)
+
+        return (private_key_pem, public_key_pem)
+
+    @classmethod
+    def create_keys(cls, keys: tuple = None) -> tuple:
+        private_key, public_key = keys if keys else cls.generate_keys()
+        home_dir = cls.home_dir()
+        try:
+            with open(f'{home_dir}/{PRIVATE_KEY_FILE}', 'wb') as f:
+                f.write(private_key)
+                os.chmod(f.name, 0o600)
+
+            with open(f'{home_dir}/{PUBLIC_KEY_FILE}', 'wb') as f:
+                f.write(public_key)
+                os.chmod(f.name, 0o600)
+
+            cls.keys.clear()  # -- cls.keys() will then read from the files
+            return (private_key, public_key)
+
+        except Exception:
+            return (None, None)
+
+    @classmethod
+    @cache
+    def keys(cls) -> tuple:
+        home_dir = cls.home_dir()
+        file = f'{home_dir}/{PRIVATE_KEY_FILE}'
+        if os.path.exists(file):
+            try:
+                with open(file, 'rb') as f:
+                    private_key = f.read()
+
+                with open(f'{home_dir}/{PUBLIC_KEY_FILE}', 'rb') as f:
+                    public_key = f.read()
+
+                return (private_key, public_key)
+
+            except Exception:
+                pass
+
+        return (None, None)
+
+    @classmethod
+    def encrypt(cls, message, public_key: bytes = None) -> bytes | None:
+        if type(message) is str:
+            message = bytes(message, encoding=ENCODING)
+
+        if public_key is None:
+            _, public_key = cls.keys()
+            if public_key is None:
+                return None
+
+        public_key = load_pem_public_key(public_key)
+        # fmt: off
+        return public_key.encrypt(
+            message,
+            padding.OAEP(
+                mgf         = padding.MGF1(algorithm = hashes.SHA256()),
+                algorithm   = hashes.SHA256(),
+                label       = None
+            )
+        )
+        # fmt: on
+
+    @classmethod
+    def decrypt(cls, encrypted_message: bytes, to_str=True):
+        private_key, _ = cls.keys()
+        if private_key is None:
+            return None
+
+        private_key = load_pem_private_key(private_key, password=None)
+        # fmt: off
+        res = private_key.decrypt(
+            encrypted_message,
+            padding.OAEP(
+                mgf         = padding.MGF1(algorithm = hashes.SHA256()),
+                algorithm   = hashes.SHA256(),
+                label       = None
+            )
+        )
+        # fmt: on
+
+        if to_str:
+            res = res.decode(encoding=ENCODING)
+
+        return res
+
+    @classmethod
+    def encrypt_private_key(cls, password) -> bytes | None:
+        if type(password) is str:
+            password = bytes(password, encoding=ENCODING)
+
+        private_key, _ = cls.keys()
+        if private_key is None:
+            return None
+
+        private_key = load_pem_private_key(private_key, password=None)
+        # fmt: off
+        return private_key.private_bytes(
+            encoding                = serialization.Encoding.PEM,
+            format                  = serialization.PrivateFormat.PKCS8,
+            encryption_algorithm    = serialization.BestAvailableEncryption(password),
+        )
+        # fmt: on
+
+    @classmethod
+    def decrypt_private_key(cls, private_key_with_password, password) -> bytes:
+        if type(password) is str:
+            password = bytes(password, encoding=ENCODING)
+
+        pk = load_pem_private_key(private_key_with_password, password=password)
+        # fmt: off
+        return pk.private_bytes(
+            encoding                = serialization.Encoding.PEM,
+            format                  = serialization.PrivateFormat.TraditionalOpenSSL,
+            encryption_algorithm    = serialization.NoEncryption(),
+        )
+        # fmt: on

core_10x/vault/vault.py

@@ -0,0 +1,56 @@
+from datetime import datetime
+
+from core_10x.xnone import XNone
+from core_10x.resource import Resource
+from core_10x.vault.vault_traitable import VaultTraitable, T, RT
+from core_10x.vault.vault_user import VaultUser
+
+class ResourceAccessor(VaultTraitable):
+    # fmt: off
+    username: str           = T(T.ID)
+    resource_uri: str       = T(T.ID)
+
+    login: str              = T()
+    password: bytes         = T()
+
+    last_updated: datetime  = T(T.EVAL_ONCE)
+
+    user: VaultUser         = RT(T.EVAL_ONCE)
+    resource: Resource      = RT(T.EVAL_ONCE)
+    # fmt: on
+
+    def username_get(self) -> str:
+        return VaultUser.myname()
+
+    def last_updated_get(self) -> datetime:
+        return datetime.utcnow()
+
+    def user_get(self) -> VaultUser:
+        return VaultUser.existing_instance(user_id = self.username)
+
+    def resource_get(self) -> Resource:
+        return Resource.instance_from_uri(
+            self.resource_uri,
+            username = self.username,
+            password = self.user.sec_keys.decrypt_text(self.password)
+        )
+
+class Vault:
+    @classmethod
+    def save_resource_accessor(cls, resource_uri: str, password: str, login: str = None, username: str = XNone):
+        if login is None:
+            login = username
+
+        ra = ResourceAccessor(username = username, resource_uri = resource_uri)
+        user = ra.user
+        ra.set_values(
+            login = login,
+            password = user.sec_keys.encrypt_text(password)
+        ).throw()
+
+        ra.save().throw()
+
+    #-- strictly speaking this method isn't necessary as it just returning existing_instance()
+    @classmethod
+    def retrieve_resource_accessor(cls, resource_uri: str, username: str = XNone) -> ResourceAccessor:
+        return ResourceAccessor.existing_instance(username = username, resource_uri = resource_uri)

core_10x/vault/vault_traitable.py

@@ -0,0 +1,56 @@
+import keyring
+
+from py10x_core import OsUser
+
+from core_10x.traitable import Traitable, T, RT, RC, RC_TRUE, TsStore, cache
+from core_10x.environment_variables import EnvVars
+
+
+class VaultTraitable(Traitable):
+    @classmethod
+    @cache
+    def retrieve_master_password(cls) -> str:
+        username = OsUser.me.name()
+        pwd = keyring.get_password(EnvVars.master_password_key, username)
+        if pwd is None:
+            raise OSError(f'XX MasterPassword for {username} is not found')
+
+        return pwd
+
+    @classmethod
+    def keep_master_password(cls, password: str):
+        username = OsUser.me.name()
+        keyring.set_password(EnvVars.master_password_key, username, password)
+
+    @classmethod
+    @cache
+    def retrieve_vault_password(cls, vault_uri: str) -> str:
+        username = OsUser.me.name()
+        pwd = keyring.get_password(vault_uri, username)
+        if pwd is None:
+            raise OSError(f'Password for {username} @ {vault_uri} is not found')
+
+        return pwd
+
+    @classmethod
+    def keep_vault_password(cls, vault_uri: str, password: str):
+        username = OsUser.me.name()
+        keyring.set_password(vault_uri, username, password)
+
+    @classmethod
+    @cache
+    def store_per_class(cls,) -> TsStore:
+        uri = EnvVars.assert_var.vault_ts_store_uri
+        spec = TsStore.spec_from_uri(uri)
+        kwargs = spec.kwargs
+        ts_class = spec.resource_class
+        hostname = kwargs[ts_class.HOSTNAME_TAG]
+        is_running, with_auth = ts_class.is_running_with_auth(hostname)
+        if not is_running or not with_auth:
+            raise OSError(f'Vault host {hostname} must be run with auth')
+
+        username = OsUser.me.name()
+        kwargs[ts_class.USERNAME_TAG] = username
+        kwargs[ts_class.PASSWORD_TAG] = cls.retrieve_master_password()
+
+        return ts_class.instance(**kwargs)

core_10x/vault/vault_user.py

@@ -0,0 +1,70 @@
+from core_10x.environment_variables import EnvVars
+from core_10x.ts_store import TsStore
+from core_10x.vault.vault_traitable import VaultTraitable, T, RT, RC, OsUser, cache
+from core_10x.vault.sec_keys import SecKeys
+
+class VaultUser(VaultTraitable):
+    # fmt: off
+    user_id: str                    = T(T.ID)   // 'OS login'
+    suspended: bool                 = T(False)
+
+    private_key_encrypted: bytes    = T()
+    public_key: bytes               = T()
+
+    sec_keys: SecKeys               = RT(T.EVAL_ONCE)
+    # fmt: on
+
+    def user_id_get(self) -> str:
+        return self.__class__.myname()
+
+    def sec_keys_get(self) -> SecKeys:
+        return SecKeys(self.private_key_encrypted, self.public_key, VaultTraitable.retrieve_master_password())
+
+    @classmethod
+    def create_new(cls, master_password: str, save = True) -> 'VaultUser':
+        VaultTraitable.keep_master_password(master_password)
+        private_key_pem, public_key_pem = SecKeys.generate_keys()
+        me = VaultUser()
+        me.public_key = public_key_pem
+        me.private_key_encrypted = SecKeys.encrypt_private_key(private_key_pem, master_password)
+
+        if save:
+            me.save().throw()
+
+        return me
+
+    @classmethod
+    def new_vault(cls, vault_uri: str, password: str, master_password: str = None):
+        username = cls.myname()
+        vault_db = TsStore.instance_from_uri(vault_uri, username = username, password = password)
+        with vault_db:
+            me = cls.existing_instance(user_id = username, _throw = False)
+            if not me:
+                if not master_password:
+                    raise AssertionError('Master password is required')
+                me = cls.create_new(master_password)
+            else:
+                try:
+                    existing_master_password = cls.retrieve_master_password()
+                except Exception:
+                    existing_master_password = None
+                if not existing_master_password:
+                    raise AssertionError('No existing MasterPassword found')
+                if existing_master_password != master_password:
+                    raise AssertionError('MasterPassword provided does not match the stored one')
+
+            cls.keep_vault_password(vault_uri, password)
+
+    @classmethod
+    def is_functional_account(cls, user_id: str) -> bool:
+        return user_id.split('-', 1) == EnvVars.functional_account_prefix
+
+    @classmethod
+    @cache
+    def myname(cls) -> str:
+        return OsUser.me.name()
+
+    @classmethod
+    @cache
+    def me(cls) -> 'VaultUser':
+        return cls.existing_instance(user_id=cls.myname())

core_10x/xdate_time.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+
+import dateutil.parser
+
+MIN_CANONICAL_DATE = 10000101
+
+
+class XDateTime:
+    """
+    All datetime values are in UTC time zone!
+    """
+
+    @staticmethod
+    def int_to_date(v: int) -> date:
+        """
+        ordinal or canonical (<yyyy><mm><dd>)
+        """
+        if v >= MIN_CANONICAL_DATE:
+            day = v % 100
+            ym = v // 100
+
+            month = ym % 100
+            year = ym // 100
+
+            return date(year=year, month=month, day=day)
+
+        return date.fromordinal(v)
+
+    @staticmethod
+    def date_to_int(v: date, ordinal: bool = True) -> int:
+        return v.toordinal() if ordinal else (10000 * v.year + 100 * v.month + v.day)
+
+    # fmt: off
+    FORMAT_X10  = '%Y%m%d'
+    FORMAT_ISO  = '%Y-%m-%d'
+    FORMAT_US   = '%m/%d/%Y'
+    FORMAT_EU   = '%d.%m.%Y'
+    # fmt: on
+
+    s_default_format = FORMAT_X10
+    formats = [s_default_format, FORMAT_X10, FORMAT_ISO, FORMAT_US, FORMAT_EU]
+
+    @classmethod
+    def set_default_format(cls, fmt: str):
+        cls.s_default_format = fmt
+        cls.formats[0] = fmt
+
+    @staticmethod
+    def str_to_date(v: str, format: str = '') -> date | None:
+        if format:
+            try:
+                return datetime.strptime(v, format).date()
+            except Exception:
+                return None
+
+        for fmt in XDateTime.formats:
+            try:
+                return datetime.strptime(v, fmt).date()
+            except Exception:
+                continue
+
+        try:
+            return dateutil.parser.parse(v).date()
+        except Exception:
+            pass
+
+    formats_to_str = (
+        f'{formats[0]} %H:%M:%S',
+        f'{formats[0]} %H:%M:%S.%f',
+    )
+
+    @staticmethod
+    def datetime_to_str(v: datetime, with_ms: bool = False) -> str:
+        fmt = XDateTime.formats_to_str[with_ms]
+        return v.strftime(fmt)
+
+    @staticmethod
+    def date_to_str(v: date, format: str = '') -> str:
+        if not format:
+            format = XDateTime.formats[0]
+        return v.strftime(format)
+
+    # fmt: off
+    date_converters = {
+        date:       lambda v:   v,
+        datetime:   lambda v:   date(v.year, v.month, v.day),
+        int:        int_to_date,
+        str:        str_to_date,
+    }
+    # fmt: on
+    @classmethod
+    def to_date(cls, v) -> date | None:
+        fn = cls.date_converters.get(type(v))
+        return fn(v) if fn else None
+
+    dt_format = ('%H:%M', '%H:%M:%S')
+
+    @staticmethod
+    def str_to_datetime(v: str) -> datetime | None:
+        parts = v.split(' ')
+        try:
+            date_part, time_part = parts
+            d = XDateTime.str_to_date(date_part)
+            if d is not None:
+                num_colons = time_part.count(':')
+                fmt = XDateTime.dt_format[num_colons]
+                if time_part.find('.') != -1:
+                    fmt = fmt + '.%f'
+                    return datetime.strptime(time_part, fmt)
+        except Exception:
+            pass
+
+        try:
+            return dateutil.parser.parse(v)
+        except Exception:
+            pass
+
+    @staticmethod
+    def date_to_datetime(d: date) -> datetime:
+        return datetime(year=d.year, month=d.month, day=d.day)
+
+    # fmt: off
+    datetime_converters = {
+        datetime:   lambda v:   v,
+        date:       lambda v:   datetime(year = v.year, month = v.month, day = v.day),
+        int:        lambda v:   XDateTime.date_to_datetime(XDateTime.int_to_date(v)),
+        str:        str_to_datetime,
+    }
+    # fmt: on
+
+    @classmethod
+    def to_datetime(cls, v) -> datetime:
+        fn = cls.datetime_converters.get(type(v))
+        return fn(v) if fn else None

core_10x/xnone.py

@@ -0,0 +1,71 @@
+class XNoneType:
+    """
+    XNone is the 10x alternative to None representing a special empty object.
+    As opposed to None, XNone may be used in many built-in python operations without extra checking, e.g.
+
+    a_dict = XNone
+    for key, value in a_dict.items():
+        ...
+
+    The above loop will merely exit on the first iteration.
+
+    - all arithmetic operations with XNone will return XNone
+    - all relational operations with XNone will return True or False accordingly
+    - a call to XNone(*args, **kwargs) will return XNone
+    """
+
+    def __getattr__(self, item):              return self
+    def __setattr__(self, key, value):        raise AttributeError('May not setattr to XNone')
+    def __getitem__(self, item):              return self
+    def __setitem__(self, key, value):        raise TypeError('\'XNone\' object does not support item assignment')
+    def __call__(self, *args, **kwargs):      return self
+    def __hash__(self):                       return id(self)
+
+    def __int__(self):                        return self
+    def __bool__(self):                       return False
+    def __float__(self):                      return self
+
+    def __repr__(self):                       return 'XNone'
+    def __str__(self):                        return ''
+
+    def __and__(self, other):                 return False
+    def __or__(self, other):                  return other
+    def __xor__(self, other):                 return other
+    def __invert__(self):                     return None   #-- the opposite to XNone
+    def __lshift__(self, other):              return self
+    def __rshift__(self, other):              return self
+
+    def __len__(self):                        return 0
+    def __iter__(self):                       return self
+    def __next__(self):                       raise StopIteration
+
+    def keys(self):                           return self
+    def values(self):                         return self
+    def items(self):                          return self
+
+    def __eq__(self, other):                  return other is self
+    def __ne__(self, other):                  return other is not self
+    def __lt__(self, other):                  return other is not self
+    def __le__(self, other):                  return True
+    def __gt__(self, other):                  return False
+    def __ge__(self, other):                  return other is self
+    def __abs__(self):                        return self
+    def __neg__(self):                        return self
+    def __add__(self, other):                 return self
+    def __radd__(self, other):                return self
+    def __sub__(self, other):                 return self
+    def __rsub__(self, other):                return self
+    def __mul__(self, other):                 return self
+    def __rmul__(self, other):                return self
+    def __pow__(self, power, modulo = None):  return self
+    def __truediv__(self, other):             return self
+    def __rtruediv__(self, other):            return self
+    def __floordiv__(self, other):            return self
+    def __rfloordiv__(self, other):           return self
+
+    s_serialized = chr(8)
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError('May not derive from XNone')
+
+XNone = XNoneType()