def getEncodedTransportScript(self, userService, transport, ip, os, user, password, request): """ Encodes the script so the client can understand it """ script, signature, params = self.getUDSTransportScript(userService, transport, ip, os, user, password, request) logger.debug('Transport script: {}'.format(script)) return encoders.encode(encoders.encode(script, 'bz2'), 'base64', asText=True).replace('\n', ''), signature, params
def data(self, value: typing.Union[str, bytes]): self.size = len(value) self.content = typing.cast( str, encoders.encode(encoders.encode(value, 'zip'), 'base64', asText=True))
def getEncodedTransportScript(self, userService, transport, ip, os, user, password, request): """ Encodes the script so the client can understand it """ script = self.getUDSTransportScript(userService, transport, ip, os, user, password, request) logger.debug('Transport script: {}'.format(script)) return encoders.encode(encoders.encode(script, 'bz2'), 'base64', asText=True).replace('\n', '')
def icon(cls, inBase64=True): ''' Reads the file specified by iconFile at module folder, and returns it content. This is used to obtain an icon so administration can represent it. Args: cls: Class inBase64: If true, the image will be returned as base 64 encoded Returns: Base 64 encoded or raw image, obtained from the specified file at 'iconFile' class attribute ''' logger.debug('Loading icon for class {0} ({1})'.format( cls, cls.iconFile)) file_ = open( os.path.dirname(sys.modules[cls.__module__].__file__) + '/' + cls.iconFile, 'rb') data = file_.read() file_.close() if inBase64 == True: return encoders.encode(data, 'base64') else: return data
def put(self, skey, value, validity=None): # logger.debug('Saving key "%s" for cache "%s"' % (skey, self._owner,)) if validity is None: validity = Cache.DEFAULT_VALIDITY key = self.__getKey(skey) value = encoders.encode(pickle.dumps(value), 'base64', asText=True) now = getSqlDatetime() try: uds.models.Cache.objects.create( owner=self._owner, key=key, value=value, created=now, validity=validity) # @UndefinedVariable except Exception: try: # Already exists, modify it c = uds.models.Cache.objects.get(pk=key) # @UndefinedVariable c.owner = self._owner c.key = key c.value = value c.created = now c.validity = validity c.save() except transaction.TransactionManagementError: logger.debug('Transaction in course, cannot store value')
def icon(cls: typing.Type['Module'], inBase64=True) -> typing.Union[str, bytes]: """ Reads the file specified by iconFile at module folder, and returns it content. This is used to obtain an icon so administration can represent it. Args: cls: Class inBase64: If true, the image will be returned as base 64 encoded Returns: Base 64 encoded or raw image, obtained from the specified file at 'iconFile' class attribute """ logger.debug('Loading icon for class %s (%s)', cls, cls.iconFile) file_ = open( os.path.dirname(sys.modules[cls.__module__].__file__) + '/' + cls.iconFile, 'rb') data = file_.read() file_.close() if inBase64: return encoders.encode(data, 'base64', asText=True) return data
def getEncodedTransportScript( self, userService: 'models.UserService', transport: 'models.Transport', ip: str, os: typing.Dict[str, str], user: '******', password: str, request: 'HttpRequest' ) -> typing.Tuple[str, str, typing.Dict[str, str]]: """ Encodes the script so the client can understand it """ script, signature, params = self.getUDSTransportScript( userService, transport, ip, os, user, password, request) logger.debug('Transport script: %s', script) return typing.cast( str, encoders.encode(encoders.encode(script, 'bz2'), 'base64', asText=True)).replace('\n', ''), signature, params
def getServicesPoolsCounters(servicePool, counter_type): # pylint: disable=no-value-for-parameter try: cacheKey = (servicePool and servicePool.id or 'all') + str(counter_type) + str(POINTS) + str(SINCE) to = getSqlDatetime() since = to - timedelta(days=SINCE) val = cache.get(cacheKey) if val is None: if servicePool is None: us = ServicePool() complete = True # Get all deployed services stats else: us = servicePool complete = False val = [] for x in counters.getCounters(us, counter_type, since=since, to=to, limit=POINTS, use_max=USE_MAX, all=complete): val.append({'stamp': x[0], 'value': int(x[1])}) if len(val) > 2: cache.put(cacheKey, encoders.encode(pickle.dumps(val), 'zip') , 600) else: val = [{'stamp': since, 'value': 0}, {'stamp': to, 'value': 0}] else: val = pickle.loads(encoders.decode(val, 'zip')) return val except: logger.exception('exception') raise ResponseError('can\'t create stats for objects!!!')
def put(self, skey: typing.Union[str, bytes], value: typing.Any, validity: typing.Optional[int] = None) -> None: # logger.debug('Saving key "%s" for cache "%s"' % (skey, self._owner,)) if validity is None: validity = Cache.DEFAULT_VALIDITY key = self.__getKey(skey) value = typing.cast( str, encoders.encode(pickle.dumps(value), 'base64', asText=True)) now: datetime = typing.cast(datetime, getSqlDatetime()) try: DBCache.objects.create(owner=self._owner, key=key, value=value, created=now, validity=validity) # @UndefinedVariable except Exception: try: # Already exists, modify it c: DBCache = DBCache.objects.get(pk=key) # @UndefinedVariable c.owner = self._owner c.key = key c.value = value c.created = now c.validity = validity c.save() except transaction.TransactionManagementError: logger.debug('Transaction in course, cannot store value')
def encrypt(self, value: typing.Union[str, bytes]) -> str: if isinstance(value, str): value = value.encode('utf-8') atfork() return encoders.encode((self._rsa.encrypt(value, b'')[0]), 'base64', asText=True)
def encrypt(self, value): if isinstance(value, six.text_type): value = value.encode('utf-8') atfork() return encoders.encode((self._rsa.encrypt(value, six.b(''))[0]), 'base64', asText=True)
def marshal(self): base = super(LinuxRandomPassManager, self).marshal() ''' Serializes the os manager data so we can store it in database ''' return '\t'.join([ 'v1', self._userAccount, encoders.encode(base, 'hex', asText=True) ]).encode('utf8')
def marshal(self) -> bytes: """ Serializes the os manager data so we can store it in database """ base = LinuxOsManager.marshal(self) return '\t'.join([ 'v1', self._userAccount, typing.cast(str, encoders.encode(base, 'hex', asText=True)) ]).encode('utf8')
def marshal(self) -> bytes: ''' Serializes the os manager data so we can store it in database ''' base = typing.cast( str, encoders.encode(super().marshal(), 'hex', asText=True)) return '\t'.join([ 'v1', self._userAccount, cryptoManager().encrypt(self._password), base ]).encode('utf8')
def generateEncoded(self): ''' Generated base 64 encoded report. Basically calls generate and encodes resuslt as base64 ''' data = self.generate() if self.encoded: return encoders.encode(data, 'base64', asText=True).replace('\n', '') else: return data
def marshal(self) -> bytes: for k, v in self.attrs.items(): logger.debug('Marshall Autoattributes: %s=%s', k, v.getValue()) return typing.cast( bytes, encoders.encode( b'\2'.join([ b'%s\1%s' % (k.encode('utf8'), pickle.dumps(v, protocol=0)) for k, v in self.attrs.items() ]), 'bz2'))
def generateEncoded(self): """ Generated base 64 encoded report. Basically calls generate and encodes resuslt as base64 """ data = self.generate() if self.encoded: data = encoders.encode(data, 'base64', asText=True).replace('\n', '') return data
def scrambleId(request, id_): if SCRAMBLE_SES not in request.session: request.session[SCRAMBLE_SES] = cryptoManager().randomString(SCRAMBLE_LEN) id_ = str(id_) if len(id_) < SCRAMBLE_LEN: id_ = (id_ + '~' + cryptoManager().randomString(SCRAMBLE_LEN))[:SCRAMBLE_LEN] scrambled = cryptoManager().xor(id_, request.session[SCRAMBLE_SES]) return encoders.encode(scrambled, 'base64', asText=True)[:-3]
def saveData(self, skey, data, attr1=None): key = self.__getKey(skey) if isinstance(data, six.text_type): data = data.encode('utf-8') data = encoders.encode(data, 'base64', asText=True) attr1 = '' if attr1 is None else attr1 try: dbStorage.objects.create(owner=self._owner, key=key, data=data, attr1=attr1) # @UndefinedVariable except Exception: dbStorage.objects.filter(key=key).update(owner=self._owner, data=data, attr1=attr1) # @UndefinedVariable
def AESCrypt(self, text: bytes, key: bytes, base64: bool = False) -> bytes: # First, match key to 16 bytes. If key is over 16, create a new one based on key of 16 bytes length cipher = AES.new(CryptoManager.AESKey(key, 16), AES.MODE_CBC, 'udsinitvectoruds') rndStr = self.randomString(cipher.block_size) paddedLength = ((len(text) + 4 + 15) // 16) * 16 toEncode = struct.pack('>i', len(text)) + text + rndStr[:paddedLength - len(text) - 4] encoded = cipher.encrypt(toEncode) if base64: return encoders.encode(encoded, 'base64', asText=False) # Return as binary return encoded
def __insert(self, instance, delay, tag): now = getSqlDatetime() exec_time = now + timedelta(seconds=delay) cls = instance.__class__ instanceDump = encoders.encode(dumps(instance), 'base64') typeName = str(cls.__module__ + '.' + cls.__name__) logger.debug('Inserting delayed task {0} with {1} bytes ({2})'.format(typeName, len(instanceDump), exec_time)) dbDelayedTask.objects.create(type=typeName, instance=instanceDump, # @UndefinedVariable insert_date=now, execution_delay=delay, execution_time=exec_time, tag=tag)
def scrambleMsg(msg: str) -> str: """ Simple scrambler so password are not seen at source page """ data = msg.encode('utf8') res = b'' n = 0x32 for c in data[::-1]: res += bytes([c ^ n]) n = (n + c) & 0xFF return typing.cast(str, encoders.encode(res, 'hex', asText=True))
def __insert(self, instance, delay, tag): now = getSqlDatetime() exec_time = now + timedelta(seconds=delay) cls = instance.__class__ instanceDump = encoders.encode(dumps(instance), 'base64', asText=True) typeName = str(cls.__module__ + '.' + cls.__name__) logger.debug('Inserting delayed task {0} with {1} bytes ({2})'.format(typeName, len(instanceDump), exec_time)) dbDelayedTask.objects.create(type=typeName, instance=instanceDump, # @UndefinedVariable insert_date=now, execution_delay=delay, execution_time=exec_time, tag=tag)
def AESCrypt(self, text, key, base64=False): # First, match key to 16 bytes. If key is over 16, create a new one based on key of 16 bytes length cipher = AES.new(CryptoManager.AESKey(key, 16), AES.MODE_CBC, 'udsinitvectoruds') rndStr = self.randomString(cipher.block_size) paddedLength = ((len(text) + 4 + 15) // 16) * 16 toEncode = struct.pack('>i', len(text)) + text + rndStr[:paddedLength - len(text) - 4] encoded = cipher.encrypt(toEncode) if hex: return encoders.encode(encoded, 'base64', True) return encoded
def marshal(self): base = super(WinDomainOsManager, self).marshal() ''' Serializes the os manager data so we can store it in database ''' return '\t'.join([ 'v3', self._domain, self._ou, self._account, CryptoManager.manager().encrypt(self._password), encoders.encode(base, 'hex', asText=True), self._group, self._serverHint ]).encode('utf8')
def marshal(self) -> bytes: ''' Serializes the os manager data so we can store it in database ''' base = typing.cast( str, encoders.encode(super().marshal(), 'hex', asText=True)) return '\t'.join([ 'v4', self._domain, self._ou, self._account, cryptoManager().encrypt(self._password), base, self._group, self._serverHint, self._ssl, self._removeOnExit ]).encode('utf8')
def marshal(self): base = super(WinDomainOsManager, self).marshal() ''' Serializes the os manager data so we can store it in database ''' return '\t'.join([ 'v3', self._domain, self._ou, self._account, CryptoManager.manager().encrypt(self._password), encoders.encode(base, 'hex', asText=True), self._group, self._serverHint] ).encode('utf8')
def scrambleId(request, id_): if SCRAMBLE_SES not in request.session: request.session[SCRAMBLE_SES] = cryptoManager().randomString( SCRAMBLE_LEN) id_ = str(id_) if len(id_) < SCRAMBLE_LEN: id_ = (id_ + '~' + cryptoManager().randomString(SCRAMBLE_LEN))[:SCRAMBLE_LEN] scrambled = cryptoManager().xor(id_, request.session[SCRAMBLE_SES]) return encoders.encode(scrambled, 'base64', asText=True)[:-3]
def errorView(request, error): idError = int(error) code = (error >> 8) & 0xFF idError = idError & 0xFF; errStr = errorString(idError) if code != 0: errStr += ' (code {0:04X})'.format(code) errStr = encoders.encode(str(errStr), 'base64', asText=True).replace('\n', '') logger.debug('Redirection to error view with {}'.format(errStr)) return HttpResponseRedirect(reverse('page.error', kwargs={'error': errStr}))
def saveData(self, skey, data, attr1=None): key = self.__getKey(skey) if isinstance(data, six.text_type): data = data.encode('utf-8') data = encoders.encode(data, 'base64', asText=True) attr1 = '' if attr1 is None else attr1 try: dbStorage.objects.create(owner=self._owner, key=key, data=data, attr1=attr1) # @UndefinedVariable except Exception: dbStorage.objects.filter(key=key).update( owner=self._owner, data=data, attr1=attr1) # @UndefinedVariable
def serializeForm(self) -> bytes: """ All values stored at form fields are serialized and returned as a single string Separating char is The returned string is zipped and then converted to base 64 Note: Hidens are not serialized, they are ignored """ # import inspect # logger.debug('Caller is : {}'.format(inspect.stack())) arr = [] val: typing.Any for k, v in self._gui.items(): logger.debug('serializing Key: %s/%s', k, v.value) if v.isType(gui.InputField.HIDDEN_TYPE ) and v.isSerializable() is False: # logger.debug('Field {0} is not serializable'.format(k)) continue if v.isType(gui.InputField.INFO_TYPE): # logger.debug('Field {} is a dummy field and will not be serialized') continue if v.isType(gui.InputField.EDITABLE_LIST) or v.isType( gui.InputField.MULTI_CHOICE_TYPE): # logger.debug('Serializing value {0}'.format(v.value)) val = b'\001' + pickle.dumps(v.value, protocol=0) elif v.isType(gui.InfoField.PASSWORD_TYPE): val = b'\004' + cryptoManager().AESCrypt( v.value.encode('utf8'), UDSB, True) elif v.isType(gui.InputField.NUMERIC_TYPE): val = str(int(v.num())).encode('utf8') elif v.isType(gui.InputField.CHECKBOX_TYPE): val = v.isTrue() else: val = v.value.encode('utf8') if val is True: val = gui.TRUE.encode('utf8') elif val is False: val = gui.FALSE.encode('utf8') arr.append(k.encode('utf8') + b'\003' + val) logger.debug('Arr, >>%s<<', arr) return typing.cast(bytes, encoders.encode(b'\002'.join(arr), 'zip'))
def AESCrypt(self, text: bytes, key: bytes, base64: bool = False) -> bytes: # First, match key to 16 bytes. If key is over 16, create a new one based on key of 16 bytes length cipher = Cipher(algorithms.AES(CryptoManager.AESKey(key, 16)), modes.CBC(b'udsinitvectoruds'), backend=default_backend()) rndStr = self.randomString( 16).encode() # Same as block size of CBC (that is 16 here) paddedLength = ((len(text) + 4 + 15) // 16) * 16 toEncode = struct.pack( '>i', len(text)) + text + rndStr[:paddedLength - len(text) - 4] encryptor = cipher.encryptor() encoded = encryptor.update(toEncode) + encryptor.finalize() if base64: return typing.cast(bytes, encoders.encode(encoded, 'base64')) # Return as binary return encoded
def __insert(self, instance: DelayedTask, delay: int, tag: str) -> None: now = getSqlDatetime() exec_time = now + timedelta(seconds=delay) cls = instance.__class__ instanceDump = encoders.encode(pickle.dumps(instance), 'base64', asText=True) typeName = str(cls.__module__ + '.' + cls.__name__) logger.debug('Inserting delayed task %s with %s bytes (%s)', typeName, len(instanceDump), exec_time) DBDelayedTask.objects.create( type=typeName, instance=instanceDump, # @UndefinedVariable insert_date=now, execution_delay=delay, execution_time=exec_time, tag=tag)
def serializeForm(self): """ All values stored at form fields are serialized and returned as a single string Separating char is The returned string is zipped and then converted to base 64 Note: Hidens are not serialized, they are ignored """ # import inspect # logger.debug('Caller is : {}'.format(inspect.stack())) arr = [] for k, v in self._gui.items(): logger.debug('serializing Key: {0}/{1}'.format(k, v.value)) if v.isType(gui.InputField.HIDDEN_TYPE) and v.isSerializable() is False: # logger.debug('Field {0} is not serializable'.format(k)) continue if v.isType(gui.InputField.INFO_TYPE): # logger.debug('Field {} is a dummy field and will not be serialized') continue if v.isType(gui.InputField.EDITABLE_LIST) or v.isType(gui.InputField.MULTI_CHOICE_TYPE): # logger.debug('Serializing value {0}'.format(v.value)) val = b'\001' + pickle.dumps(v.value, protocol=0) elif v.isType(gui.InputField.NUMERIC_TYPE): val = str(int(v.num())).encode('utf8') elif v.isType(gui.InputField.CHECKBOX_TYPE): val = v.isTrue() else: val = v.value.encode('utf8') if val is True: val = gui.TRUE.encode('utf8') elif val is False: val = gui.FALSE.encode('utf8') arr.append(k.encode('utf8') + b'\003' + val) logger.debug('Arr, >>%s<<', arr) return encoders.encode(b'\002'.join(arr), 'zip')
def put(self, skey, value, validity=None): # logger.debug('Saving key "%s" for cache "%s"' % (skey, self._owner,)) if validity is None: validity = Cache.DEFAULT_VALIDITY key = self.__getKey(skey) value = encoders.encode(pickle.dumps(value), 'base64', asText=True) now = getSqlDatetime() try: uds.models.Cache.objects.create(owner=self._owner, key=key, value=value, created=now, validity=validity) # @UndefinedVariable except Exception: try: # Already exists, modify it c = uds.models.Cache.objects.get(pk=key) # @UndefinedVariable c.owner = self._owner c.key = key c.value = value c.created = datetime.now() c.validity = validity c.save() except transaction.TransactionManagementError: logger.debug('Transaction in course, cannot store value')
def serializeForm(self): """ All values stored at form fields are serialized and returned as a single string Separating char is The returned string is zipped and then converted to base 64 Note: Hidens are not serialized, they are ignored """ # import inspect # logger.debug('Caller is : {}'.format(inspect.stack())) arr = [] for k, v in six.iteritems(self._gui): logger.debug('serializing Key: {0}/{1}'.format(k, v.value)) if v.isType(gui.InputField.HIDDEN_TYPE ) and v.isSerializable() is False: # logger.debug('Field {0} is not serializable'.format(k)) continue if v.isType(gui.InputField.INFO_TYPE): # logger.debug('Field {} is a dummy field and will not be serialized') continue if v.isType(gui.InputField.EDITABLE_LIST) or v.isType( gui.InputField.MULTI_CHOICE_TYPE): # logger.debug('Serializing value {0}'.format(v.value)) val = '\001' + pickle.dumps(v.value) elif v.isType(gui.InputField.NUMERIC_TYPE): val = six.text_type(int(v.num())) else: val = v.value if val is True: val = gui.TRUE elif val is False: val = gui.FALSE arr.append(k + '\003' + val) return encoders.encode('\002'.join(arr), 'zip')
def icon(cls, inBase64=True): """ Reads the file specified by iconFile at module folder, and returns it content. This is used to obtain an icon so administration can represent it. Args: cls: Class inBase64: If true, the image will be returned as base 64 encoded Returns: Base 64 encoded or raw image, obtained from the specified file at 'iconFile' class attribute """ logger.debug('Loading icon for class {0} ({1})'.format(cls, cls.iconFile)) file_ = open(os.path.dirname(sys.modules[cls.__module__].__file__) + '/' + cls.iconFile, 'rb') data = file_.read() file_.close() if inBase64: return encoders.encode(data, 'base64', asText=True) else: return data
def getServicesPoolsCounters( servicePool: typing.Optional[models.ServicePool], counter_type: int) -> typing.List[typing.Dict[str, typing.Any]]: # pylint: disable=no-value-for-parameter try: cacheKey = (servicePool and servicePool.id or 'all') + str(counter_type) + str(POINTS) + str(SINCE) to = models.getSqlDatetime() since: datetime.datetime = to - datetime.timedelta(days=SINCE) val: typing.Any = cache.get(cacheKey) if not val: if not servicePool: us = models.ServicePool() complete = True # Get all deployed services stats else: us = servicePool complete = False val = [] for x in counters.getCounters(us, counter_type, since=since, to=to, max_intervals=POINTS, use_max=USE_MAX, all=complete): val.append({'stamp': x[0], 'value': int(x[1])}) if len(val) > 2: cache.put(cacheKey, encoders.encode(pickle.dumps(val), 'zip'), 600) else: val = [{'stamp': since, 'value': 0}, {'stamp': to, 'value': 0}] else: val = pickle.loads(typing.cast(bytes, encoders.decode(val, 'zip'))) return val except: logger.exception('exception') raise ResponseError('can\'t create stats for objects!!!')
def put(self, skey, value, validity=None): # logger.debug('Saving key "%s" for cache "%s"' % (skey, self._owner,)) if validity is None: validity = Cache.DEFAULT_VALIDITY key = self.__getKey(skey) value = encoders.encode(pickle.dumps(value), 'base64') now = getSqlDatetime() try: uds.models.Cache.objects.create( owner=self._owner, key=key, value=value, created=now, validity=validity) # @UndefinedVariable except Exception: # Already exists, modify it c = uds.models.Cache.objects.get(pk=key) # @UndefinedVariable c.owner = self._owner c.key = key c.value = value c.created = datetime.now() c.validity = validity c.save()
def marshal(self): return encoders.encode('\2'.join(['%s\1%s' % (k, pickle.dumps(v)) for k, v in self.dict.iteritems()]), 'bz2')
def encode64(data): return encoders.encode(data, 'base64', asText=True).replace('\n', '') # Removes \n
def marshal(self): return encoders.encode(b'\2'.join([b'%s\1%s' % (k.encode('utf8'), pickle.dumps(v, protocol=0)) for k, v in self.dict.items()]), 'bz2')
def get(self): # pylint: disable=too-many-locals """ Processes get requests """ logger.debug('Client args for GET: %s', self._args) if not self._args: # Gets version return Client.result({ 'availableVersion': CLIENT_VERSION, 'requiredVersion': REQUIRED_CLIENT_VERSION, 'downloadUrl': self._request.build_absolute_uri( reverse('page.client-download')) }) if len(self._args) == 1: # Simple test return Client.result(_('Correct')) try: ticket, scrambler = self._args # If more than 2 args, got an error. pylint: disable=unbalanced-tuple-unpacking hostname = self._params[ 'hostname'] # Or if hostname is not included... srcIp = self._request.ip # Ip is optional, if GlobalConfig.HONOR_CLIENT_IP_NOTIFY.getBool() is True: srcIp = self._params.get('ip', srcIp) except Exception: raise RequestError('Invalid request') logger.debug('Got Ticket: %s, scrambled: %s, Hostname: %s, Ip: %s', ticket, scrambler, hostname, srcIp) try: data = TicketStore.get(ticket) except Exception: return Client.result(error=errors.ACCESS_DENIED) self._request.user = User.objects.get(uuid=data['user']) try: logger.debug(data) ip, userService, userServiceInstance, transport, transportInstance = userServiceManager( ).getService(self._request.user, self._request.os, self._request.ip, data['service'], data['transport']) logger.debug('Res: %s %s %s %s %s', ip, userService, userServiceInstance, transport, transportInstance) password = cryptoManager().symDecrpyt(data['password'], scrambler) userService.setConnectionSource( srcIp, hostname ) # Store where we are accessing from so we can notify Service transportScript, signature, params = transportInstance.getEncodedTransportScript( userService, transport, ip, self._request.os, self._request.user, password, self._request) logger.debug('Signature: %s', signature) logger.debug('Data:#######\n%s\n###########', params) return Client.result( result={ 'script': transportScript, 'signature': signature, # It is already on base64 'params': encoders.encode(encoders.encode(json.dumps(params), 'bz2'), 'base64', asText=True), }) except ServiceNotReadyError as e: # Refresh ticket and make this retrayable TicketStore.revalidate( ticket, 20) # Retry will be in at most 5 seconds, so 20 is fine :) return Client.result(error=errors.SERVICE_IN_PREPARATION, errorCode=e.code, retryable=True) except Exception as e: logger.exception("Exception") return Client.result(error=str(e))
def marshal(self): base = super(LinuxRandomPassManager, self).marshal() ''' Serializes the os manager data so we can store it in database ''' return '\t'.join(['v1', self._userAccount, encoders.encode(base, 'hex', asText=True)]).encode('utf8')
def serialize(self): ''' Serializes and "obfuscates' the data. ''' return encoders.encode(self.marshal(), 'base64', asText=True)
def data(self, value): self.size = len(value) content = encoders.encode(encoders.encode(value, 'zip'), 'base64', asText=True) self.content = content