SkidSec WebShell

Server Address : 172.31.38.4

Web Server : Apache/2.4.58 (Ubuntu)

Uname : Linux ip-172-31-38-4 6.14.0-1017-aws #17~24.04.1-Ubuntu SMP Wed Nov 5 10:48:17 UTC 2025 x86_64

PHP Version : 7.4.33

# Copyright (C) 2012 Canonical Ltd. # Copyright (C) 2012, 2013 Hewlett-Packard Development Company, L.P. # Copyright (C) 2012 Yahoo! Inc. # # Author: Scott Moser <scott.moser@canonical.com> # Author: Juerg Haefliger <juerg.haefliger@hp.com> # Author: Joshua Harlow <harlowja@yahoo-inc.com> # # This file is part of cloud-init. See LICENSE file for license information. import abc import logging import os from cloudinit import importer, type_utils, util from cloudinit.settings import FREQUENCIES, PER_ALWAYS, PER_INSTANCE LOG = logging.getLogger(__name__) # Used as the content type when a message is not multipart # and it doesn't contain its own content-type NOT_MULTIPART_TYPE = "text/x-not-multipart" # When none is assigned this gets used OCTET_TYPE = "application/octet-stream" # Special content types that signal the start and end of processing CONTENT_END = "__end__" CONTENT_START = "__begin__" CONTENT_SIGNALS = [CONTENT_START, CONTENT_END] # Used when a part-handler type is encountered # to allow for registration of new types. PART_CONTENT_TYPES = ["text/part-handler"] PART_HANDLER_FN_TMPL = "part-handler-%03d" # For parts without filenames PART_FN_TPL = "part-%03d" # Different file beginnings to their content type INCLUSION_TYPES_MAP = { "#include": "text/x-include-url", "#include-once": "text/x-include-once-url", "#!": "text/x-shellscript", "#cloud-config": "text/cloud-config", "#part-handler": "text/part-handler", "#cloud-boothook": "text/cloud-boothook", "#cloud-config-archive": "text/cloud-config-archive", "#cloud-config-jsonp": "text/cloud-config-jsonp", "## template: jinja": "text/jinja2", # Note: for the next 3 entries, the prefix doesn't matter because these # are for types that can only be used as part of a MIME message. However, # including these entries suppresses warnings during `cloudinit devel # make-mime`, which otherwise would require `--force`. "text/x-shellscript-per-boot": "text/x-shellscript-per-boot", "text/x-shellscript-per-instance": "text/x-shellscript-per-instance", "text/x-shellscript-per-once": "text/x-shellscript-per-once", } # Sorted longest first INCLUSION_SRCH = sorted( list(INCLUSION_TYPES_MAP.keys()), key=(lambda e: 0 - len(e)) ) class Handler(metaclass=abc.ABCMeta): def __init__(self, frequency, version=2): self.handler_version = version self.frequency = frequency def __repr__(self): return "%s: [%s]" % (type_utils.obj_name(self), self.list_types()) def list_types(self): # Each subclass must define the supported content prefixes it handles. if not hasattr(self, "prefixes"): raise NotImplementedError("Missing prefixes subclass attribute") else: return [ INCLUSION_TYPES_MAP[prefix] for prefix in getattr(self, "prefixes") ] @abc.abstractmethod def handle_part(self, *args, **kwargs): raise NotImplementedError() def run_part(mod, data, filename, payload, frequency, headers): mod_freq = mod.frequency if not ( mod_freq == PER_ALWAYS or (frequency == PER_INSTANCE and mod_freq == PER_INSTANCE) ): return # Sanity checks on version (should be an int convertible) try: mod_ver = mod.handler_version mod_ver = int(mod_ver) except (TypeError, ValueError, AttributeError): mod_ver = 1 content_type = headers["Content-Type"] try: LOG.debug( "Calling handler %s (%s, %s, %s) with frequency %s", mod, content_type, filename, mod_ver, frequency, ) if mod_ver == 3: # Treat as v. 3 which does get a frequency + headers mod.handle_part( data, content_type, filename, payload, frequency, headers ) elif mod_ver == 2: # Treat as v. 2 which does get a frequency mod.handle_part(data, content_type, filename, payload, frequency) elif mod_ver == 1: # Treat as v. 1 which gets no frequency mod.handle_part(data, content_type, filename, payload) else: raise ValueError("Unknown module version %s" % (mod_ver)) except Exception: util.logexc( LOG, "Failed calling handler %s (%s, %s, %s) with frequency %s", mod, content_type, filename, mod_ver, frequency, ) def call_begin(mod, data, frequency): # Create a fake header set headers = { "Content-Type": CONTENT_START, } run_part(mod, data, None, None, frequency, headers) def call_end(mod, data, frequency): # Create a fake header set headers = { "Content-Type": CONTENT_END, } run_part(mod, data, None, None, frequency, headers) def walker_handle_handler(pdata, _ctype, _filename, payload): curcount = pdata["handlercount"] modname = PART_HANDLER_FN_TMPL % (curcount) frequency = pdata["frequency"] modfname = os.path.join(pdata["handlerdir"], "%s" % (modname)) if not modfname.endswith(".py"): modfname = "%s.py" % (modfname) # TODO(harlowja): Check if path exists?? util.write_file(modfname, payload, 0o600) handlers = pdata["handlers"] try: mod = fixup_handler(importer.import_module(modname)) call_begin(mod, pdata["data"], frequency) # Only register and increment after the above have worked, so we don't # register if it fails starting. handlers.register(mod, initialized=True) pdata["handlercount"] = curcount + 1 except Exception: util.logexc( LOG, "Failed at registering python file: %s (part handler %s)", modfname, curcount, ) def _extract_first_or_bytes(blob, size): # Extract the first line or upto X symbols for text objects # Extract first X bytes for binary objects try: if isinstance(blob, str): start = blob.split("\n", 1)[0] else: # We want to avoid decoding the whole blob (it might be huge) # By taking 4*size bytes we guarantee to decode size utf8 chars start = blob[: 4 * size].decode(errors="ignore").split("\n", 1)[0] if len(start) >= size: start = start[:size] except UnicodeDecodeError: # Bytes array doesn't contain text so return chunk of raw bytes start = blob[0:size] return start def _escape_string(text): try: return text.encode("string_escape") except (LookupError, TypeError): try: # Unicode (and Python 3's str) doesn't support string_escape... return text.encode("unicode_escape") except TypeError: # Give up... pass except AttributeError: # We're in Python3 and received blob as text # No escaping is needed because bytes are printed # as 'b\xAA\xBB' automatically in Python3 pass return text def walker_callback(data, filename, payload, headers): content_type = headers["Content-Type"] if content_type in data.get("excluded"): LOG.debug('content_type "%s" is excluded', content_type) return if content_type in PART_CONTENT_TYPES: walker_handle_handler(data, content_type, filename, payload) return handlers = data["handlers"] if content_type in handlers: run_part( handlers[content_type], data["data"], filename, payload, data["frequency"], headers, ) elif payload: # Extract the first line or 24 bytes for displaying in the log start = _extract_first_or_bytes(payload, 24) details = "'%s...'" % (_escape_string(start)) if content_type == NOT_MULTIPART_TYPE: LOG.warning( "Unhandled non-multipart (%s) userdata: %s", content_type, details, ) else: LOG.warning( "Unhandled unknown content-type (%s) userdata: %s", content_type, details, ) else: LOG.debug("Empty payload of type %s", content_type) # Callback is a function that will be called with # (data, content_type, filename, payload) def walk(msg, callback, data): partnum = 0 for part in msg.walk(): # multipart/* are just containers if part.get_content_maintype() == "multipart": continue ctype = part.get_content_type() if ctype is None: ctype = OCTET_TYPE filename = part.get_filename() if not filename: filename = PART_FN_TPL % (partnum) headers = dict(part) LOG.debug(headers) headers["Content-Type"] = ctype payload = util.fully_decoded_payload(part) callback(data, filename, payload, headers) partnum = partnum + 1 def fixup_handler(mod, def_freq=PER_INSTANCE): if not hasattr(mod, "handler_version"): setattr(mod, "handler_version", 1) if not hasattr(mod, "frequency"): setattr(mod, "frequency", def_freq) else: freq = mod.frequency if freq and freq not in FREQUENCIES: LOG.warning("Handler %s has an unknown frequency %s", mod, freq) return mod def type_from_starts_with(payload, default=None): try: payload_lc = util.decode_binary(payload).lower() except UnicodeDecodeError: return default payload_lc = payload_lc.lstrip() for text in INCLUSION_SRCH: if payload_lc.startswith(text): return INCLUSION_TYPES_MAP[text] return default