srctree

}

 

pub fn main() !void {

.server_secret_key = "You must provide your own strong secret key here",

.base = provider,

});

 

}

 

/// Default CookieAuth Helper uses Sha256 as the HMAC primitive.

 

pub const cookie_auth = struct {

/// Why are you using sha1?

 

pub const sha2 = struct {

};

};

 

/// TODO document

return struct {

base: ?Provider,

// TODO key safety

const decoded = buffer[0..len];

b64_dec.decode(decoded, token) catch return error.InvalidAuth;

const time = decoded[0..8];

const username = decoded[8..][0..i];

var extra_data: ?[]const u8 = null;

var given_hash: []const u8 = decoded[8..][i + 1 ..][0..HMAC.mac_length];

extra_data = decoded[8..][i + 1 ..][0..ed];

given_hash = decoded[8..][i + 1 ..][ed + 1 .. HMAC.mac_length];

}

if (extra_data) |ed| hm.update(ed);

var our_hash: [HMAC.mac_length]u8 = undefined;

hm.final(our_hash[0..]);

return username;

}

 

if (cookies.value_list.next != null) return error.InvalidAuth;

const cookie = cookies.value_list.value;

std.debug.print("cookie: {s} \n", .{cookie});

while (itr.next()) |tkn| {

if (startsWith(u8, tkn, ca.cookie_name)) {

var un_buf: [64]u8 = undefined;

user.session_next = ca.session_buffer[0..len];

}

 

const ca: *Self = @ptrCast(@alignCast(ptr));

if (ca.base) |base| if (base.vtable.get_cookie) |_| {

return base.getCookie(user);

};

}

 

const a = std.testing.allocator;

.alloc = a,

.server_secret_key = "This may surprise you; but this secret_key is more secure than most of the secret keys in prod use",

});

try std.testing.expectStringStartsWith(decoded[8..], "testing user:");

}

 

const a = std.testing.allocator;

.alloc = a,

.server_secret_key = "This may surprise you; but this secret_key is more secure than most of the secret keys in prod use",

});

try std.testing.expectStringStartsWith(decoded[21..], "extra data:");

}

 

const a = std.testing.allocator;

.alloc = a,

.server_secret_key = "This may surprise you; but this secret_key is more secure than most of the secret keys in prod use",

});

 

var username_buf: [64]u8 = undefined;

var hm = Hmac.sha2.HmacSha256.init(auth.server_secret_key);

try std.testing.expectEqualStrings(user.username.?, valid);

}

 

try std.testing.expectError(error.UnknownUser, erruser);

}

 

const std = @import("std");

const Allocator = std.mem.Allocator;

const toBytes = std.mem.toBytes;

const startsWith = std.mem.startsWith;

const nativeToLittle = std.mem.nativeToLittle;

const Hmac = std.crypto.auth.hmac;

const b64_enc = std.base64.url_safe.Encoder;

const b64_dec = std.base64.url_safe.Decoder;

const Headers = @import("headers.zig");