LICENSE

The MIT License (MIT)

Copyright (c) 2015 David Weinstein

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

MegaRenameClass.py

#? name=Mega Rename Class, shortcut=Ctrl+Shift+I, author=David Weinstein, help=Rename classes using multiple strategies.

# based partly on https://github.com/SecureBrain/JEB-sample-scripts/blob/master/RenameObfuscatedClasses.py

from jeb.api import IScript
from jeb.api.ui import View
from jeb.api.ui import CodePosition
import re

class MegaRenameClass(IScript):

    def run(self, jeb):
        self.jeb = jeb
        self.dex = jeb.getDex()
        self.ui = jeb.getUI()
        self.dry_run = False
        should_refresh = False

        if not self.dex:
            print 'Error! Please provide an input file.'
            return None

        if True:
            for obj in self.emit_classes(count=None):
                did_rename = self.rename_class_strategy(obj)
                if not should_refresh and did_rename:
                    should_refresh = True
        else:
            self.ui.focusView(View.Type.JAVA)
            j_view = self.j_view = self.ui.getView(View.Type.JAVA)
            cls = j_view.getCodePosition(j_view.getCaretLine()).getSignature().split('->')[0]
            should_refresh = self.rename_class_strategy(self.classNameToObj(cls))

        if should_refresh:
            self.slowRefreshViews()

    def slowRefreshViews(self):
        # refresh view
        self.ui.getView(View.Type.ASSEMBLY).refresh()
        self.ui.getView(View.Type.JAVA).refresh()
        self.ui.getView(View.Type.CLASS_HIERARCHY).refresh()
        return self

    def classNameToObj(self, name):
        return self.dex.getClass(name)

    def ind2str(self, ind):
        return self.dex.getString(ind)

    def emit_classes(self, count=None):
        print "emitting %s classes in dex" % (count or "all")
        for i in xrange(0, count or self.dex.getClassCount()):
            yield self.dex.getClass(i)

    def fileToName(self, aStr):
        if aStr:
            return aStr.split('.')[0]
        return None

    def renameClass(self, old, new):
        #print "Want to rename %s => %s" % (old, new)
        if self.dry_run:
            return

        res = self.jeb.renameClass(old, new)
        if not res:
            for i in xrange(0, 50):
                res = self.jeb.renameClass(old, "%s%d" % (new, i))
                if res:
                    break
        return res

    def rename_by_source(self, cls):
      name = self.dex.getType(cls.getClasstypeIndex())
      if '$' in name:
          return False # don't rename nested classes based on source

      sourceIndex = cls.getSourceIndex()
      if sourceIndex < 0:
          return
      sourceName = self.fileToName(self.ind2str(sourceIndex))
      if sourceName:
          renamed = self.renameClass(name, sourceName)
          return renamed

      return False

    def rename_class_strategy(self, cls):
        """Rename class based on multiple strategies.
        First try to rename based on the source file name.

        """
        cls_name = self.dex.getType(cls.getClasstypeIndex())

        ret = self.rename_by_source(cls) or False
        if not ret:
            ret |= self.rename_by_super_class(cls) or False
            ret |= self.rename_by_accessor(cls) or False
            ret |= self.rename_by_interfaces(cls) or False

        if ret:
            new_name = self.dex.getType(cls.getClasstypeIndex())
            if cls_name != new_name:
                print "RENAMED '%s' => '%s'" % (cls_name, new_name)
                return True

        return False


    def append_cls_name(self, cls, append_str):
        p = re.compile("^.*\/([\w$]+);$")
        # cls_name has package path
        cls_name = self.dex.getType(cls.getClasstypeIndex())
        if cls_name.find(append_str) == -1:
            s = re.search(p, cls_name)
            if s:
              simple_new_name = s.group(1) + '_' + append_str 
              return self.renameClass(cls_name, simple_new_name)
        return False

    def rename_by_super_class(self, cls):
        rename_targets = {
            'Landroid/app/Service;': 'Service',
            'Landroid/app/Activity;': 'Activity',
            'Landroid/content/BroadcastReceiver;': 'Receiver',
            'Landroid/content/ContentProvider;': 'Provider',
            'Ljava/lang/Thread;': 'Thread',
            'Landroid/os/AsyncTask;': 'AsyncTask',
            'Ljava/util/TimerTask;': 'TimerTask',
            'Landroid/database/sqlite/SQLiteDatabase;': 'SQLiteDatabase',
            'Landroid/database/sqlite/SQLiteOpenHelper;': 'SQLiteOpenHelper',
            'Landroid/database/ContentObserver;': 'ContentObserver',
            'Landroid/os/Handler;': 'Handler',
        }
        super_cls_type = self.dex.getType(cls.getSuperclassIndex())
        if super_cls_type in rename_targets.keys():
            val = rename_targets[super_cls_type]
            return self.append_cls_name(cls, val)
        else:
            return False

    def rename_by_accessor(self, cls):
        flg = cls.getAccessFlags()
        ret = False
        if flg & 0x200:
            ret |= self.append_cls_name(cls, 'Interface')
        if flg & 0x400:
            ret |= self.append_cls_name(cls, 'Abstract')
        if flg & 0x4000:
            ret |= self.append_cls_name(cls, 'Enum')
        return ret


    def rename_by_interfaces(self, cls):
        ret = False
        for idx in cls.getInterfaceIndexes():
            if_name = self.dex.getType(idx)
            if if_name.endswith('ClickListener;'):
                ret |= self.append_cls_name(cls, 'ClickListener')
            if if_name.endswith('CancelListener;'):
                ret |= self.append_cls_name(cls, 'CancelListener')
            if if_name == 'Ljava/lang/Runnable;':
                ret |= self.append_cls_name(cls, 'Runnable')
            if if_name == 'Landroid/os/IInterface;':
                ret |= self.append_cls_name(cls, 'IInterface')

        return ret