feat!: release v2 (#6545)

Co-authored-by: Artur <145776561+arturict@users.noreply.github.com>
Co-authored-by: arturict <arturict@users.noreply.github.com>
Co-authored-by: Thomas <thomas@ajnart.fr>
Co-authored-by: Afonso Jorge Ramos <afonsojorgeramos@gmail.com>
Co-authored-by: Danura30082 <danura30082+github@gmail.com>
Co-authored-by: Kushie <122986913+kushiemoon-dev@users.noreply.github.com>
Co-authored-by: ajnart <thomas@ajnart.fr>
Co-authored-by: ajnart <thomas@ajnart.dev>
Co-authored-by: chenjun <chenjun@foxmail.com>
Co-authored-by: Wikibear <wikibear@users.noreply.github.com>
Co-authored-by: Bergasha <bergasha@gmail.com>
Co-authored-by: leafyelin <43306196+leafyelin@users.noreply.github.com>
Co-authored-by: Lucas Araujo <lucas.lra@gmail.com>
Co-authored-by: GreenMonito <86085570+GreenMonito@users.noreply.github.com>
Co-authored-by: Nerdy-Technician <roffo@nerdy-technician.social>
Co-authored-by: Jun <34545896+jcstrong@users.noreply.github.com>
Co-authored-by: Edmond Abraham <54119952+gitedmond@users.noreply.github.com>
Co-authored-by: thrawnx <tight.bulb9384@fastmail.com>
Co-authored-by: Chris <58918656+nordada@users.noreply.github.com>
Co-authored-by: yi111 <153097222+Yi-111-a@users.noreply.github.com>
Co-authored-by: Yanis <naamaneyanis@gmail.com>
Co-authored-by: Wikibear <me@sej.de>
Co-authored-by: alessiottavo <93441886+alessiottavo@users.noreply.github.com>
This commit is contained in:
3286 files changed
+284386 -139176

No files matched your search

+3 -2
View File
@@ -29,9 +29,10 @@ export const getSessionFromApiKeyAsync = async (
return null;
}
const [apiKeyId, apiKey] = apiKeyHeaderValue.split(".");
const apiKeyParts = apiKeyHeaderValue.split(".");
const [apiKeyId, apiKey] = apiKeyParts;
if (!apiKeyId || !apiKey) {
if (apiKeyParts.length !== 2 || !apiKeyId || !apiKey) {
logger.warn("Failed to authenticate with api-key", { ipAddress, userAgent, reason: "API_KEY_INVALID_FORMAT" });
return null;
}
+5 -10
View File
@@ -9,7 +9,7 @@ import { groupMembers, groups, users } from "@homarr/db/schema";
import { colorSchemeCookieKey, everyoneGroup } from "@homarr/definitions";
import { env } from "./env";
import { extractProfileName } from "./providers/oidc/oidc-provider";
import { extractProfileName, getProfileValueByPath } from "./providers/oidc/profile";
const logger = createLogger({ module: "authEvents" });
@@ -31,16 +31,11 @@ export const createSignInEventHandler = (db: Database): Exclude<NextAuthConfig["
if (!dbUser) throw new Error("User not found");
const groupsKey = env.AUTH_OIDC_GROUPS_ATTRIBUTE;
const profileGroups = profile ? getProfileValueByPath(profile, groupsKey) : undefined;
// Groups from oidc provider are provided from the profile, it's not typed.
if (
!env.AUTH_OIDC_GROUPS_LOCAL_MANAGEMENT &&
dbUser.provider === "oidc" &&
profile &&
groupsKey in profile &&
Array.isArray(profile[groupsKey])
) {
logger.debug(`Using profile groups (${groupsKey}): ${JSON.stringify(profile[groupsKey])}`);
await synchronizeGroupsWithExternalForUserAsync(db, user.id, profile[groupsKey] as string[]);
if (!env.AUTH_OIDC_GROUPS_LOCAL_MANAGEMENT && dbUser.provider === "oidc" && Array.isArray(profileGroups)) {
logger.debug(`Using profile groups (${groupsKey}): ${JSON.stringify(profileGroups)}`);
await synchronizeGroupsWithExternalForUserAsync(db, user.id, profileGroups as string[]);
}
// In ldap-authroization we return the groups from ldap, it's not typed.
@@ -15,14 +15,15 @@ export const constructIntegrationPermissions = (integration: IntegrationPermissi
const permissions = integration.userPermissions
.concat(integration.groupPermissions)
.map(({ permission }) => permission);
const hasGlobalFullAccess = session?.user.permissions.includes("integration-full-all") ?? false;
const hasGlobalInteractAccess =
hasGlobalFullAccess || (session?.user.permissions.includes("integration-interact-all") ?? false);
const hasGlobalUseAccess =
hasGlobalInteractAccess || (session?.user.permissions.includes("integration-use-all") ?? false);
return {
hasFullAccess:
(session?.user.permissions.includes("integration-full-all") ?? false) || permissions.includes("full"),
hasInteractAccess:
permissions.includes("full") ||
permissions.includes("interact") ||
(session?.user.permissions.includes("integration-interact-all") ?? false),
hasUseAccess: permissions.length >= 1 || (session?.user.permissions.includes("integration-use-all") ?? false),
hasFullAccess: hasGlobalFullAccess || permissions.includes("full"),
hasInteractAccess: hasGlobalInteractAccess || permissions.includes("full") || permissions.includes("interact"),
hasUseAccess: hasGlobalUseAccess || permissions.length >= 1,
};
};
@@ -20,32 +20,27 @@ export const IntegrationProvider = ({ integrations, children }: PropsWithChildre
return <IntegrationContext.Provider value={{ integrations }}>{children}</IntegrationContext.Provider>;
};
export const useIntegrationsWithUseAccess = () => {
const useIntegrationContext = () => {
const context = useContext(IntegrationContext);
if (!context) {
throw new Error("useIntegrationsWithUseAccess must be used within an IntegrationProvider");
throw new Error("Integration hooks must be used within an IntegrationProvider");
}
return context.integrations.filter((integration) => integration.permissions.hasUseAccess);
return context;
};
export const useIntegrations = () => useIntegrationContext().integrations;
export const useIntegrationsWithUseAccess = () =>
useIntegrationContext().integrations.filter((integration) => integration.permissions.hasUseAccess);
export const useIntegrationsWithInteractAccess = () => {
const context = useContext(IntegrationContext);
if (!context) {
throw new Error("useIntegrationsWithInteractAccess must be used within an IntegrationProvider");
}
const context = useIntegrationContext();
return context.integrations.filter((integration) => integration.permissions.hasInteractAccess);
};
export const useIntegrationsWithFullAccess = () => {
const context = useContext(IntegrationContext);
if (!context) {
throw new Error("useIntegrationsWithFullAccess must be used within an IntegrationProvider");
}
const context = useIntegrationContext();
return context.integrations.filter((integration) => integration.permissions.hasFullAccess);
};
@@ -30,6 +30,18 @@ describe("constructIntegrationPermissions", () => {
expect(result.hasUseAccess).toBe(true);
});
test("should derive lower access levels from an unexpanded full permission", () => {
const result = constructIntegrationPermissions(
{ userPermissions: [], groupPermissions: [] },
{
user: { id: "2", permissions: ["integration-full-all"], colorScheme: "light" },
expires: new Date().toISOString(),
},
);
expect(result).toEqual({ hasFullAccess: true, hasInteractAccess: true, hasUseAccess: true });
});
test("should return hasInteractAccess as true when session permissions include integration-interact-all", () => {
// Arrange
const integration = {
@@ -1,4 +1,5 @@
import { CredentialsSignin } from "@auth/core/errors";
import { EqualityFilter } from "ldapts";
import type { z } from "zod/v4";
import { createId } from "@homarr/common";
@@ -37,7 +38,13 @@ export const authorizeWithLdapCredentialsAsync = async (
options: {
filter: createLdapUserFilter(credentials.name),
scope: env.AUTH_LDAP_SEARCH_SCOPE,
attributes: [env.AUTH_LDAP_USERNAME_ATTRIBUTE, env.AUTH_LDAP_USER_MAIL_ATTRIBUTE],
attributes: [
...new Set([
env.AUTH_LDAP_USERNAME_ATTRIBUTE,
env.AUTH_LDAP_USER_MAIL_ATTRIBUTE,
env.AUTH_LDAP_GROUP_MEMBER_USER_ATTRIBUTE,
]),
],
},
})
.then((entries) => {
@@ -80,14 +87,17 @@ export const authorizeWithLdapCredentialsAsync = async (
logger.info("User credentials are correct. Retrieving user groups...", { userName: credentials.name });
const groupClassFilter = new EqualityFilter({ attribute: "objectClass", value: env.AUTH_LDAP_GROUP_CLASS });
const groupMemberFilter = new EqualityFilter({
attribute: env.AUTH_LDAP_GROUP_MEMBER_ATTRIBUTE,
value: ldapUser[env.AUTH_LDAP_GROUP_MEMBER_USER_ATTRIBUTE],
});
const userGroups = await client
.searchAsync({
base: env.AUTH_LDAP_BASE,
options: {
// For example, if the user is doejohn, the filter will be (&(objectClass=group)(uid=doejohn)) or (&(objectClass=group)(uid=doejohn)(sAMAccountType=1234))
filter: `(&(objectClass=${env.AUTH_LDAP_GROUP_CLASS})(${
env.AUTH_LDAP_GROUP_MEMBER_ATTRIBUTE
}=${ldapUser[env.AUTH_LDAP_GROUP_MEMBER_USER_ATTRIBUTE]})${env.AUTH_LDAP_GROUP_FILTER_EXTRA_ARG ?? ""})`,
filter: `(&${groupClassFilter.toString()}${groupMemberFilter.toString()}${env.AUTH_LDAP_GROUP_FILTER_EXTRA_ARG ?? ""})`,
scope: env.AUTH_LDAP_SEARCH_SCOPE,
attributes: ["cn"],
},
@@ -139,11 +149,12 @@ export const authorizeWithLdapCredentialsAsync = async (
};
const createLdapUserFilter = (username: string) => {
const userFilter = new EqualityFilter({ attribute: env.AUTH_LDAP_USERNAME_ATTRIBUTE, value: username }).toString();
if (env.AUTH_LDAP_USERNAME_FILTER_EXTRA_ARG) {
// For example, if the username is doejohn and the extra arg is (sAMAccountType=1234), the filter will be (&(uid=doejohn)(sAMAccountType=1234))
return `(&(${env.AUTH_LDAP_USERNAME_ATTRIBUTE}=${username})${env.AUTH_LDAP_USERNAME_FILTER_EXTRA_ARG})`;
return `(&${userFilter}${env.AUTH_LDAP_USERNAME_FILTER_EXTRA_ARG})`;
}
// For example, if the username is doejohn, the filter will be (uid=doejohn)
return `(${env.AUTH_LDAP_USERNAME_ATTRIBUTE}=${username})`;
return userFilter;
};
@@ -48,7 +48,8 @@ export class LdapClient {
...objectEntries(entry)
.map(([key, value]) => [key, LdapClient.convertEntryPropertyToString(value)] as const)
.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {} as Record<string, string>),
dn: LdapClient.getEntryDn(entry),
// Keep RFC 4514 escaping intact for the subsequent user bind.
dn: entry.dn,
} as {
[key: string]: string;
dn: string;
@@ -66,21 +67,6 @@ export class LdapClient {
return firstValue.toString("utf8");
}
/**
* dn is the only attribute returned with special characters formatted in UTF-8 (Bad for any letters with an accent)
* Regex replaces any backslash followed by 2 hex characters with a percentage unless said backslash is preceded by another backslash.
* That can then be processed by decodeURIComponent which will turn back characters to normal.
* @param entry search entry from ldap
* @returns normalized distinguishedName
*/
private static getEntryDn(entry: Entry) {
try {
return decodeURIComponent(entry.dn.replace(/(?<!\\)\\([0-9a-fA-F]{2})/g, "%$1"));
} catch {
throw new Error(`Cannot resolve distinguishedName for the entry ${entry.dn}`);
}
}
/**
* Disconnects the client from the LDAP server.
*/
@@ -7,6 +7,7 @@ import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/h
import { env } from "../../env";
import { createRedirectUri } from "../../redirect";
import { extractProfileName } from "./profile";
import { assertVerifiedEmailForCredentialsLinking } from "./verified-email";
export const OidcProvider = (headers: ReadonlyHeaders | null): OIDCConfig<Profile> => ({
@@ -76,12 +77,3 @@ export const OidcProvider = (headers: ReadonlyHeaders | null): OIDCConfig<Profil
// @ts-expect-error `undici` has a `duplex` option
[customFetch]: fetchWithTrustedCertificatesAsync,
});
export const extractProfileName = (profile: Profile) => {
if (!env.AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE) {
// Use the name as the username if the preferred_username is an email address
return profile.preferred_username?.includes("@") ? profile.name : profile.preferred_username;
}
return profile[env.AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE as keyof typeof profile] as string;
};
+23
View File
@@ -0,0 +1,23 @@
import type { Profile } from "@auth/core/types";
import { env } from "../../env";
export const getProfileValueByPath = (profile: Profile, path: string): unknown => {
return path.split(".").reduce<unknown>((value, key) => {
if (typeof value !== "object" || value === null || !Object.hasOwn(value, key)) {
return undefined;
}
return (value as Record<string, unknown>)[key];
}, profile);
};
export const extractProfileName = (profile: Profile): string | undefined => {
if (!env.AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE) {
// Use the name as the username if the preferred_username is an email address
return (profile.preferred_username?.includes("@") ? profile.name : profile.preferred_username) ?? undefined;
}
const profileName = getProfileValueByPath(profile, env.AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE);
return typeof profileName === "string" ? profileName : undefined;
};
@@ -0,0 +1,96 @@
import type { Profile } from "@auth/core/types";
import { afterEach, describe, expect, test, vi } from "vitest";
const mockEnv = vi.hoisted(() => ({
AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE: undefined as string | undefined,
}));
vi.mock("../../../env", () => ({ env: mockEnv }));
import { extractProfileName, getProfileValueByPath } from "../profile";
afterEach(() => {
mockEnv.AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE = undefined;
});
describe("getProfileValueByPath", () => {
const profile = {
sub: "user-id",
resource_access: {
homarr: {
roles: ["admins"],
},
},
} satisfies Profile;
test("returns a top-level claim", () => {
expect(getProfileValueByPath(profile, "sub")).toBe("user-id");
});
test("returns a nested claim", () => {
expect(getProfileValueByPath(profile, "resource_access.homarr.roles")).toEqual(["admins"]);
});
test("returns undefined when the path does not exist", () => {
expect(getProfileValueByPath(profile, "resource_access.missing.roles")).toBeUndefined();
});
});
describe("extractProfileName", () => {
test("uses preferred_username when overwrite is not set", () => {
const profile = {
sub: "user-id",
preferred_username: "johndoe",
} satisfies Profile;
expect(extractProfileName(profile)).toBe("johndoe");
});
test("uses name when preferred_username is an email", () => {
const profile = {
sub: "user-id",
preferred_username: "john@example.com",
name: "John Doe",
} satisfies Profile;
expect(extractProfileName(profile)).toBe("John Doe");
});
test("returns undefined when the fallback name is null", () => {
const profile = {
sub: "user-id",
preferred_username: "john@example.com",
name: null,
} satisfies Profile;
expect(extractProfileName(profile)).toBeUndefined();
});
test("returns undefined when preferred_username is missing", () => {
const profile = {
sub: "user-id",
} satisfies Profile;
expect(extractProfileName(profile)).toBeUndefined();
});
test("uses a nested name claim when configured", () => {
mockEnv.AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE = "user.profile.display_name";
const profile = {
sub: "user-id",
user: { profile: { display_name: "Nested User" } },
} satisfies Profile;
expect(extractProfileName(profile)).toBe("Nested User");
});
test("returns undefined when the configured claim is not a string", () => {
mockEnv.AUTH_OIDC_NAME_ATTRIBUTE_OVERWRITE = "user.profile";
const profile = {
sub: "user-id",
user: { profile: { display_name: "Nested User" } },
} satisfies Profile;
expect(extractProfileName(profile)).toBeUndefined();
});
});
@@ -1,4 +1,5 @@
import { CredentialsSignin } from "@auth/core/errors";
import { FilterParser } from "ldapts";
import { describe, expect, test, vi } from "vitest";
import { createId } from "@homarr/common";
@@ -9,17 +10,57 @@ import { createDb } from "@homarr/db/test";
import { authorizeWithLdapCredentialsAsync } from "../credentials/authorization/ldap-authorization";
import * as ldapClient from "../credentials/ldap-client";
import { env } from "../../env";
vi.mock("../../env", () => ({
env: {
AUTH_LDAP_BIND_DN: "bind_dn",
AUTH_LDAP_BIND_PASSWORD: "bind_password",
AUTH_LDAP_USER_MAIL_ATTRIBUTE: "mail",
AUTH_LDAP_USERNAME_ATTRIBUTE: "uid",
AUTH_LDAP_GROUP_CLASS: "group",
AUTH_LDAP_GROUP_MEMBER_ATTRIBUTE: "member",
get AUTH_LDAP_GROUP_MEMBER_USER_ATTRIBUTE() {
return "dn";
},
},
}));
describe("authorizeWithLdapCredentials", () => {
test("requests the group lookup attribute and preserves literal filter values", async () => {
const memberAttribute = vi.spyOn(env, "AUTH_LDAP_GROUP_MEMBER_USER_ATTRIBUTE", "get");
memberAttribute.mockReturnValue("distinguishedName");
const username = "user*)(uid=*)";
const dn = "cn=Comma\\2C User (test),dc=example,dc=com";
const search = vi
.fn()
.mockResolvedValueOnce([{ dn, distinguishedName: dn, mail: "literal@example.com" }])
.mockResolvedValueOnce([{ cn: "homarr-users" }]);
vi.spyOn(ldapClient, "LdapClient").mockImplementation(function () {
return {
bindAsync: vi.fn().mockResolvedValue(undefined),
searchAsync: search,
disconnectAsync: vi.fn().mockResolvedValue(undefined),
} as unknown as ldapClient.LdapClient;
});
try {
const result = await authorizeWithLdapCredentialsAsync(createDb(), { name: username, password: "test" });
const userSearch = search.mock.calls[0]?.[0];
const groupSearch = search.mock.calls[1]?.[0];
expect(userSearch.options.attributes).toContain("distinguishedName");
const userFilter = FilterParser.parseString(userSearch.options.filter);
expect(userFilter.matches({ uid: username })).toBe(true);
expect(userFilter.matches({ uid: "some-other-user" })).toBe(false);
const groupFilter = FilterParser.parseString(groupSearch.options.filter);
expect(groupFilter.matches({ objectClass: "group", member: dn })).toBe(true);
expect(groupFilter.matches({ objectClass: "group", member: "cn=other,dc=example,dc=com" })).toBe(false);
expect(result.groups).toEqual(["homarr-users"]);
} finally {
memberAttribute.mockRestore();
}
});
test("should fail when wrong ldap base credentials", async () => {
// Arrange
const spy = vi.spyOn(ldapClient, "LdapClient");
@@ -0,0 +1,23 @@
import { Client } from "ldapts";
import { describe, expect, test, vi } from "vitest";
import { LdapClient } from "../credentials/ldap-client";
vi.mock("../../env", () => ({ env: { AUTH_LDAP_URI: "ldap://127.0.0.1:389" } }));
describe("LDAP search distinguished names", () => {
test.each([
"cn=Comma\\2C User,dc=example,dc=com",
"cn=100% User,dc=example,dc=com",
"cn=Unicode\\c4\\87,dc=example,dc=com",
"cn=Громов Иван,dc=example,dc=com",
])("preserves %s for the subsequent bind", async (dn) => {
vi.spyOn(Client.prototype, "search").mockResolvedValueOnce({
searchEntries: [{ dn, mail: [Buffer.from("user@example.com")] }],
searchReferences: [],
});
const entries = await new LdapClient().searchAsync({ base: "dc=example,dc=com", options: {} });
expect(entries).toEqual([{ dn, mail: "user@example.com" }]);
});
});
+7
View File
@@ -1 +1,8 @@
import { sanitizeRedirectionUrl } from "@homarr/validation/redirection-url";
export * from "./permissions";
export const createLoginUrl = (redirectUrl: string) => {
const searchParams = new URLSearchParams({ redirect: sanitizeRedirectionUrl(redirectUrl) });
return `/auth/login?${searchParams.toString()}`;
};
+31 -1
View File
@@ -1,7 +1,7 @@
import type { ResponseCookie } from "next/dist/compiled/@edge-runtime/cookies";
import type { ReadonlyRequestCookies } from "next/dist/server/web/spec-extension/adapters/request-cookies";
import { cookies } from "next/headers";
import { describe, expect, test, vi } from "vitest";
import { afterEach, describe, expect, test, vi } from "vitest";
import { eq } from "@homarr/db";
import type { Database } from "@homarr/db";
@@ -21,6 +21,12 @@ vi.mock("../env", () => {
env: mockEnv,
};
});
afterEach(() => {
mockEnv.AUTH_OIDC_GROUPS_ATTRIBUTE = "someRandomGroupsKey";
mockEnv.AUTH_OIDC_GROUPS_LOCAL_MANAGEMENT = false;
});
// eslint-disable-next-line @typescript-eslint/consistent-type-imports
type HeadersExport = typeof import("next/headers");
vi.mock("next/headers", async (importOriginal) => {
@@ -152,6 +158,30 @@ describe("createSignInEventHandler should create signInEventHandler", () => {
});
expect(dbGroupMembers?.groupId).toBe("1");
});
test("should add missing group membership from a nested claim", async () => {
// Arrange
mockEnv.AUTH_OIDC_GROUPS_ATTRIBUTE = "resource_access.homarr.roles";
const db = createDb();
await createUserAsync(db, "oidc");
await createGroupAsync(db);
const eventHandler = createSignInEventHandler(db);
// Act
await eventHandler?.({
user: { id: "1", name: "test" },
profile: {
preferred_username: "test",
resource_access: { homarr: { roles: ["test"] } },
},
account: null,
});
// Assert
const dbGroupMembers = await db.query.groupMembers.findFirst({
where: eq(groupMembers.userId, "1"),
});
expect(dbGroupMembers?.groupId).toBe("1");
});
test("should remove group membership", async () => {
// Arrange
const db = createDb();
-9
View File
@@ -10,15 +10,6 @@ describe("hashPassword should return a hash", () => {
expect(result.length).toBeGreaterThan(55);
expect(result).not.toEqual(password);
});
it("should return a different hash each time", async () => {
const password = "password";
const password2 = "another password";
const result1 = await hashPasswordAsync(password);
const result2 = await hashPasswordAsync(password2);
expect(result1).not.toEqual(result2);
});
it("should return a different hash for the same password with different salts", async () => {
const password = "password";