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