rhodes 5.5.0.7 → 5.5.0.22

data/lib/commonAPI/devicesecurity/ext/build

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+
+if [ "$RHO_PLATFORM" = "android" ]; then
+
+cd platform/android
+rake --trace
+
+elif [ "$RHO_PLATFORM" = "iphone" ]; then
+
+cd platform/iphone
+rake --trace
+
+elif [ "$RHO_PLATFORM" = "osx" ]; then
+
+cd platform/qt
+rake --trace
+
+fi

data/lib/commonAPI/devicesecurity/ext/build.bat

@@ -0,0 +1,29 @@
+
+if "%RHO_PLATFORM%" == "android" (
+
+cd platform\android
+rake --trace
+
+)
+
+if "%RHO_PLATFORM%" == "iphone" (
+
+cd platform\phone
+rake --trace
+
+)
+
+if "%RHO_PLATFORM%" == "win32" (
+
+call "%RHO_VSCMNTOOLS%..\..\VC\vcvarsall.bat" x86
+cd platform\qt
+rake --trace
+
+)
+
+if "%RHO_PLATFORM%" == "bb" (
+
+cd platform\bb
+rake --trace
+
+)

data/lib/commonAPI/devicesecurity/ext/platform/android/InbuiltValues.erb

@@ -0,0 +1,16 @@
+package com.rho.devicesecurity;
+
+class InbuiltValues {
+
+  public static final String[] ALLOWED_CERT_SIGNATURES = {
+    <% for s in allowed_signatures %>
+      <%= "\"#{s}\"," %>
+    <% end %>
+  };
+
+  public static final String[] ALLOWED_INSTALLERS = {
+    <% for i in allowed_installers %>
+      <%= "\"#{i}\"," %>
+    <% end %>
+  };
+};

data/lib/commonAPI/devicesecurity/ext/platform/android/Rakefile

@@ -0,0 +1,166 @@
+require 'fileutils'
+
+SOURCEPATH = ENV['SOURCEPATH']
+raise 'SOURCEPATH is not set' if SOURCEPATH.nil?
+
+SOURCELIST = ENV['SOURCELIST']
+raise 'SOURCELIS is not setT' if SOURCELIST.nil?
+
+BUILDARGS = ENV['BUILDARGS'].split if ENV['BUILDARGS']
+  
+TARGETDIR = ENV['TARGETPATH']
+raise "TARGETPATH is not set" if TARGETDIR.nil?
+
+TARGETLIB = ENV['TARGETLIB']
+raise "TARGETLIB is not set" if TARGETLIB.nil?
+
+OBJDIR = ENV['TEMP_FILES_DIR']
+raise "TEMP_FILES_DIR is not set" if OBJDIR.nil?
+
+$rootdir = ENV['RHO_ROOT']
+raise "RHO_ROOT is not set" if $rootdir.nil?
+
+$appincdir = ENV["RHO_INC"]
+raise "RHO_INC is not set" if $appincdir.nil?
+
+ANDROID_NDK = ENV['ANDROID_NDK']
+raise 'ANDROID_NDK is not set' if ANDROID_NDK.nil?
+
+ANDROID_API_LEVEL = ENV['ANDROID_API_LEVEL']
+raise 'ANDROID_API_LEVEL is not set' if ANDROID_API_LEVEL.nil?
+
+$debug = ENV['RHO_DEBUG'] == 'true'
+
+cd SOURCEPATH
+
+require File.join($rootdir, 'platform/android/build/androidcommon.rb')
+
+ARGS = ['-Iext/platform/android/generated/jni',
+    '-Iext/platform/android/jni',
+    '-Iext/shared',
+    "-I\"#{$rootdir}/platform/android/Rhodes/jni/include\"",
+    "-I\"#{$rootdir}/platform/android/Rhodes/jni/include/rhodes/details\"",
+    "-I\"#{$rootdir}/platform/shared/ruby/include\"",
+    "-I\"#{$rootdir}/platform/shared\"",
+    "-I\"#{$rootdir}/platform/shared/common\"",
+    "-I\"#{$rootdir}/platform/shared/api_generator\"",
+    "-I\"#{$appincdir}\"",
+    "-I\"#{$rootdir}/platform/shared/ruby\"",
+    "-I\"#{$rootdir}/platform/shared/ruby/android\"",
+    "-I\"#{$rootdir}/platform/shared/ruby/generated\""]
+
+OBJDIR_ARM = File.join(OBJDIR,'arm')
+OBJDIR_x86 = File.join(OBJDIR,'x86')
+OBJDIR_MIPS = File.join(OBJDIR,'mips')
+
+    
+SRC = get_sources File.join(SOURCELIST)
+
+OBJ_ARM = FileList.new(get_objects(SRC, OBJDIR_ARM))
+OBJ_x86 = FileList.new(get_objects(SRC, OBJDIR_x86))
+OBJ_MIPS = FileList.new(get_objects(SRC, OBJDIR_MIPS))
+
+TARGETDIR_ARM = File.join(TARGETDIR,'armeabi')
+TARGETDIR_x86 = File.join(TARGETDIR,'x86')
+TARGETDIR_MIPS = File.join(TARGETDIR,'mips')
+
+TARGETLIB_ARM = File.join(TARGETDIR_ARM,TARGETLIB)
+TARGETLIB_x86 = File.join(TARGETDIR_x86,TARGETLIB)
+TARGETLIB_MIPS = File.join(TARGETDIR_MIPS,TARGETLIB)
+
+cd '../../..'
+
+namespace 'config' do
+  task :arm do
+      setup_ndk(ANDROID_NDK, ANDROID_API_LEVEL,'arm')
+  end
+  
+  task :x86 do
+      setup_ndk(ANDROID_NDK, ANDROID_API_LEVEL,'x86')
+  end
+  
+  task :mips do
+      setup_ndk(ANDROID_NDK, ANDROID_API_LEVEL,'mips')
+  end
+end
+
+directory TARGETDIR_ARM
+directory TARGETDIR_x86
+directory TARGETDIR_MIPS
+directory OBJDIR_ARM
+directory OBJDIR_x86
+directory OBJDIR_MIPS
+
+rule '.o' => lambda {|obj| find_source(obj) } do |t|
+  abi = File.basename(File.dirname(t.name))
+  Rake::Task["config:#{abi}"].invoke
+  cc_compile(find_source(t.name), File.dirname(t.name), BUILDARGS.nil? ? ARGS : BUILDARGS) or raise "\e[31mCompilation failed: #{find_source(t.name)}\e[0m"
+end
+
+task OBJ_ARM => OBJDIR_ARM
+task OBJ_x86 => OBJDIR_x86
+task OBJ_MIPS => OBJDIR_MIPS
+
+def find_source(objfile)
+  base = File.basename(objfile, '.o')
+  src = SRC.find { |s| File.basename(s) == base }
+  src
+end
+
+file TARGETLIB_ARM => TARGETDIR_ARM do |t|
+    Rake::Task["config:arm"].invoke
+    cc_ar t.name, OBJ_ARM or raise "\e[31mCreating library failed: #{t.name}\e[0m"
+end
+multitask TARGETLIB_ARM => OBJ_ARM
+
+file TARGETLIB_x86 => TARGETDIR_x86 do |t|
+    Rake::Task["config:x86"].invoke
+    cc_ar t.name, OBJ_x86 or raise "\e[31mCreating library failed: #{t.name}\e[0m"
+end
+multitask TARGETLIB_x86 => OBJ_x86
+
+file TARGETLIB_MIPS => TARGETDIR_MIPS do |t|
+    Rake::Task["config:mips"].invoke
+    cc_ar t.name, OBJ_MIPS or raise "\e[31mCreating library failed: #{t.name}\e[0m"
+end
+multitask TARGETLIB_MIPS => OBJ_MIPS
+
+
+namespace 'build' do
+  task :arm => OBJ_ARM
+  task :x86 => OBJ_x86
+  task :mips => OBJ_MIPS
+end
+
+namespace 'arch' do
+  task :arm => TARGETLIB_ARM
+  task :x86 => TARGETLIB_x86
+  task :mips => TARGETLIB_MIPS
+end
+
+task :generate_inbuilt_values do
+  require File.join(ENV['RHO_ROOT'], 'lib/build/jake.rb')
+
+  cfg = Jake.config( File.open( File.join( ENV['RHO_APP_DIR'], 'build.yml' )))
+  andr_cfg = cfg['android']
+  security_cfg = andr_cfg['security'] if andr_cfg
+
+  allowed_signatures = []
+  allowed_installers = []
+
+  if security_cfg
+    allowed_signatures = security_cfg[ 'allowed_cert_signatures' ] || []
+    allowed_installers = security_cfg[ 'allowed_installers' ] || []
+  end
+
+  require 'erb'
+
+  myroot = File.join(ENV['SOURCEPATH'],'ext/platform/android/')
+
+  inbuilt_template = File.read( File.join(myroot, 'InbuiltValues.erb' ) )
+  result = ERB.new( inbuilt_template ).result( binding )
+
+  File.write(  File.join( myroot, 'generated/src/com/rho/devicesecurity/InbuiltValues.java' ), result )
+end
+
+task :default => ["arch:arm"]

data/lib/commonAPI/devicesecurity/ext/platform/android/ext_java.files

@@ -0,0 +1,10 @@
+ext/platform/android/generated/src/com/rho/devicesecurity/DeviceSecurityBase.java
+ext/platform/android/generated/src/com/rho/devicesecurity/DeviceSecurityFactorySingleton.java
+ext/platform/android/generated/src/com/rho/devicesecurity/DeviceSecuritySingletonBase.java
+ext/platform/android/generated/src/com/rho/devicesecurity/IDeviceSecurity.java
+ext/platform/android/generated/src/com/rho/devicesecurity/IDeviceSecurityFactory.java
+ext/platform/android/generated/src/com/rho/devicesecurity/IDeviceSecuritySingleton.java
+ext/platform/android/generated/src/com/rho/devicesecurity/InbuiltValues.java
+ext/platform/android/src/com/rho/devicesecurity/DeviceSecurity.java
+ext/platform/android/src/com/rho/devicesecurity/DeviceSecurityFactory.java
+ext/platform/android/src/com/rho/devicesecurity/DeviceSecuritySingleton.java

data/lib/commonAPI/devicesecurity/ext/platform/android/ext_native.files

@@ -0,0 +1,7 @@
+ext/platform/android/generated/jni/DeviceSecurity.cpp
+ext/platform/android/generated/jni/devicesecurity_ruby_wrap.cpp
+ext/platform/android/generated/jni/devicesecurity_js_wrap.cpp
+ext/platform/android/jni/DeviceSecurity_impl.cpp
+ext/shared/generated/devicesecurity_api_init.cpp
+ext/shared/generated/devicesecurity_js_api.cpp
+ext/shared/generated/devicesecurity_ruby_api.c

data/lib/commonAPI/devicesecurity/ext/platform/android/jni/DeviceSecurity_impl.cpp

@@ -0,0 +1,61 @@
+#include "rhodes.h"
+#include "DeviceSecurity.h"
+
+#include "logging/RhoLog.h"
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "DeviceSecurity_impl"
+
+#define DEVICESECURITY_FACTORY_CLASS "com.rho.devicesecurity.DeviceSecurityFactory"
+
+extern "C" void Init_DeviceSecurity_API(void);
+
+extern "C" void Init_DeviceSecurity(void)
+{
+    RAWTRACE(__FUNCTION__);
+
+    JNIEnv *env = jnienv();
+    if(env)
+    {
+        jclass cls = rho_find_class(env, DEVICESECURITY_FACTORY_CLASS);
+        if(!cls)
+        {
+            RAWLOG_ERROR1("Failed to find java class: %s", DEVICESECURITY_FACTORY_CLASS);
+            return;
+        }
+        jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V");
+        if(!midFactory)
+        {
+            RAWLOG_ERROR1("Failed to get constructor for java class %s", DEVICESECURITY_FACTORY_CLASS);
+            return;
+        }
+        jobject jFactory = env->NewObject(cls, midFactory);
+        if(env->IsSameObject(jFactory, NULL))
+        {
+            RAWLOG_ERROR1("Failed to create %s instance", DEVICESECURITY_FACTORY_CLASS);
+            return;
+        }
+        
+        RAWTRACE("Initializing Java factory");
+
+        rho::CDeviceSecurityBase::setJavaFactory(env, jFactory);
+
+        RAWTRACE("Deleting JNI reference");
+
+        env->DeleteLocalRef(jFactory);
+
+        RAWTRACE("Initializing API");
+
+        Init_DeviceSecurity_API();
+
+        RAWTRACE("Init_DeviceSecurity succeeded");
+    }
+    else
+    {
+        RAWLOG_ERROR("Failed to initialize DeviceSecurity API: jnienv() is failed");
+    }
+
+}
+
+extern "C" void Init_DeviceSecurity_extension() {
+    Init_DeviceSecurity();
+}

data/lib/commonAPI/devicesecurity/ext/platform/android/src/com/rho/devicesecurity/DeviceSecurity.java

@@ -0,0 +1,14 @@
+package com.rho.devicesecurity;
+
+import java.util.Map;
+
+import com.rhomobile.rhodes.api.IMethodResult;
+import com.rhomobile.rhodes.api.MethodResult;
+
+public class DeviceSecurity extends DeviceSecurityBase implements IDeviceSecurity {
+
+    public DeviceSecurity(String id) {
+        super(id);
+    }
+
+}

data/lib/commonAPI/devicesecurity/ext/platform/android/src/com/rho/devicesecurity/DeviceSecurityFactory.java

@@ -0,0 +1,18 @@
+package com.rho.devicesecurity;
+
+import com.rhomobile.rhodes.api.RhoApiFactory;
+
+public class DeviceSecurityFactory
+        extends RhoApiFactory< DeviceSecurity, DeviceSecuritySingleton>
+        implements IDeviceSecurityFactory {
+
+    @Override
+    protected DeviceSecuritySingleton createSingleton() {
+        return new DeviceSecuritySingleton(this);
+    }
+
+    @Override
+    protected DeviceSecurity createApiObject(String id) {
+        return new DeviceSecurity(id);
+    }
+}

data/lib/commonAPI/devicesecurity/ext/platform/android/src/com/rho/devicesecurity/DeviceSecuritySingleton.java

@@ -0,0 +1,412 @@
+package com.rho.devicesecurity;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ArrayList;
+
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+import java.security.MessageDigest;
+
+import android.util.Base64;
+import android.os.Build;
+import android.os.Environment;
+import android.bluetooth.BluetoothAdapter;
+
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.Signature;
+
+import android.content.Context;
+import com.rhomobile.rhodes.RhodesService;
+import com.rhomobile.rhodes.api.IMethodResult;
+import com.rhomobile.rhodes.Logger;
+import com.rhomobile.rhodes.util.Utils;
+
+class DeviceSecuritySingleton extends DeviceSecuritySingletonBase implements IDeviceSecuritySingleton {
+
+    protected static String TAG = DeviceSecuritySingleton.class.getSimpleName();
+
+    public DeviceSecuritySingleton(DeviceSecurityFactory factory) {
+        super();
+    }
+
+
+    @Override
+    public void isDeviceSecured(IMethodResult result) {
+        result.set((!checkDeviceRooted()) && (!checkEmulator()) && (!checkDebuggable()) && checkAllowedInstallers() && checkAllowedSignatures() );
+    }
+
+    @Override
+    public void isDeviceJailbroken(IMethodResult result) {
+        result.set(false);
+    }
+
+
+    public static boolean checkDeviceRooted() {
+            return checkRootMethod1() || checkRootMethod2() || checkRootMethod3();
+        }
+
+        private static boolean checkRootMethod1() {
+            String buildTags = android.os.Build.TAGS;
+            return buildTags != null && buildTags.contains("test-keys");
+        }
+
+        private static boolean checkRootMethod2() {
+            String[] paths = { "/system/app/Superuser.apk", "/sbin/su", "/system/bin/su", "/system/xbin/su", "/data/local/xbin/su", "/data/local/bin/su", "/system/sd/xbin/su",
+                    "/system/bin/failsafe/su", "/data/local/su", "/su/bin/su"};
+            for (String path : paths) {
+                if (new File(path).exists()) return true;
+            }
+            return false;
+        }
+
+        private static boolean checkRootMethod3() {
+            Process process = null;
+            try {
+                process = Runtime.getRuntime().exec(new String[] { "/system/xbin/which", "su" });
+                BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream()));
+                if (in.readLine() != null) return true;
+                return false;
+            } catch (Throwable t) {
+                return false;
+            } finally {
+                if (process != null) process.destroy();
+            }
+        }
+
+
+
+    @Override
+    public void isDeviceRooted(IMethodResult result) {
+        result.set(checkDeviceRooted());
+    }
+
+
+    private static String getSystemProperty(String name) throws Exception {
+
+        Class systemPropertyClazz = Class.forName("android.os.SystemProperties");
+        return (String) systemPropertyClazz.getMethod("get", new Class[] { String.class }).invoke(systemPropertyClazz, new Object[] { name });
+    }
+
+    private static boolean checkEmulator() {
+        return checkEmulatorMethod3();
+    }
+
+    private static boolean checkEmulatorMethod1() {
+
+        try {
+
+          boolean goldfish = getSystemProperty("ro.hardware").contains("goldfish");
+
+          boolean emu = getSystemProperty("ro.kernel.qemu").length() > 0;
+
+          boolean sdk = getSystemProperty("ro.product.model").equals("sdk");
+
+          if (emu || goldfish || sdk) {
+
+            return true;
+
+          }
+
+        } catch (Exception e) {
+
+        }
+
+        return false;
+
+      }
+
+    private static boolean checkEmulatorMethod2() {
+        return Build.FINGERPRINT.startsWith("generic")
+            || Build.FINGERPRINT.startsWith("unknown")
+            || Build.MODEL.contains("google_sdk")
+            || Build.MODEL.contains("Emulator")
+            || Build.MODEL.contains("Android SDK built for x86")
+            || Build.MANUFACTURER.contains("Genymotion")
+            || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
+            || "google_sdk".equals(Build.PRODUCT)
+            || "goldfish".equals(Build.HARDWARE);
+    }
+
+    private static boolean checkEmulatorMethod3() {
+        int rating = 0;
+
+        if (Build.PRODUCT.contains("sdk") ||
+                Build.PRODUCT.contains("Andy") ||
+                Build.PRODUCT.contains("ttVM_Hdragon") ||
+                Build.PRODUCT.contains("google_sdk") ||
+                Build.PRODUCT.contains("Droid4X") ||
+                Build.PRODUCT.contains("sdk_x86") ||
+                Build.PRODUCT.contains("sdk_google") ||
+                Build.PRODUCT.contains("vbox86p")) {
+            rating++;
+        }
+
+        if (Build.MANUFACTURER.equals("unknown") ||
+                Build.MANUFACTURER.equals("Genymotion") ||
+                Build.MANUFACTURER.contains("Andy") ||
+                Build.MANUFACTURER.contains("TiantianVM")){
+            rating++;
+        }
+
+        if (Build.BRAND.equals("generic") ||
+                Build.BRAND.equals("generic_x86") ||
+                Build.BRAND.equals("TTVM") ||
+                Build.BRAND.contains("Andy")) {
+            rating++;
+        }
+
+        if (Build.DEVICE.contains("generic") ||
+                Build.DEVICE.contains("generic_x86") ||
+                Build.DEVICE.contains("Andy") ||
+                Build.DEVICE.contains("ttVM_Hdragon") ||
+                Build.DEVICE.contains("Droid4X") ||
+                Build.DEVICE.contains("generic_x86_64") ||
+                Build.DEVICE.contains("vbox86p")) {
+            rating++;
+        }
+
+        if (Build.MODEL.equals("sdk") ||
+                Build.MODEL.equals("google_sdk") ||
+                Build.MODEL.contains("Droid4X") ||
+                Build.MODEL.contains("TiantianVM") ||
+                Build.MODEL.contains("Andy") ||
+                Build.MODEL.equals("Android SDK built for x86_64") ||
+                Build.MODEL.equals("Android SDK built for x86")) {
+            rating++;
+        }
+
+        if (Build.HARDWARE.equals("goldfish") ||
+                Build.HARDWARE.equals("vbox86") ||
+                Build.HARDWARE.contains("ttVM_x86")) {
+            rating++;
+        }
+
+        if (Build.FINGERPRINT.contains("generic/sdk/generic") ||
+                Build.FINGERPRINT.contains("generic_x86/sdk_x86/generic_x86") ||
+                Build.FINGERPRINT.contains("Andy") ||
+                Build.FINGERPRINT.contains("ttVM_Hdragon") ||
+                Build.FINGERPRINT.contains("generic_x86_64") ||
+                Build.FINGERPRINT.contains("generic/google_sdk/generic") ||
+                Build.FINGERPRINT.contains("vbox86p") ||
+                Build.FINGERPRINT.contains("generic/vbox86p/vbox86p")) {
+            rating++;
+        }
+/*
+        try {
+            String opengl = android.opengl.GLES20.glGetString(android.opengl.GLES20.GL_RENDERER);
+            if (opengl != null && opengl.contains("Bluestacks")){
+                rating += 10;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+*/
+        try {
+            File sharedFolder = new File(Environment
+                    .getExternalStorageDirectory().toString()
+                    + File.separatorChar
+                    + "windows"
+                    + File.separatorChar
+                    + "BstSharedFolder");
+
+            if (sharedFolder.exists()) {
+                rating += 10;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        try {
+            BluetoothAdapter m_BluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+            String m_bluetoothAdd = m_BluetoothAdapter.getAddress();
+            if (m_bluetoothAdd == null){
+                rating += 3;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }    
+
+        return rating > 3;
+    }
+
+    private static Context getContext() {
+        Context context = null;
+        try {
+            context = RhodesService.getContext();
+        }
+        catch (IllegalStateException e) {
+            context = null;
+            Logger.E(TAG, "Check Debuggable ERROR : Rhodes main Service (com.rhomobile.rhodes.RhodesService) is not run !!!");
+        }
+
+        return context;
+    }
+
+    @Override
+    public void isRunOnSimulator(IMethodResult result) {
+        result.set(checkEmulator());
+    }
+
+    private static boolean checkDebuggable(){
+
+        Context context = getContext();
+
+        boolean res = false;
+        if (context != null) {
+            res = (context.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
+        }
+        return res;
+
+    }
+
+
+    @Override
+    public void isDebugMode(IMethodResult result)  {
+        result.set(checkDebuggable());
+
+    }
+
+    //should always be 1 signature really...
+    private Signature[] getSignatures() {
+        try {
+            Context context = getContext();
+            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), PackageManager.GET_SIGNATURES);
+            return packageInfo.signatures;
+        } catch ( Exception e ) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    private String signatureToString( Signature signature ) {
+        try {
+            byte[] signatureBytes = signature.toByteArray();
+            MessageDigest md = MessageDigest.getInstance("SHA");
+            md.update(signature.toByteArray());
+            return Base64.encodeToString(md.digest(), Base64.DEFAULT).trim();
+        } catch ( Exception e ) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    @Override
+    public void getAppCertificateSignatures(IMethodResult result) {        
+
+        Collection<Object> signatures = new ArrayList<Object>();
+
+        try {
+            Signature[] sigs = getSignatures();
+            
+            for (Signature signature : sigs ) {
+                signatures.add( signatureToString( signature ) );
+            }
+
+            result.set(signatures);
+
+        } catch (Exception e) {
+            result.setError( Utils.getExceptionDetails(e) );
+        }
+    }
+
+    @Override
+    public void getAllowedCertificateSignatures(IMethodResult result) {
+        Collection<Object> signatures = new ArrayList<Object>();
+        for ( String s : InbuiltValues.ALLOWED_CERT_SIGNATURES ) {
+            signatures.add( s );
+        }
+
+        result.set( signatures );
+    }
+
+    private String getInsallerPackage() {
+        Context context = getContext();        
+        return context.getPackageManager().getInstallerPackageName(context.getPackageName());
+    }
+
+    @Override
+    public void getInstallerPackageName(IMethodResult result) {
+        Context context = getContext();
+
+        try {
+            final String installer = getInsallerPackage();
+            result.set( installer );
+        } catch ( Exception e ) {
+            result.setError( Utils.getExceptionDetails(e) );
+        }
+    }
+
+    @Override
+    public void getAllowedInstallerPackages(IMethodResult result) {
+        Collection<Object> packages = new ArrayList<Object>();
+        for ( String p : InbuiltValues.ALLOWED_INSTALLERS ) {
+            packages.add( p );
+        }
+
+        result.set( packages );
+    }
+
+    private boolean checkAllowedInstallers() {
+        //allow any installer if none specified
+        boolean res = (InbuiltValues.ALLOWED_INSTALLERS.length == 0);
+        final String myInstaller = getInsallerPackage();
+
+        for ( String installer: InbuiltValues.ALLOWED_INSTALLERS ) {
+            if ( installer.equals( myInstaller ) ) {
+                res = true;
+                break;
+            }
+        }
+
+        return res;
+    }
+
+    @Override
+    public void haveAnyInstallerIssues(IMethodResult result) {
+        result.set( !checkAllowedInstallers() );
+    }
+
+    private boolean checkAllowedSignatures() {                
+        Signature[] mySignatures = getSignatures();
+
+        //allow any signature if none specified
+        final int requiredMatches = (InbuiltValues.ALLOWED_CERT_SIGNATURES.length==0)?0:mySignatures.length;
+        int foundMatches = 0;
+
+        for ( Signature mySignature : mySignatures ) {
+            for ( String allowedSignature : InbuiltValues.ALLOWED_CERT_SIGNATURES ) {
+
+                final String sMySignature = signatureToString( mySignature );
+
+                //Logger.I( TAG, "Comparing signatures, system: " 
+                //    + sMySignature + " ;len:" + String.valueOf(sMySignature.length() ) +
+                //    "; inbuilt: " + allowedSignature + " ;len: " + String.valueOf(allowedSignature.length() ) );
+
+                if ( sMySignature.equals(allowedSignature) ) {
+                    //Logger.I( TAG, "Found matching signature: " + sMySignature );
+                    ++foundMatches;
+                    break;
+                }
+            }
+        }
+
+        //Logger.I( TAG, "checkAllowedSignatures, requiredMatches: " 
+        //                + String.valueOf(requiredMatches) + " ; foundMatches: " + String.valueOf( foundMatches ) );
+
+        return (foundMatches>=requiredMatches);
+    }
+
+    @Override
+    public void haveAnySignatureIssues(IMethodResult result) {
+        result.set( !checkAllowedSignatures() );
+    }
+
+}