@sumsub/cordova-idensic-mobile-sdk-plugin 1.18.1

package/demo/plugins/cordova-plugin-advanced-http/src/android/com/silkimen/cordovahttp/CordovaHttpPlugin.java

@@ -0,0 +1,240 @@
+package com.silkimen.cordovahttp;
+
+import java.security.KeyStore;
+import java.util.HashMap;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.concurrent.Future;
+
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.util.Log;
+import android.util.Base64;
+
+import javax.net.ssl.TrustManagerFactory;
+
+public class CordovaHttpPlugin extends CordovaPlugin implements Observer {
+  private static final String TAG = "Cordova-Plugin-HTTP";
+
+  private TLSConfiguration tlsConfiguration;
+
+  private HashMap<Integer, Future<?>> reqMap;
+  private final Object reqMapLock = new Object();
+
+  @Override
+  public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+    super.initialize(cordova, webView);
+
+    this.tlsConfiguration = new TLSConfiguration();
+
+    this.reqMap = new HashMap<Integer, Future<?>>();
+
+    try {
+      KeyStore store = KeyStore.getInstance("AndroidCAStore");
+      String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
+      TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
+
+      store.load(null);
+      tmf.init(store);
+
+      this.tlsConfiguration.setHostnameVerifier(null);
+      this.tlsConfiguration.setTrustManagers(tmf.getTrustManagers());
+    } catch (Exception e) {
+      Log.e(TAG, "An error occured while loading system's CA certificates", e);
+    }
+  }
+
+  @Override
+  public boolean execute(String action, final JSONArray args, final CallbackContext callbackContext)
+      throws JSONException {
+
+    if (action == null) {
+      return false;
+    }
+
+    if ("get".equals(action)) {
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    } else if ("head".equals(action)) {
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    } else if ("delete".equals(action)) {
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    } else if ("options".equals(action)) {
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    } else if ("post".equals(action)) {
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    } else if ("put".equals(action)) {
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    } else if ("patch".equals(action)) {
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    } else if ("uploadFiles".equals(action)) {
+      return this.uploadFiles(args, callbackContext);
+    } else if ("downloadFile".equals(action)) {
+      return this.downloadFile(args, callbackContext);
+    } else if ("setServerTrustMode".equals(action)) {
+      return this.setServerTrustMode(args, callbackContext);
+    } else if ("setClientAuthMode".equals(action)) {
+      return this.setClientAuthMode(args, callbackContext);
+    } else if ("abort".equals(action)) {
+      return this.abort(args, callbackContext);
+    } else {
+      return false;
+    }
+  }
+
+  private boolean executeHttpRequestWithoutData(final String method, final JSONArray args,
+      final CallbackContext callbackContext) throws JSONException {
+
+    String url = args.getString(0);
+    JSONObject headers = args.getJSONObject(1);
+    int timeout = args.getInt(2) * 1000;
+    boolean followRedirect = args.getBoolean(3);
+    String responseType = args.getString(4);
+
+    Integer reqId = args.getInt(5);
+    CordovaObservableCallbackContext observableCallbackContext = new CordovaObservableCallbackContext(callbackContext, reqId);
+
+    CordovaHttpOperation request = new CordovaHttpOperation(method.toUpperCase(), url, headers, timeout, followRedirect,
+        responseType, this.tlsConfiguration, observableCallbackContext);
+
+    startRequest(reqId, observableCallbackContext, request);
+
+    return true;
+  }
+
+  private boolean executeHttpRequestWithData(final String method, final JSONArray args,
+      final CallbackContext callbackContext) throws JSONException {
+
+    String url = args.getString(0);
+    Object data = args.get(1);
+    String serializer = args.getString(2);
+    JSONObject headers = args.getJSONObject(3);
+    int timeout = args.getInt(4) * 1000;
+    boolean followRedirect = args.getBoolean(5);
+    String responseType = args.getString(6);
+
+    Integer reqId = args.getInt(7);
+    CordovaObservableCallbackContext observableCallbackContext = new CordovaObservableCallbackContext(callbackContext, reqId);
+
+    CordovaHttpOperation request = new CordovaHttpOperation(method.toUpperCase(), url, serializer, data, headers,
+        timeout, followRedirect, responseType, this.tlsConfiguration, observableCallbackContext);
+
+    startRequest(reqId, observableCallbackContext, request);
+
+    return true;
+  }
+
+  private boolean uploadFiles(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    String url = args.getString(0);
+    JSONObject headers = args.getJSONObject(1);
+    JSONArray filePaths = args.getJSONArray(2);
+    JSONArray uploadNames = args.getJSONArray(3);
+    int timeout = args.getInt(4) * 1000;
+    boolean followRedirect = args.getBoolean(5);
+    String responseType = args.getString(6);
+
+    Integer reqId = args.getInt(7);
+    CordovaObservableCallbackContext observableCallbackContext = new CordovaObservableCallbackContext(callbackContext, reqId);
+
+    CordovaHttpUpload upload = new CordovaHttpUpload(url, headers, filePaths, uploadNames, timeout, followRedirect,
+        responseType, this.tlsConfiguration, this.cordova.getActivity().getApplicationContext(), observableCallbackContext);
+
+    startRequest(reqId, observableCallbackContext, upload);
+
+    return true;
+  }
+
+  private boolean downloadFile(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    String url = args.getString(0);
+    JSONObject headers = args.getJSONObject(1);
+    String filePath = args.getString(2);
+    int timeout = args.getInt(3) * 1000;
+    boolean followRedirect = args.getBoolean(4);
+
+    Integer reqId = args.getInt(5);
+    CordovaObservableCallbackContext observableCallbackContext = new CordovaObservableCallbackContext(callbackContext, reqId);
+
+    CordovaHttpDownload download = new CordovaHttpDownload(url, headers, filePath, timeout, followRedirect,
+        this.tlsConfiguration, observableCallbackContext);
+
+    startRequest(reqId, observableCallbackContext, download);
+
+    return true;
+  }
+
+  private void startRequest(Integer reqId, CordovaObservableCallbackContext observableCallbackContext, CordovaHttpBase request) {
+    synchronized (reqMapLock) {
+      observableCallbackContext.setObserver(this);
+      Future<?> task = cordova.getThreadPool().submit(request);
+      this.addReq(reqId, task, observableCallbackContext);
+    }
+  }
+
+  private boolean setServerTrustMode(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    CordovaServerTrust runnable = new CordovaServerTrust(args.getString(0), this.cordova.getActivity(),
+        this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(runnable);
+
+    return true;
+  }
+
+  private boolean setClientAuthMode(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    byte[] pkcs = args.isNull(2) ? null : Base64.decode(args.getString(2), Base64.DEFAULT);
+
+    CordovaClientAuth runnable = new CordovaClientAuth(args.getString(0), args.isNull(1) ? null : args.getString(1),
+        pkcs, args.getString(3), this.cordova.getActivity(), this.cordova.getActivity().getApplicationContext(),
+        this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(runnable);
+
+    return true;
+  }
+
+  private boolean abort(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+
+    int reqId = args.getInt(0);
+    boolean result = false;
+    // NOTE no synchronized (reqMapLock), since even if the req was already removed from reqMap,
+    //      the worst that would happen calling task.cancel(true) is a result of false
+    //      (i.e. same result as locking & not finding the req in reqMap)
+    Future<?> task = this.reqMap.get(reqId);
+    if (task != null && !task.isDone()) {
+      result = task.cancel(true);
+    }
+    callbackContext.success(new JSONObject().put("aborted", result));
+
+    return true;
+  }
+
+  private void addReq(final Integer reqId, final Future<?> task, final CordovaObservableCallbackContext observableCallbackContext) {
+    synchronized (reqMapLock) {
+      if(!task.isDone()){
+        this.reqMap.put(reqId, task);
+      }
+    }
+  }
+
+  private void removeReq(final Integer reqId) {
+    synchronized (reqMapLock) {
+      this.reqMap.remove(reqId);
+    }
+  }
+
+  @Override
+  public void update(Observable o, Object arg) {
+    synchronized (reqMapLock) {
+      CordovaObservableCallbackContext c = (CordovaObservableCallbackContext) arg;
+      if (c.getCallbackContext().isFinished()) {
+        removeReq(c.getRequestId());
+      }
+    }
+  }
+}

package/demo/plugins/cordova-plugin-advanced-http/src/android/com/silkimen/cordovahttp/CordovaHttpResponse.java

@@ -0,0 +1,100 @@
+package com.silkimen.cordovahttp;
+
+import java.nio.ByteBuffer;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.text.TextUtils;
+import android.util.Log;
+import android.util.Base64;
+
+class CordovaHttpResponse {
+  private int status;
+  private String url;
+  private Map<String, List<String>> headers;
+  private String body;
+  private byte[] rawData;
+  private JSONObject fileEntry;
+  private boolean hasFailed;
+  private boolean isFileOperation;
+  private boolean isRawResponse;
+  private String error;
+
+  public void setStatus(int status) {
+    this.status = status;
+  }
+
+  public void setUrl(String url) {
+    this.url = url;
+  }
+
+  public void setHeaders(Map<String, List<String>> headers) {
+    this.headers = headers;
+  }
+
+  public void setBody(String body) {
+    this.body = body;
+  }
+
+  public void setData(byte[] rawData) {
+    this.isRawResponse = true;
+    this.rawData = rawData;
+  }
+
+  public void setFileEntry(JSONObject entry) {
+    this.isFileOperation = true;
+    this.fileEntry = entry;
+  }
+
+  public void setErrorMessage(String message) {
+    this.hasFailed = true;
+    this.error = message;
+  }
+
+  public boolean hasFailed() {
+    return this.hasFailed;
+  }
+
+  public JSONObject toJSON() throws JSONException {
+    JSONObject json = new JSONObject();
+
+    json.put("status", this.status);
+    json.put("url", this.url);
+
+    if (this.headers != null && !this.headers.isEmpty()) {
+      json.put("headers", new JSONObject(getFilteredHeaders()));
+    }
+
+    if (this.hasFailed) {
+      json.put("error", this.error);
+    } else if (this.isFileOperation) {
+      json.put("file", this.fileEntry);
+    } else if (this.isRawResponse) {
+      json.put("data", Base64.encodeToString(this.rawData, Base64.DEFAULT));
+    } else {
+      json.put("data", this.body);
+    }
+
+    return json;
+  }
+
+  private Map<String, String> getFilteredHeaders() throws JSONException {
+    Map<String, String> filteredHeaders = new HashMap<String, String>();
+
+    for (Map.Entry<String, List<String>> entry : this.headers.entrySet()) {
+      String key = entry.getKey();
+      List<String> value = entry.getValue();
+
+      if ((key != null) && (!value.isEmpty())) {
+        filteredHeaders.put(key.toLowerCase(), TextUtils.join(", ", value));
+      }
+    }
+
+    return filteredHeaders;
+  }
+}

package/demo/plugins/cordova-plugin-advanced-http/src/android/com/silkimen/cordovahttp/CordovaHttpUpload.java

@@ -0,0 +1,91 @@
+package com.silkimen.cordovahttp;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.OpenableColumns;
+import android.webkit.MimeTypeMap;
+
+import com.silkimen.http.HttpRequest;
+import com.silkimen.http.TLSConfiguration;
+
+import java.io.File;
+import java.io.InputStream;
+import java.net.URI;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+class CordovaHttpUpload extends CordovaHttpBase {
+  private JSONArray filePaths;
+  private JSONArray uploadNames;
+  private Context applicationContext;
+
+  public CordovaHttpUpload(String url, JSONObject headers, JSONArray filePaths, JSONArray uploadNames, int timeout,
+      boolean followRedirects, String responseType, TLSConfiguration tlsConfiguration,
+      Context applicationContext, CordovaObservableCallbackContext callbackContext) {
+
+    super("POST", url, headers, timeout, followRedirects, responseType, tlsConfiguration, callbackContext);
+    this.filePaths = filePaths;
+    this.uploadNames = uploadNames;
+    this.applicationContext = applicationContext;
+  }
+
+  @Override
+  protected void sendBody(HttpRequest request) throws Exception {
+    for (int i = 0; i < this.filePaths.length(); ++i) {
+      String uploadName = this.uploadNames.getString(i);
+      String filePath = this.filePaths.getString(i);
+
+      Uri fileUri = Uri.parse(filePath);
+
+      // File Scheme
+      if (ContentResolver.SCHEME_FILE.equals(fileUri.getScheme())) {
+        File file = new File(new URI(filePath));
+        String fileName = file.getName().trim();
+        String mimeType = this.getMimeTypeFromFileName(fileName);
+
+        request.part(uploadName, fileName, mimeType, file);
+      }
+
+      // Content Scheme
+      if (ContentResolver.SCHEME_CONTENT.equals(fileUri.getScheme())) {
+        InputStream inputStream = this.applicationContext.getContentResolver().openInputStream(fileUri);
+        String fileName = this.getFileNameFromContentScheme(fileUri, this.applicationContext).trim();
+        String mimeType = this.getMimeTypeFromFileName(fileName);
+
+        request.part(uploadName, fileName, mimeType, inputStream);
+      }
+    }
+  }
+
+  private String getFileNameFromContentScheme(Uri contentSchemeUri, Context applicationContext) {
+    Cursor returnCursor = applicationContext.getContentResolver().query(contentSchemeUri, null, null, null, null);
+
+    if (returnCursor == null || !returnCursor.moveToFirst()) {
+      return null;
+    }
+
+    int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
+    String fileName = returnCursor.getString(nameIndex);
+    returnCursor.close();
+
+    return fileName;
+  }
+
+  private String getMimeTypeFromFileName(String fileName) {
+    if (fileName == null || !fileName.contains(".")) {
+      return null;
+    }
+
+    MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
+    int extIndex = fileName.lastIndexOf('.') + 1;
+    String extension = fileName.substring(extIndex).toLowerCase();
+
+    return mimeTypeMap.getMimeTypeFromExtension(extension);
+  }
+}

package/demo/plugins/cordova-plugin-advanced-http/src/android/com/silkimen/cordovahttp/CordovaObservableCallbackContext.java

@@ -0,0 +1,58 @@
+package com.silkimen.cordovahttp;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONObject;
+
+import java.util.Observer;
+
+public class CordovaObservableCallbackContext {
+
+    private CallbackContext callbackContext;
+    private Integer requestId;
+    private Observer observer;
+
+    public CordovaObservableCallbackContext(CallbackContext callbackContext, Integer requestId) {
+        this.callbackContext = callbackContext;
+        this.requestId = requestId;
+    }
+
+    public void success(JSONObject message) {
+        this.callbackContext.success(message);
+        this.notifyObserver();
+    }
+
+    public void error(JSONObject message) {
+        this.callbackContext.error(message);
+        this.notifyObserver();
+    }
+
+    public Integer getRequestId() {
+        return this.requestId;
+    }
+
+    public CallbackContext getCallbackContext() {
+        return callbackContext;
+    }
+
+    public Observer getObserver() {
+        return observer;
+    }
+
+    protected void notifyObserver() {
+        if(this.observer != null){
+            this.observer.update(null, this);
+        }
+    }
+
+    /**
+     * Set an observer that is notified, when {@link #success(JSONObject)}
+     * or {@link #error(JSONObject)} are called.
+     *
+     * NOTE the observer is notified with
+     * <pre>observer.update(null, cordovaObservableCallbackContext)</pre>
+     * @param observer
+     */
+    public void setObserver(Observer observer) {
+        this.observer = observer;
+    }
+}

package/demo/plugins/cordova-plugin-advanced-http/src/android/com/silkimen/cordovahttp/CordovaServerTrust.java

@@ -0,0 +1,124 @@
+package com.silkimen.cordovahttp;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+
+import android.app.Activity;
+import android.util.Log;
+import android.content.res.AssetManager;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+class CordovaServerTrust implements Runnable {
+  private static final String TAG = "Cordova-Plugin-HTTP";
+
+  private final TrustManager[] noOpTrustManagers;
+  private final HostnameVerifier noOpVerifier;
+
+  private String mode;
+  private Activity activity;
+  private TLSConfiguration tlsConfiguration;
+  private CallbackContext callbackContext;
+
+  public CordovaServerTrust(final String mode, final Activity activity, final TLSConfiguration configContainer,
+      final CallbackContext callbackContext) {
+
+    this.mode = mode;
+    this.activity = activity;
+    this.tlsConfiguration = configContainer;
+    this.callbackContext = callbackContext;
+
+    this.noOpTrustManagers = new TrustManager[] { new X509TrustManager() {
+      public X509Certificate[] getAcceptedIssuers() {
+        return new X509Certificate[0];
+      }
+
+      public void checkClientTrusted(X509Certificate[] chain, String authType) {
+        // intentionally left blank
+      }
+
+      public void checkServerTrusted(X509Certificate[] chain, String authType) {
+        // intentionally left blank
+      }
+    } };
+
+    this.noOpVerifier = new HostnameVerifier() {
+      public boolean verify(String hostname, SSLSession session) {
+        return true;
+      }
+    };
+  }
+
+  @Override
+  public void run() {
+    try {
+      if ("legacy".equals(this.mode)) {
+        this.tlsConfiguration.setHostnameVerifier(null);
+        this.tlsConfiguration.setTrustManagers(null);
+      } else if ("nocheck".equals(this.mode)) {
+        this.tlsConfiguration.setHostnameVerifier(this.noOpVerifier);
+        this.tlsConfiguration.setTrustManagers(this.noOpTrustManagers);
+      } else if ("pinned".equals(this.mode)) {
+        this.tlsConfiguration.setHostnameVerifier(null);
+        this.tlsConfiguration.setTrustManagers(this.getTrustManagers(this.getCertsFromBundle("www/certificates")));
+      } else {
+        this.tlsConfiguration.setHostnameVerifier(null);
+        this.tlsConfiguration.setTrustManagers(this.getTrustManagers(this.getCertsFromKeyStore("AndroidCAStore")));
+      }
+
+      callbackContext.success();
+    } catch (Exception e) {
+      Log.e(TAG, "An error occured while configuring SSL cert mode", e);
+      callbackContext.error("An error occured while configuring SSL cert mode");
+    }
+  }
+
+  private TrustManager[] getTrustManagers(KeyStore store) throws GeneralSecurityException {
+    String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
+    TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
+    tmf.init(store);
+
+    return tmf.getTrustManagers();
+  }
+
+  private KeyStore getCertsFromBundle(String path) throws GeneralSecurityException, IOException {
+    AssetManager assetManager = this.activity.getAssets();
+    String[] files = assetManager.list(path);
+
+    CertificateFactory cf = CertificateFactory.getInstance("X.509");
+    String keyStoreType = KeyStore.getDefaultType();
+    KeyStore keyStore = KeyStore.getInstance(keyStoreType);
+
+    keyStore.load(null, null);
+
+    for (int i = 0; i < files.length; i++) {
+      int index = files[i].lastIndexOf('.');
+
+      if (index == -1 || !files[i].substring(index).equals(".cer")) {
+        continue;
+      }
+
+      keyStore.setCertificateEntry("CA" + i, cf.generateCertificate(assetManager.open(path + "/" + files[i])));
+    }
+
+    return keyStore;
+  }
+
+  private KeyStore getCertsFromKeyStore(String storeType) throws GeneralSecurityException, IOException {
+    KeyStore store = KeyStore.getInstance(storeType);
+    store.load(null);
+
+    return store;
+  }
+}

package/demo/plugins/cordova-plugin-advanced-http/src/android/com/silkimen/http/HttpBodyDecoder.java

@@ -0,0 +1,55 @@
+package com.silkimen.http;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.MalformedInputException;
+
+public class HttpBodyDecoder {
+  private static final String[] ACCEPTED_CHARSETS = new String[] { "UTF-8", "ISO-8859-1" };
+
+  public static String decodeBody(byte[] body, String charsetName)
+      throws CharacterCodingException, MalformedInputException {
+
+    return decodeBody(ByteBuffer.wrap(body), charsetName);
+  }
+
+  public static String decodeBody(ByteBuffer body, String charsetName)
+      throws CharacterCodingException, MalformedInputException {
+
+    if (charsetName == null) {
+      return tryDecodeByteBuffer(body);
+    } else {
+      return decodeByteBuffer(body, charsetName);
+    }
+  }
+
+  private static String tryDecodeByteBuffer(ByteBuffer buffer)
+      throws CharacterCodingException, MalformedInputException {
+
+    for (int i = 0; i < ACCEPTED_CHARSETS.length - 1; i++) {
+      try {
+        return decodeByteBuffer(buffer, ACCEPTED_CHARSETS[i]);
+      } catch (MalformedInputException e) {
+        continue;
+      } catch (CharacterCodingException e) {
+        continue;
+      }
+    }
+
+    return decodeBody(buffer, ACCEPTED_CHARSETS[ACCEPTED_CHARSETS.length - 1]);
+  }
+
+  private static String decodeByteBuffer(ByteBuffer buffer, String charsetName)
+      throws CharacterCodingException, MalformedInputException {
+
+    return createCharsetDecoder(charsetName).decode(buffer).toString();
+  }
+
+  private static CharsetDecoder createCharsetDecoder(String charsetName) {
+    return Charset.forName(charsetName).newDecoder().onMalformedInput(CodingErrorAction.REPORT)
+        .onUnmappableCharacter(CodingErrorAction.REPORT);
+  }
+}