supplier-meesho.webflow 1.0.0

package/MobSF/mobsf/DynamicAnalyzer/tools/frida_scripts/default/root_bypass.js

@@ -0,0 +1,260 @@
+// Based on  https://codeshare.frida.re/@dzonerzy/fridantiroot/
+Java.performNow(function () {
+    var RootPackages = ["com.noshufou.android.su", "com.noshufou.android.su.elite", "eu.chainfire.supersu",
+        "com.koushikdutta.superuser", "com.thirdparty.superuser", "com.yellowes.su", "com.koushikdutta.rommanager",
+        "com.koushikdutta.rommanager.license", "com.dimonvideo.luckypatcher", "com.chelpus.lackypatch",
+        "com.ramdroid.appquarantine", "com.ramdroid.appquarantinepro", "com.devadvance.rootcloak", "com.devadvance.rootcloakplus",
+        "de.robv.android.xposed.installer", "com.saurik.substrate", "com.zachspong.temprootremovejb", "com.amphoras.hidemyroot",
+        "com.amphoras.hidemyrootadfree", "com.formyhm.hiderootPremium", "com.formyhm.hideroot", "me.phh.superuser",
+        "eu.chainfire.supersu.pro", "com.kingouser.com"
+    ];
+    var RootBinaries = ["mu", ".su", "su", "busybox", "supersu", "Superuser.apk", "KingoUser.apk", "SuperSu.apk"];
+    var RootProperties = {
+        "ro.build.selinux": "1",
+        "ro.debuggable": "0",
+        "service.adb.root": "0",
+        "ro.secure": "1"
+    };
+    var RootPropertiesKeys = [];
+    for (var k in RootProperties) RootPropertiesKeys.push(k);
+
+    // Patch Native functions early
+
+    // File.exists check
+    var NativeFile = Java.use('java.io.File');
+    NativeFile.exists.implementation = function () {
+        var name = NativeFile.getName.call(this);
+        if (RootBinaries.indexOf(name) > -1) {
+            send("[RootDetection Bypass] return value for binary: " + name);
+            return false;
+        } else {
+            return this.exists.call(this);
+        }
+    };
+
+    // String.contains check
+    var String = Java.use('java.lang.String');
+    String.contains.implementation = function (name) {
+        if (name == "test-keys") {
+            send("[RootDetection Bypass] test-keys check");
+            return false;
+        }
+        return this.contains.call(this, name);
+    };
+
+    // Runtime.exec check
+    function isRootCheck(cmd) {
+        var fakeCmd;
+        if (cmd.indexOf("getprop") != -1 || cmd == "mount" || cmd.indexOf("build.prop") != -1 || cmd == "id" || cmd == "sh") {
+            fakeCmd = "grep";
+            send("[RootDetection Bypass] " + cmd + " command");
+            return fakeCmd;
+        }
+        if (cmd == "su") {
+            fakeCmd = "justafakecommandthatcannotexistsusingthisshouldthowanexceptionwheneversuiscalled";
+            send("[RootDetection Bypass] " + cmd + " command");
+            return fakeCmd;
+        }
+        return false;
+    }
+    // Get all implementations
+    function get_implementations(toHook) {
+        var imp_args = []
+        toHook.overloads.forEach(function (impl, _) {
+            if (impl.hasOwnProperty('argumentTypes')) {
+                var args = [];
+                var argTypes = impl.argumentTypes
+                argTypes.forEach(function (arg_type, __) {
+                    args.push(arg_type.className)
+                });
+                imp_args.push(args);
+            }
+        });
+        return imp_args;
+    }
+
+    var Runtime = Java.use('java.lang.Runtime');
+    var execImplementations = get_implementations(Runtime.exec)
+    var exec = Runtime.exec.overload('java.lang.String')
+
+    execImplementations.forEach(function (args, _) {
+        Runtime.exec.overload.apply(null, args).implementation = function () {
+            var fakeCmd;
+            var argz = [].slice.call(arguments);
+            var cmd = argz[0];
+            if (typeof cmd === 'string') {
+                fakeCmd = isRootCheck(cmd);
+                if (fakeCmd) {
+                    send("[RootDetection Bypass] " + cmd + " command");
+                    return exec.call(this, fakeCmd);
+                }
+            } else if (typeof cmd === 'object') {
+                for (var i = 0; i < cmd.length; i = i + 1) {
+                    var tmp_cmd = cmd[i];
+                    fakeCmd = isRootCheck(tmp_cmd);
+                    if (fakeCmd) {
+                        send("[RootDetection Bypass] " + cmd + " command");
+                        return exec.call(this, '');
+                    }
+                }
+            }
+            return this['exec'].apply(this, argz);
+        };
+    });
+
+    // BufferedReader checkLine check
+    var BufferedReader = Java.use('java.io.BufferedReader');
+    BufferedReader.readLine.overload().implementation = function () {
+        var text = this.readLine.call(this);
+        if (text === null) {
+            // just pass , i know it's ugly as hell but test != null won't work :(
+        } else {
+            var shouldFakeRead = (text.indexOf("ro.build.tags=test-keys") > -1);
+            if (shouldFakeRead) {
+                send("[RootDetection Bypass] build.prop file read");
+                text = text.replace("ro.build.tags=test-keys", "ro.build.tags=release-keys");
+            }
+        }
+        return text;
+    }
+
+    // ProcessBuilder.start check
+    var ProcessBuilder = Java.use('java.lang.ProcessBuilder');
+    ProcessBuilder.start.implementation = function () {
+        var cmd = this.command.call(this);
+        var shouldModifyCommand = false;
+        for (var i = 0; i < cmd.size(); i = i + 1) {
+            var tmp_cmd = cmd.get(i).toString();
+            if (tmp_cmd.indexOf("getprop") != -1 || tmp_cmd.indexOf("mount") != -1 || tmp_cmd.indexOf("build.prop") != -1 || tmp_cmd.indexOf("id") != -1) {
+                shouldModifyCommand = true;
+            }
+        }
+        if (shouldModifyCommand) {
+            send("[RootDetection Bypass] ProcessBuilder " + cmd);
+            this.command.call(this, ["grep"]);
+            return this.start.call(this);
+        }
+        if (cmd.indexOf("su") != -1) {
+            send("[RootDetection Bypass] ProcessBuilder " + cmd);
+            this.command.call(this, ["justafakecommandthatcannotexistsusingthisshouldthowanexceptionwheneversuiscalled"]);
+            return this.start.call(this);
+        }
+
+        return this.start.call(this);
+    }
+
+    // Patch other libraries after the above ones
+    var toHook, className, classMethod;
+    try {
+        className = 'android.app.ApplicationPackageManager'
+        classMethod = 'getPackageInfo'
+        toHook = Java.use(className)[classMethod];
+        if (!toHook) {
+            send('[RootDetection Bypass] Cannot find ' + className + '.' + classMethod);
+            return
+        }
+        toHook.overload('java.lang.String', 'int').implementation = function (pname, flags) {
+            var shouldFakePackage = (RootPackages.indexOf(pname) > -1);
+            if (shouldFakePackage) {
+                send("[RootDetection Bypass] root check for package: " + pname);
+                pname = "set.package.name.to.a.fake.one.so.we.can.bypass.it";
+            }
+            return this.getPackageInfo.call(this, pname, flags);
+        }
+    } catch (err) {
+        send('[RootDetection Bypass] Error ' + className + '.' + classMethod + err);
+        return
+    }
+
+    try {
+        className = 'android.os.SystemProperties'
+        classMethod = 'get'
+        toHook = Java.use(className)[classMethod];
+        if (!toHook) {
+            send('[RootDetection Bypass] Cannot find ' + className + '.' + classMethod);
+            return
+        }
+        toHook.overload('java.lang.String').implementation = function (name) {
+            if (RootPropertiesKeys.indexOf(name) != -1) {
+                send("[RootDetection Bypass] " + name);
+                return RootProperties[name];
+            }
+            return this.get.call(this, name);
+        }
+    } catch (err) {
+        send('[RootDetection Bypass] Error ' + className + '.' + classMethod + err);
+        return
+    }
+    try {
+        className = 'android.security.keystore.KeyInfo'
+        classMethod = 'isInsideSecureHardware'
+        if (parseInt(Java.androidVersion, 10) < 6) {
+            send('[RootDetection Bypass] Not Hooking unavailable class/classMethod - ' + className + '.' + classMethod)
+            return
+        }
+        toHook = Java.use(className)[classMethod];
+        if (!toHook) {
+            send('[RootDetection Bypass] Cannot find ' + className + '.' + classMethod);
+            return
+        }
+        toHook.implementation = function () {
+            send("[RootDetection Bypass] isInsideSecureHardware");
+            return true;
+        }
+    } catch (err) {
+        send('[RootDetection Bypass] Error ' + className + '.' + classMethod + err);
+        return
+    }
+
+    // Native Root Check Bypass
+
+    Interceptor.attach(Module.findExportByName("libc.so", "fopen"), {
+        onEnter: function (args) {
+            var path = Memory.readCString(args[0]);
+            path = path.split("/");
+            var executable = path[path.length - 1];
+            var shouldFakeReturn = (RootBinaries.indexOf(executable) > -1)
+            if (shouldFakeReturn) {
+                Memory.writeUtf8String(args[0], "/notexists");
+                send("[RootDetection Bypass] native fopen");
+            }
+        },
+        onLeave: function (retval) {
+
+        }
+    });
+    Interceptor.attach(Module.findExportByName("libc.so", "system"), {
+        onEnter: function (args) {
+            var cmd = Memory.readCString(args[0]);
+            send("[RootDetection Bypass] SYSTEM CMD: " + cmd);
+            if (cmd.indexOf("getprop") != -1 || cmd == "mount" || cmd.indexOf("build.prop") != -1 || cmd == "id") {
+                send("[RootDetection Bypass] native system: " + cmd);
+                Memory.writeUtf8String(args[0], "grep");
+            }
+            if (cmd == "su") {
+                send("[RootDetection Bypass] native system: " + cmd);
+                Memory.writeUtf8String(args[0], "justafakecommandthatcannotexistsusingthisshouldthowanexceptionwheneversuiscalled");
+            }
+        },
+        onLeave: function (retval) {
+
+        }
+
+    });
+    /*
+
+    TO IMPLEMENT:
+
+    Exec Family
+
+    int execl(const char *path, const char *arg0, ..., const char *argn, (char *)0);
+    int execle(const char *path, const char *arg0, ..., const char *argn, (char *)0, char *const envp[]);
+    int execlp(const char *file, const char *arg0, ..., const char *argn, (char *)0);
+    int execlpe(const char *file, const char *arg0, ..., const char *argn, (char *)0, char *const envp[]);
+    int execv(const char *path, char *const argv[]);
+    int execve(const char *path, char *const argv[], char *const envp[]);
+    int execvp(const char *file, char *const argv[]);
+    int execvpe(const char *file, char *const argv[], char *const envp[]);
+
+    */
+});

package/MobSF/mobsf/DynamicAnalyzer/tools/frida_scripts/default/ssl_pinning_bypass.js

@@ -0,0 +1,255 @@
+Java.perform(function() {
+    var androidVersion = parseInt(Java.androidVersion, 10) 
+    if (androidVersion > 6){
+        try{
+            // Generic SSL Pinning Bypass tested on Android 7, 7.1, 8, and 9
+            // https://android.googlesource.com/platform/external/conscrypt/+/1186465/src/platform/java/org/conscrypt/TrustManagerImpl.java#391
+            var TrustManagerImpl = Java.use('com.android.org.conscrypt.TrustManagerImpl');
+            TrustManagerImpl.checkTrustedRecursive.implementation = function(certs, host, clientAuth, untrustedChain, trustedChain, used) {
+                send('[SSL Pinning Bypass] checkTrustedRecursive() bypassed');
+                return Java.use('java.util.ArrayList').$new();
+            }
+        }catch (err) {
+            send('[SSL Pinning Bypass] TrustManagerImpl.checkTrustedRecursive() not found');
+        }
+        try {
+            var TrustManagerImpl2 = Java.use('com.android.org.conscrypt.TrustManagerImpl');
+            TrustManagerImpl2.verifyChain.implementation = function (untrustedChain, trustAnchorChain, host, clientAuth, ocspData, tlsSctData) {
+                send('[SSL Pinning Bypass] verifyChain() bypassed for: ' + host);
+                return untrustedChain;
+            }
+        } catch (err) {
+            send('[SSL Pinning Bypass] TrustManagerImpl.verifyChain() not found');
+        }
+        try {
+            var ConscryptFileDescriptorSocket = Java.use('com.android.org.conscrypt.ConscryptFileDescriptorSocket');
+            ConscryptFileDescriptorSocket.verifyCertificateChain.implementation = function (certChain, authMethod) {
+                send('[SSL Pinning Bypass] verifyCertificateChain() bypassed');
+                return;
+            }
+        } catch (err) {
+            send('[SSL Pinning Bypass] ConscryptFileDescriptorSocket.verifyCertificateChain() not found');
+        }
+    } else if (androidVersion > 4 && androidVersion < 7) {
+        // Generic SSL Pinning Bypass tested on Android 5, 5,1, 6
+        // https://codeshare.frida.re/@akabe1/frida-universal-pinning-bypasser/
+        try {
+            var OpenSSLSocketImpl = Java.use('com.android.org.conscrypt.OpenSSLSocketImpl');
+            OpenSSLSocketImpl.verifyCertificateChain.implementation = function (certRefs, authMethod) {
+                send('[SSL Pinning Bypass] OpenSSLSocketImpl.verifyCertificateChain() bypassed');
+                return;
+            }
+        } catch (err) {
+            send('[SSL Pinning Bypass] OpenSSLSocketImpl.verifyCertificateChain() not found');
+        }
+    }
+    // 3rd Party Pinning
+    try{
+        var OkHttpClient = Java.use('com.squareup.okhttp.OkHttpClient');
+        OkHttpClient.setCertificatePinner.implementation = function(certificatePinner){
+            send('[SSL Pinning Bypass] OkHttpClient.setCertificatePinner() bypassed');
+            return this;
+        };
+        // Invalidate the certificate pinnet checks (if 'setCertificatePinner' was called before the previous invalidation)
+        var CertificatePinner = Java.use('com.squareup.okhttp.CertificatePinner');
+        CertificatePinner.check.overload('java.lang.String', '[Ljava.security.cert.Certificate;').implementation = function(p0, p1){
+            send('[SSL Pinning Bypass] CertificatePinner.check() 1 bypassed');
+            return;
+        };
+        CertificatePinner.check.overload('java.lang.String', 'java.util.List').implementation = function(p0, p1){
+            send('[SSL Pinning Bypass] CertificatePinner.check() 2 bypassed');
+            return;
+        };
+    } catch(err) {
+        send('[SSL Pinning Bypass] okhttp CertificatePinner not found');
+    }
+    try {
+        var CertificatePinner2 = Java.use('okhttp3.CertificatePinner');
+        CertificatePinner2.check.overload('java.lang.String', 'java.util.List').implementation = function (str) {
+            send('[SSL Pinning Bypass] okhttp3.CertificatePinner.check() bypassed for ' + str);
+            return;
+        };
+    } catch(err) {
+        send('[SSL Pinning Bypass] okhttp3 CertificatePinner not found');
+    }
+    try {
+        // https://gist.github.com/cubehouse/56797147b5cb22768b500f25d3888a22
+        var dataTheorem = Java.use('com.datatheorem.android.trustkit.pinning.OkHostnameVerifier');
+        dataTheorem.verify.overload('java.lang.String', 'javax.net.ssl.SSLSession').implementation = function (str) {
+            send('[SSL Pinning Bypass] DataTheorem trustkit.pinning.OkHostnameVerifier.verify() 1 bypassed for ' + str);
+            return true;
+        };
+
+        dataTheorem.verify.overload('java.lang.String', 'java.security.cert.X509Certificate').implementation = function (str) {
+            send('[SSL Pinning Bypass] DataTheorem trustkit.pinning.OkHostnameVerifier.verify() 2 bypassed for ' + str);
+            return true;
+        };
+    } catch(err) {
+        send('[SSL Pinning Bypass] DataTheorem trustkit not found');
+    }
+    try {
+        var PinningTrustManager = Java.use('appcelerator.https.PinningTrustManager');
+        PinningTrustManager.checkServerTrusted.implementation = function () {
+            send('[SSL Pinning Bypass] Appcelerator appcelerator.https.PinningTrustManager.checkServerTrusted() bypassed');
+        }
+    } catch (err) {
+       send('[SSL Pinning Bypass] Appcelerator PinningTrustManager not found');
+    }
+    try {
+        var SSLCertificateChecker = Java.use('nl.xservices.plugins.SSLCertificateChecker');
+        SSLCertificateChecker.execute.overload('java.lang.String', 'org.json.JSONArray', 'org.apache.cordova.CallbackContext').implementation = function (action, args, callbackContext) {
+            send('[SSL Pinning Bypass] Apache Cordova - SSLCertificateChecker.execute() bypassed');
+            callbackContext.success('CONNECTION_SECURE');
+            return;
+        };
+    } catch(err) {
+        send('[SSL Pinning Bypass] Apache Cordova SSLCertificateChecker not found');
+    }
+    try {
+        var wultra = Java.use('com.wultra.android.sslpinning.CertStore');
+        wultra.validateFingerprint.overload('java.lang.String', '[B').implementation = function (commonName, fingerprint) {
+            send('[SSL Pinning Bypass] Wultra com.wultra.android.sslpinning.CertStore.validateFingerprint() bypassed');
+            var ValidationResult = Java.use('com.wultra.android.sslpinning.ValidationResult');
+            return ValidationResult.TRUSTED;
+        };
+    } catch(err) {
+        send('[SSL Pinning Bypass] Wultra CertStore.validateFingerprint not found');
+    }
+
+    /* Based on https://blog.csdn.net/ALakers/article/details/107642166
+    WebView SSL Error Bypass */
+    try {
+        var WebViewClient = Java.use('android.webkit.WebViewClient');
+        WebViewClient.onReceivedSslError.implementation = function(webView, sslErrorHandler, sslError) {
+            send('WebViewClient onReceivedSslError bypassed');
+            sslErrorHandler.proceed();
+            return;
+        };
+        WebViewClient.onReceivedError.overload('android.webkit.WebView', 'int', 'java.lang.String', 'java.lang.String').implementation = function(a, b, c, d) {
+            send('WebViewClient onReceivedError bypassed');
+            return;
+        };
+        WebViewClient.onReceivedError.overload('android.webkit.WebView', 'android.webkit.WebResourceRequest', 'android.webkit.WebResourceError').implementation = function() {
+            send('WebViewClient onReceivedError bypassed');
+            return;
+        };
+    } catch(err) {
+        send('[SSL Pinning Bypass] WebViewClient not found');
+    }
+    /*** HttpsURLConnection ***/
+    try {
+        var HttpsURLConnection = Java.use('javax.net.ssl.HttpsURLConnection');
+        /*
+        HttpsURLConnection.setDefaultHostnameVerifier.implementation = function(hostnameVerifier) {
+            send('[SSL Pinning Bypass] HttpsURLConnection.setDefaultHostnameVerifier bypassed');
+            return null;
+        };*/
+        HttpsURLConnection.setSSLSocketFactory.implementation = function(SSLSocketFactory) {
+            send('[SSL Pinning Bypass] HttpsURLConnection.setSSLSocketFactory bypassed');
+            return null;
+        };
+        HttpsURLConnection.setHostnameVerifier.implementation = function(hostnameVerifier) {
+            send('[SSL Pinning Bypass] HttpsURLConnection.setHostnameVerifier bypassed');
+            return null;
+        };
+    } catch(err) {
+        send('[SSL Pinning Bypass] HttpsURLConnection not found');
+    }
+    try {
+        /* SSLContext */
+        var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
+        var HostnameVerifier = Java.use('javax.net.ssl.HostnameVerifier');
+        var SSLContext = Java.use('javax.net.ssl.SSLContext');
+        var TrustManager;
+        try {
+            TrustManager = Java.registerClass({
+                name: 'fake.TrustManager',
+                implements: [X509TrustManager],
+                methods: {
+                    checkClientTrusted: function(chain, authType) {},
+                    checkServerTrusted: function(chain, authType) {},
+                    getAcceptedIssuers: function() {
+                        return [];
+                    }
+                }
+            });
+        } catch (e) {
+        }
+
+        var EmptySSLFactory;
+        try {
+            var TrustManagers = [TrustManager.$new()];
+            var TLS_SSLContext = SSLContext.getInstance('TLS');
+            TLS_SSLContext.init(null, TrustManagers, null);
+            EmptySSLFactory = TLS_SSLContext.getSocketFactory();
+
+            var SSLContext_init = SSLContext.init.overload('[Ljavax.net.ssl.KeyManager;', '[Ljavax.net.ssl.TrustManager;', 'java.security.SecureRandom');
+            SSLContext_init.implementation = function(keyManager, trustManager, secureRandom) {
+                SSLContext_init.call(this, null, TrustManagers, null);
+                // send('[SSL Pinning Bypass] SSLContext.init() bypass');
+            };
+        } catch (e) {
+            send('[SSL Pinning Bypass] SSLContext.init() not found');
+        }
+        /* Xutils */
+        var TrustHostnameVerifier;
+        try {
+            TrustHostnameVerifier = Java.registerClass({
+                name: 'fake.TrustHostnameVerifier',
+                implements: [HostnameVerifier],
+                method: {
+                    verify: function(hostname, session) {
+                        return true;
+                    }
+                }
+            });
+        } catch (e) {
+        }
+        var RequestParams = Java.use('org.xutils.http.RequestParams');
+        RequestParams.setSslSocketFactory.implementation = function(sslSocketFactory) {
+            sslSocketFactory = EmptySSLFactory;
+            return null;
+        }
+        RequestParams.setHostnameVerifier.implementation = function(hostnameVerifier) {
+            hostnameVerifier = TrustHostnameVerifier.$new();
+            return null;
+        }
+    } catch (e) {
+        send('[SSL Pinning Bypass] Xutils not found');
+    }
+    /* httpclientandroidlib */
+    try {
+        var AbstractVerifier = Java.use('ch.boye.httpclientandroidlib.conn.ssl.AbstractVerifier');
+        AbstractVerifier.verify.overload('java.lang.String', '[Ljava.lang.String', '[Ljava.lang.String', 'boolean').implementation = function() {
+            send('[SSL Pinning Bypass] httpclientandroidlib AbstractVerifier bypassed');
+            return null;
+        }
+    } catch (e) {
+        send('[SSL Pinning Bypass] httpclientandroidlib not found');
+    }
+    /* cronet */
+    try {
+        var netBuilder = Java.use('org.chromium.net.CronetEngine$Builder');
+        netBuilder.enablePublicKeyPinningBypassForLocalTrustAnchors.implementation = function(arg) {
+            var ret = netBuilder.enablePublicKeyPinningBypassForLocalTrustAnchors.call(this, true);
+            return ret;
+        };
+        netBuilder.addPublicKeyPins.implementation = function(hostName, pinsSha256, includeSubdomains, expirationDate) {
+            return this;
+        };
+        send('[SSL Pinning Bypass] Cronet Public Key pinning bypassed');
+    } catch (err) {
+        send('[SSL Pinning Bypass] Cronet not found');
+    }
+    /* Certificate Transparency Bypass
+       Ajin Abraham - opensecurity.in */
+    try{
+        Java.use('com.babylon.certificatetransparency.CTInterceptorBuilder').includeHost.overload('java.lang.String').implementation = function(host) {
+            send('[SSL Pinning Bypass] Bypassing Certificate Transparency check');
+            return this.includeHost('nonexistent.domain');
+        };
+    } catch (err) {
+        send('[SSL Pinning Bypass] certificatetransparency.CTInterceptorBuilder not found');
+    }
+
+}, 0);

package/MobSF/mobsf/DynamicAnalyzer/tools/frida_scripts/others/aes_key.js

@@ -0,0 +1,161 @@
+// https://codeshare.frida.re/@dzonerzy/aesinfo/
+
+Java.perform(function () {
+    var complete_bytes = new Array();
+    var index = 0;
+    var secretKeySpecDef = Java.use('javax.crypto.spec.SecretKeySpec');
+    var ivParameterSpecDef = Java.use('javax.crypto.spec.IvParameterSpec');
+    var cipherDef = Java.use('javax.crypto.Cipher');
+    var cipherDoFinal_1 = cipherDef.doFinal.overload();
+    var cipherDoFinal_2 = cipherDef.doFinal.overload('[B');
+    var cipherDoFinal_3 = cipherDef.doFinal.overload('[B', 'int');
+    var cipherDoFinal_4 = cipherDef.doFinal.overload('[B', 'int', 'int');
+    var cipherDoFinal_5 = cipherDef.doFinal.overload('[B', 'int', 'int', '[B');
+    var cipherDoFinal_6 = cipherDef.doFinal.overload('[B', 'int', 'int', '[B', 'int');
+    var cipherUpdate_1 = cipherDef.update.overload('[B');
+    var cipherUpdate_2 = cipherDef.update.overload('[B', 'int', 'int');
+    var cipherUpdate_3 = cipherDef.update.overload('[B', 'int', 'int', '[B');
+    var cipherUpdate_4 = cipherDef.update.overload('[B', 'int', 'int', '[B', 'int');
+    var secretKeySpecDef_init_1 = secretKeySpecDef.$init.overload('[B', 'java.lang.String');
+    var secretKeySpecDef_init_2 = secretKeySpecDef.$init.overload('[B', 'int', 'int', 'java.lang.String');
+    var ivParameterSpecDef_init_1 = ivParameterSpecDef.$init.overload('[B');
+    var ivParameterSpecDef_init_2 = ivParameterSpecDef.$init.overload('[B', 'int', 'int');
+    secretKeySpecDef_init_1.implementation = function (arr, alg) {
+        var key = b2s(arr);
+        send("Creating " + alg + " secret key, plaintext:\\n" + hexdump(key));
+        return secretKeySpecDef_init_1.call(this, arr, alg);
+    }
+
+    secretKeySpecDef_init_2.implementation = function (arr, off, len, alg) {
+        var key = b2s(arr);
+        send("Creating " + alg + " secret key, plaintext:\\n" + hexdump(key));
+        return secretKeySpecDef_init_2.call(this, arr, off, len, alg);
+    }
+
+    ivParameterSpecDef_init_1.implementation = function(arr)
+    {
+        var iv = b2s(arr);
+        send("Creating IV:\\n" + hexdump(iv));
+        return ivParameterSpecDef_init_1.call(this, arr);
+    }
+
+    ivParameterSpecDef_init_2.implementation = function(arr, off, len)
+    {
+        var iv = b2s(arr);
+        send("Creating IV, plaintext:\\n" + hexdump(iv));
+        return ivParameterSpecDef_init_2.call(this, arr, off, len);
+    }
+
+    cipherDoFinal_1.implementation = function () {
+        var ret = cipherDoFinal_1.call(this);
+        info(this.getIV(), this.getAlgorithm(), complete_bytes, ret);
+        return ret;
+    }
+
+    cipherDoFinal_2.implementation = function (arr) {
+        addtoarray(arr);
+        var ret = cipherDoFinal_2.call(this, arr);
+        info(this.getIV(), this.getAlgorithm(), complete_bytes, ret);
+        return ret;
+    }
+
+    cipherDoFinal_3.implementation = function (arr, a) {
+        addtoarray(arr);
+        var ret = cipherDoFinal_3.call(this, arr, a);
+        info(this.getIV(), this.getAlgorithm(), complete_bytes, ret);
+        return ret;
+    }
+
+    cipherDoFinal_4.implementation = function (arr, a, b) {
+        addtoarray(arr);
+        var ret = cipherDoFinal_4.call(this, arr, a, b);
+        info(this.getIV(), this.getAlgorithm(), complete_bytes, ret);
+        return ret;
+    }
+
+    cipherDoFinal_5.implementation = function (arr, a, b, c) {
+        addtoarray(arr);
+        var ret = cipherDoFinal_5.call(this, arr, a, b, c);
+        info(this.getIV(), this.getAlgorithm(), complete_bytes, ret);
+        return ret;
+    }
+
+    cipherDoFinal_6.implementation = function (arr, a, b, c, d) {
+        addtoarray(arr);
+        var ret = cipherDoFinal_6.call(this, arr, a, b, c, d);
+        info(this.getIV(), this.getAlgorithm(), complete_bytes, c);
+        return ret;
+    }
+
+    cipherUpdate_1.implementation = function (arr) {
+        addtoarray(arr);
+        return cipherUpdate_1.call(this, arr);
+    }
+
+    cipherUpdate_2.implementation = function (arr, a, b) {
+        addtoarray(arr);
+        return cipherUpdate_2.call(this, arr, a, b);
+    }
+
+    cipherUpdate_3.implementation = function (arr, a, b, c) {
+        addtoarray(arr);
+        return cipherUpdate_3.call(this, arr, a, b, c);
+    }
+
+    cipherUpdate_4.implementation = function (arr, a, b, c, d) {
+        addtoarray(arr);
+        return cipherUpdate_4.call(this, arr, a, b, c, d);
+    }
+
+    function info(iv, alg, plain, encoded) {
+        send("Performing encryption/decryption");
+        if (iv) {
+            send("Initialization Vector: \\n" + hexdump(b2s(iv)));
+        } else {
+            send("Initialization Vector: " + iv);
+        }
+        send("Algorithm: " + alg);
+        send("In: \\n" + hexdump(b2s(plain)));
+        send("Out: \\n" + hexdump(b2s(encoded)));
+        complete_bytes = [];
+        index = 0;
+    }
+
+    function hexdump(buffer, blockSize) {
+        blockSize = blockSize || 16;
+        var lines = [];
+        var hex = "0123456789ABCDEF";
+        for (var b = 0; b < buffer.length; b += blockSize) {
+            var block = buffer.slice(b, Math.min(b + blockSize, buffer.length));
+            var addr = ("0000" + b.toString(16)).slice(-4);
+            var codes = block.split('').map(function (ch) {
+                var code = ch.charCodeAt(0);
+                return " " + hex[(0xF0 & code) >> 4] + hex[0x0F & code];
+            }).join("");
+            codes += "   ".repeat(blockSize - block.length);
+            var chars = block.replace(/[\\x00-\\x1F\\x20]/g, '.');
+            chars += " ".repeat(blockSize - block.length);
+            lines.push(addr + " " + codes + "  " + chars);
+        }
+        return lines.join("\\n");
+    }
+
+    function b2s(array) {
+        var result = "";
+        for (var i = 0; i < array.length; i++) {
+            result += String.fromCharCode(modulus(array[i], 256));
+        }
+        return result;
+    }
+
+    function modulus(x, n) {
+        return ((x % n) + n) % n;
+    }
+
+    function addtoarray(arr) {
+        for (var i = 0; i < arr.length; i++) {
+            complete_bytes[index] = arr[i];
+            index = index + 1;
+        }
+    }
+});