OSC-10 (#12)

- During parsing of both the address pattern and type tag string, checks are made so that we don’t parse any invalid characters.
- Fixed crash with not closed brackets and curly braces e.g. "/core/[o-" and "/core/{osc"
- Fixed crash with asterisk wildcard e.g. "/core/*sc"

Sources/CoreOSC/CoreOSC.swift

@@ -26,7 +26,7 @@ import Foundation
 public enum CoreOSC {
 
     /// This package's semantic version number, mirrored also in git history as a `git tag`.
-    public static let version: String = "1.3.0"
+    public static let version: String = "1.3.1"
 
     /// The license agreement this repository is licensed under.
     public static let license: String = {

Sources/CoreOSC/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright © 2022 Sam Smallman. https://github.com/SammySmallman
+Copyright © 2023 Sam Smallman. https://github.com/SammySmallman
 
 This file is part of CoreOSC
 

Sources/CoreOSC/OSCMatch.swift

@@ -78,8 +78,8 @@ public enum OSCMatch {
                                             addressCharacterOffset: &addressCharacterOffset)
                 if match == false {
                     if patternCharacterOffset != addressPattern.endIndex &&
-                       addressPattern.index(after: patternCharacterOffset) == addressPattern.endIndex &&
-                       addressPattern[patternCharacterOffset] == "]" {
+                        addressPattern.index(after: patternCharacterOffset) == addressPattern.endIndex &&
+                        addressPattern[patternCharacterOffset] == "]" {
                         return OSCPatternMatch(match: .unmatched,
                                                patternCharactersMatched: addressPattern.distance(from: addressPattern.startIndex,
                                                                                                  to: addressPattern.endIndex),
@@ -118,7 +118,6 @@ public enum OSCMatch {
                                    patternCharactersMatched: 0,
                                    addressCharactersMatched: 0)
         }
-
         return OSCPatternMatch(match: matching,
                                patternCharactersMatched:
                                 addressPattern.distance(from: addressPattern.startIndex,
@@ -141,37 +140,19 @@ public enum OSCMatch {
                                       patternCharacterOffset: inout String.Index,
                                       address: String,
                                       addressCharacterOffset: inout String.Index) -> Bool {
-        var numberOfAsterisks = 0
         if addressCharacterOffset == address.endIndex { return false }
+        // Move address index up to next "/"
         while addressCharacterOffset != address.endIndex &&
               address[addressCharacterOffset] != "/" {
             addressCharacterOffset = address.index(after: addressCharacterOffset)
         }
+        // Move pattern index up to next "/"
         while patternCharacterOffset != pattern.endIndex &&
               pattern[patternCharacterOffset] != "/" {
-            if pattern[patternCharacterOffset] == "*" {
-                numberOfAsterisks += 1
-            }
             patternCharacterOffset = pattern.index(after: patternCharacterOffset)
         }
 
-        patternCharacterOffset = pattern.index(before: patternCharacterOffset)
-        addressCharacterOffset = address.index(before: addressCharacterOffset)
-        switch numberOfAsterisks {
-        case 1:
-            var casePatternCharacterOffset: String.Index = patternCharacterOffset
-            var caseAddressCharacterOffsetStart: String.Index = addressCharacterOffset
-            while pattern[casePatternCharacterOffset] != "*" {
-                if matchCharacters(pattern: pattern,
-                                   patternCharacterOffset: &casePatternCharacterOffset,
-                                   address: address,
-                                   addressCharacterOffset: &caseAddressCharacterOffsetStart) == false {
-                    return false
-                }
-            }
-            break
-        default: return false
-        }
+        // TODO: Match patterns backwards if the last character before the "/" is not a "*"
         return true
     }
 
@@ -224,17 +205,19 @@ public enum OSCMatch {
         while patternCharacterOffset != pattern.endIndex &&
               pattern[patternCharacterOffset] != "]" {
             if pattern[pattern.index(after: patternCharacterOffset)] == "-" {
-                if address[addressCharacterOffset].asciiValue! >= pattern[patternCharacterOffset].asciiValue! &&
-                   address[addressCharacterOffset].asciiValue! <= pattern[pattern.index(patternCharacterOffset,
-                                                                                        offsetBy: 2)].asciiValue! {
+                if address[addressCharacterOffset].asciiValue! >= pattern[patternCharacterOffset].asciiValue!,
+                   let index = pattern.index(patternCharacterOffset, offsetBy: 2, limitedBy: pattern.index(before: pattern.endIndex)),
+                   address[addressCharacterOffset].asciiValue! <= pattern[index].asciiValue! {
                     matched = val
                     while patternCharacterOffset != pattern.endIndex &&
                           pattern[patternCharacterOffset] != "]" {
                         patternCharacterOffset = pattern.index(after: patternCharacterOffset)
                     }
                     break
+                } else if let index = pattern.index(patternCharacterOffset, offsetBy: 3, limitedBy: pattern.index(before: pattern.endIndex)) {
+                    patternCharacterOffset = index
                 } else {
-                    patternCharacterOffset = pattern.index(patternCharacterOffset, offsetBy: 3)
+                    return false
                 }
             } else {
                 if pattern[patternCharacterOffset] == address[addressCharacterOffset] {
@@ -283,8 +266,12 @@ public enum OSCMatch {
                       pattern[offset] != "/" {
                     offset = pattern.index(after: offset)
                 }
-                patternCharacterOffset = offset
+                if pattern.endIndex == pattern.index(patternCharacterOffset, offsetBy: distance) || pattern[offset] != "}" {
+                    patternCharacterOffset = startIndex
+                    return false
+                }
                 addressCharacterOffset = address.index(addressCharacterOffset, offsetBy: distance - 1)
+                patternCharacterOffset = offset
                 return true
             } else {
                 offset = pattern.index(after: offset)

Sources/CoreOSC/OSCParser.swift

@@ -59,7 +59,7 @@ public enum OSCParser {
     private static func process(bundle data: Data) throws -> OSCPacket {
         return try parseOSCBundle(with: data)
     }
-    
+
     /// Parse `OSCMessage` data.
     /// - Parameters:
     ///   - data: The `Data` to parse.
@@ -68,12 +68,27 @@ public enum OSCParser {
     /// - Returns: An `OSCMessage`.
     private static func parseOSCMessage(with data: Data, startIndex: inout Int) throws -> OSCMessage {
         guard let addressPattern = parse(string: data,
-                                         startIndex: &startIndex) else {
+                                         startIndex: &startIndex,
+                                         characters: .invalid(bytes: [
+                                            0x20, // Space - ' '
+                                            0x23  // Hash - #
+                                         ])) else {
             throw OSCParserError.cantParseAddressPattern
         }
-
         guard var typeTagString = parse(string: data,
-                                        startIndex: &startIndex) else {
+                                        startIndex: &startIndex,
+                                        characters: .valid(bytes: [
+                                            0x2C, // Comma - ,
+                                            0x73, // s
+                                            0x69, // i
+                                            0x66, // f
+                                            0x62, // b
+                                            0x74, // t
+                                            0x54, // T
+                                            0x46, // F
+                                            0x4E, // N
+                                            0x49  // I
+                                        ])) else {
             throw OSCParserError.cantParseTypeTagString
         }
 
@@ -124,7 +139,8 @@ public enum OSCParser {
                 case .oscTypeTagImpulse:
                     arguments.append(OSCArgument.impulse)
                 default:
-                    continue
+                    // We shouldn't ever get here as we've checked the type tag string for invalid characters.
+                    throw OSCParserError.cantParseTypeTagString
                 }
             }
         }
@@ -213,28 +229,48 @@ public enum OSCParser {
         } while buffer < size
         return elements
     }
-
+
+    /// ASCII Characters that are either valid or invalid when parsing an OSC string.
+    enum OSCCharacters {
+        /// A collection of valid ASCII characters.
+        case valid(bytes: Set<UInt8>)
+        /// A collection of invalid ASCII characters.
+        case invalid(bytes: Set<UInt8>)
+    }
+
     /// Parse OSC string data.
     /// - Parameters:
     ///   - data: The `Data` to parse.
     ///   - startIndex: The index of where to start parsing from in the `Data`.
     /// - Returns: A `String` or nil if an OSC string could not be parsed with the given data.
-    private static func parse(string data: Data, startIndex: inout Int) -> String? {
+    private static func parse(string data: Data, startIndex: inout Int, characters: OSCCharacters? = nil) -> String? {
         // Read the data from the start index until you hit a zero, the part before will be the string data.
-        for (index, byte) in data[startIndex...].enumerated() where byte == 0x0 {
-            guard let result = String(data: data[startIndex..<(startIndex + index)],
-                                      encoding: .utf8) else { return nil }
-             // An OSC String is a sequence of non-null ASCII characters followed by a null,
-             // followed by 0-3 additional null characters to make the total number
-             // of bits a multiple of 32 Bits, 4 Bytes.
-            let bytesRead = startIndex + index + 1 // Include the Null bytes we found.
-            if bytesRead.isMultiple(of: 4) {
-                startIndex = bytesRead
-            } else {
-                let number = (Double(bytesRead) / 4.0).rounded(.up)
-                startIndex = Int(4.0 * number)
+        for (index, byte) in data[startIndex...].enumerated() {
+            if byte == 0x0 {
+                guard let result = String(data: data[startIndex..<(startIndex + index)],
+                                          encoding: .utf8) else { return nil }
+                 // An OSC String is a sequence of non-null ASCII characters followed by a null,
+                 // followed by 0-3 additional null characters to make the total number
+                 // of bits a multiple of 32 Bits, 4 Bytes.
+                let bytesRead = startIndex + index + 1 // Include the Null bytes we found.
+                if bytesRead.isMultiple(of: 4) {
+                    startIndex = bytesRead
+                } else {
+                    let number = (Double(bytesRead) / 4.0).rounded(.up)
+                    startIndex = Int(4.0 * number)
+                }
+                return result
+
+            } else if let characters = characters {
+                switch characters {
+                case .valid(let bytes):
+                    // ,sifbtTFNI are the only characters valid in an OSC Type Tag string.
+                    if !bytes.contains(byte) { return nil }
+                case .invalid(let bytes):
+                    // Space and Hash characters are invalid in an OSC Address Pattern.
+                    if bytes.contains(byte) { return nil }
+                }
             }
-            return result
         }
         return nil
     }

Sources/CoreOSC/en.lproj/Localizable.strings

@@ -1,7 +1,7 @@
 /* OSC Address Error */
 
 /* OSC Version */
-"OSC_VERSION" = "1.3.0";
+"OSC_VERSION" = "1.3.1";
 
 /* OSC Address Error: Invalid Address */
 "OSC_ADDRESS_ERROR_INVALID_ADDRESS" = "Invalid address";

Tests/CoreOSCTests/CoreOSCTests.swift

@@ -29,13 +29,13 @@ import XCTest
 class CoreOSCTests: XCTestCase {
 
     func testVersion() {
-        XCTAssertEqual(CoreOSC.version, "1.3.0")
+        XCTAssertEqual(CoreOSC.version, "1.3.1")
         XCTAssertEqual(NSLocalizedString("OSC_VERSION", bundle: .module, comment: "OSC Version"), CoreOSC.version)
     }
 
     func testLicense() {
         let license = CoreOSC.license
-        XCTAssertTrue(license.hasPrefix("Copyright © 2022 Sam Smallman. https://github.com/SammySmallman"))
+        XCTAssertTrue(license.hasPrefix("Copyright © 2023 Sam Smallman. https://github.com/SammySmallman"))
         XCTAssertTrue(license.hasSuffix("<https://www.gnu.org/licenses/why-not-lgpl.html>.\n"))
     }
 

Tests/CoreOSCTests/OSCMatchTests.swift

@@ -68,6 +68,18 @@ final class OSCMatchTests: XCTestCase {
                        OSCPatternMatch(match: .fullMatch,
                                        patternCharactersMatched: "/*/*/*".count,
                                        addressCharactersMatched: "/abc/def/hij".count))
+
+        XCTAssertEqual(OSCMatch.match(addressPattern: "/abc/*",
+                                      address: "/abc/def"),
+                       OSCPatternMatch(match: .fullMatch,
+                                       patternCharactersMatched: "/abc/*".count,
+                                       addressCharactersMatched: "/abc/def".count))
+
+        XCTAssertEqual(OSCMatch.match(addressPattern: "/a/*cd",
+                                      address: "/a/bcd"),
+                       OSCPatternMatch(match: .fullMatch,
+                                       patternCharactersMatched: "/a/*cd".count,
+                                       addressCharactersMatched: "/a/bcd".count))
     }
 
     func testAsteriskPartialAddressMatch() {
@@ -85,15 +97,23 @@ final class OSCMatchTests: XCTestCase {
                                        patternCharactersMatched: "/a/b/c".count,
                                        addressCharactersMatched: "/a/b/c".count))
     }
-    
+
     func testAsteriskUnmatched() {
         XCTAssertEqual(OSCMatch.match(addressPattern: "/*/abc",
                                       address: "/abc/def"),
                        OSCPatternMatch(match: .unmatched,
                                        patternCharactersMatched: "/*/".count,
                                        addressCharactersMatched: "/abc/".count))
+
+// TODO: Match patterns backwards if the last character before the "/" is not a "*"
+// OSCMatch.swift:156
+//        XCTAssertEqual(OSCMatch.match(addressPattern: "/a/*cd",
+//                                      address: "/a/bef"),
+//                       OSCPatternMatch(match: .unmatched,
+//                                       patternCharactersMatched: "/a/*".count,
+//                                       addressCharactersMatched: "/a/b".count))
     }
-    
+
     // MARK: - Question Mark Wildcard OSC Address Pattern Tests
 
     func testQuestionMarkFullMatch() {
@@ -257,7 +277,21 @@ final class OSCMatchTests: XCTestCase {
                                        patternCharactersMatched: "/abc/[!d-f]".count,
                                        addressCharactersMatched: "/abc/".count))
     }
-
+
+    func testInvalidSquareBracketsNotClosed() {
+        XCTAssertEqual(OSCMatch.match(addressPattern: "/abc/[d-",
+                                      address: "/abc/d"),
+                       OSCPatternMatch(match: .unmatched,
+                                       patternCharactersMatched: "/abc/[".count,
+                                       addressCharactersMatched: "/abc/".count))
+
+        XCTAssertEqual(OSCMatch.match(addressPattern: "/abc/[!d-",
+                                      address: "/abc/d"),
+                       OSCPatternMatch(match: .unmatched,
+                                       patternCharactersMatched: "/abc/[!".count,
+                                       addressCharactersMatched: "/abc/".count))
+    }
+
     // MARK: - Curly Braces Wildcard OSC Address Pattern Tests
 
     func testCurlyBracesFullMatch() {
@@ -284,14 +318,34 @@ final class OSCMatchTests: XCTestCase {
                                        addressCharactersMatched: "/abc".count))
     }
 
-    func testCurlyBraceUnmatched() {
+    func testCurlyBracesUnmatched() {
         XCTAssertEqual(OSCMatch.match(addressPattern: "/{abc,def}/{ghi,jkl}",
                                       address: "/abc/mno"),
                        OSCPatternMatch(match: .unmatched,
                                        patternCharactersMatched: "/{abc,def}/".count,
                                        addressCharactersMatched: "/abc/".count))
     }
-
+
+    func testInvalidCurlyBracesNotClosed() {
+        XCTAssertEqual(OSCMatch.match(addressPattern: "/abc/{d",
+                                      address: "/abc/d"),
+                       OSCPatternMatch(match: .unmatched,
+                                       patternCharactersMatched: "/abc/".count,
+                                       addressCharactersMatched: "/abc/".count))
+
+        XCTAssertEqual(OSCMatch.match(addressPattern: "/abc/{d/ghi",
+                                      address: "/abc/d/g"),
+                       OSCPatternMatch(match: .unmatched,
+                                       patternCharactersMatched: "/abc/".count,
+                                       addressCharactersMatched: "/abc/".count))
+
+        XCTAssertEqual(OSCMatch.match(addressPattern: "/{a}/{d/g",
+                                      address: "/a/d/g"),
+                       OSCPatternMatch(match: .unmatched,
+                                       patternCharactersMatched: "/{a}/".count,
+                                       addressCharactersMatched: "/a/".count))
+    }
+
     // MARK: - All Wildcards OSC Address Pattern Tests
 
     func testAllWildcardsFullMatch() {