how to encrypt/decrypt Secure QR - Code into readable format in Swift

Question

I have successfully scan and read the stringValue from QR.But couldn't convert the stringValue to readable format. https://uidai.gov.in/images/resource/User_manulal_QR_Code_15032019.pdf I have tried to convert using the above procedure but couldn't succeed.

1) I have tried library to convert to BigInt and converted to binary value

 let str = String(self.metadataStringValue, radix: 2)
        print(str)

2)Convert the Big Integer into byte array successfully

 let byteArray = Array(BigUInt(str)!.serialize())
        print(byteArray)

3) Used Apple's decompression algorithm (zlib)

4) Read the value of byte array from index 0 to till first delimiter value“255” and convert this byte array value into string with encoding “ISO-8859-1”.

var firstDelimiter = ArraySlice<UInt8>()
    var firstDelimiterArray = [UInt8]()
    var delimiterIndex:Int = 0

for index in 0..<byteArray.count {

    if byteArray[index] == 255 {
        firstDelimiter = byteArray[delimiterIndex...index]
        delimiterIndex = index + 1

        firstDelimiterArray = firstDelimiter.map { $0 }

        let data2 = Data(bytes: firstDelimiterArray, count: firstDelimiterArray.count)
        print(data2 as NSData)
     }
}

5)“ISO-8859-1” encoding Couldn't convert to readbale format(I have used .isolatin1)

Answer 1

For swift 5,

I have decoded aadhar's secure QR Code and fetched name, DOB and gender

Referred: https://uidai.gov.in/images/resource/User_manulal_QR_Code_15032019.pdf

Install these pods

pod 'BigInt'
pod 'GzipSwift'

Import these pods

import BigInt
import Gzip

After scanning QR Code call the below function

func scannedData(code: String) {
    print(code)
    
    //Convert to BigInt
    let bInt = BigInt(code, radix: 10)
    
    //Convert to bytes
    let byteData = bInt?.serialize() ?? Data()
    
    //Convert to byte array
    var data = Array(bInt?.serialize() ?? Data())
    
    // Decompress
    let decompressedData: Data
    if byteData.isGzipped {
        decompressedData = try! byteData.gunzipped()
        data = [UInt8](decompressedData)
    } else {
        decompressedData = byteData
    }
    
    var firstDelimiter = ArraySlice<UInt8>()
    var firstDelimiterArray = [UInt8]()
    var delimiterIndex:Int = 0
    var set:Int = 0

    for index in 0..<data.count {
        
        if data[index] == 255 {
            set = set + 1
            firstDelimiter = data[delimiterIndex..<index]
            delimiterIndex = index + 1
            
            firstDelimiterArray = firstDelimiter.map { $0 }
            let sepData = Data(bytes: firstDelimiterArray, count: firstDelimiterArray.count)
            // name
            if set == 3 {
                let name = convertString(data: sepData)
            }
            // DOB
            if set == 4 {
                let dob = convertString(data: sepData)
            }
            // Gender
            if set == 5 {
                let gender = convertString(data: sepData)
            }
        }
    }
}

To encode the separated bytes use this function

 private func convertString(data: Data) -> String {
     return String(data: data, encoding: .windowsCP1250) ?? ""
 }

Use this extension

extension BigInt {
    
    public func serialize() -> Data {
        var array = Array(BigUInt.init(self.magnitude).serialize())
        
        if array.count > 0 {
            if self.sign == BigInt.Sign.plus {
                if array[0] >= 128 {
                    array.insert(0, at: 0)
                }
            } else if self.sign == BigInt.Sign.minus {
                if array[0] <= 127 {
                    array.insert(255, at: 0)
                }
            }
        }
        
        return Data.init(bytes: array)
    }
    
    public init(_ data: Data) {
        var dataArray = Array(data)
        var sign: BigInt.Sign = BigInt.Sign.plus
        
        if dataArray.count > 0 {
            if dataArray[0] >= 128 {
                sign = BigInt.Sign.minus
                
                if dataArray.count > 1 {
                    if dataArray[0] == 255, dataArray.count > 1 {
                        dataArray.remove(at: 0)
                    } else {
                        dataArray[0] = UInt8(256 - Int(dataArray[0]))
                    }
                }
            }
        }
        
        let magnitude = BigUInt.init(Data.init(bytes: dataArray))
        
        self .init(sign: sign, magnitude: magnitude)
    }
}