@capgo/capacitor-ssl-pinning 8.0.0

package/android/src/main/java/io/ionic/sslpinning/CertificateLoader.java

@@ -0,0 +1,99 @@
+package io.ionic.sslpinning;
+
+import android.content.Context;
+import com.getcapacitor.Bridge;
+import com.getcapacitor.PluginConfig;
+import java.io.InputStream;
+import java.net.URL;
+import java.security.KeyStore;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManagerFactory;
+
+final class CertificateLoader {
+
+    private static final String CERTS_DIR = "public/certs";
+
+    private CertificateLoader() {}
+
+    static String[] getConfiguredCertPaths(final Bridge bridge) {
+        final PluginConfig config = bridge.getConfig().getPluginConfiguration("SSLPinning");
+        final String[] certs = config.getArray("certs", new String[0]);
+        return certs == null ? new String[0] : certs;
+    }
+
+    static String[] getExcludedDomains(final Bridge bridge) {
+        final PluginConfig config = bridge.getConfig().getPluginConfiguration("SSLPinning");
+        final String[] excludedDomains = config.getArray("excludedDomains", new String[0]);
+        return excludedDomains == null ? new String[0] : excludedDomains;
+    }
+
+    static SSLSocketFactory createSocketFactory(final Context context, final String[] configuredCertPaths) throws Exception {
+        final KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+        keyStore.load(null, null);
+
+        int index = 0;
+        for (String configuredCertPath : configuredCertPaths) {
+            final X509Certificate certificate = loadCertificate(context, configuredCertPath);
+            keyStore.setCertificateEntry("sslpinning-" + index, certificate);
+            index += 1;
+        }
+
+        final TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        trustManagerFactory.init(keyStore);
+
+        final SSLContext sslContext = SSLContext.getInstance("TLS");
+        sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
+        return sslContext.getSocketFactory();
+    }
+
+    static boolean isExcluded(final URL requestUrl, final String[] excludedDomains) {
+        for (String rawExcludedDomain : excludedDomains) {
+            if (rawExcludedDomain == null || rawExcludedDomain.trim().isEmpty()) {
+                continue;
+            }
+
+            try {
+                final URL excludedUrl = new URL(rawExcludedDomain);
+                final int excludedPort = excludedUrl.getPort() == -1 ? excludedUrl.getDefaultPort() : excludedUrl.getPort();
+                final int requestPort = requestUrl.getPort() == -1 ? requestUrl.getDefaultPort() : requestUrl.getPort();
+
+                if (!excludedUrl.getProtocol().equalsIgnoreCase(requestUrl.getProtocol())) {
+                    continue;
+                }
+                if (!excludedUrl.getHost().equalsIgnoreCase(requestUrl.getHost())) {
+                    continue;
+                }
+                if (excludedPort != requestPort) {
+                    continue;
+                }
+
+                final String excludedPath = excludedUrl.getPath() == null ? "" : excludedUrl.getPath();
+                if (excludedPath.isEmpty() || "/".equals(excludedPath)) {
+                    return true;
+                }
+
+                final String requestPath = requestUrl.getPath() == null ? "" : requestUrl.getPath();
+                if (requestPath.startsWith(excludedPath)) {
+                    return true;
+                }
+            } catch (Exception ignored) {
+                if (requestUrl.toString().startsWith(rawExcludedDomain)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private static X509Certificate loadCertificate(final Context context, final String configuredCertPath) throws Exception {
+        final String fileName = configuredCertPath.substring(configuredCertPath.lastIndexOf('/') + 1);
+        try (InputStream inputStream = context.getAssets().open(CERTS_DIR + "/" + fileName)) {
+            final CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
+            return (X509Certificate) certificateFactory.generateCertificate(inputStream);
+        }
+    }
+}

package/android/src/main/java/io/ionic/sslpinning/SSLPinning.java

@@ -0,0 +1,68 @@
+package io.ionic.sslpinning;
+
+import android.util.Log;
+import com.getcapacitor.Bridge;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.net.URL;
+import java.util.Arrays;
+import javax.net.ssl.SSLSocketFactory;
+
+@CapacitorPlugin(name = "SSLPinning")
+public class SSLPinning extends Plugin {
+
+    private static final String TAG = "SSLPinning";
+    private static final Object LOCK = new Object();
+    private static SSLSocketFactory cachedSocketFactory;
+    private static String[] cachedCertPaths = new String[0];
+
+    @PluginMethod
+    public void getConfiguration(final PluginCall call) {
+        final Bridge bridge = getBridge();
+        final JSObject result = new JSObject();
+        final String[] certs = CertificateLoader.getConfiguredCertPaths(bridge);
+        final String[] excludedDomains = CertificateLoader.getExcludedDomains(bridge);
+        result.put("configured", certs.length > 0);
+        result.put("certs", certs);
+        result.put("excludedDomains", excludedDomains);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void getPluginVersion(final PluginCall call) {
+        final JSObject result = new JSObject();
+        result.put("version", "android");
+        call.resolve(result);
+    }
+
+    public Boolean isDomainExcluded(final Bridge bridge, final URL url) {
+        return CertificateLoader.isExcluded(url, CertificateLoader.getExcludedDomains(bridge));
+    }
+
+    public SSLSocketFactory getSSLSocketFactory(final Bridge bridge) {
+        final String[] certPaths = CertificateLoader.getConfiguredCertPaths(bridge);
+        if (certPaths.length == 0) {
+            return null;
+        }
+
+        synchronized (LOCK) {
+            if (cachedSocketFactory != null && Arrays.equals(certPaths, cachedCertPaths)) {
+                return cachedSocketFactory;
+            }
+
+            try {
+                cachedSocketFactory = CertificateLoader.createSocketFactory(bridge.getContext(), certPaths);
+                cachedCertPaths = Arrays.copyOf(certPaths, certPaths.length);
+                return cachedSocketFactory;
+            } catch (Exception exception) {
+                Log.e(TAG, "Failed to create SSL socket factory", exception);
+                cachedSocketFactory = null;
+                cachedCertPaths = new String[0];
+                return null;
+            }
+        }
+    }
+}

package/dist/docs.json

@@ -0,0 +1,86 @@
+{
+  "api": {
+    "name": "SSLPinningPlugin",
+    "slug": "sslpinningplugin",
+    "docs": "Capacitor API for inspecting SSL pinning configuration.\n\nNative enforcement is applied automatically to `CapacitorHttp` requests when:\n1. `plugins.CapacitorHttp.enabled` is `true`\n2. `plugins.SSLPinning.certs` contains at least one certificate",
+    "tags": [],
+    "methods": [
+      {
+        "name": "getConfiguration",
+        "signature": "() => Promise<SSLPinningConfigurationState>",
+        "parameters": [],
+        "returns": "Promise<SSLPinningConfigurationState>",
+        "tags": [],
+        "docs": "Returns the active native configuration visible to the plugin.",
+        "complexTypes": [
+          "SSLPinningConfigurationState"
+        ],
+        "slug": "getconfiguration"
+      },
+      {
+        "name": "getPluginVersion",
+        "signature": "() => Promise<PluginVersionResult>",
+        "parameters": [],
+        "returns": "Promise<PluginVersionResult>",
+        "tags": [],
+        "docs": "Returns the native implementation version marker.",
+        "complexTypes": [
+          "PluginVersionResult"
+        ],
+        "slug": "getpluginversion"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "SSLPinningConfigurationState",
+      "slug": "sslpinningconfigurationstate",
+      "docs": "Static SSL pinning configuration currently visible to the plugin.",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "configured",
+          "tags": [],
+          "docs": "Whether at least one certificate is configured for native pinning.",
+          "complexTypes": [],
+          "type": "boolean"
+        },
+        {
+          "name": "certs",
+          "tags": [],
+          "docs": "Certificate paths from `capacitor.config.*` relative to the app root.",
+          "complexTypes": [],
+          "type": "string[]"
+        },
+        {
+          "name": "excludedDomains",
+          "tags": [],
+          "docs": "Fully-qualified URLs that should bypass SSL pinning.",
+          "complexTypes": [],
+          "type": "string[]"
+        }
+      ]
+    },
+    {
+      "name": "PluginVersionResult",
+      "slug": "pluginversionresult",
+      "docs": "Plugin version payload.",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "version",
+          "tags": [],
+          "docs": "Version identifier returned by the platform implementation.",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Plugin version payload.
+ */
+export interface PluginVersionResult {
+    /**
+     * Version identifier returned by the platform implementation.
+     */
+    version: string;
+}
+/**
+ * Static SSL pinning configuration currently visible to the plugin.
+ */
+export interface SSLPinningConfigurationState {
+    /**
+     * Whether at least one certificate is configured for native pinning.
+     */
+    configured: boolean;
+    /**
+     * Certificate paths from `capacitor.config.*` relative to the app root.
+     */
+    certs: string[];
+    /**
+     * Fully-qualified URLs that should bypass SSL pinning.
+     */
+    excludedDomains: string[];
+}
+/**
+ * Plugin configuration added under `plugins.SSLPinning` in `capacitor.config.*`.
+ */
+export interface SSLPinningPluginConfig {
+    /**
+     * Certificate files relative to the application root.
+     *
+     * During `bunx cap sync`, this plugin copies them into `webDir/certs` so native runtimes can load them from
+     * the bundled web assets.
+     */
+    certs?: string[];
+    /**
+     * Fully-qualified URLs that should bypass pinning.
+     *
+     * Match is done by origin, and by path-prefix when the configured URL contains a path.
+     */
+    excludedDomains?: string[];
+}
+/**
+ * Capacitor API for inspecting SSL pinning configuration.
+ *
+ * Native enforcement is applied automatically to `CapacitorHttp` requests when:
+ * 1. `plugins.CapacitorHttp.enabled` is `true`
+ * 2. `plugins.SSLPinning.certs` contains at least one certificate
+ */
+export interface SSLPinningPlugin {
+    /**
+     * Returns the active native configuration visible to the plugin.
+     */
+    getConfiguration(): Promise<SSLPinningConfigurationState>;
+    /**
+     * Returns the native implementation version marker.
+     */
+    getPluginVersion(): Promise<PluginVersionResult>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Plugin version payload.\n */\nexport interface PluginVersionResult {\n  /**\n   * Version identifier returned by the platform implementation.\n   */\n  version: string;\n}\n\n/**\n * Static SSL pinning configuration currently visible to the plugin.\n */\nexport interface SSLPinningConfigurationState {\n  /**\n   * Whether at least one certificate is configured for native pinning.\n   */\n  configured: boolean;\n\n  /**\n   * Certificate paths from `capacitor.config.*` relative to the app root.\n   */\n  certs: string[];\n\n  /**\n   * Fully-qualified URLs that should bypass SSL pinning.\n   */\n  excludedDomains: string[];\n}\n\n/**\n * Plugin configuration added under `plugins.SSLPinning` in `capacitor.config.*`.\n */\nexport interface SSLPinningPluginConfig {\n  /**\n   * Certificate files relative to the application root.\n   *\n   * During `bunx cap sync`, this plugin copies them into `webDir/certs` so native runtimes can load them from\n   * the bundled web assets.\n   */\n  certs?: string[];\n\n  /**\n   * Fully-qualified URLs that should bypass pinning.\n   *\n   * Match is done by origin, and by path-prefix when the configured URL contains a path.\n   */\n  excludedDomains?: string[];\n}\n\n/**\n * Capacitor API for inspecting SSL pinning configuration.\n *\n * Native enforcement is applied automatically to `CapacitorHttp` requests when:\n * 1. `plugins.CapacitorHttp.enabled` is `true`\n * 2. `plugins.SSLPinning.certs` contains at least one certificate\n */\nexport interface SSLPinningPlugin {\n  /**\n   * Returns the active native configuration visible to the plugin.\n   */\n  getConfiguration(): Promise<SSLPinningConfigurationState>;\n\n  /**\n   * Returns the native implementation version marker.\n   */\n  getPluginVersion(): Promise<PluginVersionResult>;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { SSLPinningPlugin } from './definitions';
+declare const SSLPinning: SSLPinningPlugin;
+export * from './definitions';
+export { SSLPinning };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const SSLPinning = registerPlugin('SSLPinning', {
+    web: () => import('./web').then((m) => new m.SSLPinningWeb()),
+});
+export * from './definitions';
+export { SSLPinning };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,UAAU,GAAG,cAAc,CAAmB,YAAY,EAAE;IAChE,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;CAC9D,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,CAAC","sourcesContent":["import { registerPlugin } from '@capacitor/core';\n\nimport type { SSLPinningPlugin } from './definitions';\n\nconst SSLPinning = registerPlugin<SSLPinningPlugin>('SSLPinning', {\n  web: () => import('./web').then((m) => new m.SSLPinningWeb()),\n});\n\nexport * from './definitions';\nexport { SSLPinning };\n"]}

package/dist/esm/web.d.ts

@@ -0,0 +1,6 @@
+import { WebPlugin } from '@capacitor/core';
+import type { PluginVersionResult, SSLPinningConfigurationState, SSLPinningPlugin } from './definitions';
+export declare class SSLPinningWeb extends WebPlugin implements SSLPinningPlugin {
+    getConfiguration(): Promise<SSLPinningConfigurationState>;
+    getPluginVersion(): Promise<PluginVersionResult>;
+}

package/dist/esm/web.js

@@ -0,0 +1,16 @@
+import { WebPlugin } from '@capacitor/core';
+export class SSLPinningWeb extends WebPlugin {
+    async getConfiguration() {
+        return {
+            configured: false,
+            certs: [],
+            excludedDomains: [],
+        };
+    }
+    async getPluginVersion() {
+        return {
+            version: 'web',
+        };
+    }
+}
+//# sourceMappingURL=web.js.map

package/dist/esm/web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.js","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,OAAO,aAAc,SAAQ,SAAS;IAC1C,KAAK,CAAC,gBAAgB;QACpB,OAAO;YACL,UAAU,EAAE,KAAK;YACjB,KAAK,EAAE,EAAE;YACT,eAAe,EAAE,EAAE;SACpB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,OAAO;YACL,OAAO,EAAE,KAAK;SACf,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { WebPlugin } from '@capacitor/core';\n\nimport type { PluginVersionResult, SSLPinningConfigurationState, SSLPinningPlugin } from './definitions';\n\nexport class SSLPinningWeb extends WebPlugin implements SSLPinningPlugin {\n  async getConfiguration(): Promise<SSLPinningConfigurationState> {\n    return {\n      configured: false,\n      certs: [],\n      excludedDomains: [],\n    };\n  }\n\n  async getPluginVersion(): Promise<PluginVersionResult> {\n    return {\n      version: 'web',\n    };\n  }\n}\n"]}

package/dist/plugin.cjs.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+const SSLPinning = core.registerPlugin('SSLPinning', {
+    web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.SSLPinningWeb()),
+});
+
+class SSLPinningWeb extends core.WebPlugin {
+    async getConfiguration() {
+        return {
+            configured: false,
+            certs: [],
+            excludedDomains: [],
+        };
+    }
+    async getPluginVersion() {
+        return {
+            version: 'web',
+        };
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    SSLPinningWeb: SSLPinningWeb
+});
+
+exports.SSLPinning = SSLPinning;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst SSLPinning = registerPlugin('SSLPinning', {\n    web: () => import('./web').then((m) => new m.SSLPinningWeb()),\n});\nexport * from './definitions';\nexport { SSLPinning };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class SSLPinningWeb extends WebPlugin {\n    async getConfiguration() {\n        return {\n            configured: false,\n            certs: [],\n            excludedDomains: [],\n        };\n    }\n    async getPluginVersion() {\n        return {\n            version: 'web',\n        };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AACK,MAAC,UAAU,GAAGA,mBAAc,CAAC,YAAY,EAAE;AAChD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;AACjE,CAAC;;ACFM,MAAM,aAAa,SAASC,cAAS,CAAC;AAC7C,IAAI,MAAM,gBAAgB,GAAG;AAC7B,QAAQ,OAAO;AACf,YAAY,UAAU,EAAE,KAAK;AAC7B,YAAY,KAAK,EAAE,EAAE;AACrB,YAAY,eAAe,EAAE,EAAE;AAC/B,SAAS;AACT,IAAI;AACJ,IAAI,MAAM,gBAAgB,GAAG;AAC7B,QAAQ,OAAO;AACf,YAAY,OAAO,EAAE,KAAK;AAC1B,SAAS;AACT,IAAI;AACJ;;;;;;;;;"}

package/dist/plugin.js

@@ -0,0 +1,33 @@
+var capacitorSSLPinning = (function (exports, core) {
+    'use strict';
+
+    const SSLPinning = core.registerPlugin('SSLPinning', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.SSLPinningWeb()),
+    });
+
+    class SSLPinningWeb extends core.WebPlugin {
+        async getConfiguration() {
+            return {
+                configured: false,
+                certs: [],
+                excludedDomains: [],
+            };
+        }
+        async getPluginVersion() {
+            return {
+                version: 'web',
+            };
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        SSLPinningWeb: SSLPinningWeb
+    });
+
+    exports.SSLPinning = SSLPinning;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst SSLPinning = registerPlugin('SSLPinning', {\n    web: () => import('./web').then((m) => new m.SSLPinningWeb()),\n});\nexport * from './definitions';\nexport { SSLPinning };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class SSLPinningWeb extends WebPlugin {\n    async getConfiguration() {\n        return {\n            configured: false,\n            certs: [],\n            excludedDomains: [],\n        };\n    }\n    async getPluginVersion() {\n        return {\n            version: 'web',\n        };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;AACK,UAAC,UAAU,GAAGA,mBAAc,CAAC,YAAY,EAAE;IAChD,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;IACjE,CAAC;;ICFM,MAAM,aAAa,SAASC,cAAS,CAAC;IAC7C,IAAI,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,OAAO;IACf,YAAY,UAAU,EAAE,KAAK;IAC7B,YAAY,KAAK,EAAE,EAAE;IACrB,YAAY,eAAe,EAAE,EAAE;IAC/B,SAAS;IACT,IAAI;IACJ,IAAI,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,OAAO;IACf,YAAY,OAAO,EAAE,KAAK;IAC1B,SAAS;IACT,IAAI;IACJ;;;;;;;;;;;;;;;"}

package/ios/Sources/SSLPinningPlugin/SSLPinningPlugin.swift

@@ -0,0 +1,37 @@
+import Capacitor
+import Foundation
+
+@objc(SSLPinningPlugin)
+public class SSLPinningPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "SSLPinningPlugin"
+    public let jsName = "SSLPinning"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getConfiguration", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
+    ]
+
+    @objc func getConfiguration(_ call: CAPPluginCall) {
+        let configuration = SSLPinningConfiguration.from(getConfig())
+        call.resolve(configuration.asJSObject)
+    }
+
+    @objc func getPluginVersion(_ call: CAPPluginCall) {
+        call.resolve([
+            "version": Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "ios"
+        ])
+    }
+
+    @objc override public func handleWKWebViewURLAuthenticationChallenge(
+        _ challenge: URLAuthenticationChallenge,
+        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
+    ) -> Bool {
+        let configuration = SSLPinningConfiguration.from(getConfig())
+        guard configuration.configured else {
+            return false
+        }
+
+        let result = SSLPinningTrustEvaluator.evaluate(challenge: challenge, configuration: configuration)
+        completionHandler(result.0, result.1)
+        return true
+    }
+}