105 lines
4.9 KiB
Swift
105 lines
4.9 KiB
Swift
import Foundation
|
|
|
|
func values(_ input: String) -> [String: String] {
|
|
var result: [String: String] = [:]
|
|
for item in input.split(separator: ";") {
|
|
let pair = item.split(separator: "=", maxSplits: 1).map(String.init)
|
|
if pair.count == 2 { result[pair[0]] = pair[1] }
|
|
}
|
|
return result
|
|
}
|
|
|
|
func evaluate(_ kind: String, _ input: String) -> String {
|
|
let values = values(input)
|
|
switch kind {
|
|
case "version": return ["1", "0", "-1"].contains(input) ? "valid" : "invalid:unsupported_version"
|
|
case "page":
|
|
guard let raw = values["limit"], let limit = Int(raw), (1...100).contains(limit) else { return "invalid:invalid_limit" }
|
|
return "valid"
|
|
case "manifest":
|
|
for key in ["provider_url", "vm_address", "password", "private_key"] where values[key] != nil { return "invalid:forbidden_field" }
|
|
return values["version"] == "1" && values["gateway_id"] != nil && (values["grant"]?.utf8.count ?? 0) >= 43 && values["purpose"] == "launch" ? "valid" : "invalid:invalid_manifest"
|
|
case "clipboard": return values["encoding"] == "utf-8" && values["file"] == nil ? "valid" : "invalid:unsupported_clipboard"
|
|
case "event":
|
|
guard values["version"] == "1" else { return "invalid:unsupported_version" }
|
|
if let after = Int(values["after"] ?? ""), let earliest = Int(values["earliest"] ?? ""), after > 0, earliest > 0, after < earliest - 1 { return "invalid:gap" }
|
|
if (Int(values["payload_bytes"] ?? "") ?? Int.max) > 16384 { return "invalid:payload_limit" }
|
|
guard let sequence = Int(values["sequence"] ?? ""), sequence > 0, values["correlation_id"] != nil else { return "invalid:required" }
|
|
return "valid"
|
|
case "tunnel":
|
|
if ["1", "0", "-1"].contains(values["offered"] ?? "") && values["feature"] == "control.v1" { return "valid" }
|
|
return values["feature"] == "control.v1" ? "invalid:unsupported_version" : "invalid:unsupported_feature"
|
|
case "datagram": return classifyDatagram(values["hex"] ?? "")
|
|
default: return "invalid:unknown_kind"
|
|
}
|
|
}
|
|
|
|
func classifyDatagram(_ encoded: String) -> String {
|
|
let characters = Array(encoded)
|
|
guard characters.count % 2 == 0 else { return "invalid:hex" }
|
|
var raw: [UInt8] = []
|
|
for index in stride(from: 0, to: characters.count, by: 2) {
|
|
guard let byte = UInt8(String(characters[index...index + 1]), radix: 16) else { return "invalid:hex" }
|
|
raw.append(byte)
|
|
}
|
|
guard raw.count >= 21 else { return "invalid:truncated" }
|
|
guard raw[0] == 0x56 && raw[1] == 0x44 else { return "invalid:magic" }
|
|
guard raw[2] == 1 else { return "invalid:unsupported_version" }
|
|
let limit: Int
|
|
switch raw[3] {
|
|
case 1: limit = 1024
|
|
case 2: limit = 2048
|
|
case 3: limit = 65515
|
|
case 10, 11, 12: limit = 1179
|
|
default: return "invalid:unknown_channel"
|
|
}
|
|
guard raw[4] == 0 else { return "invalid:flags" }
|
|
guard raw[18] > 0 && raw[17] < raw[18] else { return "invalid:fragment" }
|
|
let payloadLength = Int(raw[19]) * 256 + Int(raw[20])
|
|
guard payloadLength <= limit else { return "invalid:payload_limit" }
|
|
guard raw.count == 21 + payloadLength else { return "invalid:length_mismatch" }
|
|
guard raw.count <= 65536 else { return "invalid:frame_limit" }
|
|
return "valid"
|
|
}
|
|
|
|
func normalizedDigest(_ results: [String]) -> String {
|
|
var value: UInt64 = 14695981039346656037
|
|
for result in results {
|
|
for byte in Array("\(result)\n".utf8) {
|
|
value ^= UInt64(byte)
|
|
value = value &* 1099511628211
|
|
}
|
|
}
|
|
return String(format: "%016llx", value)
|
|
}
|
|
|
|
func fixtureHash() -> String {
|
|
let text = try! String(contentsOfFile: "fixtures/manifest.json", encoding: .utf8)
|
|
let marker = "\"corpus_sha256\": \""
|
|
guard let start = text.range(of: marker)?.upperBound else { fatalError("fixture hash") }
|
|
let suffix = text[start...]
|
|
guard let end = suffix.firstIndex(of: "\"") else { fatalError("fixture hash") }
|
|
return String(suffix[..<end])
|
|
}
|
|
|
|
@main
|
|
struct ConformanceMain {
|
|
static func main() {
|
|
let names = try! FileManager.default.contentsOfDirectory(atPath: "fixtures/conformance").filter { $0.hasSuffix(".tsv") }.sorted()
|
|
var results: [String] = []
|
|
for name in names {
|
|
let text = try! String(contentsOfFile: "fixtures/conformance/\(name)", encoding: .utf8)
|
|
var lines = text.split(whereSeparator: \.isNewline).map(String.init)
|
|
precondition(lines.removeFirst() == "id\tversion\tkind\tinput\texpected")
|
|
for line in lines {
|
|
let fields = line.split(separator: "\t", omittingEmptySubsequences: false).map(String.init)
|
|
precondition(fields.count == 5)
|
|
let actual = evaluate(fields[2], fields[3])
|
|
precondition(actual == fields[4], fields[0])
|
|
results.append("\(fields[0])\t\(actual)")
|
|
}
|
|
}
|
|
print("Swift conformance passed normalized=\(normalizedDigest(results)) fixtures=\(fixtureHash())")
|
|
}
|
|
}
|