@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/android/src/main/java/com/trustchex/reactnativesdk/mrz/MRZValidator.kt

@@ -0,0 +1,419 @@
+package com.trustchex.reactnativesdk.mrz
+
+/**
+ * Pure MRZ validation logic with no React Native dependencies.
+ * Used by both MRZValidationModule and TrustchexCameraView.
+ */
+object MRZValidator {
+
+    data class MRZResult(
+        val valid: Boolean,
+        val format: String,
+        val error: String? = null,
+        val documentCode: String? = null,
+        val issuingState: String? = null,
+        val documentNumber: String? = null,
+        val lastName: String? = null,
+        val firstName: String? = null,
+        val birthDate: String? = null,
+        val sex: String? = null,
+        val expirationDate: String? = null,
+        val nationality: String? = null,
+        val optional1: String? = null,
+        val optional2: String? = null,
+        val rawLines: String? = null
+    )
+
+    fun validateWithCorrections(ocrText: String): MRZResult {
+        val fixedText = fixMRZ(ocrText)
+        val lines = fixedText.trim().split("\n").map { it.trim() }
+
+        if (lines.isEmpty() || fixedText.length < 60) {
+            return MRZResult(valid = false, format = "UNKNOWN", error = "MRZ text too short")
+        }
+
+        val format = detectMRZFormat(lines)
+        if (format == "UNKNOWN") {
+            return MRZResult(valid = false, format = "UNKNOWN", error = "Unknown MRZ format")
+        }
+
+        // Phase 1: position-aware corrections
+        var result = parseMRZ(fixedText)
+        if (result.valid) return result
+
+        // Phase 2: composite checksum brute-force
+        val compositePos = when (format) {
+            "TD1" -> Pair(1, 29)
+            "TD2" -> Pair(1, 35)
+            "TD3" -> Pair(1, 43)
+            else -> null
+        }
+        if (compositePos != null) {
+            val mutableLines = lines.toMutableList()
+            val targetLine = mutableLines[compositePos.first]
+            for (digit in 0..9) {
+                val testLine = targetLine.substring(0, compositePos.second) +
+                    digit +
+                    targetLine.substring(compositePos.second + 1)
+                mutableLines[compositePos.first] = testLine
+                val testResult = parseMRZ(mutableLines.joinToString("\n"))
+                if (testResult.valid) return testResult
+            }
+        }
+
+        // Phase 3: O/0 permutations
+        for (permutation in generateO0Permutations(fixedText)) {
+            val testResult = parseMRZ(permutation)
+            if (testResult.valid) return testResult
+        }
+
+        // Phase 4: I/1 permutations
+        for (permutation in generateI1Permutations(fixedText)) {
+            val testResult = parseMRZ(permutation)
+            if (testResult.valid) return testResult
+        }
+
+        // Phase 5: S/5 permutations
+        for (permutation in generatePairPermutations(fixedText, 'S', '5', 30)) {
+            val testResult = parseMRZ(permutation)
+            if (testResult.valid) return testResult
+        }
+
+        // Phase 6: B/8 permutations
+        for (permutation in generatePairPermutations(fixedText, 'B', '8', 30)) {
+            val testResult = parseMRZ(permutation)
+            if (testResult.valid) return testResult
+        }
+
+        // Phase 7: Z/2 permutations
+        for (permutation in generatePairPermutations(fixedText, 'Z', '2', 30)) {
+            val testResult = parseMRZ(permutation)
+            if (testResult.valid) return testResult
+        }
+
+        // Phase 8: G/6 permutations
+        for (permutation in generatePairPermutations(fixedText, 'G', '6', 30)) {
+            val testResult = parseMRZ(permutation)
+            if (testResult.valid) return testResult
+        }
+
+        return result
+    }
+
+    private fun parseMRZ(rawText: String): MRZResult {
+        val lines = rawText.trim().split("\n").map { it.trim() }
+        val format = detectMRZFormat(lines)
+
+        if (format == "UNKNOWN") {
+            return MRZResult(valid = false, format = "UNKNOWN", error = "Unknown MRZ format")
+        }
+
+        val fields = when (format) {
+            "TD1" -> parseTD1(lines)
+            "TD2" -> parseTD2(lines)
+            "TD3" -> parseTD3(lines)
+            else -> return MRZResult(valid = false, format = "UNKNOWN", error = "Unsupported format")
+        }
+
+        val allValid = validateChecksums(format, lines)
+        return fields.copy(valid = allValid, format = format, rawLines = if (allValid) rawText.trim() else null)
+    }
+
+    private fun detectMRZFormat(lines: List<String>): String = when {
+        lines.size == 3 && lines.all { it.length == 30 } -> "TD1"
+        lines.size == 2 && lines.all { it.length == 36 } -> "TD2"
+        lines.size == 2 && lines.all { it.length == 44 } -> "TD3"
+        else -> "UNKNOWN"
+    }
+
+    private fun parseTD1(lines: List<String>): MRZResult {
+        val names = lines[2].split("<<")
+        return MRZResult(
+            valid = false,
+            format = "TD1",
+            documentCode = lines[0].substring(0, 2).replace('<', ' ').trim(),
+            issuingState = lines[0].substring(2, 5).replace('<', ' ').trim(),
+            documentNumber = lines[0].substring(5, 14).replace('<', ' ').trim(),
+            optional1 = lines[0].substring(15, 30).replace('<', ' ').trim(),
+            birthDate = lines[1].substring(0, 6),
+            sex = lines[1].substring(7, 8),
+            expirationDate = lines[1].substring(8, 14),
+            nationality = lines[1].substring(15, 18).replace('<', ' ').trim(),
+            optional2 = lines[1].substring(18, 29).replace('<', ' ').trim(),
+            lastName = names[0].replace('<', ' ').trim(),
+            firstName = if (names.size > 1) names[1].replace('<', ' ').trim() else ""
+        )
+    }
+
+    private fun parseTD2(lines: List<String>): MRZResult {
+        val names = lines[0].substring(5, 36).split("<<")
+        return MRZResult(
+            valid = false,
+            format = "TD2",
+            documentCode = lines[0].substring(0, 2).replace('<', ' ').trim(),
+            issuingState = lines[0].substring(2, 5).replace('<', ' ').trim(),
+            lastName = names[0].replace('<', ' ').trim(),
+            firstName = if (names.size > 1) names[1].replace('<', ' ').trim() else "",
+            documentNumber = lines[1].substring(0, 9).replace('<', ' ').trim(),
+            nationality = lines[1].substring(10, 13).replace('<', ' ').trim(),
+            birthDate = lines[1].substring(13, 19),
+            sex = lines[1].substring(20, 21),
+            expirationDate = lines[1].substring(21, 27),
+            optional1 = lines[1].substring(28, 35).replace('<', ' ').trim()
+        )
+    }
+
+    private fun parseTD3(lines: List<String>): MRZResult {
+        val names = lines[0].substring(5, 44).split("<<")
+        return MRZResult(
+            valid = false,
+            format = "TD3",
+            documentCode = lines[0].substring(0, 2).replace('<', ' ').trim(),
+            issuingState = lines[0].substring(2, 5).replace('<', ' ').trim(),
+            lastName = names[0].replace('<', ' ').trim(),
+            firstName = if (names.size > 1) names[1].replace('<', ' ').trim() else "",
+            documentNumber = lines[1].substring(0, 9).replace('<', ' ').trim(),
+            nationality = lines[1].substring(10, 13).replace('<', ' ').trim(),
+            birthDate = lines[1].substring(13, 19),
+            sex = lines[1].substring(20, 21),
+            expirationDate = lines[1].substring(21, 27),
+            optional1 = lines[1].substring(28, 42).replace('<', ' ').trim()
+        )
+    }
+
+    private fun validateChecksums(format: String, lines: List<String>): Boolean {
+        return try {
+            when (format) {
+                "TD1" -> {
+                    val docNumValid = calculateMRZChecksum(lines[0].substring(5, 14)) == lines[0][14]
+                    val birthValid = calculateMRZChecksum(lines[1].substring(0, 6)) == lines[1][6]
+                    val expiryValid = calculateMRZChecksum(lines[1].substring(8, 14)) == lines[1][14]
+                    val composite = lines[0].substring(5, 30) + lines[1].substring(0, 7) +
+                        lines[1].substring(8, 15) + lines[1].substring(18, 29)
+                    val compositeValid = calculateMRZChecksum(composite) == lines[1][29]
+                    docNumValid && birthValid && expiryValid && compositeValid
+                }
+                "TD2" -> {
+                    val line = lines[1]
+                    val docNumValid = calculateMRZChecksum(line.substring(0, 9)) == line[9]
+                    val birthValid = calculateMRZChecksum(line.substring(13, 19)) == line[19]
+                    val expiryValid = calculateMRZChecksum(line.substring(21, 27)) == line[27]
+                    val composite = line.substring(0, 10) + line.substring(13, 20) + line.substring(21, 35)
+                    val compositeValid = calculateMRZChecksum(composite) == line[35]
+                    docNumValid && birthValid && expiryValid && compositeValid
+                }
+                "TD3" -> {
+                    val line = lines[1]
+                    val docNumValid = calculateMRZChecksum(line.substring(0, 9)) == line[9]
+                    val birthValid = calculateMRZChecksum(line.substring(13, 19)) == line[19]
+                    val expiryValid = calculateMRZChecksum(line.substring(21, 27)) == line[27]
+                    val personalValid = calculateMRZChecksum(line.substring(28, 42)) == line[42]
+                    val composite = line.substring(0, 10) + line.substring(13, 20) + line.substring(21, 43)
+                    val compositeValid = calculateMRZChecksum(composite) == line[43]
+                    docNumValid && birthValid && expiryValid && personalValid && compositeValid
+                }
+                else -> false
+            }
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private fun calculateMRZChecksum(data: String): Char {
+        val weights = intArrayOf(7, 3, 1)
+        var sum = 0
+        for (i in data.indices) {
+            val value = when (val c = data[i]) {
+                in '0'..'9' -> c - '0'
+                in 'A'..'Z' -> c - 'A' + 10
+                else -> 0
+            }
+            sum += value * weights[i % 3]
+        }
+        return ('0' + (sum % 10))
+    }
+
+    fun fixMRZ(rawText: String): String {
+        var fixed = rawText
+            .replace(" ", "")
+            .replace("«", "")
+            .replace(Regex("<K+|r+K+|<r+K+"), "")
+
+        fixed = fixed.replace(Regex("""\bI<TUR([A-Z0-9]{3})0([A-Z0-9]{6})\b"""), "I<TUR$1O$2")
+
+        val lines = fixed.split("\n").map { it.trim() }
+
+        // Extract only lines that look like MRZ (uppercase alphanumeric + filler only, exact MRZ lengths)
+        val mrzLines = lines.filter { line ->
+            (line.length == 30 || line.length == 36 || line.length == 44) &&
+                line.matches(Regex("[A-Z0-9<]+"))
+        }
+
+        // If no exact-length MRZ lines found, fall back to lines containing '<' that could be padded
+        val candidateLines = if (mrzLines.isNotEmpty()) mrzLines else lines.filter { it.contains('<') }
+
+        val targetLength = when {
+            candidateLines.all { it.length <= 30 } -> 30
+            candidateLines.all { it.length <= 36 } -> 36
+            candidateLines.all { it.length <= 44 } -> 44
+            else -> return rawText
+        }
+
+        // Keep only lines that fit the target length (filter out non-MRZ lines)
+        val filteredLines = candidateLines.filter { it.length <= targetLength && it.matches(Regex("[A-Z0-9<]+")) }
+        if (filteredLines.isEmpty()) return rawText
+
+        val paddedLines = filteredLines.map { line ->
+            if (line.length < targetLength) line.padEnd(targetLength, '<') else line
+        }
+
+        return applyOCRCorrections(paddedLines.joinToString("\n"))
+    }
+
+    private fun applyOCRCorrections(mrzText: String): String {
+        val lines = mrzText.split("\n").toMutableList()
+        if (lines.isEmpty()) return mrzText
+
+        val format = detectMRZFormat(lines)
+        if (format == "UNKNOWN") return mrzText
+
+        when (format) {
+            "TD1" -> {
+                lines[0] = correctLetterPositions(lines[0], listOf(0..1, 2..4))
+                lines[0] = correctCheckDigitPositions(lines[0], listOf(14))
+                lines[1] = correctDigitPositions(lines[1], listOf(0..5, 8..13))
+                lines[1] = correctCheckDigitPositions(lines[1], listOf(6, 14, 29))
+                lines[1] = correctLetterPositions(lines[1], listOf(7..7, 15..17))
+                lines[2] = correctLetterPositions(lines[2], listOf(0..29))
+            }
+            "TD2" -> {
+                lines[0] = correctLetterPositions(lines[0], listOf(0..1, 2..4, 5..35))
+                lines[1] = correctDigitPositions(lines[1], listOf(13..18, 21..26))
+                lines[1] = correctCheckDigitPositions(lines[1], listOf(9, 19, 27, 35))
+                lines[1] = correctLetterPositions(lines[1], listOf(10..12, 20..20))
+            }
+            "TD3" -> {
+                lines[0] = correctLetterPositions(lines[0], listOf(0..1, 2..4, 5..43))
+                lines[1] = correctDigitPositions(lines[1], listOf(13..18, 21..26))
+                lines[1] = correctCheckDigitPositions(lines[1], listOf(9, 19, 27, 42))
+                lines[1] = correctLetterPositions(lines[1], listOf(10..12, 20..20))
+            }
+        }
+
+        return lines.joinToString("\n")
+    }
+
+    private fun correctDigitPositions(line: String, ranges: List<IntRange>): String {
+        var corrected = line
+        ranges.forEach { range ->
+            range.forEach { pos ->
+                if (pos < corrected.length) {
+                    val replacement = when (corrected[pos]) {
+                        'O', 'o' -> '0'; 'I', 'l' -> '1'; 'Z' -> '2'
+                        'S' -> '5'; 'G' -> '6'; 'B' -> '8'; 'D', 'Q' -> '0'
+                        else -> corrected[pos]
+                    }
+                    if (replacement != corrected[pos])
+                        corrected = corrected.substring(0, pos) + replacement + corrected.substring(pos + 1)
+                }
+            }
+        }
+        return corrected
+    }
+
+    private fun correctLetterPositions(line: String, ranges: List<IntRange>): String {
+        var corrected = line
+        ranges.forEach { range ->
+            range.forEach { pos ->
+                if (pos < corrected.length) {
+                    val replacement = when (corrected[pos]) {
+                        '0' -> 'O'; '1' -> 'I'; '5' -> 'S'; '8' -> 'B'; '2' -> 'Z'; '6' -> 'G'
+                        else -> corrected[pos]
+                    }
+                    if (replacement != corrected[pos])
+                        corrected = corrected.substring(0, pos) + replacement + corrected.substring(pos + 1)
+                }
+            }
+        }
+        return corrected
+    }
+
+    private fun correctCheckDigitPositions(line: String, positions: List<Int>): String {
+        var corrected = line
+        positions.forEach { pos ->
+            if (pos < corrected.length) {
+                val replacement = when (corrected[pos]) {
+                    'O', 'o' -> '0'; 'I', 'l' -> '1'; 'Z' -> '2'
+                    'S' -> '5'; 'G' -> '6'; 'B' -> '8'
+                    else -> corrected[pos]
+                }
+                if (replacement != corrected[pos])
+                    corrected = corrected.substring(0, pos) + replacement + corrected.substring(pos + 1)
+            }
+        }
+        return corrected
+    }
+
+    private fun generateO0Permutations(mrzText: String, maxPermutations: Int = 100): List<String> {
+        val permutations = mutableSetOf(mrzText)
+        val positions = mrzText.indices
+            .filter { val c = mrzText[it]; c == 'O' || c == 'o' || c == '0' }
+            .take(7)
+        val limit = minOf(1 shl positions.size, maxPermutations)
+        for (i in 0 until limit) {
+            var variant = mrzText
+            positions.forEachIndexed { j, pos ->
+                val useZero = (i and (1 shl j)) != 0
+                val replacement = if (useZero && variant[pos] != '0') '0'
+                    else if (!useZero && variant[pos] != 'O') 'O'
+                    else variant[pos]
+                if (replacement != variant[pos])
+                    variant = variant.substring(0, pos) + replacement + variant.substring(pos + 1)
+            }
+            permutations.add(variant)
+        }
+        return permutations.toList()
+    }
+
+    private fun generatePairPermutations(mrzText: String, letter: Char, digit: Char, maxPermutations: Int = 30): List<String> {
+        val permutations = mutableSetOf(mrzText)
+        val positions = mrzText.indices
+            .filter { val c = mrzText[it]; c == letter || c == letter.lowercaseChar() || c == digit }
+            .take(5)
+        val limit = minOf(1 shl positions.size, maxPermutations)
+        for (i in 0 until limit) {
+            var variant = mrzText
+            positions.forEachIndexed { j, pos ->
+                val useDigit = (i and (1 shl j)) != 0
+                val replacement = if (useDigit && variant[pos] != digit) digit
+                    else if (!useDigit && variant[pos] != letter) letter
+                    else variant[pos]
+                if (replacement != variant[pos])
+                    variant = variant.substring(0, pos) + replacement + variant.substring(pos + 1)
+            }
+            permutations.add(variant)
+        }
+        return permutations.toList()
+    }
+
+    private fun generateI1Permutations(mrzText: String, maxPermutations: Int = 50): List<String> {
+        val permutations = mutableSetOf(mrzText)
+        val positions = mrzText.indices
+            .filter { val c = mrzText[it]; c == 'I' || c == 'i' || c == 'l' || c == '1' }
+            .take(6)
+        val limit = minOf(1 shl positions.size, maxPermutations)
+        for (i in 0 until limit) {
+            var variant = mrzText
+            positions.forEachIndexed { j, pos ->
+                val useOne = (i and (1 shl j)) != 0
+                val replacement = if (useOne && variant[pos] != '1') '1'
+                    else if (!useOne && (variant[pos] == '1' || variant[pos] == 'l' || variant[pos] == 'i')) 'I'
+                    else variant[pos]
+                if (replacement != variant[pos])
+                    variant = variant.substring(0, pos) + replacement + variant.substring(pos + 1)
+            }
+            permutations.add(variant)
+        }
+        return permutations.toList()
+    }
+}