Don't treat a missing passphrase as a validation error (#648)

Author: mickael-menu

CHANGELOG.md

@@ -8,7 +8,7 @@ All notable changes to this project will be documented in this file. Take a look
 
 #### LCP
 
-* The LCP License Document is now accessible via `publication.lcpLicense?.license`, even if the license validation fails with a status error. This is useful for checking the end date of an expired license, for example.
+* The LCP License Document is now accessible via `publication.lcpLicense?.license`, even if the license validation fails with a status error or missing passphrase. This is useful for checking the end date of an expired license or renew a license.
 
 
 ## [3.4.0]

Sources/LCP/Content Protection/LCPContentProtection.swift

@@ -156,7 +156,7 @@ private final class LCPContentProtectionService: ContentProtectionService {
 
     init(license: LCPLicense? = nil, error: Error? = nil) {
         self.license = license
-        self.error = error ?? license?.error.map { LCPError.licenseStatus($0) }
+        self.error = error ?? license?.error
     }
 
     convenience init(result: Result<LCPLicense, LCPError>) {

Sources/LCP/LCPLicense.swift

@@ -17,9 +17,10 @@ public protocol LCPLicense: UserRights {
     /// The license is restricted if there is a status error.
     var isRestricted: Bool { get }
 
-    /// Status error detected while validating the license, e.g. if the license
-    /// is expired or revoked.
-    var error: StatusError? { get }
+    /// Error detected after validating the license, which prevents the user
+    /// from decrypting the book. For example, the license is expired/revoked
+    /// or the passphrase was not provided.
+    var error: LCPError? { get }
 
     /// Deciphers the given encrypted data to be displayed in the reader.
     func decipher(_ data: Data) throws -> Data?

Sources/LCP/License/License.swift

@@ -28,7 +28,7 @@ final class License: Loggable {
         self.httpClient = httpClient
 
         validation.observe { [weak self] result in
-            if case let .success(documents) = result, let documents = documents {
+            if case let .success(documents) = result {
                 self?.documents = documents
             }
         }
@@ -46,15 +46,22 @@ extension License: LCPLicense {
     }
 
     public var isRestricted: Bool {
-        error != nil
+        documents.context.getOrNil() == nil
     }
 
-    public var error: StatusError? {
+    public var error: LCPError? {
         switch documents.context {
         case .success:
             return nil
         case let .failure(error):
-            return error
+            switch error {
+            // We don't report the missingPassphrase case as an error
+            // because in this case the user cancelled the passphrase prompt.
+            case .missingPassphrase:
+                return nil
+            default:
+                return error
+            }
         }
     }
 

Sources/LCP/License/LicenseValidation.swift

@@ -23,7 +23,7 @@ private let supportedProfiles = [
     "http://readium.org/lcp/profile-2.9",
 ]
 
-typealias Context = Result<LCPClientContext, StatusError>
+typealias Context = Result<LCPClientContext, LCPError>
 
 // Holds the License/Status Documents and the DRM context, once validated.
 struct ValidatedDocuments {
@@ -98,7 +98,7 @@ final actor LicenseValidation: Loggable {
 
     /// Validates the given License or Status Document.
     /// If a validation is already running, `LCPError.licenseIsBusy` will be reported.
-    func validate(_ document: Document) async throws -> ValidatedDocuments? {
+    func validate(_ document: Document) async throws -> ValidatedDocuments {
         let event: Event
         switch document {
         case let .license(data):
@@ -186,7 +186,7 @@ extension LicenseValidation {
             // 4. Check the dates and license status
             case let (.checkLicenseStatus(license, status, _), .checkedLicenseStatus(error)):
                 if let error = error {
-                    self = .valid(ValidatedDocuments(license, .failure(error), status))
+                    self = .valid(ValidatedDocuments(license, .failure(.licenseStatus(error)), status))
                 } else {
                     self = .requestPassphrase(license, status)
                 }
@@ -196,8 +196,8 @@ extension LicenseValidation {
                 self = .validateIntegrity(license, status, passphrase: passphrase)
             case let (.requestPassphrase, .failed(error)):
                 self = .failure(error)
-            case (.requestPassphrase, .cancelled):
-                self = .start
+            case let (.requestPassphrase(license, status), .passphraseNotFound):
+                self = .valid(ValidatedDocuments(license, .failure(.missingPassphrase), status))
 
             // 6. Validate the license integrity
             case let (.validateIntegrity(license, status, _), .validatedIntegrity(context)):
@@ -254,8 +254,8 @@ extension LicenseValidation {
         case registeredDevice(Data?)
         // Raised when any error occurs during the validation workflow.
         case failed(Error)
-        // Raised when the user cancelled the validation.
-        case cancelled
+        // Raised when no passphrase could be found or given by the user.
+        case passphraseNotFound
     }
 
     /// Should be called by the state handlers once they're done, to go to the next State.
@@ -358,7 +358,7 @@ extension LicenseValidation {
         ) {
             try await raise(.retrievedPassphrase(passphrase))
         } else {
-            try await raise(.cancelled)
+            try await raise(.passphraseNotFound)
         }
     }
 
@@ -386,8 +386,8 @@ extension LicenseValidation {
         do {
             switch state {
             case .start:
-                // We are back to start? It means the validation was cancelled by the user.
-                notifyObservers(.success(nil))
+                // We are back to start? This should not happen.
+                throw LCPError.runtime("Unexpected license validation state")
             case let .validateLicense(data, _):
                 try await validateLicense(data: data)
             case let .fetchStatus(license):
@@ -417,7 +417,7 @@ extension LicenseValidation {
 
 /// Validation observers
 extension LicenseValidation {
-    typealias Observer = (Result<ValidatedDocuments?, Error>) -> Void
+    typealias Observer = (Result<ValidatedDocuments, Error>) -> Void
 
     enum ObserverPolicy {
         // The observer is automatically removed when called.
@@ -450,15 +450,15 @@ extension LicenseValidation {
         observers.append((observer, policy))
     }
 
-    func observe() async throws -> ValidatedDocuments? {
+    func observe() async throws -> ValidatedDocuments {
         try await withCheckedThrowingContinuation { continuation in
             observe(.once) { result in
                 continuation.resume(with: result)
             }
         }
     }
 
-    private func notifyObservers(_ result: Result<ValidatedDocuments?, Error>) {
+    private func notifyObservers(_ result: Result<ValidatedDocuments, Error>) {
         for observer in observers {
             observer.callback(result)
         }

Sources/LCP/Services/LicensesService.swift

@@ -98,9 +98,7 @@ final class LicensesService: Loggable {
             onLicenseValidated: onLicenseValidated
         )
 
-        guard let documents = try await validation.validate(.license(initialData)) else {
-            throw LCPError.missingPassphrase
-        }
+        let documents = try await validation.validate(.license(initialData))
 
         return License(documents: documents, client: client, validation: validation, licenses: licenses, device: device, httpClient: httpClient)
     }