react-native-instantpay-code-push 1.1.8 → 1.2.0

package/ios/NotificationExtension.swift

@@ -0,0 +1,13 @@
+//
+//  NotificationExtension.swift
+//  InstantpayCodePush
+//
+//  Created by Dhananjay kumar on 09/02/26.
+//
+
+import Foundation
+
+extension Notification.Name {
+    static let downloadProgressUpdate = Notification.Name("IpayCodePushDownloadProgressUpdate")
+    static let downloadDidFinish = Notification.Name("IpayCodePushDownloadDidFinish")
+}

package/ios/SignatureVerifier.swift

@@ -0,0 +1,358 @@
+//
+//  SignatureVerifier.swift
+//  InstantpayCodePush
+//
+//  Created by Dhananjay kumar on 06/02/26.
+//
+
+import Foundation
+import Security
+
+/// Prefix for signed file hash format.
+private let SIGNED_HASH_PREFIX = "sig:"
+
+
+/// Error types for signature verification failures.
+public enum SignatureVerificationError: Error, CustomNSError {
+    case publicKeyNotConfigured
+    case invalidPublicKeyFormat
+    case missingFileHash
+    case invalidSignatureFormat
+    case signatureVerificationFailed
+    case fileHashMismatch
+    case fileReadFailed
+    case unsignedNotAllowed
+    case securityFrameworkError(OSStatus)
+    
+    // CustomNSError protocol implementation
+    public static var errorDomain: String {
+        return "IpayCodePush.SignatureVerificationError"
+    }
+
+    public var errorCode: Int {
+        return 0
+    }
+    
+    public var errorCodeString: String {
+        switch self {
+        case .publicKeyNotConfigured: return "PUBLIC_KEY_NOT_CONFIGURED"
+        case .invalidPublicKeyFormat: return "INVALID_PUBLIC_KEY_FORMAT"
+        case .missingFileHash: return "MISSING_FILE_HASH"
+        case .invalidSignatureFormat: return "INVALID_SIGNATURE_FORMAT"
+        case .signatureVerificationFailed: return "SIGNATURE_VERIFICATION_FAILED"
+        case .fileHashMismatch: return "FILE_HASH_MISMATCH"
+        case .fileReadFailed: return "FILE_READ_FAILED"
+        case .unsignedNotAllowed: return "UNSIGNED_NOT_ALLOWED"
+        case .securityFrameworkError: return "SECURITY_FRAMEWORK_ERROR"
+        }
+    }
+    
+    public var errorUserInfo: [String: Any] {
+        var userInfo: [String: Any] = [:]
+
+        switch self {
+        case .publicKeyNotConfigured:
+            userInfo[NSLocalizedDescriptionKey] = "Public key not configured for signature verification"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "Add IPAY_CODE_PUSH_PUBLIC_KEY to Info.plist with your RSA public key"
+
+        case .invalidPublicKeyFormat:
+            userInfo[NSLocalizedDescriptionKey] = "Public key format is invalid"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "Ensure the public key is in PEM format (BEGIN PUBLIC KEY)"
+
+        case .missingFileHash:
+            userInfo[NSLocalizedDescriptionKey] = "File hash is missing or empty"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "Ensure the bundle update includes a valid file hash"
+
+        case .invalidSignatureFormat:
+            userInfo[NSLocalizedDescriptionKey] = "Signature format is invalid or corrupted"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "The signature data is malformed or cannot be decoded. Bundle may be corrupted"
+
+        case .signatureVerificationFailed:
+            userInfo[NSLocalizedDescriptionKey] = "Bundle signature verification failed"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "The bundle may be corrupted or tampered with. Rejecting update for security"
+
+        case .fileHashMismatch:
+            userInfo[NSLocalizedDescriptionKey] = "File hash verification failed"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "The bundle file hash does not match the expected value. File may be corrupted"
+
+        case .fileReadFailed:
+            userInfo[NSLocalizedDescriptionKey] = "Failed to read file for verification"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "Could not read file for hash verification"
+
+        case .unsignedNotAllowed:
+            userInfo[NSLocalizedDescriptionKey] = "Unsigned bundle not allowed when signing is enabled"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "Public key is configured but bundle is not signed. Rejecting update"
+
+        case .securityFrameworkError(let status):
+            userInfo[NSLocalizedDescriptionKey] = "Security framework error during verification (OSStatus: \(status))"
+            userInfo[NSLocalizedRecoverySuggestionErrorKey] = "Check public key format and signature data"
+        }
+
+        return userInfo
+    }
+}
+
+/**
+ * Service for verifying bundle integrity through hash or RSA-SHA256 signature verification.
+ * Uses iOS Security framework for cryptographic operations.
+ *
+ * fileHash format:
+ * - Signed: `sig:<base64_signature>` - Verify signature (implicitly verifies hash)
+ * - Unsigned: `<hex_hash>` - Verify SHA256 hash only
+ *
+ * Security rules:
+ * - null/empty fileHash → REJECT
+ * - sig:... + public key configured → verify signature → Install/REJECT
+ * - sig:... + public key NOT configured → REJECT (can't verify)
+ * - <hash> + public key configured → REJECT (unsigned not allowed)
+ * - <hash> + public key NOT configured → verify hash → Install/REJECT
+ */
+public class SignatureVerifier {
+    
+    public static let CLASS_TAG: String = "*SignatureVerifier"
+    
+    /**
+     * Reads public key from Info.plist configuration.
+     * @return Public key PEM string or nil if not configured
+     */
+    private static func getPublicKeyFromConfig() -> String? {
+        guard let publicKeyPEM = Bundle.main.object(forInfoDictionaryKey: "IPAY_CODE_PUSH_PUBLIC_KEY") as? String else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "IPAY_CODE_PUSH_PUBLIC_KEY not found in Info.plist")
+            return nil
+        }
+        return publicKeyPEM
+    }
+    
+    /**
+     * Checks if signing is enabled (public key is configured).
+     * @return true if public key is configured
+     */
+    public static func isSigningEnabled() -> Bool {
+        return getPublicKeyFromConfig() != nil
+    }
+    
+    /**
+     * Checks if fileHash is in signed format (starts with "sig:").
+     * @param fileHash The file hash string to check
+     * @return true if signed format
+     */
+    public static func isSignedFormat(_ fileHash: String?) -> Bool {
+        guard let hash = fileHash else { return false }
+        return hash.hasPrefix(SIGNED_HASH_PREFIX)
+    }
+    
+    /**
+     * Extracts signature from signed format fileHash.
+     * @param fileHash The signed file hash (sig:<signature>)
+     * @return Base64-encoded signature or nil if not signed format
+     */
+    public static func extractSignature(_ fileHash: String?) -> String? {
+        guard let hash = fileHash, isSignedFormat(hash) else { return nil }
+        return String(hash.dropFirst(SIGNED_HASH_PREFIX.count))
+    }
+    
+    /**
+     * Verifies bundle integrity based on fileHash format.
+     * Determines verification mode by checking for "sig:" prefix.
+     *
+     * @param fileURL URL of the bundle file to verify
+     * @param fileHash Combined hash string (sig:<signature> or <hex_hash>)
+     * @return Result indicating verification success or failure with error
+     */
+    public static func verifyBundle(fileURL: URL, fileHash: String?) -> Result<Void, SignatureVerificationError> {
+        let signingEnabled = isSigningEnabled()
+
+        // Rule: null/empty fileHash → REJECT
+        guard let hash = fileHash, !hash.isEmpty else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "[SignatureVerifier] fileHash is null or empty. Rejecting update.")
+            return .failure(.missingFileHash)
+        }
+
+        if isSignedFormat(hash) {
+            // Signed format: sig:<signature>
+            guard let signature = extractSignature(hash) else {
+                IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "[SignatureVerifier] Failed to extract signature from fileHash")
+                return .failure(.invalidSignatureFormat)
+            }
+
+            // Rule: sig:... + public key NOT configured → REJECT
+            guard signingEnabled else {
+                IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "[SignatureVerifier] Signed bundle but public key not configured. Cannot verify.")
+                return .failure(.publicKeyNotConfigured)
+            }
+
+            // Rule: sig:... + public key configured → verify signature
+            return verifySignature(fileURL: fileURL, signatureBase64: signature)
+        } else {
+            // Unsigned format: <hex_hash>
+
+            // Rule: <hash> + public key configured → REJECT
+            if signingEnabled {
+                IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "[SignatureVerifier] Unsigned bundle not allowed when signing is enabled. Rejecting.")
+                return .failure(.unsignedNotAllowed)
+            }
+
+            // Rule: <hash> + public key NOT configured → verify hash
+            return verifyHash(fileURL: fileURL, expectedHash: hash)
+        }
+    }
+    
+    /**
+     * Verifies SHA256 hash of a file.
+     * @param fileURL URL of the file to verify
+     * @param expectedHash Expected SHA256 hash (hex string)
+     * @return Result indicating verification success or failure
+     */
+    public static func verifyHash(fileURL: URL, expectedHash: String) -> Result<Void, SignatureVerificationError> {
+        IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Verifying hash for file: \(fileURL.lastPathComponent)")
+
+        guard HashUtils.verifyHash(fileURL: fileURL, expectedHash: expectedHash) else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Hash mismatch!")
+            return .failure(.fileHashMismatch)
+        }
+
+        IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "✅ Hash verified successfully")
+        return .success(())
+    }
+    
+    /**
+     * Verifies RSA-SHA256 signature of a file.
+     * Calculates the file hash internally and verifies the signature.
+     *
+     * @param fileURL URL of the file to verify
+     * @param signatureBase64 Base64-encoded RSA-SHA256 signature
+     * @return Result indicating verification success or failure with error
+     */
+    public static func verifySignature(fileURL: URL, signatureBase64: String) -> Result<Void, SignatureVerificationError> {
+        
+        IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Verifying signature for file: \(fileURL.lastPathComponent)")
+
+        // Get public key from config
+        guard let publicKeyPEM = getPublicKeyFromConfig() else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Cannot verify signature: public key not configured in Info.plist")
+            return .failure(.publicKeyNotConfigured)
+        }
+
+        // Convert PEM to SecKey
+        let publicKeyResult = createPublicKey(from: publicKeyPEM)
+        guard case .success(let publicKey) = publicKeyResult else {
+            if case .failure(let error) = publicKeyResult {
+                return .failure(error)
+            }
+            return .failure(.invalidPublicKeyFormat)
+        }
+
+        // Calculate file hash
+        guard let fileHashHex = HashUtils.calculateSHA256(fileURL: fileURL) else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Failed to calculate file hash")
+            return .failure(.fileReadFailed)
+        }
+
+        IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Calculated file hash: \(fileHashHex)")
+
+        // Decode signature from base64
+        guard let signatureData = Data(base64Encoded: signatureBase64) else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Failed to decode signature from base64")
+            return .failure(.invalidSignatureFormat)
+        }
+
+        // Convert hex fileHash to data
+        guard let fileHashData = dataFromHexString(fileHashHex) else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Failed to convert fileHash from hex")
+            return .failure(.invalidSignatureFormat)
+        }
+
+        // Verify signature
+        let algorithm: SecKeyAlgorithm = .rsaSignatureMessagePKCS1v15SHA256
+
+        guard SecKeyIsAlgorithmSupported(publicKey, .verify, algorithm) else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "RSA-SHA256 algorithm not supported")
+            return .failure(.securityFrameworkError(-1))
+        }
+
+        var error: Unmanaged<CFError>?
+        let verified = SecKeyVerifySignature(
+            publicKey,
+            algorithm,
+            fileHashData as CFData,
+            signatureData as CFData,
+            &error
+        )
+
+        if let err = error?.takeRetainedValue() {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Verification failed: \(err)")
+            return .failure(.signatureVerificationFailed)
+        }
+
+        if verified {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "✅ Signature verified successfully")
+            return .success(())
+        } else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "❌ Signature verification failed")
+            return .failure(.signatureVerificationFailed)
+        }
+    }
+    
+    /**
+     * Converts PEM-formatted public key to SecKey.
+     * @param publicKeyPEM Public key in PEM format
+     * @return SecKey or error
+     */
+    private static func createPublicKey(from publicKeyPEM: String) -> Result<SecKey, SignatureVerificationError> {
+        // Remove PEM headers/footers and whitespace
+        var keyString = publicKeyPEM
+            .replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "-----END PUBLIC KEY-----", with: "")
+            .replacingOccurrences(of: "\\n", with: "")
+            .replacingOccurrences(of: "\n", with: "")
+            .replacingOccurrences(of: " ", with: "")
+
+        // Decode base64
+        guard let keyData = Data(base64Encoded: keyString) else {
+            IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "Failed to decode public key from base64")
+            return .failure(.invalidPublicKeyFormat)
+        }
+
+        // SecKeyCreateWithData auto-detects key size from SPKI-formatted key data.
+        // This supports any valid RSA key size (2048, 3072, 4096-bit, etc.)
+        let attributes: [String: Any] = [
+            kSecAttrKeyType as String: kSecAttrKeyTypeRSA,
+            kSecAttrKeyClass as String: kSecAttrKeyClassPublic
+        ]
+
+        var error: Unmanaged<CFError>?
+        guard let secKey = SecKeyCreateWithData(keyData as CFData, attributes as CFDictionary, &error) else {
+            if let err = error?.takeRetainedValue() {
+                IpayCodePushHelper.logPrint(classTag: CLASS_TAG, log: "SecKeyCreateWithData failed: \(err)")
+            }
+            return .failure(.invalidPublicKeyFormat)
+        }
+
+        return .success(secKey)
+    }
+    
+    /**
+     * Converts hex string to Data.
+     * @param hexString Hex-encoded string
+     * @return Data or nil if invalid format
+     */
+    private static func dataFromHexString(_ hexString: String) -> Data? {
+        var data = Data(capacity: hexString.count / 2)
+
+        var index = hexString.startIndex
+        while index < hexString.endIndex {
+            let nextIndex = hexString.index(index, offsetBy: 2)
+            guard nextIndex <= hexString.endIndex else { return nil }
+
+            let byteString = hexString[index..<nextIndex]
+            guard let byte = UInt8(byteString, radix: 16) else { return nil }
+
+            data.append(byte)
+            index = nextIndex
+        }
+
+        return data
+    }
+    
+    
+}

package/ios/URLSessionDownloadService.swift

@@ -0,0 +1,251 @@
+//
+//  URLSessionDownloadService.swift
+//  InstantpayCodePush
+//
+//  Created by Dhananjay kumar on 09/02/26.
+//
+
+import Foundation
+#if !os(macOS)
+import UIKit
+#endif
+
+protocol DownloadService {
+    /**
+     * Downloads a file from a URL.
+     * @param url The URL to download from
+     * @param destination The local path to save to
+     * @param fileSizeHandler Optional callback called when file size is known
+     * @param progressHandler Callback for download progress updates
+     * @param completion Callback with downloaded file URL or error
+     * @return The download task (optional)
+     */
+    func downloadFile(from url: URL, to destination: String, fileSizeHandler: ((Int64) -> Void)?, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask?
+}
+
+enum DownloadError: Error {
+    case incompleteDownload(expected: Int64, actual: Int64)
+    case invalidContentLength
+}
+
+// Task state for persistence and recovery
+struct TaskState: Codable {
+    let taskIdentifier: Int
+    let destination: String
+    let bundleId: String
+    let startedAt: TimeInterval
+}
+
+class URLSessionDownloadService: NSObject, DownloadService {
+    
+    private var session: URLSession!
+    private var backgroundSession: URLSession!
+    private var progressHandlers: [URLSessionTask: (Double) -> Void] = [:]
+    private var completionHandlers: [URLSessionTask: (Result<URL, Error>) -> Void] = [:]
+    private var destinations: [URLSessionTask: String] = [:]
+    private var fileSizeHandlers: [URLSessionTask: (Int64) -> Void] = [:]
+    private var taskStates: [Int: TaskState] = [:]
+    
+    override init() {
+        super.init()
+
+        // Foreground session (existing behavior)
+        let defaultConfig = URLSessionConfiguration.default
+        session = URLSession(configuration: defaultConfig, delegate: self, delegateQueue: nil)
+
+        // Background session for persistent downloads
+        let backgroundConfig = URLSessionConfiguration.background(
+            withIdentifier: "com.ipaycodepush.background.download"
+        )
+        backgroundConfig.isDiscretionary = false
+        backgroundConfig.sessionSendsLaunchEvents = true
+        backgroundSession = URLSession(configuration: backgroundConfig, delegate: self, delegateQueue: nil)
+
+        // Load persisted task states
+        taskStates = loadTaskStates()
+    }
+    
+    // MARK: - State Persistence
+    
+    private var stateFileURL: URL {
+        let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+        return documentsPath.appendingPathComponent("download-state.json")
+    }
+    
+    private func saveTaskState(_ state: TaskState) {
+        taskStates[state.taskIdentifier] = state
+
+        if let data = try? JSONEncoder().encode(taskStates) {
+            try? data.write(to: stateFileURL)
+        }
+    }
+    
+    private func loadTaskStates() -> [Int: TaskState] {
+        guard let data = try? Data(contentsOf: stateFileURL),
+              let states = try? JSONDecoder().decode([Int: TaskState].self, from: data) else {
+            return [:]
+        }
+        return states
+    }
+    
+    private func removeTaskState(_ taskIdentifier: Int) {
+        taskStates.removeValue(forKey: taskIdentifier)
+
+        if let data = try? JSONEncoder().encode(taskStates) {
+            try? data.write(to: stateFileURL)
+        }
+    }
+    
+    func downloadFile(from url: URL, to destination: String, fileSizeHandler: ((Int64) -> Void)?, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask? {
+        // Determine if we should use background session
+        #if !os(macOS)
+        let appState = UIApplication.shared.applicationState
+        let useBackgroundSession = (appState == .background || appState == .inactive)
+        #else
+        let useBackgroundSession = false
+        #endif
+
+        let selectedSession = useBackgroundSession ? backgroundSession : session
+        let task = selectedSession?.downloadTask(with: url)
+
+        guard let task = task else {
+            return nil
+        }
+
+        progressHandlers[task] = progressHandler
+        completionHandlers[task] = completion
+        destinations[task] = destination
+        if let handler = fileSizeHandler {
+            fileSizeHandlers[task] = handler
+        }
+
+        // Extract bundleId from destination path (e.g., "bundle-store/{bundleId}/bundle.zip")
+        let bundleId = (destination as NSString).pathComponents
+            .dropFirst()
+            .first(where: { $0 != "bundle-store" }) ?? "unknown"
+
+        // Save task metadata for background recovery
+        let taskState = TaskState(
+            taskIdentifier: task.taskIdentifier,
+            destination: destination,
+            bundleId: bundleId,
+            startedAt: Date().timeIntervalSince1970
+        )
+        saveTaskState(taskState)
+
+        task.resume()
+        return task
+    }
+}
+
+extension URLSessionDownloadService: URLSessionDownloadDelegate {
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        let completion = completionHandlers[downloadTask]
+        let destination = destinations[downloadTask]
+
+        defer {
+            progressHandlers.removeValue(forKey: downloadTask)
+            completionHandlers.removeValue(forKey: downloadTask)
+            destinations.removeValue(forKey: downloadTask)
+            fileSizeHandlers.removeValue(forKey: downloadTask)
+            removeTaskState(downloadTask.taskIdentifier)
+
+            // 다운로드 완료 알림
+            NotificationCenter.default.post(name: .downloadDidFinish, object: downloadTask)
+        }
+
+        guard let destination = destination else {
+            completion?(.failure(NSError(domain: "IpayCodePushError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Destination path not found"])))
+            return
+        }
+
+        // Verify file size
+        let expectedSize = downloadTask.response?.expectedContentLength ?? -1
+        let actualSize: Int64?
+        do {
+            let attributes = try FileManager.default.attributesOfItem(atPath: location.path)
+            actualSize = attributes[.size] as? Int64
+        } catch {
+            IpayCodePushHelper.logPrint(classTag: "DownloadService", log: "Failed to get file attributes: \(error.localizedDescription)")
+            actualSize = nil
+        }
+
+        if expectedSize > 0, let actualSize = actualSize, actualSize != expectedSize {
+            IpayCodePushHelper.logPrint(classTag: "DownloadService", log: "Download incomplete: \(actualSize) / \(expectedSize) bytes")
+            // Delete incomplete file
+            try? FileManager.default.removeItem(at: location)
+            completion?(.failure(DownloadError.incompleteDownload(expected: expectedSize, actual: actualSize)))
+            return
+        }
+
+        do {
+            let destinationURL = URL(fileURLWithPath: destination)
+
+            // Delete existing file if needed
+            if FileManager.default.fileExists(atPath: destination) {
+                try FileManager.default.removeItem(at: destinationURL)
+            }
+
+            try FileManager.default.copyItem(at: location, to: destinationURL)
+            
+            IpayCodePushHelper.logPrint(classTag: "DownloadService", log: "Download completed successfully: \(actualSize ?? 0) bytes")
+            
+            completion?(.success(destinationURL))
+        } catch {
+            
+            IpayCodePushHelper.logPrint(classTag: "DownloadService", log: "Failed to copy downloaded file: \(error.localizedDescription)")
+            
+            completion?(.failure(error))
+        }
+    }
+    
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        let completion = completionHandlers[task]
+        defer {
+            progressHandlers.removeValue(forKey: task)
+            completionHandlers.removeValue(forKey: task)
+            destinations.removeValue(forKey: task)
+            fileSizeHandlers.removeValue(forKey: task)
+            removeTaskState(task.taskIdentifier)
+
+            NotificationCenter.default.post(name: .downloadDidFinish, object: task)
+        }
+
+        if let error = error {
+            completion?(.failure(error))
+        }
+    }
+    
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
+        let progressHandler = progressHandlers[downloadTask]
+
+        // Call file size handler on first callback when size is known
+        if totalBytesWritten == bytesWritten && bytesWritten > 0 {
+            if let fileSizeHandler = fileSizeHandlers[downloadTask] {
+                if totalBytesExpectedToWrite > 0 {
+                    fileSizeHandler(totalBytesExpectedToWrite)
+                } else {
+                    
+                    IpayCodePushHelper.logPrint(classTag: "DownloadService", log: "Content-Length not available, proceeding without disk space check")
+                }
+                fileSizeHandlers.removeValue(forKey: downloadTask)
+            }
+        }
+
+        if totalBytesExpectedToWrite > 0 {
+            let progress = Double(totalBytesWritten) / Double(totalBytesExpectedToWrite)
+            progressHandler?(progress)
+
+            let progressInfo: [String: Any] = [
+                "progress": progress,
+                "totalBytesReceived": totalBytesWritten,
+                "totalBytesExpected": totalBytesExpectedToWrite
+            ]
+            NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: progressInfo)
+        } else {
+            progressHandler?(0)
+
+            NotificationCenter.default.post(name: .downloadProgressUpdate, object: downloadTask, userInfo: ["progress": 0.0, "totalBytesReceived": 0, "totalBytesExpected": 0])
+        }
+    }
+}