apple_kit

Apple-native services for Radroots iOS and macOS apps
git clone https://radroots.dev/git/apple_kit.git
Log | Files | Refs | README | LICENSE

RadrootsBackgroundTransferValidation.swift (8320B)


      1 import Foundation
      2 
      3 public enum RadrootsBackgroundTransferValidation {
      4     public static func normalizedIdentifier(_ value: String) throws -> String {
      5         let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
      6         guard !trimmed.isEmpty else {
      7             throw RadrootsBackgroundTransferError.invalidRequest
      8         }
      9         guard trimmed.count <= 128 else {
     10             throw RadrootsBackgroundTransferError.invalidRequest
     11         }
     12         guard
     13             trimmed.range(
     14                 of: "^[a-z0-9][a-z0-9._-]*[a-z0-9]$|^[a-z0-9]$", options: .regularExpression)
     15                 != nil
     16         else {
     17             throw RadrootsBackgroundTransferError.invalidRequest
     18         }
     19         guard !trimmed.contains("..") else {
     20             throw RadrootsBackgroundTransferError.invalidRequest
     21         }
     22         return trimmed
     23     }
     24 
     25     public static func validate(
     26         remoteURL: URL, method: RadrootsBackgroundTransferMethod,
     27         operation: RadrootsBackgroundTransferOperation, headers: [String: String],
     28         metadata: [String: String], networkPolicy: RadrootsBackgroundTransferNetworkPolicy,
     29         responsePolicy: RadrootsBackgroundTransferResponsePolicy, expectedSourceSHA256: String?,
     30         maximumTransferBytes: UInt64
     31     ) throws {
     32         try validate(remoteURL: remoteURL, networkPolicy: networkPolicy)
     33         try validate(method: method, operation: operation)
     34         try validate(headers: headers)
     35         try validate(metadata: metadata)
     36         guard maximumTransferBytes > 0,
     37             maximumTransferBytes <= RadrootsBackgroundTransferRequest.absoluteMaximumTransferBytes
     38         else {
     39             throw RadrootsBackgroundTransferError.invalidRequest
     40         }
     41         if case .download = operation, responsePolicy != .discard {
     42             throw RadrootsBackgroundTransferError.invalidRequest
     43         }
     44         if let expectedSourceSHA256 {
     45             guard case .upload = operation,
     46                 expectedSourceSHA256.range(of: "^[0-9a-f]{64}$", options: .regularExpression) != nil
     47             else {
     48                 throw RadrootsBackgroundTransferError.invalidRequest
     49             }
     50         }
     51         if case .upload(.stagedBlob(let blob)) = operation,
     52             UInt64(blob.sizeBytes) > maximumTransferBytes
     53         {
     54             throw RadrootsBackgroundTransferError.invalidRequest
     55         }
     56     }
     57 
     58     private static func validate(
     59         remoteURL: URL, networkPolicy: RadrootsBackgroundTransferNetworkPolicy
     60     ) throws {
     61         try RadrootsNativeDestinationPolicy.validate(remoteURL, policy: networkPolicy)
     62     }
     63 
     64     private static func validate(
     65         method: RadrootsBackgroundTransferMethod, operation: RadrootsBackgroundTransferOperation
     66     ) throws {
     67         switch operation {
     68         case .download(let destination):
     69             guard method == .get else {
     70                 throw RadrootsBackgroundTransferError.invalidRequest
     71             }
     72             guard case .file = destination else {
     73                 throw RadrootsBackgroundTransferError.invalidRequest
     74             }
     75             try validateLocalFile(destination)
     76         case .upload(let source):
     77             guard method == .post || method == .put else {
     78                 throw RadrootsBackgroundTransferError.invalidRequest
     79             }
     80             try validateLocalFile(source)
     81         }
     82     }
     83 
     84     static func validateLocalFile(_ localFile: RadrootsBackgroundTransferLocalFile) throws {
     85         switch localFile {
     86         case .file(let reference):
     87             let path = reference.relativePath.trimmingCharacters(in: .whitespacesAndNewlines)
     88             guard !path.isEmpty, !NSString(string: path).isAbsolutePath,
     89                 !path.split(separator: "/", omittingEmptySubsequences: false).contains(where: {
     90                     $0 == ".."
     91                 })
     92             else {
     93                 throw RadrootsBackgroundTransferError.invalidRequest
     94             }
     95         case .stagedBlob(let blob):
     96             guard
     97                 (try? RadrootsStagedBlobReference(
     98                     blobID: blob.blobID, sizeBytes: blob.sizeBytes, mediaType: blob.mediaType,
     99                     filenameHint: blob.filenameHint
    100                 )) != nil
    101             else {
    102                 throw RadrootsBackgroundTransferError.invalidRequest
    103             }
    104         }
    105     }
    106 
    107     private static func validate(headers: [String: String]) throws {
    108         guard headers.count <= 32 else {
    109             throw RadrootsBackgroundTransferError.invalidRequest
    110         }
    111         for (key, value) in headers {
    112             try validateSafeText(key, field: "background transfer header name", maximumLength: 80)
    113             guard
    114                 key.range(of: "^[!#$%&'*+.^_`|~0-9A-Za-z-]+$", options: .regularExpression) != nil,
    115                 !["connection", "content-length", "host", "transfer-encoding"].contains(
    116                     key.lowercased())
    117             else {
    118                 throw RadrootsBackgroundTransferError.invalidRequest
    119             }
    120             try validateSafeText(
    121                 value, field: "background transfer header value", maximumLength: 8192)
    122         }
    123     }
    124 
    125     private static func validate(metadata: [String: String]) throws {
    126         guard metadata.count <= 32 else {
    127             throw RadrootsBackgroundTransferError.invalidRequest
    128         }
    129         for (key, value) in metadata {
    130             try validateSafeText(key, field: "background transfer metadata key", maximumLength: 80)
    131             try validateSafeText(
    132                 value, field: "background transfer metadata value", maximumLength: 500)
    133             let unsafeKey = key.lowercased()
    134             guard
    135                 !["auth", "token", "secret", "credential", "cookie", "header", "path", "url"]
    136                     .contains(
    137                         where: { unsafeKey.contains($0) }
    138                     )
    139             else {
    140                 throw RadrootsBackgroundTransferError.invalidRequest
    141             }
    142         }
    143     }
    144 
    145     static func normalizedMediaType(_ value: String) throws -> String {
    146         let normalized =
    147             value.split(separator: ";", maxSplits: 1).first?.trimmingCharacters(
    148                 in: .whitespacesAndNewlines
    149             ).lowercased() ?? ""
    150         guard
    151             normalized.range(
    152                 of: "^[a-z0-9!#$&^_.+-]+/[a-z0-9!#$&^_.+-]+$", options: .regularExpression)
    153                 != nil,
    154             normalized.utf8.count <= 127
    155         else {
    156             throw RadrootsBackgroundTransferError.invalidRequest
    157         }
    158         return normalized
    159     }
    160 
    161     static func validate(
    162         response: RadrootsBackgroundTransferResponse,
    163         policy: RadrootsBackgroundTransferResponsePolicy
    164     ) throws {
    165         guard (200...299).contains(response.statusCode) else {
    166             throw RadrootsBackgroundTransferError.invalidRequest
    167         }
    168         if policy.maximumBodyBytes == 0 {
    169             guard response.body == nil, response.mediaType == nil else {
    170                 throw RadrootsBackgroundTransferError.invalidRequest
    171             }
    172             return
    173         }
    174         guard let body = response.body, body.count <= policy.maximumBodyBytes,
    175             let mediaType = response.mediaType,
    176             policy.acceptedMediaTypes.contains(mediaType)
    177         else {
    178             throw RadrootsBackgroundTransferError.invalidRequest
    179         }
    180         if mediaType == "application/json" {
    181             guard (try? JSONSerialization.jsonObject(with: body)) is [String: Any] else {
    182                 throw RadrootsBackgroundTransferError.invalidRequest
    183             }
    184         }
    185     }
    186 
    187     private static func validateSafeText(_ value: String, field _: String, maximumLength: Int)
    188         throws
    189     {
    190         let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
    191         guard !trimmed.isEmpty else {
    192             throw RadrootsBackgroundTransferError.invalidRequest
    193         }
    194         guard value.count <= maximumLength else {
    195             throw RadrootsBackgroundTransferError.invalidRequest
    196         }
    197         guard doesNotContainControlCharacters(value) else {
    198             throw RadrootsBackgroundTransferError.invalidRequest
    199         }
    200     }
    201 
    202     private static func doesNotContainControlCharacters(_ value: String) -> Bool {
    203         value.unicodeScalars.allSatisfy { !CharacterSet.controlCharacters.contains($0) }
    204     }
    205 }