merge main

frontend/src/hooks/api/auth/queries.tsx

@@ -77,11 +77,16 @@ export const selectOrganization = async (data: {
 export const useSelectOrganization = () => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async (details: { organizationId: string; userAgent?: UserAgentType }) => {
+    mutationFn: async (details: {
+      organizationId: string;
+      userAgent?: UserAgentType;
+      forceSetCredentials?: boolean;
+    }) => {
       const data = await selectOrganization(details);
 
       // If a custom user agent is set, then this session is meant for another consuming application, not the web application.
-      if (!details.userAgent && !data.isMfaEnabled) {
+      if ((!details.userAgent && !data.isMfaEnabled) || details.forceSetCredentials) {
+        localStorage.setItem("orgData.id", details.organizationId);
         SecurityClient.setToken(data.token);
         SecurityClient.setProviderAuthToken("");
       }

frontend/src/hooks/api/ca/constants.tsx

@@ -1,3 +1,6 @@
+import { SshCaStatus } from "@app/hooks/api/ssh-ca";
+import { SshCertTemplateStatus } from "@app/hooks/api/sshCertificateTemplates";
+
 import { CaStatus, CaType } from "./enums";
 
 export const caTypeToNameMap: { [K in CaType]: string } = {
@@ -11,7 +14,7 @@ export const caStatusToNameMap: { [K in CaStatus]: string } = {
   [CaStatus.PENDING_CERTIFICATE]: "Pending Certificate"
 };
 
-export const getCaStatusBadgeVariant = (status: CaStatus) => {
+export const getCaStatusBadgeVariant = (status: CaStatus | SshCaStatus | SshCertTemplateStatus) => {
   switch (status) {
     case CaStatus.ACTIVE:
       return "success";

frontend/src/hooks/api/index.tsx

@@ -38,6 +38,8 @@ export * from "./secretSharing";
 export * from "./secretSnapshots";
 export * from "./serverDetails";
 export * from "./serviceTokens";
+export * from "./ssh-ca";
+export * from "./sshCertificateTemplates";
 export * from "./ssoConfig";
 export * from "./subscriptions";
 export * from "./tags";

frontend/src/hooks/api/integrations/queries.tsx

@@ -80,6 +80,7 @@ export const useCreateIntegration = () => {
           key: string;
           value: string;
         }[];
+        azureLabel?: string;
         githubVisibility?: string;
         githubVisibilityRepoIds?: string[];
         kmsKeyId?: string;

frontend/src/hooks/api/integrations/types.ts

@@ -41,6 +41,7 @@ export type TIntegration = {
       key: string;
       value: string;
     }[];
+    azureLabel?: string;
 
     kmsKeyId?: string;
     secretSuffix?: string;

frontend/src/hooks/api/organization/queries.tsx

@@ -1,5 +1,6 @@
 import { useMutation, useQuery, useQueryClient, UseQueryOptions } from "@tanstack/react-query";
 
+import SecurityClient from "@app/components/utilities/SecurityClient";
 import { apiRequest } from "@app/config/request";
 import { OrderByDirection } from "@app/hooks/api/generic/types";
 
@@ -67,7 +68,7 @@ export const useCreateOrg = (options: { invalidate: boolean } = { invalidate: tr
     mutationFn: async ({ name }: { name: string }) => {
       const {
         data: { organization }
-      } = await apiRequest.post("/api/v2/organizations", {
+      } = await apiRequest.post<{ organization: { id: string } }>("/api/v2/organizations", {
         name
       });
 
@@ -437,10 +438,13 @@ export const useDeleteOrgById = () => {
   return useMutation({
     mutationFn: async ({ organizationId }: { organizationId: string }) => {
       const {
-        data: { organization }
-      } = await apiRequest.delete<{ organization: Organization }>(
+        data: { organization, accessToken }
+      } = await apiRequest.delete<{ organization: Organization; accessToken: string }>(
         `/api/v2/organizations/${organizationId}`
       );
+      SecurityClient.setToken(accessToken);
+      localStorage.removeItem("orgData.id");
+
       return organization;
     },
     onSuccess(_, dto) {

frontend/src/hooks/api/ssh-ca/constants.tsx

@@ -0,0 +1,14 @@
+export enum SshCaStatus {
+  ACTIVE = "active",
+  DISABLED = "disabled"
+}
+
+export enum SshCertType {
+  USER = "user",
+  HOST = "host"
+}
+
+export const sshCertTypeToNameMap: { [K in SshCertType]: string } = {
+  [SshCertType.USER]: "User",
+  [SshCertType.HOST]: "Host"
+};

frontend/src/hooks/api/ssh-ca/index.tsx

@@ -0,0 +1,9 @@
+export { SshCaStatus } from "./constants";
+export {
+  useCreateSshCa,
+  useDeleteSshCa,
+  useIssueSshCreds,
+  useSignSshKey,
+  useUpdateSshCa
+} from "./mutations";
+export { useGetSshCaById, useGetSshCaCertTemplates } from "./queries";

frontend/src/hooks/api/ssh-ca/mutations.tsx

@@ -0,0 +1,91 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { workspaceKeys } from "../workspace/query-keys";
+import {
+  TCreateSshCaDTO,
+  TDeleteSshCaDTO,
+  TIssueSshCredsDTO,
+  TIssueSshCredsResponse,
+  TSignSshKeyDTO,
+  TSignSshKeyResponse,
+  TSshCertificateAuthority,
+  TUpdateSshCaDTO
+} from "./types";
+
+export const sshCaKeys = {
+  getSshCaById: (caId: string) => [{ caId }, "ssh-ca"]
+};
+
+export const useCreateSshCa = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshCertificateAuthority, {}, TCreateSshCaDTO>({
+    mutationFn: async (body) => {
+      const {
+        data: { ca }
+      } = await apiRequest.post<{ ca: TSshCertificateAuthority }>("/api/v1/ssh/ca/", body);
+      return ca;
+    },
+    onSuccess: ({ projectId }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceSshCas(projectId));
+    }
+  });
+};
+
+export const useUpdateSshCa = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshCertificateAuthority, {}, TUpdateSshCaDTO>({
+    mutationFn: async ({ caId, ...body }) => {
+      const {
+        data: { ca }
+      } = await apiRequest.patch<{ ca: TSshCertificateAuthority }>(`/api/v1/ssh/ca/${caId}`, body);
+      return ca;
+    },
+    onSuccess: ({ projectId }, { caId }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceSshCas(projectId));
+      queryClient.invalidateQueries(sshCaKeys.getSshCaById(caId));
+    }
+  });
+};
+
+export const useDeleteSshCa = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshCertificateAuthority, {}, TDeleteSshCaDTO>({
+    mutationFn: async ({ caId }) => {
+      const {
+        data: { ca }
+      } = await apiRequest.delete<{ ca: TSshCertificateAuthority }>(`/api/v1/ssh/ca/${caId}`);
+      return ca;
+    },
+    onSuccess: ({ projectId }) => {
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceSshCas(projectId));
+    }
+  });
+};
+
+export const useSignSshKey = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSignSshKeyResponse, {}, TSignSshKeyDTO>({
+    mutationFn: async (body) => {
+      const { data } = await apiRequest.post<TSignSshKeyResponse>("/api/v1/ssh/sign", body);
+      return data;
+    },
+    onSuccess: (_, { projectId }) => {
+      queryClient.invalidateQueries(workspaceKeys.allWorkspaceSshCertificates(projectId));
+    }
+  });
+};
+
+export const useIssueSshCreds = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TIssueSshCredsResponse, {}, TIssueSshCredsDTO>({
+    mutationFn: async (body) => {
+      const { data } = await apiRequest.post<TIssueSshCredsResponse>("/api/v1/ssh/issue", body);
+      return data;
+    },
+    onSuccess: (_, { projectId }) => {
+      queryClient.invalidateQueries(workspaceKeys.allWorkspaceSshCertificates(projectId));
+    }
+  });
+};

frontend/src/hooks/api/ssh-ca/queries.tsx

@@ -0,0 +1,37 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { TSshCertificateTemplate } from "../sshCertificateTemplates/types";
+import { TSshCertificateAuthority } from "./types";
+
+export const sshCaKeys = {
+  getSshCaById: (caId: string) => [{ caId }, "ssh-ca"],
+  getSshCaCertTemplates: (caId: string) => [{ caId }, "ssh-ca-cert-templates"]
+};
+
+export const useGetSshCaById = (caId: string) => {
+  return useQuery({
+    queryKey: sshCaKeys.getSshCaById(caId),
+    queryFn: async () => {
+      const {
+        data: { ca }
+      } = await apiRequest.get<{ ca: TSshCertificateAuthority }>(`/api/v1/ssh/ca/${caId}`);
+      return ca;
+    },
+    enabled: Boolean(caId)
+  });
+};
+
+export const useGetSshCaCertTemplates = (caId: string) => {
+  return useQuery({
+    queryKey: sshCaKeys.getSshCaCertTemplates(caId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{
+        certificateTemplates: TSshCertificateTemplate[];
+      }>(`/api/v1/ssh/ca/${caId}/certificate-templates`);
+      return data;
+    },
+    enabled: Boolean(caId)
+  });
+};

frontend/src/hooks/api/ssh-ca/types.ts

@@ -0,0 +1,74 @@
+import { CertKeyAlgorithm } from "../certificates/enums";
+import { SshCaStatus, SshCertType } from "./constants";
+
+export type TSshCertificate = {
+  id: string;
+  sshCaId: string;
+  sshCertificateTemplateId: string;
+  serialNumber: string;
+  certType: SshCertType;
+  principals: string[];
+  keyId: string;
+  notBefore: string;
+  notAfter: string;
+};
+
+export type TSshCertificateAuthority = {
+  id: string;
+  projectId: string;
+  status: SshCaStatus;
+  friendlyName: string;
+  keyAlgorithm: CertKeyAlgorithm;
+  createdAt: string;
+  updatedAt: string;
+  publicKey: string;
+};
+
+export type TCreateSshCaDTO = {
+  projectId: string;
+  friendlyName?: string;
+  keyAlgorithm: CertKeyAlgorithm;
+};
+
+export type TUpdateSshCaDTO = {
+  caId: string;
+  friendlyName?: string;
+  status?: SshCaStatus;
+};
+
+export type TDeleteSshCaDTO = {
+  caId: string;
+};
+
+export type TSignSshKeyDTO = {
+  projectId: string;
+  certificateTemplateId: string;
+  publicKey?: string;
+  certType: SshCertType;
+  principals: string[];
+  ttl?: string;
+  keyId?: string;
+};
+
+export type TSignSshKeyResponse = {
+  serialNumber: string;
+  signedKey: string;
+};
+
+export type TIssueSshCredsDTO = {
+  projectId: string;
+  certificateTemplateId: string;
+  keyAlgorithm: CertKeyAlgorithm;
+  certType: SshCertType;
+  principals: string[];
+  ttl?: string;
+  keyId?: string;
+};
+
+export type TIssueSshCredsResponse = {
+  serialNumber: string;
+  signedKey: string;
+  privateKey: string;
+  publicKey: string;
+  keyAlgorithm: CertKeyAlgorithm;
+};

frontend/src/hooks/api/sshCertificateTemplates/index.tsx

@@ -0,0 +1,7 @@
+export {
+  useCreateSshCertTemplate,
+  useDeleteSshCertTemplate,
+  useUpdateSshCertTemplate
+} from "./mutations";
+export { useGetSshCertTemplate } from "./queries";
+export * from "./types";

frontend/src/hooks/api/sshCertificateTemplates/mutations.tsx

@@ -0,0 +1,59 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { sshCaKeys } from "../ssh-ca/queries";
+import {
+  TCreateSshCertificateTemplateDTO,
+  TDeleteSshCertificateTemplateDTO,
+  TSshCertificateTemplate,
+  TUpdateSshCertificateTemplateDTO
+} from "./types";
+
+export const useCreateSshCertTemplate = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshCertificateTemplate, {}, TCreateSshCertificateTemplateDTO>({
+    mutationFn: async (data) => {
+      const { data: certificateTemplate } = await apiRequest.post<TSshCertificateTemplate>(
+        "/api/v1/ssh/certificate-templates",
+        data
+      );
+      return certificateTemplate;
+    },
+    onSuccess: ({ sshCaId }) => {
+      queryClient.invalidateQueries(sshCaKeys.getSshCaCertTemplates(sshCaId));
+    }
+  });
+};
+
+export const useUpdateSshCertTemplate = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshCertificateTemplate, {}, TUpdateSshCertificateTemplateDTO>({
+    mutationFn: async (data) => {
+      const { data: certificateTemplate } = await apiRequest.patch<TSshCertificateTemplate>(
+        `/api/v1/ssh/certificate-templates/${data.id}`,
+        data
+      );
+
+      return certificateTemplate;
+    },
+    onSuccess: ({ sshCaId }) => {
+      queryClient.invalidateQueries(sshCaKeys.getSshCaCertTemplates(sshCaId));
+    }
+  });
+};
+
+export const useDeleteSshCertTemplate = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshCertificateTemplate, {}, TDeleteSshCertificateTemplateDTO>({
+    mutationFn: async (data) => {
+      const { data: certificateTemplate } = await apiRequest.delete<TSshCertificateTemplate>(
+        `/api/v1/ssh/certificate-templates/${data.id}`
+      );
+      return certificateTemplate;
+    },
+    onSuccess: ({ sshCaId }) => {
+      queryClient.invalidateQueries(sshCaKeys.getSshCaCertTemplates(sshCaId));
+    }
+  });
+};

frontend/src/hooks/api/sshCertificateTemplates/queries.tsx

@@ -0,0 +1,22 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { TSshCertificateTemplate } from "./types";
+
+export const certTemplateKeys = {
+  getSshCertTemplateById: (id: string) => [{ id }, "ssh-cert-template"]
+};
+
+export const useGetSshCertTemplate = (id: string) => {
+  return useQuery({
+    queryKey: certTemplateKeys.getSshCertTemplateById(id),
+    queryFn: async () => {
+      const { data: certificateTemplate } = await apiRequest.get<TSshCertificateTemplate>(
+        `/api/v1/ssh/certificate-templates/${id}`
+      );
+      return certificateTemplate;
+    },
+    enabled: Boolean(id)
+  });
+};

frontend/src/hooks/api/sshCertificateTemplates/types.ts

@@ -0,0 +1,47 @@
+export enum SshCertTemplateStatus {
+  ACTIVE = "active",
+  DISABLED = "disabled"
+}
+
+export type TSshCertificateTemplate = {
+  id: string;
+  sshCaId: string;
+  status: SshCertTemplateStatus;
+  name: string;
+  ttl: string;
+  maxTTL: string;
+  allowedUsers: string[];
+  allowedHosts: string[];
+  allowUserCertificates: boolean;
+  allowHostCertificates: boolean;
+  allowCustomKeyIds: boolean;
+};
+
+export type TCreateSshCertificateTemplateDTO = {
+  sshCaId: string;
+  name: string;
+  ttl: string;
+  maxTTL: string;
+  allowedUsers: string[];
+  allowedHosts: string[];
+  allowUserCertificates: boolean;
+  allowHostCertificates: boolean;
+  allowCustomKeyIds: boolean;
+};
+
+export type TUpdateSshCertificateTemplateDTO = {
+  id: string;
+  status?: SshCertTemplateStatus;
+  name?: string;
+  ttl?: string;
+  maxTTL?: string;
+  allowedUsers?: string[];
+  allowedHosts?: string[];
+  allowUserCertificates?: boolean;
+  allowHostCertificates?: boolean;
+  allowCustomKeyIds?: boolean;
+};
+
+export type TDeleteSshCertificateTemplateDTO = {
+  id: string;
+};

frontend/src/hooks/api/workspace/index.tsx

@@ -32,6 +32,9 @@ export {
   useListWorkspaceGroups,
   useListWorkspacePkiAlerts,
   useListWorkspacePkiCollections,
+  useListWorkspaceSshCas,
+  useListWorkspaceSshCertificates,
+  useListWorkspaceSshCertificateTemplates,
   useNameWorkspaceSecrets,
   useToggleAutoCapitalization,
   useUpdateIdentityWorkspaceRole,

frontend/src/hooks/api/workspace/queries.tsx

@@ -15,6 +15,8 @@ import { TIntegration } from "../integrations/types";
 import { TPkiAlert } from "../pkiAlerts/types";
 import { TPkiCollection } from "../pkiCollections/types";
 import { EncryptedSecret } from "../secrets/types";
+import { TSshCertificate, TSshCertificateAuthority } from "../ssh-ca/types";
+import { TSshCertificateTemplate } from "../sshCertificateTemplates/types";
 import { userKeys } from "../users/query-keys";
 import { TWorkspaceUser } from "../users/types";
 import { ProjectSlackConfig } from "../workflowIntegrations/types";
@@ -731,6 +733,67 @@ export const useListWorkspaceCertificateTemplates = ({ workspaceId }: { workspac
   });
 };
 
+export const useListWorkspaceSshCertificates = ({
+  offset,
+  limit,
+  projectId
+}: {
+  offset: number;
+  limit: number;
+  projectId: string;
+}) => {
+  return useQuery({
+    queryKey: workspaceKeys.specificWorkspaceSshCertificates({
+      offset,
+      limit,
+      projectId
+    }),
+    queryFn: async () => {
+      const params = new URLSearchParams({
+        offset: String(offset),
+        limit: String(limit)
+      });
+
+      const { data } = await apiRequest.get<{
+        certificates: TSshCertificate[];
+        totalCount: number;
+      }>(`/api/v2/workspace/${projectId}/ssh-certificates`, {
+        params
+      });
+      return data;
+    },
+    enabled: Boolean(projectId)
+  });
+};
+
+export const useListWorkspaceSshCas = (projectId: string) => {
+  return useQuery({
+    queryKey: workspaceKeys.getWorkspaceSshCas(projectId),
+    queryFn: async () => {
+      const {
+        data: { cas }
+      } = await apiRequest.get<{ cas: Omit<TSshCertificateAuthority, "publicKey">[] }>(
+        `/api/v2/workspace/${projectId}/ssh-cas`
+      );
+      return cas;
+    },
+    enabled: Boolean(projectId)
+  });
+};
+
+export const useListWorkspaceSshCertificateTemplates = (projectId: string) => {
+  return useQuery({
+    queryKey: workspaceKeys.getWorkspaceSshCertificateTemplates(projectId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{ certificateTemplates: TSshCertificateTemplate[] }>(
+        `/api/v2/workspace/${projectId}/ssh-certificate-templates`
+      );
+      return data;
+    },
+    enabled: Boolean(projectId)
+  });
+};
+
 export const useGetWorkspaceSlackConfig = ({ workspaceId }: { workspaceId: string }) => {
   return useQuery({
     queryKey: workspaceKeys.getWorkspaceSlackConfig(workspaceId),

frontend/src/hooks/api/workspace/query-keys.tsx

@@ -53,5 +53,19 @@ export const workspaceKeys = {
   getWorkspaceCertificateTemplates: (workspaceId: string) =>
     [{ workspaceId }, "workspace-certificate-templates"] as const,
   getWorkspaceSlackConfig: (workspaceId: string) =>
-    [{ workspaceId }, "workspace-slack-config"] as const
+    [{ workspaceId }, "workspace-slack-config"] as const,
+  getWorkspaceSshCas: (projectId: string) => [{ projectId }, "workspace-ssh-cas"] as const,
+  allWorkspaceSshCertificates: (projectId: string) =>
+    [{ projectId }, "workspace-ssh-certificates"] as const,
+  specificWorkspaceSshCertificates: ({
+    offset,
+    limit,
+    projectId
+  }: {
+    offset: number;
+    limit: number;
+    projectId: string;
+  }) => [...workspaceKeys.allWorkspaceSshCertificates(projectId), { offset, limit }] as const,
+  getWorkspaceSshCertificateTemplates: (projectId: string) =>
+    [{ projectId }, "workspace-ssh-certificate-templates"] as const
 };

frontend/src/hooks/api/workspace/types.ts

@@ -11,7 +11,8 @@ export enum ProjectVersion {
 export enum ProjectType {
   SecretManager = "secret-manager",
   CertificateManager = "cert-manager",
-  KMS = "kms"
+  KMS = "kms",
+  SSH = "ssh"
 }
 
 export enum ProjectUserMembershipTemporaryMode {