@vppos/react-native-nfc 1.0.0

package/vendor/ios-passport-reader/Sources/NFCPassportReader/PassportReader.swift

@@ -0,0 +1,387 @@
+//
+//  PassportReader.swift
+//  NFCTest
+//
+//  Created by Andy Qua on 11/06/2019.
+//  Copyright © 2019 Andy Qua. All rights reserved.
+//
+
+import Foundation
+import OSLog
+
+#if !os(macOS)
+import UIKit
+import CoreNFC
+
+@available(iOS 15, *)
+public class PassportReader : NSObject {
+    private typealias NFCCheckedContinuation = CheckedContinuation<NFCPassportModel, Error>
+    private var nfcContinuation: NFCCheckedContinuation?
+
+    private var passport : NFCPassportModel = NFCPassportModel()
+    
+    private var readerSession: NFCTagReaderSession?
+    private var currentlyReadingDataGroup : DataGroupId?
+    
+    private var dataGroupsToRead : [DataGroupId] = []
+    private var readAllDatagroups = false
+    private var skipSecureElements = true
+    private var skipCA = false
+    private var skipPACE = false
+    private var useExtendedMode = false
+
+    private var bacHandler : BACHandler?
+    private var caHandler : ChipAuthenticationHandler?
+    private var paceHandler : PACEHandler?
+    private var canKey : String = ""
+    private var dataAmountToReadOverride : Int? = nil
+    
+    private var scanCompletedHandler: ((NFCPassportModel?, NFCPassportReaderError?)->())!
+    private var nfcViewDisplayMessageHandler: ((NFCViewDisplayMessage) -> String?)?
+    private var masterListURL : URL?
+    private var shouldNotReportNextReaderSessionInvalidationErrorUserCanceled : Bool = false
+
+    // By default, Passive Authentication uses the new RFS5652 method to verify the SOD, but can be switched to use
+    // the previous OpenSSL CMS verification if necessary
+    public var passiveAuthenticationUsesOpenSSL : Bool = false
+
+    public init( masterListURL: URL? = nil ) {
+        super.init()
+        
+        self.masterListURL = masterListURL
+    }
+    
+    public func setMasterListURL( _ masterListURL : URL ) {
+        self.masterListURL = masterListURL
+    }
+    
+    // This function allows you to override the amount of data the TagReader tries to read from the NFC
+    // chip. NOTE - this really shouldn't be used for production but is useful for testing as different
+    // passports support different data amounts.
+    // It appears that the most reliable is 0xA0 (160 chars) but some will support arbitary reads (0xFF or 256)
+    public func overrideNFCDataAmountToRead( amount: Int ) {
+        dataAmountToReadOverride = amount
+    }
+    
+    public func readPassport( canKey : String, tags : [DataGroupId] = [], skipSecureElements : Bool = true, skipCA : Bool = false, skipPACE : Bool = false, useExtendedMode : Bool = false, customDisplayMessage : ((NFCViewDisplayMessage) -> String?)? = nil) async throws -> NFCPassportModel {
+        
+        self.passport = NFCPassportModel()
+        self.canKey = canKey
+        self.skipCA = skipCA
+        self.skipPACE = skipPACE
+        self.useExtendedMode = useExtendedMode
+        
+        self.dataGroupsToRead.removeAll()
+        self.dataGroupsToRead.append( contentsOf:tags)
+        self.nfcViewDisplayMessageHandler = customDisplayMessage
+        self.skipSecureElements = skipSecureElements
+        self.currentlyReadingDataGroup = nil
+        self.bacHandler = nil
+        self.caHandler = nil
+        self.paceHandler = nil
+        
+        // If no tags specified, read all
+        if self.dataGroupsToRead.count == 0 {
+            // Start off with .COM, will always read (and .SOD but we'll add that after), and then add the others from the COM
+            self.dataGroupsToRead.append(contentsOf:[.COM, .SOD] )
+            self.readAllDatagroups = true
+        } else {
+            // We are reading specific datagroups
+            self.readAllDatagroups = false
+        }
+        
+        guard NFCNDEFReaderSession.readingAvailable else {
+            throw NFCPassportReaderError.NFCNotSupported
+        }
+        
+        if NFCTagReaderSession.readingAvailable {
+            readerSession = NFCTagReaderSession(pollingOption: [.iso14443], delegate: self, queue: nil)
+            
+            self.updateReaderSessionMessage( alertMessage: NFCViewDisplayMessage.requestPresentPassport )
+            readerSession?.begin()
+        }
+        
+        return try await withCheckedThrowingContinuation({ (continuation: NFCCheckedContinuation) in
+            self.nfcContinuation = continuation
+        })
+    }
+}
+
+@available(iOS 15, *)
+extension PassportReader : NFCTagReaderSessionDelegate {
+    // MARK: - NFCTagReaderSessionDelegate
+    public func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {
+        // If necessary, you may perform additional operations on session start.
+        // At this point RF polling is enabled.
+        Logger.passportReader.debug( "tagReaderSessionDidBecomeActive" )
+    }
+    
+    public func tagReaderSession(_ session: NFCTagReaderSession, didInvalidateWithError error: Error) {
+        // If necessary, you may handle the error. Note session is no longer valid.
+        // You must create a new session to restart RF polling.
+        Logger.passportReader.debug( "tagReaderSession:didInvalidateWithError - \(error.localizedDescription)" )
+        self.readerSession?.invalidate()
+        self.readerSession = nil
+
+        if let readerError = error as? NFCReaderError, readerError.code == NFCReaderError.readerSessionInvalidationErrorUserCanceled
+            && self.shouldNotReportNextReaderSessionInvalidationErrorUserCanceled {
+            
+            self.shouldNotReportNextReaderSessionInvalidationErrorUserCanceled = false
+        } else {
+            var userError = NFCPassportReaderError.UnexpectedError
+            if let readerError = error as? NFCReaderError {
+                Logger.passportReader.error( "tagReaderSession:didInvalidateWithError - Got NFCReaderError - \(readerError.localizedDescription)" )
+                switch (readerError.code) {
+                case NFCReaderError.readerSessionInvalidationErrorUserCanceled:
+                    Logger.passportReader.error( "     - User cancelled session" )
+                    userError = NFCPassportReaderError.UserCanceled
+                default:
+                    Logger.passportReader.error( "     - some other error - \(readerError.localizedDescription)" )
+                    userError = NFCPassportReaderError.UnexpectedError
+                }
+            } else {
+                Logger.passportReader.error( "tagReaderSession:didInvalidateWithError - Received error - \(error.localizedDescription)" )
+            }
+            nfcContinuation?.resume(throwing: userError)
+            nfcContinuation = nil
+        }
+    }
+    
+    public func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) {
+        Logger.passportReader.debug( "tagReaderSession:didDetect - found \(tags)" )
+        if tags.count > 1 {
+            Logger.passportReader.debug( "tagReaderSession:more than 1 tag detected! - \(tags)" )
+
+            let errorMessage = NFCViewDisplayMessage.error(.MoreThanOneTagFound)
+            self.invalidateSession(errorMessage: errorMessage, error: NFCPassportReaderError.MoreThanOneTagFound)
+            return
+        }
+
+        let tag = tags.first!
+        var passportTag: NFCISO7816Tag
+        switch tags.first! {
+        case let .iso7816(tag):
+            passportTag = tag
+        default:
+            Logger.passportReader.debug( "tagReaderSession:invalid tag detected!!!" )
+
+            let errorMessage = NFCViewDisplayMessage.error(NFCPassportReaderError.TagNotValid)
+            self.invalidateSession(errorMessage:errorMessage, error: NFCPassportReaderError.TagNotValid)
+            return
+        }
+        
+        Task { [passportTag] in
+            do {
+                try await session.connect(to: tag)
+                
+                Logger.passportReader.debug( "tagReaderSession:connected to tag - starting authentication" )
+                self.updateReaderSessionMessage( alertMessage: NFCViewDisplayMessage.authenticatingWithPassport(0) )
+                
+                let tagReader = TagReader(tag:passportTag)
+                
+                if let newAmount = self.dataAmountToReadOverride {
+                    tagReader.overrideDataAmountToRead(newAmount: newAmount)
+                }
+                
+                tagReader.progress = { [unowned self] (progress) in
+                    if let dgId = self.currentlyReadingDataGroup {
+                        self.updateReaderSessionMessage( alertMessage: NFCViewDisplayMessage.readingDataGroupProgress(dgId, progress) )
+                    } else {
+                        self.updateReaderSessionMessage( alertMessage: NFCViewDisplayMessage.authenticatingWithPassport(progress) )
+                    }
+                }
+                
+                let passportModel = try await self.startReading( tagReader : tagReader)
+                nfcContinuation?.resume(returning: passportModel)
+                nfcContinuation = nil
+
+                
+            } catch let error as NFCPassportReaderError {
+                let errorMessage = NFCViewDisplayMessage.error(error)
+                self.invalidateSession(errorMessage: errorMessage, error: error)
+            } catch let error {
+                Logger.passportReader.debug( "tagReaderSession:failed to connect to tag - \(error.localizedDescription)" )
+                let errorMessage = NFCViewDisplayMessage.error(NFCPassportReaderError.ConnectionError)
+                self.invalidateSession(errorMessage: errorMessage, error: NFCPassportReaderError.Unknown(error))
+            }
+        }
+    }
+    
+    func updateReaderSessionMessage(alertMessage: NFCViewDisplayMessage ) {
+        self.readerSession?.alertMessage = self.nfcViewDisplayMessageHandler?(alertMessage) ?? alertMessage.description
+    }
+}
+
+@available(iOS 15, *)
+extension PassportReader {
+    
+    func startReading(tagReader : TagReader) async throws -> NFCPassportModel {
+
+        if !skipPACE {
+            do {
+//                let data = try await tagReader.readCardAccess()
+                
+                let data = hexRepToBin("3134300d060804007f0007020202020101300f060a04007f000702020302020201013012060a04007f0007020204020202010202010d")
+
+//                Logger.passportReader.debug( "Read CardAccess - data \(binToHexRep(data))" )
+                let cardAccess = try CardAccess(data)
+                passport.cardAccess = cardAccess
+     
+                Logger.passportReader.info( "Starting Password Authenticated Connection Establishment (PACE)" )
+                 
+                let paceHandler = try PACEHandler( cardAccess: cardAccess, tagReader: tagReader )
+                try await paceHandler.doPACE(canKey: canKey )
+                passport.PACEStatus = .success
+                Logger.passportReader.debug( "PACE Succeeded" )
+            } catch let error  {
+                passport.PACEStatus = .failed
+                Logger.passportReader.error("Có lỗi xảy ra: \(error)")
+                Logger.passportReader.error( "PACE Failed - falling back to BAC" )
+            }
+            
+            _ = try await tagReader.selectPassportApplication()
+        }
+        
+        // Now to read the datagroups
+        try await readDataGroups(tagReader: tagReader)
+
+        try await doActiveAuthenticationIfNeccessary(tagReader : tagReader)
+
+        self.updateReaderSessionMessage(alertMessage: NFCViewDisplayMessage.successfulRead)
+        self.shouldNotReportNextReaderSessionInvalidationErrorUserCanceled = true
+        self.readerSession?.invalidate()
+
+        // If we have a masterlist url set then use that and verify the passport now
+        self.passport.verifyPassport(masterListURL: self.masterListURL, useCMSVerification: self.passiveAuthenticationUsesOpenSSL)
+
+        return self.passport
+    }
+    
+    
+    func doActiveAuthenticationIfNeccessary( tagReader : TagReader) async throws {
+        guard self.passport.activeAuthenticationSupported else {
+            return
+        }
+        self.updateReaderSessionMessage(alertMessage: NFCViewDisplayMessage.activeAuthentication)
+
+        Logger.passportReader.info( "Performing Active Authentication" )
+
+        let challenge = generateRandomUInt8Array(8)
+        Logger.passportReader.debug( "Generated Active Authentication challange - \(binToHexRep(challenge))")
+        let response = try await tagReader.doInternalAuthentication(challenge: challenge, useExtendedMode: useExtendedMode)
+        self.passport.verifyActiveAuthentication( challenge:challenge, signature:response.data )
+    }
+
+    func readDataGroups( tagReader: TagReader ) async throws {
+        
+        // Read COM
+        var DGsToRead = [DataGroupId]()
+
+        self.updateReaderSessionMessage( alertMessage: NFCViewDisplayMessage.readingDataGroupProgress(.COM, 0) )
+        if let com = try await readDataGroup(tagReader:tagReader, dgId:.COM) as? COM {
+            self.passport.addDataGroup( .COM, dataGroup:com )
+        
+            // SOD and COM shouldn't be present in the DG list but just in case (worst case here we read the sod twice)
+            DGsToRead = [.SOD] + com.dataGroupsPresent.map { DataGroupId.getIDFromName(name:$0) }
+            DGsToRead.removeAll { $0 == .COM }
+        }
+        
+        if DGsToRead.contains( .DG14 ) {
+            DGsToRead.removeAll { $0 == .DG14 }
+            
+            if !skipCA {
+                // Do Chip Authentication
+                if let dg14 = try await readDataGroup(tagReader:tagReader, dgId:.DG14) as? DataGroup14 {
+                    self.passport.addDataGroup( .DG14, dataGroup:dg14 )
+                    let caHandler = ChipAuthenticationHandler(dg14: dg14, tagReader: tagReader)
+                     
+                    if caHandler.isChipAuthenticationSupported {
+                        do {
+                            // Do Chip authentication and then continue reading datagroups
+                            try await caHandler.doChipAuthentication()
+                            self.passport.chipAuthenticationStatus = .success
+                        } catch {
+                            Logger.passportReader.info( "Chip Authentication failed - re-establishing BAC")
+                            self.passport.chipAuthenticationStatus = .failed
+                        }
+                    }
+                }
+            }
+        }
+
+        // If we are skipping secure elements then remove .DG3 and .DG4
+        if self.skipSecureElements {
+            DGsToRead = DGsToRead.filter { $0 != .DG3 && $0 != .DG4 }
+        }
+
+        if self.readAllDatagroups != true {
+            DGsToRead = DGsToRead.filter { dataGroupsToRead.contains($0) }
+        }
+        for dgId in DGsToRead {
+            self.updateReaderSessionMessage( alertMessage: NFCViewDisplayMessage.readingDataGroupProgress(dgId, 0) )
+            if let dg = try await readDataGroup(tagReader:tagReader, dgId:dgId) {
+                self.passport.addDataGroup( dgId, dataGroup:dg )
+            }
+        }
+    }
+    
+    func readDataGroup( tagReader : TagReader, dgId : DataGroupId ) async throws -> DataGroup?  {
+
+        self.currentlyReadingDataGroup = dgId
+        Logger.passportReader.info( "Reading tag - \(dgId.getName())" )
+        var readAttempts = 0
+        var nfcPassportReaderError: NFCPassportReaderError
+        
+        self.updateReaderSessionMessage( alertMessage: NFCViewDisplayMessage.readingDataGroupProgress(dgId, 0) )
+
+        repeat {
+            do {
+                let response = try await tagReader.readDataGroup(dataGroup:dgId)
+                let dg = try DataGroupParser().parseDG(data: response)
+                return dg
+            } catch let error as NFCPassportReaderError {
+                Logger.passportReader.error( "TagError reading tag - \(error)" )
+                nfcPassportReaderError = error
+
+                // OK we had an error - depending on what happened, we may want to try to re-read this
+                // E.g. we failed to read the last Datagroup because its protected and we can't
+                let errMsg = error.value
+                Logger.passportReader.error( "ERROR - \(errMsg)" )
+                if errMsg == "Session invalidated" || errMsg == "Class not supported" || errMsg == "Tag connection lost" || errMsg == "Tag response error / no response" {
+                    // Check if we have done Chip Authentication, if so, set it to nil and try to redo BAC
+                    if self.caHandler != nil {
+                        self.caHandler = nil
+                    } else {
+                        // Can't go any more!
+                        throw error
+                    }
+                } else if errMsg == "Security status not satisfied" || errMsg == "File not found" {
+                    // Can't read this element as we aren't allowed - remove it and return out so we re-do BAC
+                    self.dataGroupsToRead.removeFirst()
+                
+                } else if errMsg == "SM data objects incorrect" || errMsg == "Class not supported" {
+                    // Can't read this element security objects now invalid - and return out so we re-do BAC
+                } else if errMsg.hasPrefix( "Wrong length" ) || errMsg.hasPrefix( "End of file" ) {  // Should now handle errors 0x6C xx, and 0x67 0x00
+                    // OK passport can't handle max length so drop it down
+                    tagReader.reduceDataReadingAmount()
+                }
+                
+            }
+            readAttempts += 1
+        } while ( readAttempts < 2 )
+
+        // The error will be thrown after n attempts
+        throw nfcPassportReaderError
+    }
+
+    func invalidateSession(errorMessage: NFCViewDisplayMessage, error: NFCPassportReaderError) {
+        // Mark the next 'invalid session' error as not reportable (we're about to cause it by invalidating the
+        // session). The real error is reported back with the call to the completed handler
+        self.shouldNotReportNextReaderSessionInvalidationErrorUserCanceled = true
+        self.readerSession?.invalidate(errorMessage: self.nfcViewDisplayMessageHandler?(errorMessage) ?? errorMessage.description)
+        nfcContinuation?.resume(throwing: error)
+        nfcContinuation = nil
+    }
+    
+}
+#endif

package/vendor/ios-passport-reader/Sources/NFCPassportReader/Resources/PrivacyInfo.xcprivacy

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+    <dict>
+        <key>NSPrivacyCollectedDataTypes</key>
+        <array/>
+        <key>NSPrivacyAccessedAPITypes</key>
+        <array/>
+        <key>NSPrivacyTrackingDomains</key>
+        <array/>
+        <key>NSPrivacyTracking</key>
+        <false/>
+    </dict>
+</plist>

package/vendor/ios-passport-reader/Sources/NFCPassportReader/ResponseAPDU.swift

@@ -0,0 +1,25 @@
+//
+//  ResponseAPDU.swift
+//  NFCPassportReader
+//
+//  Created by Andy Qua on 09/02/2021.
+//  Copyright © 2021 Andy Qua. All rights reserved.
+//
+
+#if !os(macOS)
+
+@available(iOS 13, *)
+public struct ResponseAPDU {
+    
+    public var data : [UInt8]
+    public var sw1 : UInt8
+    public var sw2 : UInt8
+    
+    public init(data: [UInt8], sw1: UInt8, sw2: UInt8) {
+        self.data = data
+        self.sw1 = sw1
+        self.sw2 = sw2
+    }
+}
+
+#endif