diff --git a/app/app_session.zig b/app/app_session.zig new file mode 100644 index 0000000..66b696b --- /dev/null +++ b/app/app_session.zig @@ -0,0 +1,76 @@ +const std = @import("std"); +const http = @import("core").vfs.http; +const A = std.mem.Allocator; +const E = @import("core").vfs.Error; +pub var cookie: Cookied = undefined; +pub fn hex(value: []const u8) ?[64]u8 { + if (value.len != 64) return null; + for (value) |c| if (!std.ascii.isHex(c)) return null; + return value[0..64].*; +} +pub const Cookied = struct { + inner: http.Transport, + value: ?[64]u8 = null, + pub fn transport(self: *Cookied) http.Transport { + return .{ .ptr = self, .vtable = &.{ .request = request, .cancel = cancel, .pump = pump } }; + } + fn request(p: *anyopaque, a: A, r: http.Request, cb: http.DoneFn, c: ?*anyopaque) E!http.Job { + const self: *Cookied = @ptrCast(@alignCast(p)); + if (r.headers.len > 7) return error.Io; + var hs: [8]http.Header = undefined; + @memcpy(hs[0..r.headers.len], r.headers); + const v = "heronin_session=" ++ (self.value orelse @as([64]u8, @splat(0))); + var copy = r; + if (self.value != null) hs[r.headers.len] = .{ .name = "Cookie", .value = v }; + copy.headers = hs[0 .. r.headers.len + @intFromBool(self.value != null)]; + return self.inner.request(a, copy, cb, c); + } + fn cancel(ptr: *anyopaque, job: http.Job) void { + @as(*Cookied, @ptrCast(@alignCast(ptr))).inner.cancel(job); + } + fn pump(ptr: *anyopaque) void { + @as(*Cookied, @ptrCast(@alignCast(ptr))).inner.pump(); + } +}; +pub const Claim = struct { + verifier: [64]u8 = undefined, + session: ?[64]u8 = null, + state: enum { waiting, done, failed } = .waiting, + next_ms: i128 = 2000, + tries: u8 = 0, + job: ?http.Job = null, + a: A = undefined, + pub fn begin(self: *Claim, random: [32]u8, a: A, base: []const u8) ![]const u8 { + self.* = .{ .verifier = std.fmt.bytesToHex(random, .lower), .a = a }; + var hash: [32]u8 = undefined; + std.crypto.hash.sha2.Sha256.hash(&self.verifier, &hash, .{}); + const path = "login?app=" ++ std.fmt.bytesToHex(hash, .lower); + return @import("tag_queue.zig").serverUrl(a, base, path); + } + pub fn step(self: *Claim, now_ms: i128, tr: http.Transport, base: []const u8) void { + if (self.state != .waiting or self.job != null or now_ms < self.next_ms) return; + self.next_ms = now_ms +| 2000; + self.tries +|= 1; + const url = @import("tag_queue.zig").serverUrl(self.a, base, "app-session") catch return; + defer self.a.free(url); + const json = "{\"verifier\":\"" ++ self.verifier ++ "\"}"; + const h = &.{http.Header{ .name = "Content-Type", .value = "application/json" }}; + const req: http.Request = .{ .method = .POST, .url = url, .body = json, .headers = h }; + self.job = tr.request(self.a, req, answered, self) catch return answered(self, error.Io); + } + fn answered(ctx: ?*anyopaque, result: E!http.Response) void { + const self: *Claim = @ptrCast(@alignCast(ctx.?)); + self.job = null; + self.state = if (self.tries >= 150) .failed else .waiting; + const response = result catch return; + defer response.deinit(self.a); + if (response.status != 200) return; + self.state = .failed; + const Reply = struct { session: []const u8 }; + const options: std.json.ParseOptions = .{ .ignore_unknown_fields = true }; + const parsed = std.json.parseFromSlice(Reply, self.a, response.body, options) catch return; + defer parsed.deinit(); + self.session = hex(parsed.value.session); + if (self.session != null) self.state = .done; + } +}; diff --git a/app/app_session_tests.zig b/app/app_session_tests.zig new file mode 100644 index 0000000..1f06cc4 --- /dev/null +++ b/app/app_session_tests.zig @@ -0,0 +1,129 @@ +const std = @import("std"); +const session = @import("app_session.zig"); +const http = @import("core").vfs.http; +const t = std.testing; +const aa: [64]u8 = @splat('a'); +const zz: [64]u8 = @splat('0'); +var req: http.Request = undefined; +var headers: [8]http.Header = undefined; +var cookie_value: [80]u8 = undefined; +var url: [256]u8 = undefined; +var body: [128]u8 = undefined; +var cb: http.DoneFn = undefined; +var ctx: ?*anyopaque = null; +var calls: usize = 0; +var cancelled = false; +var pumped = false; +fn request( + _: *anyopaque, + _: std.mem.Allocator, + r: http.Request, + done: http.DoneFn, + context: ?*anyopaque, +) @import("core").vfs.Error!http.Job { + req = r; + @memcpy(headers[0..r.headers.len], r.headers); + req.headers = headers[0..r.headers.len]; + if (r.headers.len > 1) { + @memcpy(cookie_value[0..r.headers[1].value.len], r.headers[1].value); + headers[1].value = cookie_value[0..r.headers[1].value.len]; + } + @memcpy(url[0..r.url.len], r.url); + req.url = url[0..r.url.len]; + @memcpy(body[0..r.body.len], r.body); + req.body = body[0..r.body.len]; + cb, ctx = .{ done, context }; + calls += 1; + return .{ .id = 1 }; +} +fn cancel(_: *anyopaque, _: http.Job) void { + cancelled = true; +} +fn pump(_: *anyopaque) void { + pumped = true; +} +fn answer(status: u16, value: []const u8) !void { + cb(ctx, .{ .status = status, .body = try t.allocator.dupe(u8, value) }); +} +fn transport(dummy: *u8) http.Transport { + return .{ .ptr = dummy, .vtable = &.{ .request = request, .cancel = cancel, .pump = pump } }; +} +fn ignore(_: ?*anyopaque, _: @import("core").vfs.Error!http.Response) void {} +test "cookie forwards headers cancel and pump and limits caller headers" { + var dummy: u8 = 0; + var c: session.Cookied = .{ .inner = transport(&dummy) }; + const tr = c.transport(); + const content = http.Header{ .name = "Content-Type", .value = "application/json" }; + const r: http.Request = .{ .method = .POST, .url = "", .headers = &.{content} }; + const job = try tr.request(t.allocator, r, ignore, null); + try t.expectEqual(@as(usize, 1), req.headers.len); + try t.expectEqualStrings(content.value, req.headers[0].value); + c.value = @splat('a'); + _ = try tr.request(t.allocator, r, ignore, null); + try t.expectEqualStrings("Content-Type", req.headers[0].name); + try t.expectEqualStrings("Cookie", req.headers[1].name); + try t.expectEqualStrings("heronin_session=" ++ aa, req.headers[1].value); + try t.expectError(error.Io, tr.request(t.allocator, .{ + .method = .GET, + .url = "", + .headers = &(@as([8]http.Header, @splat(content))), + }, ignore, null)); + tr.cancel(job); + tr.pump(); + try t.expect(cancelled and pumped); +} +test "claim hashes verifier polls and accepts session" { + var claim: session.Claim = .{}; + const login = try claim.begin(@splat(0), t.allocator, "http://example.invalid/"); + defer t.allocator.free(login); + try t.expectEqualStrings(&zz, &claim.verifier); + var hash: [32]u8 = undefined; + std.crypto.hash.sha2.Sha256.hash(&zz, &hash, .{}); + try t.expectEqualStrings( + "http://example.invalid/heronin/api/login?app=" ++ std.fmt.bytesToHex(hash, .lower), + login, + ); + var dummy: u8 = 0; + calls = 0; + claim.step(0, transport(&dummy), ""); + try t.expectEqual(@as(usize, 0), calls); + claim.step(2000, transport(&dummy), ""); + try t.expectEqual(.POST, req.method); + try t.expectEqualStrings("/heronin/api/app-session", req.url); + try t.expectEqualStrings("{\"verifier\":\"" ++ zz ++ "\"}", req.body); + claim.step(4000, transport(&dummy), ""); + try t.expectEqual(@as(usize, 1), calls); + try answer(404, ""); + claim.step(4000, transport(&dummy), ""); + try t.expectEqual(@as(usize, 2), calls); + try answer(200, "{\"session\":\"" ++ aa ++ "\"}"); + try t.expectEqual(.done, claim.state); + try t.expectEqualStrings(&aa, &claim.session.?); +} +test "claim stops after answered attempts and rejects short session" { + var claim: session.Claim = .{}; + const login = try claim.begin(@splat(0), t.allocator, ""); + defer t.allocator.free(login); + var dummy: u8 = 0; + for (0..150) |i| { + claim.step(@as(i128, i + 1) * 2000, transport(&dummy), ""); + try answer(404, ""); + } + try t.expectEqual(.failed, claim.state); + claim.state = .waiting; + claim.step(400000, transport(&dummy), ""); + try answer(200, "{\"session\":\"short\"}"); + try t.expectEqual(.failed, claim.state); +} +test "claim keeps polling after transport errors and other statuses" { + var claim: session.Claim = .{}; + const login = try claim.begin(@splat(0), t.allocator, ""); + defer t.allocator.free(login); + var dummy: u8 = 0; + claim.step(2000, transport(&dummy), ""); + cb(ctx, error.Io); + try t.expectEqual(.waiting, claim.state); + claim.step(4000, transport(&dummy), ""); + try answer(503, ""); + try t.expectEqual(.waiting, claim.state); +} diff --git a/app/app_tests.zig b/app/app_tests.zig index e43b811..d1c7188 100644 --- a/app/app_tests.zig +++ b/app/app_tests.zig @@ -1,4 +1,5 @@ test { + _ = @import("app_session_tests.zig"); _ = @import("drive_link_tests.zig"); _ = @import("sign_in_tests.zig"); _ = @import("views/agent.zig"); diff --git a/app/plugin.zig b/app/plugin.zig index 119c68d..6a9a04c 100644 --- a/app/plugin.zig +++ b/app/plugin.zig @@ -1,3 +1,4 @@ +const session = @import("app_session.zig"); const drive_link = @import("drive_link.zig"); const sign_in = @import("sign_in.zig"); var places_base: ?[]const u8 = if (@import("builtin").cpu.arch == .wasm32) "" else null; @@ -55,9 +56,12 @@ fn deinit(_: *anyopaque) void { current = .library; } fn draw(_: ?*anyopaque) anyerror!dvui.App.Result { + const host: *sdk.Host = @ptrCast(@alignCast(plugin.state)); if (fake == null) { agent.init(); - if (@import("builtin").cpu.arch == .wasm32) sign_in.check(agent.transport, places_base orelse ""); + if (@import("builtin").cpu.arch != .wasm32) + session.cookie.value = session.hex(host.getSecret("heronin.session") orelse ""); + if (places_base) |base| sign_in.check(agent.transport, base); @import("agent_settings.zig").load(agent.transport, places_base); state.tag_queue = &tagging; fake = try @import("fake_store.zig").FakeStore.init(@import("std").heap.page_allocator); @@ -65,6 +69,9 @@ fn draw(_: ?*anyopaque) anyerror!dvui.App.Result { drive_link.link.current(fake.?.store()).places(&state, library.State.placed); } sign_in.step(); + if (@import("builtin").cpu.arch != .wasm32 and sign_in.account.state == .opening and + dvui.timerDoneOrNone(dvui.parentGet().data().id)) + dvui.timer(dvui.parentGet().data().id, 2000000); drive_link.link.step(); if (drive_link.link.changed) { drive_link.link.changed = false; @@ -76,6 +83,11 @@ fn draw(_: ?*anyopaque) anyerror!dvui.App.Result { if (current != .add) queue.step(drive_link.link.current(fake.?.store())); if (queue.busy) dvui.refresh(null, @src(), null); agent.transport.pump(); + if (sign_in.session_changed) { + const saved = host.setSecret("heronin.session", if (session.cookie.value) |*v| v else ""); + saved catch @import("std").log.err("session not saved", .{}); + sign_in.session_changed = false; + } if (@import("builtin").cpu.arch == .wasm32) @import("core").transport.WebOAuth.pump(); if (drive_link.link.state == .waiting or drive_link.link.retry) dvui.refresh(null, @src(), null); if (sign_in.account.state == .checking) dvui.refresh(null, @src(), null); diff --git a/app/sign_in.zig b/app/sign_in.zig index 6261846..2647562 100644 --- a/app/sign_in.zig +++ b/app/sign_in.zig @@ -1,3 +1,6 @@ +const app_session = @import("app_session.zig"); +pub var claim: app_session.Claim = .{}; +pub var session_changed = false; const drive_link = @import("drive_link.zig"); const std = @import("std"); const core = @import("core"); @@ -16,6 +19,8 @@ pub const Account = struct { fn deinitAccount(self: *Account) void { if (self.job) |job| self.transport.?.cancel(job); if (@import("builtin").cpu.arch == .wasm32) core.transport.WebOAuth.cancel(); + if (claim.job) |job| if (self.transport) |tr| tr.cancel(job); + claim = .{}; self.arena.deinit(); self.* = .{}; } @@ -38,6 +43,7 @@ fn answered(_: ?*anyopaque, result: core.vfs.Error!core.vfs.http.Response) void defer response.deinit(account.arena.child_allocator); if (account.state != .checking) { if (response.status == 204) { + clearSession(); if (drive_link.link.host) |host| drive_link.link.give(host, "", 0); account.state, account.email = .{ .signed_out, null }; } else failure(); @@ -45,6 +51,7 @@ fn answered(_: ?*anyopaque, result: core.vfs.Error!core.vfs.http.Response) void } account.state = if (response.status == 200) .checking else if (response.status == 502) .signed_in else if (response.status == 401) .signed_out else .off; if (response.status == 401) account.email = null; + if (response.status == 401) clearSession(); if (response.status != 200) return; const parsed = std.json.parseFromSlice(struct { email: []const u8, access_token: []const u8, expires_in: u32 }, account.arena.child_allocator, response.body, .{ .ignore_unknown_fields = true }) catch return failure(); defer parsed.deinit(); @@ -57,8 +64,20 @@ pub fn open() void { if (@import("builtin").cpu.arch == .wasm32) { account.state, account.failed = .{ .opening, .none }; core.transport.WebOAuth.begin(account.arena.allocator(), "/heronin/api/login", opened, null) catch {}; + } else { + if (account.base.len == 0) return; + var random: [32]u8 = undefined; + dvui.io.randomSecure(&random) catch return; + const url = claim.begin(random, account.arena.allocator(), account.base) catch return; + _ = open_url(.{ .url = url }); + account.state, account.failed = .{ .opening, .none }; } } +pub var open_url: *const fn (dvui.OpenURLOptions) bool = dvui.openURL; +fn clearSession() void { + if (@import("builtin").cpu.arch == .wasm32) return; + app_session.cookie.value, session_changed = .{ null, true }; +} pub fn opened(_: ?*anyopaque, result: ?[]u8) void { if (result) |value| { account.arena.allocator().free(value); @@ -83,12 +102,28 @@ pub fn banner() void { if (account.state != .signed_out and account.state != .opening) return; dvui.labelNoFmt(@src(), "Sign in with Google to tag photos and name places", .{}, .{}); button(0); - if (account.failed == .popup) dvui.labelNoFmt(@src(), "Sign-in did not finish. Allow pop-ups for this site and try again.", .{}, .{ .tag = "heronin-sign-in-note" }); + const web = @import("builtin").cpu.arch == .wasm32; + if (account.failed == .popup) dvui.labelNoFmt(@src(), if (web) + "Sign-in did not finish. Allow pop-ups for this site and try again." + else + "Sign-in did not finish. Try again.", .{}, .{ .tag = "heronin-sign-in-note" }); } fn failure() void { account.state, account.failed = if (account.state == .checking) .{ .off, .none } else .{ .signed_in, .sign_out }; } pub fn step() void { + if (@import("builtin").cpu.arch != .wasm32 and account.state == .opening) { + if (claim.state == .waiting) + claim.step(@divTrunc(dvui.frameTimeNS(), 1000000), account.transport.?, account.base); + switch (claim.state) { + .done => { + app_session.cookie.value, session_changed = .{ claim.session, true }; + check(account.transport.?, account.base); + }, + .failed => opened(null, null), + .waiting => {}, + } + } if (account.job != null or account.state != .signed_in or (!drive_link.link.token_due and !drive_link.link.retry)) return; drive_link.link.token_due = false; drive_link.link.retry = false; diff --git a/app/sign_in_tests.zig b/app/sign_in_tests.zig index fc80f73..dc7f976 100644 --- a/app/sign_in_tests.zig +++ b/app/sign_in_tests.zig @@ -117,3 +117,59 @@ test "token response reaches only the drive command arguments" { sign.lost(); host.deliverEvents(); } +fn openURL(_: @import("dvui").OpenURLOptions) bool { + return false; +} +var seen_cookie: [80]u8 = undefined; +var seen_cookie_len: usize = 0; +fn cookieRequest( + ptr: *anyopaque, + a: std.mem.Allocator, + r: http.Request, + cb: http.DoneFn, + ctx: ?*anyopaque, +) core.vfs.Error!http.Job { + if (r.headers.len > 0) { + seen_cookie_len = r.headers[r.headers.len - 1].value.len; + @memcpy(seen_cookie[0..seen_cookie_len], r.headers[r.headers.len - 1].value); + } + return request(ptr, a, r, cb, ctx); +} +test "native claim installs cookie token check carries it and logout clears it" { + const session = @import("app_session.zig"); + const t = std.testing; + sign.account = .{ .arena = .init(t.allocator) }; + defer sign.account.deinit(); + @import("dvui").io = std.testing.io; + sign.open_url = openURL; + defer sign.open_url = @import("dvui").openURL; + var dummy: u8 = 0; + session.cookie = .{ .inner = .{ + .ptr = &dummy, + .vtable = &.{ .request = cookieRequest, .cancel = cancel, .pump = pump }, + } }; + defer session.cookie.value = null; + sign.check(session.cookie.transport(), "http://127.0.0.1:1"); + try answer(401, ""); + sign.session_changed = false; + sign.open(); + try t.expectEqual(.opening, sign.account.state); + try t.expectEqual(.waiting, sign.claim.state); + sign.claim.state = .done; + sign.claim.session = @splat('a'); + sign.step(); + try t.expectEqual(sign.claim.session, session.cookie.value); + try t.expect(sign.session_changed); + const expected: [64]u8 = @splat('a'); + try t.expectEqualStrings("heronin_session=" ++ expected, seen_cookie[0..seen_cookie_len]); + try answer(502, ""); + sign.session_changed = false; + sign.signOut(); + try answer(204, ""); + try t.expect(session.cookie.value == null and sign.session_changed); + session.cookie.value = @splat('a'); + sign.session_changed = false; + sign.check(session.cookie.transport(), "http://127.0.0.1:1"); + try answer(401, ""); + try t.expect(session.cookie.value == null and sign.session_changed); +} diff --git a/app/views/agent.zig b/app/views/agent.zig index ab3e65c..108f18c 100644 --- a/app/views/agent.zig +++ b/app/views/agent.zig @@ -55,7 +55,9 @@ pub fn init() void { transport = core.transport.Web.transport(std.heap.page_allocator); } else { native = .init(std.heap.page_allocator, dvui.io, null); - transport = native.transport(); + const session = @import("../app_session.zig"); + session.cookie = .{ .inner = native.transport() }; + transport = session.cookie.transport(); } } pub fn deinit() void {