react-native-security-suite 0.9.21 → 1.0.0-rc.1

package/ios/SslPinning.swift

@@ -1,303 +1,282 @@
 import Pulse
+import Foundation
+import Security
+import CommonCrypto
 
 @available(iOS 13.0, *)
-class SSLPinning: NSObject, URLSessionDataDelegate {
-  var url: NSString!
-  var data: NSDictionary!
-  var callback: RCTResponseSenderBlock!
-  var validDomains: [String] = []
-  var intermediateKeyHashes: [Data] = []
-  var leafKeyHashes: [Data] = []
-  var networkLogger: NetworkLogger = .init()
-  var responseData: Data = Data()
-  let pulseNotification = PulseUINotification()
-
-  init(url: NSString, data: NSDictionary, callback: @escaping RCTResponseSenderBlock) {
-      self.url = url
-      self.data = data
-      self.callback = callback
-  }
-
-  func urlSession(
-    _ session: URLSession,
-    didReceive challenge: URLAuthenticationChallenge,
-    completionHandler: @escaping (
-      URLSession.AuthChallengeDisposition,
-      URLCredential?
-    ) -> Void
-  ) {
-    if let certs = data["certificates"] as? [String] {
-      for cert in certs {
-        let filteredCert = cert.replacingOccurrences(
-          of: "sha256/",
-          with: "",
-          options: .caseInsensitive,
-          range: nil
-        )
-        intermediateKeyHashes.append(Data(base64Encoded: filteredCert)!)
-      }
-    } else {
-      return completionHandler(.performDefaultHandling, nil)
-    }
-        
-    if let domains = data["validDomains"] as? [String] {
-      for domain in domains {
-        validDomains.append(domain)
-      }
-    } else {
-      return completionHandler(.performDefaultHandling, nil)
-    }
-      
-    guard let trust = challenge.protectionSpace.serverTrust else {
-      return completionHandler(.cancelAuthenticationChallenge, nil)
-    }
+final class PinningConfiguration {
+    let enabled: Bool
+    let error: String?
+    let validDomains: [String]
+    let pinHashes: Set<Data>
+
+    init(data: NSDictionary) {
+        let hasCertificates = data["certificates"] != nil
+        let hasValidDomains = data["validDomains"] != nil
+
+        if hasCertificates != hasValidDomains {
+            self.enabled = false
+            self.error = "SSL pinning requires both 'certificates' (SPKI SHA-256 hashes) and 'validDomains'"
+            self.validDomains = []
+            self.pinHashes = []
+            return
+        }
+
+        guard hasCertificates, let certs = data["certificates"] as? [String],
+              let domains = data["validDomains"] as? [String] else {
+            self.enabled = false
+            self.error = nil
+            self.validDomains = []
+            self.pinHashes = []
+            return
+        }
+
+        guard !certs.isEmpty else {
+            self.enabled = false
+            self.error = "At least one certificate/public key pin is required"
+            self.validDomains = []
+            self.pinHashes = []
+            return
+        }
+
+        guard !domains.isEmpty else {
+            self.enabled = false
+            self.error = "At least one valid domain is required"
+            self.validDomains = []
+            self.pinHashes = []
+            return
+        }
+
+        self.validDomains = domains
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() }
+            .filter { !$0.isEmpty }
+        self.pinHashes = Set(certs.compactMap { cert in
+            let filtered = cert
+                .replacingOccurrences(of: "sha256/", with: "", options: .caseInsensitive)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            return Data(base64Encoded: filtered)
+        }.filter { !$0.isEmpty })
 
-    let host = challenge.protectionSpace.host
-    let port = challenge.protectionSpace.port
-    guard port == 443, (3...4).contains(trust.certificates.count),
-          let leafCertificate = trust.certificates.first,
-          let commonName = leafCertificate.commonName,
-          validDomains
-      .contains(where: { commonName == $0 || commonName.hasSuffix("." + $0) }) else {
-      completionHandler(.cancelAuthenticationChallenge, nil)
-      return
+        if self.pinHashes.isEmpty {
+            self.enabled = false
+            self.error = "No valid SPKI SHA-256 pins found in certificates"
+        } else {
+            self.enabled = true
+            self.error = nil
+        }
     }
-    let intermediateCertificatesValid = trust.certificates.dropFirst().prefix(2).allSatisfy {
-      ($0.pin.map(intermediateKeyHashes.contains) ?? false)
+}
+
+@available(iOS 13.0, *)
+class SSLPinning: NSObject, URLSessionDataDelegate {
+    var url: NSString!
+    var data: NSDictionary!
+    var callback: RCTResponseSenderBlock!
+    let config: PinningConfiguration
+    var loggerEnabled = false
+    var networkLogger: NetworkLogger = .init()
+    var responseData: Data = Data()
+    let pulseNotification = PulseUINotification()
+
+    init(url: NSString, data: NSDictionary, callback: @escaping RCTResponseSenderBlock) {
+        self.url = url
+        self.data = data
+        self.callback = callback
+        self.config = PinningConfiguration(data: data)
+        super.init()
+
+        #if DEBUG
+        loggerEnabled = (data["loggerIsEnabled"] as? Bool) == true
+        #else
+        loggerEnabled = false
+        #endif
     }
-    let leafCertificateValid = leafKeyHashes.contains(
-      leafCertificate.pin ?? .init()
-    )
-        
-    let pattern = commonName
-      .replacingOccurrences(of: ".", with: "\\.")
-      .replacingOccurrences(of: "*", with: ".+", options: [.anchored])
-    guard intermediateCertificatesValid && (
-      leafKeyHashes.isEmpty || leafCertificateValid
-    ),
-          let commonNameRegex = try? NSRegularExpression(pattern: pattern) else {
-      completionHandler(.cancelAuthenticationChallenge, nil)
-      return
+
+    static func isHttpsURL(_ urlString: String) -> Bool {
+        guard let url = URL(string: urlString.trimmingCharacters(in: .whitespacesAndNewlines)),
+              let scheme = url.scheme?.lowercased(),
+              let host = url.host, !host.isEmpty else {
+            return false
+        }
+        return scheme == "https"
     }
-        
-    guard commonNameRegex.textMatches(in: host) == [host] else {
-      completionHandler(.cancelAuthenticationChallenge, nil)
-      return
+
+    static func hostnameMatchesValidDomains(_ host: String, validDomains: [String]) -> Bool {
+        let normalizedHost = host.lowercased()
+        return validDomains.contains { domain in
+            normalizedHost == domain || normalizedHost.hasSuffix("." + domain)
+        }
     }
-        
-    trust.policies = [.ssl(server: true, hostname: host)]
-    do {
-      if try !trust.evaluate() {
-        completionHandler(.cancelAuthenticationChallenge, nil)
-      }
-    } catch {
-      completionHandler(.cancelAuthenticationChallenge, nil)
-      return
+
+    func urlSession(
+        _ session: URLSession,
+        didReceive challenge: URLAuthenticationChallenge,
+        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
+    ) {
+        guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust else {
+            completionHandler(.performDefaultHandling, nil)
+            return
+        }
+
+        guard config.enabled else {
+            // No pinning configured: standard TLS validation only.
+            completionHandler(.performDefaultHandling, nil)
+            return
+        }
+
+        guard let trust = challenge.protectionSpace.serverTrust else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        let host = challenge.protectionSpace.host.lowercased()
+        let port = challenge.protectionSpace.port
+
+        guard port == 443 else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        guard Self.hostnameMatchesValidDomains(host, validDomains: config.validDomains) else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        // Enforce hostname policy before trust evaluation.
+        SecTrustSetPolicies(trust, SecPolicyCreateSSL(true, host as CFString))
+
+        var pinMatched = false
+        let certificateCount = SecTrustGetCertificateCount(trust)
+        for index in 0..<certificateCount {
+            guard let certificate = SecTrustGetCertificateAtIndex(trust, index) else { continue }
+
+            if let spkiHash = certificate.publicKeyPinHash, config.pinHashes.contains(spkiHash) {
+                pinMatched = true
+                break
+            }
+
+            let certData = SecCertificateCopyData(certificate) as Data
+            let certHash = certData._hash()
+            if config.pinHashes.contains(certHash) {
+                pinMatched = true
+                break
+            }
+        }
+
+        guard pinMatched else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        var error: CFError?
+        guard SecTrustEvaluateWithError(trust, &error) else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        completionHandler(.useCredential, URLCredential(trust: trust))
     }
-        
-    let credential = URLCredential(trust: trust)
-    completionHandler(.useCredential, credential)
-  }
-    
+
     func urlSession(_ session: URLSession, didCreateTask task: URLSessionTask) {
-      networkLogger.logTaskCreated(task)
+        guard loggerEnabled else { return }
+        networkLogger.logTaskCreated(task)
     }
-  
+
     func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
-      networkLogger.logDataTask(dataTask, didReceive: data)
-      responseData.append(data)
+        if loggerEnabled {
+            networkLogger.logDataTask(dataTask, didReceive: data)
+        }
+        responseData.append(data)
     }
-    
+
     func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
-      networkLogger.logTask(task, didCompleteWithError: error)
-      
-      if let error = error {
-          callback([nil, error.localizedDescription])
-      } else {
-        if let httpResponse = task.response as? HTTPURLResponse {
-          let url = httpResponse.url?.absoluteString ?? url! as String
-          let status = httpResponse.statusCode
-          let headers = httpResponse.allHeaderFields
-          
-          if(httpResponse.statusCode > 299) {
-            callback([NSNull(),  [
-              "url": url,
-              "status": status,
-              "headers": status,
-              "error": String(data: responseData, encoding: .utf8) ?? "",
+        if loggerEnabled {
+            networkLogger.logTask(task, didCompleteWithError: error)
+        }
+
+        if let error = error {
+            callback([NSNull(), error.localizedDescription])
+            return
+        }
+
+        guard let httpResponse = task.response as? HTTPURLResponse else {
+            callback([NSNull(), "Unknown error occurred"])
+            return
+        }
+
+        let responseUrl = httpResponse.url?.absoluteString ?? (url as String)
+        let status = httpResponse.statusCode
+        let headers = Self.sanitizedHeaders(httpResponse.allHeaderFields)
+
+        if status > 299 {
+            callback([NSNull(), [
+                "url": responseUrl,
+                "status": status,
+                "headers": headers,
+                "error": String(data: responseData, encoding: .utf8) ?? "",
             ]])
-          } else {
+        } else {
             callback([[
-              "url": url,
-              "status": status,
-              "headers": headers,
-              "response": String.init(decoding: responseData, as: UTF8.self),
-              "responseJson": try? JSONSerialization.jsonObject(with: responseData, options: []),
+                "url": responseUrl,
+                "status": status,
+                "headers": headers,
+                "response": String(decoding: responseData, as: UTF8.self),
+                "responseJson": try? JSONSerialization.jsonObject(with: responseData, options: []),
             ], NSNull()])
-          }
-        } else {
-            callback([NSNull(), "Unknown error occurred"])
         }
-      }
     }
 
     func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
+        guard loggerEnabled else { return }
         networkLogger.logTask(task, didFinishCollecting: metrics)
-        if (data["loggerIsEnabled"] as? Bool) == true {
-          if let httpResponse = task.response as? HTTPURLResponse {
-            if let url = URL(string: httpResponse.url?.absoluteString ?? url! as String) {
-              pulseNotification.showNotification(body: "\(httpResponse.statusCode) \(url.relativePath)")
+        if let httpResponse = task.response as? HTTPURLResponse,
+           let responseURL = URL(string: httpResponse.url?.absoluteString ?? (url as String)) {
+            pulseNotification.showNotification(body: "\(httpResponse.statusCode) \(responseURL.relativePath)")
+        }
+    }
+
+    private static let sensitiveHeaders: Set<String> = [
+        "authorization", "proxy-authorization", "cookie", "set-cookie",
+        "x-api-key", "x-auth-token", "x-access-token", "x-jws-signature", "x-request-signature", "x-csrf-token",
+    ]
+
+    static func sanitizedHeaders(_ headers: [AnyHashable: Any]) -> [String: String] {
+        var result: [String: String] = [:]
+        for (key, value) in headers {
+            guard let name = key as? String else { continue }
+            let stringValue = String(describing: value)
+            if sensitiveHeaders.contains(name.lowercased()) {
+                result[name] = maskValue(stringValue)
+            } else {
+                result[name] = stringValue
             }
-          }
         }
+        return result
+    }
+
+    static func maskValue(_ value: String) -> String {
+        guard value.count > 8 else { return "***" }
+        return String(value.prefix(4)) + "***" + String(value.suffix(2))
     }
 }
 
 @available(iOS 13.0, *)
 extension Data {
-    /**
-     Calculates hash digest of data.
-     
-     - Parameter digest: digest type. Currently only SHA is supported.
-     - Returns: A data object with length equal to digest length.
-    */
     public func _hash() -> Data {
         guard !isEmpty else { return Data() }
-        var result = [UInt8](repeating: 0, count: 256/8)
-        self.withUnsafeBytes { (buf: UnsafeRawBufferPointer) -> Void in
-            let ptr = buf.baseAddress!
-            let dataLen = CC_LONG(buf.count)
-            CC_SHA256(ptr, dataLen, &result)
+        var result = [UInt8](repeating: 0, count: 256 / 8)
+        self.withUnsafeBytes { (buf: UnsafeRawBufferPointer) in
+            guard let ptr = buf.baseAddress else { return }
+            _ = CC_SHA256(ptr, CC_LONG(buf.count), &result)
         }
-        
         return Data(result)
     }
 }
 
-extension Dictionary {
- func toString() -> String? {
-     return (self.compactMap({ (key, value) -> String in
-         return "\(key)=\(value)"
-     }) as Array).joined(separator: "&")
- }
-}
-
-@available(iOS 13.0, *)
-extension SecTrust {
-    // Returns certificates of the certificate chain used to evaluate trust.
-    fileprivate var certificates: [SecCertificate] {
-        (0..<SecTrustGetCertificateCount(self))
-            .map { SecTrustGetCertificateAtIndex(self, $0 as CFIndex)! }
-    }
-    
-    // Retrieves the policies used by a given trust management object.
-    fileprivate var policies: [SecPolicy]? {
-        get {
-            var result: CFArray?
-            SecTrustCopyPolicies(self, &result)
-            return result as? [SecPolicy]
-        }
-        set {
-            if let newValue = newValue {
-                SecTrustSetPolicies(self, newValue as CFArray)
-            } else {
-                SecTrustSetPolicies(self, [] as CFArray)
-            }
-        }
-    }
-    
-    fileprivate func evaluate() throws -> Bool {
-        var error: CFError?
-        let success = SecTrustEvaluateWithError(self, &error)
-        if let error = error {
-            throw error
-        }
-        return success
-    }
-}
-
 @available(iOS 13.0, *)
 extension SecCertificate {
-    fileprivate var key: SecKey? {
-        SecCertificateCopyKey(self)
-    }
-    
-    fileprivate var commonName: String? {
-        var result: CFString?
-        SecCertificateCopyCommonName(self, &result)
-        return result as String?
-    }
-    
-    fileprivate var pin: Data? {
-        try? key?.bytes().hash(digest: .sha256)
-    }
-}
-
-extension SecPolicy {
-    static func ssl(server: Bool, hostname: String) -> SecPolicy {
-        SecPolicyCreateSSL(server, hostname as CFString)
-    }
-    
-    static func basicX509() -> SecPolicy {
-        SecPolicyCreateBasicX509()
-    }
-}
-
-extension NSRegularExpression {
-    public func matches(
-        in string: String,
-        options: NSRegularExpression.MatchingOptions = []
-    ) -> [NSTextCheckingResult] {
-        matches(in: string, options: options, range: NSRange(string.startIndex..., in: string))
-    }
-    
-    public func textMatches(
-        in string: String,
-        options: NSRegularExpression.MatchingOptions = []
-    ) -> [String] {
-        textMatches(in: string, options: options, range: string.startIndex...)
-    }
-
-    public func matches<R: RangeExpression>(
-        in string: String,
-        options: NSRegularExpression.MatchingOptions = [],
-        range: R
-    ) -> [NSTextCheckingResult] where R.Bound == String.Index {
-        matches(in: string, options: options, range: NSRange(range, in: string))
-    }
-    
-    public func textMatches<R: RangeExpression>(
-        in string: String,
-        options: NSRegularExpression.MatchingOptions = [],
-        range: R
-    ) -> [String] where R.Bound == String.Index {
-        matches(in: string, options: options, range: NSRange(range, in: string))
-            .map {
-                guard let range = Range($0.range, in: string) else {
-                    return ""
-                }
-                return String(string[range])
-            }
-    }
-}
-
-struct JoseHeader: Codable {
-    internal init(alg: String = "HS256", kid: String, b64: Bool = false, crit: [String] = ["b64"], requestId: String) {
-        self.alg = alg
-        self.kid = kid
-        self.b64 = b64
-        self.crit = crit
-        self.requestId = requestId
-    }
-    
-    private enum CodingKeys: String, CodingKey {
-        case alg, kid, b64, crit
-        case requestId = "request_id"
+    fileprivate var publicKeyPinHash: Data? {
+        guard let key = SecCertificateCopyKey(self) else { return nil }
+        return try? key.bytes().hash(digest: .sha256)
     }
-    
-    let alg: String
-    let kid: String
-    let b64: Bool
-    let crit: [String]
-    let requestId: String
 }

package/lib/commonjs/clipboard/index.js

@@ -0,0 +1,3 @@
+/** Phase 2+ namespace placeholder. */
+"use strict";
+//# sourceMappingURL=index.js.map

package/lib/commonjs/clipboard/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["clipboard/index.ts"],"mappings":"AAAA;AAAA","ignoreList":[]}

package/lib/commonjs/crypto/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Crypto = void 0;
+var _bridge = require("../native/bridge.js");
+function toNativeCryptoOptions(options) {
+  return {
+    keyAgreementAlgorithm: options?.keyAgreementAlgorithm ?? 'X25519',
+    keyFactoryAlgorithm: options?.keyType ?? options?.keyFactoryAlgorithm ?? 'OKP',
+    encryptionKeyAlgorithm: options?.encryptionKeyAlgorithm ?? 'AES-256',
+    hmacKeyAlgorithm: options?.hmacAlgorithm ?? options?.hmacKeyAlgorithm ?? 'HMAC-SHA-512',
+    cipherTransformation: options?.cipher ?? options?.cipherTransformation ?? 'AES-GCM',
+    gcmTagLength: options?.tagLength ?? options?.gcmTagLength ?? 128,
+    gcmIvLength: options?.ivLength ?? options?.gcmIvLength ?? 12
+  };
+}
+const Crypto = exports.Crypto = {
+  getPublicKey() {
+    return (0, _bridge.getNativeModule)().getPublicKey();
+  },
+  /**
+   * Derives a shared encryption key natively without returning it to JavaScript.
+   * Call `encryptBySharedKey` / `decryptBySharedKey` afterward (legacy bridge methods).
+   */
+  establishSharedKey(serverPublicKey, options) {
+    const native = (0, _bridge.getNativeModule)();
+    const nativeOptions = toNativeCryptoOptions(options);
+    if (options?.returnSharedKey) {
+      return native.getSharedKey(serverPublicKey, nativeOptions);
+    }
+    if (typeof native.establishSharedKey === 'function') {
+      return native.establishSharedKey(serverPublicKey, nativeOptions);
+    }
+    return native.getSharedKey(serverPublicKey, nativeOptions).then(() => undefined);
+  }
+};
+//# sourceMappingURL=index.js.map

package/lib/commonjs/crypto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_bridge","require","toNativeCryptoOptions","options","keyAgreementAlgorithm","keyFactoryAlgorithm","keyType","encryptionKeyAlgorithm","hmacKeyAlgorithm","hmacAlgorithm","cipherTransformation","cipher","gcmTagLength","tagLength","gcmIvLength","ivLength","Crypto","exports","getPublicKey","getNativeModule","establishSharedKey","serverPublicKey","native","nativeOptions","returnSharedKey","getSharedKey","then","undefined"],"sourceRoot":"../../../src","sources":["crypto/index.ts"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAGA,SAASC,qBAAqBA,CAACC,OAA8B,EAAE;EAC7D,OAAO;IACLC,qBAAqB,EAAED,OAAO,EAAEC,qBAAqB,IAAI,QAAQ;IACjEC,mBAAmB,EAAEF,OAAO,EAAEG,OAAO,IAAIH,OAAO,EAAEE,mBAAmB,IAAI,KAAK;IAC9EE,sBAAsB,EAAEJ,OAAO,EAAEI,sBAAsB,IAAI,SAAS;IACpEC,gBAAgB,EAAEL,OAAO,EAAEM,aAAa,IAAIN,OAAO,EAAEK,gBAAgB,IAAI,cAAc;IACvFE,oBAAoB,EAAEP,OAAO,EAAEQ,MAAM,IAAIR,OAAO,EAAEO,oBAAoB,IAAI,SAAS;IACnFE,YAAY,EAAET,OAAO,EAAEU,SAAS,IAAIV,OAAO,EAAES,YAAY,IAAI,GAAG;IAChEE,WAAW,EAAEX,OAAO,EAAEY,QAAQ,IAAIZ,OAAO,EAAEW,WAAW,IAAI;EAC5D,CAAC;AACH;AAOO,MAAME,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAG;EACpBE,YAAYA,CAAA,EAAoB;IAC9B,OAAO,IAAAC,uBAAe,EAAC,CAAC,CAACD,YAAY,CAAC,CAAC;EACzC,CAAC;EAED;AACF;AACA;AACA;EACEE,kBAAkBA,CAChBC,eAAuB,EACvBlB,OAAmC,EACX;IACxB,MAAMmB,MAAM,GAAG,IAAAH,uBAAe,EAAC,CAAC;IAChC,MAAMI,aAAa,GAAGrB,qBAAqB,CAACC,OAAO,CAAC;IAEpD,IAAIA,OAAO,EAAEqB,eAAe,EAAE;MAC5B,OAAOF,MAAM,CAACG,YAAY,CAACJ,eAAe,EAAEE,aAAa,CAAC;IAC5D;IAEA,IAAI,OAAOD,MAAM,CAACF,kBAAkB,KAAK,UAAU,EAAE;MACnD,OAAOE,MAAM,CAACF,kBAAkB,CAACC,eAAe,EAAEE,aAAa,CAAC;IAClE;IAEA,OAAOD,MAAM,CAACG,YAAY,CAACJ,eAAe,EAAEE,aAAa,CAAC,CAACG,IAAI,CAAC,MAAMC,SAAS,CAAC;EAClF;AACF,CAAC","ignoreList":[]}

package/lib/commonjs/device/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeviceSecurity = void 0;
+var _reactNative = require("react-native");
+var _bridge = require("../native/bridge.js");
+function parseEnvironment(raw) {
+  return {
+    isEmulator: Boolean(raw.isEmulator),
+    isSimulator: Boolean(raw.isSimulator),
+    indicators: Array.isArray(raw.indicators) ? raw.indicators.filter(item => typeof item === 'string') : []
+  };
+}
+const DeviceSecurity = exports.DeviceSecurity = {
+  /** @deprecated Use `isCompromised()` or `SecuritySuite.getSecurityReport()`. */
+  hasSecurityRisk() {
+    return (0, _bridge.getNativeModule)().deviceHasSecurityRisk();
+  },
+  isCompromised() {
+    return (0, _bridge.getNativeModule)().deviceHasSecurityRisk();
+  },
+  isRooted() {
+    if (_reactNative.Platform.OS !== 'android') {
+      return Promise.resolve(false);
+    }
+    return (0, _bridge.getNativeModule)().deviceHasSecurityRisk();
+  },
+  isJailbroken() {
+    if (_reactNative.Platform.OS !== 'ios') {
+      return Promise.resolve(false);
+    }
+    return (0, _bridge.getNativeModule)().deviceHasSecurityRisk();
+  },
+  getEnvironment() {
+    return (0, _bridge.getNativeModule)().deviceGetEnvironment().then(result => parseEnvironment(result));
+  }
+};
+//# sourceMappingURL=index.js.map

package/lib/commonjs/device/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_bridge","parseEnvironment","raw","isEmulator","Boolean","isSimulator","indicators","Array","isArray","filter","item","DeviceSecurity","exports","hasSecurityRisk","getNativeModule","deviceHasSecurityRisk","isCompromised","isRooted","Platform","OS","Promise","resolve","isJailbroken","getEnvironment","deviceGetEnvironment","then","result"],"sourceRoot":"../../../src","sources":["device/index.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAGA,SAASE,gBAAgBA,CAACC,GAA4B,EAAqB;EACzE,OAAO;IACLC,UAAU,EAAEC,OAAO,CAACF,GAAG,CAACC,UAAU,CAAC;IACnCE,WAAW,EAAED,OAAO,CAACF,GAAG,CAACG,WAAW,CAAC;IACrCC,UAAU,EAAEC,KAAK,CAACC,OAAO,CAACN,GAAG,CAACI,UAAU,CAAC,GACrCJ,GAAG,CAACI,UAAU,CAACG,MAAM,CAAEC,IAAI,IAAqB,OAAOA,IAAI,KAAK,QAAQ,CAAC,GACzE;EACN,CAAC;AACH;AAEO,MAAMC,cAAc,GAAAC,OAAA,CAAAD,cAAA,GAAG;EAC5B;EACAE,eAAeA,CAAA,EAAqB;IAClC,OAAO,IAAAC,uBAAe,EAAC,CAAC,CAACC,qBAAqB,CAAC,CAAC;EAClD,CAAC;EAEDC,aAAaA,CAAA,EAAqB;IAChC,OAAO,IAAAF,uBAAe,EAAC,CAAC,CAACC,qBAAqB,CAAC,CAAC;EAClD,CAAC;EAEDE,QAAQA,CAAA,EAAqB;IAC3B,IAAIC,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;MAC7B,OAAOC,OAAO,CAACC,OAAO,CAAC,KAAK,CAAC;IAC/B;IACA,OAAO,IAAAP,uBAAe,EAAC,CAAC,CAACC,qBAAqB,CAAC,CAAC;EAClD,CAAC;EAEDO,YAAYA,CAAA,EAAqB;IAC/B,IAAIJ,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzB,OAAOC,OAAO,CAACC,OAAO,CAAC,KAAK,CAAC;IAC/B;IACA,OAAO,IAAAP,uBAAe,EAAC,CAAC,CAACC,qBAAqB,CAAC,CAAC;EAClD,CAAC;EAEDQ,cAAcA,CAAA,EAA+B;IAC3C,OAAO,IAAAT,uBAAe,EAAC,CAAC,CACrBU,oBAAoB,CAAC,CAAC,CACtBC,IAAI,CAAEC,MAAM,IAAKzB,gBAAgB,CAACyB,MAAM,CAAC,CAAC;EAC/C;AACF,CAAC","ignoreList":[]}