Example #1
0
    def collect_impl(self):
        if self.is_change():
            with self.open_left() as lfd:
                linfo = unpack_class(lfd.read())

            with self.open_right() as rfd:
                rinfo = unpack_class(rfd.read())

            yield JavaClassReport(linfo, rinfo, self.reporter)
Example #2
0
    def collect_impl(self):
        if self.is_change():
            with self.open_left() as lfd:
                linfo = unpack_class(lfd.read())

            with self.open_right() as rfd:
                rinfo = unpack_class(rfd.read())

            yield JavaClassReport(linfo, rinfo, self.reporter)
Example #3
0
    def scan(self, payload: Payload,
             request_meta: RequestMeta) -> WorkerResponse:
        """
        Decodes and extracts information from Java Class files

        """

        results = {}

        try:
            content = unpack_class(payload.content)
        except ClassUnpackException as err:
            raise StoqPluginException(f'Unable to parse payload: {err}')

        try:
            results = {
                'provided': content.get_provides(),
                'required': content.get_requires(),
                'constants': [],
            }
            for obj, _, data in content.cpool.pretty_constants():
                if len(data) <= 6:
                    continue
                constants = {}
                constants['id'] = obj
                constants['data'] = data
                results['constants'].append(constants)
        except Exception as err:
            raise StoqPluginException(f'Unable to analyze Java Class {err}')

        return WorkerResponse(results)
    def get_classinfo(self, entry):
        """
        fetch a class entry as a JavaClassInfo instance
        """

        with self.open(entry) as cfd:
            return unpack_class(cfd)
Example #5
0
    def _run(self, scanObject, result, depth, args):
        moduleResult = []

        try:
            class_obj = unpack_class(scanObject.buffer)

            class_requires = class_obj.get_requires()
            scanObject.addMetadata(self.module_name, 'Requires',
                                   class_requires)

            class_provides = class_obj.get_provides()
            scanObject.addMetadata(self.module_name, 'Provides',
                                   class_provides)

            class_constants = tuple(class_obj.cpool.pretty_constants())
            constantsDict = dict((i, v) for i, t, v in class_constants)
            scanObject.addMetadata(self.module_name, 'Constants',
                                   constantsDict)

        except ScanError:
            raise
        except Unimplemented:
            scanObject.addFlag('java_class:err:unimplemented_feature')
        except ClassUnpackException:
            scanObject.addFlag('java_class:err:class_unpack_exception')

        return moduleResult
Example #6
0
    def get_classinfo(self, entry):
        """
        fetch a class entry as a JavaClassInfo instance
        """

        with self.open(entry) as cfd:
            return unpack_class(cfd)
    def scan(self, payload, **kwargs):
        """
        Decodes and extracts information from Java Class files

        :param bytes payload: Payload to be decoded

        :returns: Java Class Information
        :rtype: dict

        """

        results = {}

        try:
            content = unpack_class(payload)
        except Exception as err:
            self.log.error("Unable to parse payload: {}".format(err))
            return

        try:
            results['provided'] = content.get_provides()
            results['required'] = content.get_requires()
            results['constants'] = []
            for obj, _, data in content.cpool.pretty_constants():
                if len(data) <= 6:
                    continue
                constants = {}
                constants['id'] = obj
                constants['data'] = data
                results['constants'].append(constants)
        except Exception as err:
            self.log.error("Unable to analyze Java Class: {}".format(err))

        return results
Example #8
0
def META_JAVA_CLASS(s, buff):
   # Function must return a dictionary
   META_DICT = {}

   options = classinfo_options()
   info = unpack_class(buff)
   META_DICT = classinfo.cli_simplify_classinfo(options, info)

   return META_DICT
Example #9
0
def META_JAVA_CLASS(s, buff):
    # Function must return a dictionary
    META_DICT = {}

    options = classinfo_options()
    info = unpack_class(buff)
    META_DICT = classinfo.cli_simplify_classinfo(options, info)
    _constants_pool = []
    for x in META_DICT['constants_pool']:
        _constants_pool.append({"index": x[0], "type": x[1], "value": x[2]})
    META_DICT["constants_pool"] = _constants_pool
    return META_DICT
Example #10
0
def extract_class(jar, name):
    """Extracts a LinkableClass from a jar.

    Args:
        jar: An open ZipFile instance.
        name: A string containing the binary name of a class.

    Raises:
        KeyError: The class does not exist in the jar.
    """

    with jar.open(name) as entry:
        return LinkableClass(javatools.unpack_class(entry))
Example #11
0
def extract_class(jar, name):
    """Extracts a LinkableClass from a jar.

    Args:
        jar: An open ZipFile instance.
        name: A string containing the binary name of a class.

    Raises:
        KeyError: The class does not exist in the jar.
    """

    with jar.open(name) as entry:
        return LinkableClass(javatools.unpack_class(entry))
Example #12
0
    def _run(self, scanObject, result, depth, args):
        moduleResult = []

        try:
                class_obj = unpack_class(scanObject.buffer)
                class_requires = class_obj.get_requires()
                scanObject.addMetadata(self.module_name, 'Requires', class_requires)

                class_provides = class_obj.get_provides()
                scanObject.addMetadata(self.module_name, 'Provides', class_provides)

                class_constants = tuple(class_obj.cpool.pretty_constants())
                constantsDict = dict((i,v) for i,t,v in class_constants)
                scanObject.addMetadata(self.module_name, 'Constants', constantsDict)


        except (QuitScanException, GlobalScanTimeoutError, GlobalModuleTimeoutError):
                raise
        except:
                logging.debug("Failed to parse class file")

        return moduleResult
Example #13
0
    def _run(self, scanObject, result, depth, args):
        moduleResult = []

        try:
            class_obj = unpack_class(scanObject.buffer)

            class_requires = class_obj.get_requires()
            scanObject.addMetadata(self.module_name, 'Requires', class_requires)

            class_provides = class_obj.get_provides()
            scanObject.addMetadata(self.module_name, 'Provides', class_provides)

            class_constants = tuple(class_obj.cpool.pretty_constants())
            constantsDict = dict((i,v) for i,t,v in class_constants)
            scanObject.addMetadata(self.module_name, 'Constants', constantsDict)

        except ScanError:
            raise
        except Unimplemented:
            scanObject.addFlag('java_class:err:unimplemented_feature')
        except ClassUnpackException:
            scanObject.addFlag('java_class:err:class_unpack_exception')

        return moduleResult
Example #14
0
                    m.code.append('visitLdcInsn(%sd)' % const)
                else: # TODO
                    m.code.append('visitLdcInsn(%s)' % const)
            elif name[1:-2] in ['LOAD', 'STORE']:
                m.code.append('visitVarInsn(Opcodes.%s, %s)' % (name[:-2], name[-1]))
            elif name in ['GETFIELD', 'PUTFIELD', 'GETSTATIC', 'PUTSTATIC']:
                field = cpool.deref_const(args[0])
                m.code.append('visitFieldInsn(Opcodes.%s, "%s", "%s", "%s")' % (name,
                    field[0], field[1][0], field[1][1]))
            elif 'INVOKE' in name:
                target = cpool.deref_const(args[0])
                m.code.append('visitMethodInsn(Opcodes.%s, "%s", "%s", "%s")' % (name,
                    target[0], target[1][0], target[1][1]))
            elif name in ['NEW', 'ANEWARRAY', 'CHECKCAST', 'INSTANCEOF']:
                t = cpool.deref_const(args[0])
                m.code.append('visitTypeInsn(Opcodes.%s, "%s")' % (name, t))
            else:
                raise Exception('unhandled opcode ' + name)

        return m

if __name__ == '__main__':
    import sys
    translator = Translator()
    for arg in sys.argv:
        jci = javatools.unpack_class(open(sys.argv[1]))
        translator.handle_class(jci)
    import codecs
    with codecs.open('ClassAdapterFactory.java', encoding='utf-8', mode='w') as f:
        f.write(translator.java_code())