The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | // @effect-diagnostics nodeBuiltinImport:off - Hand-builds Safari's binary jar |
| 2 | // format byte by byte. |
| 3 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 4 | import { assert, describe, expect, it } from "@effect/vitest"; |
| 5 | import * as Effect from "effect/Effect"; |
| 6 | import * as FileSystem from "effect/FileSystem"; |
| 7 | import * as PlatformError from "effect/PlatformError"; |
| 8 | |
| 9 | import { |
| 10 | isPermissionDenied, |
| 11 | parseBinaryCookies, |
| 12 | readSafariCookies, |
| 13 | safariAccessDenied, |
| 14 | SafariCookieReadError, |
| 15 | } from "./SafariCookies.ts"; |
| 16 | |
| 17 | const APPLE_EPOCH_OFFSET_SECONDS = 978_307_200; |
| 18 | |
| 19 | interface FixtureCookie { |
| 20 | readonly domain: string; |
| 21 | readonly name: string; |
| 22 | readonly path: string; |
| 23 | readonly value: string; |
| 24 | readonly flags: number; |
| 25 | readonly expiry: number; |
| 26 | } |
| 27 | |
| 28 | function encodeCookie(cookie: FixtureCookie): Buffer { |
| 29 | const strings = [cookie.domain, cookie.name, cookie.path, cookie.value]; |
| 30 | const headerSize = 56; |
| 31 | const offsets: number[] = []; |
| 32 | let cursor = headerSize; |
| 33 | for (const value of strings) { |
| 34 | offsets.push(cursor); |
| 35 | cursor += Buffer.byteLength(value) + 1; |
| 36 | } |
| 37 | const size = cursor; |
| 38 | |
| 39 | const buffer = Buffer.alloc(size); |
| 40 | buffer.writeUInt32LE(size, 0); |
| 41 | buffer.writeUInt32LE(0, 4); |
| 42 | buffer.writeUInt32LE(cookie.flags, 8); |
| 43 | buffer.writeUInt32LE(0, 12); |
| 44 | buffer.writeUInt32LE(offsets[0]!, 16); |
| 45 | buffer.writeUInt32LE(offsets[1]!, 20); |
| 46 | buffer.writeUInt32LE(offsets[2]!, 24); |
| 47 | buffer.writeUInt32LE(offsets[3]!, 28); |
| 48 | buffer.writeUInt32LE(0, 32); |
| 49 | buffer.writeUInt32LE(0, 36); |
| 50 | buffer.writeDoubleLE(cookie.expiry, 40); |
| 51 | buffer.writeDoubleLE(0, 48); |
| 52 | strings.forEach((value, index) => { |
| 53 | buffer.write(value, offsets[index]!, "utf8"); |
| 54 | }); |
| 55 | return buffer; |
| 56 | } |
| 57 | |
| 58 | function encodeBinaryCookies(cookies: ReadonlyArray<FixtureCookie>): Buffer { |
| 59 | const encoded = cookies.map(encodeCookie); |
| 60 | const headerSize = 12 + encoded.length * 4; |
| 61 | const offsets: number[] = []; |
| 62 | let cursor = headerSize; |
| 63 | for (const cookie of encoded) { |
| 64 | offsets.push(cursor); |
| 65 | cursor += cookie.length; |
| 66 | } |
| 67 | |
| 68 | const page = Buffer.alloc(cursor); |
| 69 | page.writeUInt32BE(0x0000_0100, 0); |
| 70 | page.writeUInt32LE(encoded.length, 4); |
| 71 | offsets.forEach((offset, index) => page.writeUInt32LE(offset, 8 + index * 4)); |
| 72 | encoded.forEach((cookie, index) => cookie.copy(page, offsets[index]!)); |
| 73 | |
| 74 | const header = Buffer.alloc(8 + 4); |
| 75 | header.write("cook", 0, "latin1"); |
| 76 | header.writeUInt32BE(1, 4); |
| 77 | header.writeUInt32BE(page.length, 8); |
| 78 | return Buffer.concat([header, page]); |
| 79 | } |
| 80 | |
| 81 | describe("parseBinaryCookies", () => { |
| 82 | it("reads Safari's format and rebases its 2001 epoch", () => { |
| 83 | const file = encodeBinaryCookies([ |
| 84 | { |
| 85 | domain: ".apple.com", |
| 86 | name: "session", |
| 87 | path: "/", |
| 88 | value: "abc", |
| 89 | flags: 0x1 | 0x4, |
| 90 | expiry: 800_000_000, |
| 91 | }, |
| 92 | { |
| 93 | domain: "example.test", |
| 94 | name: "plain", |
| 95 | path: "/app", |
| 96 | value: "v", |
| 97 | flags: 0, |
| 98 | expiry: 0, |
| 99 | }, |
| 100 | ]); |
| 101 | |
| 102 | expect(parseBinaryCookies(file)).toEqual([ |
| 103 | { |
| 104 | url: "https://apple.com/", |
| 105 | name: "session", |
| 106 | value: "abc", |
| 107 | domain: ".apple.com", |
| 108 | path: "/", |
| 109 | secure: true, |
| 110 | httpOnly: true, |
| 111 | expirationDate: 800_000_000 + APPLE_EPOCH_OFFSET_SECONDS, |
| 112 | sameSite: "lax", |
| 113 | }, |
| 114 | { |
| 115 | url: "http://example.test/app", |
| 116 | name: "plain", |
| 117 | value: "v", |
| 118 | domain: undefined, |
| 119 | path: "/app", |
| 120 | secure: false, |
| 121 | httpOnly: false, |
| 122 | expirationDate: undefined, |
| 123 | sameSite: "lax", |
| 124 | }, |
| 125 | ]); |
| 126 | }); |
| 127 | |
| 128 | it("keeps __Host- cookies host-only so Electron accepts them", () => { |
| 129 | const file = encodeBinaryCookies([ |
| 130 | { domain: "example.test", name: "__Host-id", path: "/", value: "v", flags: 0x1, expiry: 0 }, |
| 131 | ]); |
| 132 | |
| 133 | expect(parseBinaryCookies(file)[0]).toMatchObject({ |
| 134 | url: "https://example.test/", |
| 135 | name: "__Host-id", |
| 136 | domain: undefined, |
| 137 | }); |
| 138 | }); |
| 139 | |
| 140 | it("reads cookies spread across multiple pages", () => { |
| 141 | const first = encodeBinaryCookies([ |
| 142 | { domain: "a.test", name: "one", path: "/", value: "1", flags: 0, expiry: 1 }, |
| 143 | ]); |
| 144 | const second = encodeBinaryCookies([ |
| 145 | { domain: "b.test", name: "two", path: "/", value: "2", flags: 0, expiry: 1 }, |
| 146 | ]); |
| 147 | const firstPage = first.subarray(12); |
| 148 | const secondPage = second.subarray(12); |
| 149 | const header = Buffer.alloc(16); |
| 150 | header.write("cook", 0, "latin1"); |
| 151 | header.writeUInt32BE(2, 4); |
| 152 | header.writeUInt32BE(firstPage.length, 8); |
| 153 | header.writeUInt32BE(secondPage.length, 12); |
| 154 | |
| 155 | const parsed = parseBinaryCookies(Buffer.concat([header, firstPage, secondPage])); |
| 156 | |
| 157 | expect(parsed.map((cookie) => cookie.name)).toEqual(["one", "two"]); |
| 158 | }); |
| 159 | |
| 160 | it("rejects a page that runs past the end of the file", () => { |
| 161 | const first = encodeBinaryCookies([ |
| 162 | { domain: "a.test", name: "one", path: "/", value: "1", flags: 0, expiry: 1 }, |
| 163 | ]); |
| 164 | const second = encodeBinaryCookies([ |
| 165 | { domain: "b.test", name: "two", path: "/", value: "2", flags: 0, expiry: 1 }, |
| 166 | ]); |
| 167 | const firstPage = first.subarray(12); |
| 168 | const secondPage = second.subarray(12); |
| 169 | const header = Buffer.alloc(16); |
| 170 | header.write("cook", 0, "latin1"); |
| 171 | header.writeUInt32BE(2, 4); |
| 172 | header.writeUInt32BE(firstPage.length + secondPage.length + 32, 8); |
| 173 | header.writeUInt32BE(secondPage.length, 12); |
| 174 | |
| 175 | expect(() => parseBinaryCookies(Buffer.concat([header, firstPage, secondPage]))).toThrow( |
| 176 | SafariCookieReadError, |
| 177 | ); |
| 178 | }); |
| 179 | |
| 180 | it("rejects record offsets that point into the page header or an earlier record", () => { |
| 181 | const valid = encodeBinaryCookies([ |
| 182 | { domain: "a.test", name: "n", path: "/", value: "v", expiry: 1_000, flags: 0 }, |
| 183 | { domain: "b.test", name: "m", path: "/", value: "w", expiry: 1_000, flags: 0 }, |
| 184 | ]); |
| 185 | const pageStart = 8 + 4; |
| 186 | const firstRecord = valid.readUInt32LE(pageStart + 8); |
| 187 | |
| 188 | const intoTable = Buffer.from(valid); |
| 189 | intoTable.writeUInt32LE(4, pageStart + 12); |
| 190 | expect(() => parseBinaryCookies(intoTable)).toThrow(SafariCookieReadError); |
| 191 | |
| 192 | const overlapping = Buffer.from(valid); |
| 193 | overlapping.writeUInt32LE(firstRecord, pageStart + 12); |
| 194 | expect(() => parseBinaryCookies(overlapping)).toThrow(SafariCookieReadError); |
| 195 | |
| 196 | expect(parseBinaryCookies(valid)).toHaveLength(2); |
| 197 | }); |
| 198 | |
| 199 | it("accepts the checksum and property-list trailer Safari writes", () => { |
| 200 | const file = encodeBinaryCookies([ |
| 201 | { domain: "a.test", name: "c", path: "/", value: "v", flags: 0, expiry: 0 }, |
| 202 | ]); |
| 203 | const checksum = Buffer.alloc(8); |
| 204 | const plist = Buffer.from("bplist00 stub"); |
| 205 | const plistLength = Buffer.alloc(4); |
| 206 | plistLength.writeUInt32BE(plist.length, 0); |
| 207 | |
| 208 | expect(parseBinaryCookies(Buffer.concat([file, checksum]))).toHaveLength(1); |
| 209 | expect(parseBinaryCookies(Buffer.concat([file, checksum, plistLength, plist]))).toHaveLength(1); |
| 210 | }); |
| 211 | }); |
| 212 | |
| 213 | describe("readSafariCookies", () => { |
| 214 | it.effect("reports a TCC denial as a permission the user can grant", () => |
| 215 | Effect.gen(function* () { |
| 216 | const denied = PlatformError.systemError({ |
| 217 | _tag: "Unknown", |
| 218 | module: "FileSystem", |
| 219 | method: "readFile", |
| 220 | pathOrDescriptor: "/protected/Cookies.binarycookies", |
| 221 | cause: Object.assign(new Error("operation not permitted"), { code: "EPERM" }), |
| 222 | }); |
| 223 | |
| 224 | const error = yield* readSafariCookies("/protected/Cookies.binarycookies").pipe( |
| 225 | Effect.flip, |
| 226 | Effect.provide(FileSystem.layerNoop({ readFile: () => Effect.fail(denied) })), |
| 227 | ); |
| 228 | |
| 229 | assert.equal(error.reason, "needsFullDiskAccess"); |
| 230 | }), |
| 231 | ); |
| 232 | }); |
| 233 | |
| 234 | describe("safariAccessDenied", () => { |
| 235 | it.effect("does not read a readable jar, or any other failure, as denied", () => |
| 236 | Effect.gen(function* () { |
| 237 | const fileSystem = yield* FileSystem.FileSystem; |
| 238 | const directory = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-safari-" }); |
| 239 | const jar = `${directory}/Cookies.binarycookies`; |
| 240 | yield* fileSystem.writeFile(jar, new Uint8Array([0x63, 0x6f, 0x6f, 0x6b])); |
| 241 | assert.isFalse(yield* safariAccessDenied(jar)); |
| 242 | assert.isFalse(yield* safariAccessDenied(`${directory}/absent.binarycookies`)); |
| 243 | }).pipe(Effect.provide(NodeServices.layer)), |
| 244 | ); |
| 245 | }); |
| 246 | |
| 247 | describe("isPermissionDenied", () => { |
| 248 | const platformError = (reasonTag: string, code: string): PlatformError.PlatformError => |
| 249 | ({ _tag: "PlatformError", reason: { _tag: reasonTag, cause: { code } } }) as never; |
| 250 | |
| 251 | it("does not send an ordinary EACCES failure to the Full Disk Access grant", () => { |
| 252 | expect(isPermissionDenied(platformError("PermissionDenied", "EACCES"))).toBe(false); |
| 253 | }); |
| 254 | }); |