87 | >(({ className, ...props }, ref) => (
88 | [role=checkbox]]:translate-y-[2px]",
92 | className
93 | )}
94 | {...props}
95 | />
96 | ))
97 | TableCell.displayName = "TableCell"
98 |
99 | const TableCaption = React.forwardRef<
100 | HTMLTableCaptionElement,
101 | React.HTMLAttributes
102 | >(({ className, ...props }, ref) => (
103 | () methods to interface and unions
39 | # omit_interface_checks : true
40 |
41 | # Optional: turn on to skip generation of ComplexityRoot struct content and Complexity function
42 | # omit_complexity: false
43 |
44 | # Optional: turn on to not generate any file notice comments in generated files
45 | # omit_gqlgen_file_notice: false
46 |
47 | # Optional: turn on to exclude the gqlgen version in the generated file notice. No effect if `omit_gqlgen_file_notice` is true.
48 | # omit_gqlgen_version_in_file_notice: false
49 |
50 | # Optional: turn off to make struct-type struct fields not use pointers
51 | # e.g. type Thing struct { FieldA OtherThing } instead of { FieldA *OtherThing }
52 | struct_fields_always_pointers: false
53 |
54 | # Optional: turn off to make resolvers return values instead of pointers for structs
55 | resolvers_always_return_pointers: false
56 |
57 | # Optional: turn on to return pointers instead of values in unmarshalInput
58 | # return_pointers_in_unmarshalinput: false
59 |
60 | # Optional: wrap nullable input fields with Omittable
61 | # nullable_input_omittable: true
62 |
63 | # Optional: set to speed up generation time by not performing a final validation pass.
64 | # skip_validation: true
65 |
66 | # Optional: set to skip running `go mod tidy` when generating server code
67 | # skip_mod_tidy: true
68 |
69 | # Optional: if this is set to true, argument directives that
70 | # decorate a field with a null value will still be called.
71 | #
72 | # This enables argumment directives to not just mutate
73 | # argument values but to set them even if they're null.
74 | call_argument_directives_with_null: true
75 |
76 | # gqlgen will search for any type names in the schema in these go packages
77 | # if they match it will use them, otherwise it will generate them.
78 | autobind:
79 | - "guarddev/database/postgres"
80 |
81 | # This section declares type mapping between the GraphQL and go type systems
82 | #
83 | # The first line in each type will be used as defaults for resolver arguments and
84 | # modelgen, the others will be allowed when binding to fields. Configure them to
85 | # your liking
86 | models:
87 | ID:
88 | model:
89 | - github.com/99designs/gqlgen/graphql.ID
90 | - github.com/99designs/gqlgen/graphql.Int
91 | - github.com/99designs/gqlgen/graphql.Int64
92 | - github.com/99designs/gqlgen/graphql.Int32
93 | Int:
94 | model:
95 | - github.com/99designs/gqlgen/graphql.Int
96 | - github.com/99designs/gqlgen/graphql.Int64
97 | - github.com/99designs/gqlgen/graphql.Int32
98 |
99 | Int64:
100 | model:
101 | - github.com/99designs/gqlgen/graphql.Int64
102 |
--------------------------------------------------------------------------------
/frontend/app/console/[teamSlug]/project/[projectSlug]/scan/[scanId]/page.tsx:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useQuery } from "@apollo/client";
4 | import { GET_SCANS } from "./gql";
5 | import { GetScansQuery } from "@/gql/graphql";
6 | import { useEffect, useState } from "react";
7 | import { Skeleton } from "@/components/ui/skeleton";
8 | import { DataTable } from "./data_table";
9 | import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
10 | import { Button } from "@/components/ui/button";
11 | import { ArrowLeft } from "lucide-react";
12 | import Link from "next/link";
13 | import { usePathname } from "next/navigation";
14 |
15 | export type SCAN_ITEMS = GetScansQuery["teams"][0]["projects"][0]["scans"][0]["scanItems"][0];
16 |
17 | const ScanPage = ({ params }: { params: { teamSlug: string; projectSlug: string; scanId: string } }) => {
18 | const { teamSlug, projectSlug, scanId } = params;
19 | const pathname = usePathname();
20 | const parentPath = pathname.split('/scan/')[0];
21 |
22 | const [scanCompleted, setScanComplete] = useState(false);
23 |
24 | const { data, loading } = useQuery(GET_SCANS, { variables: { teamSlug, projectSlug, scanId }, pollInterval: scanCompleted ? 0 : 5000 });
25 |
26 | const scanData = data?.teams[0].projects[0].scans[0];
27 | const scans = scanData?.scanItems;
28 | const scanCompl = scanData?.scanCompleted;
29 |
30 | useEffect(() => {
31 | if (scanCompl) {
32 | setScanComplete(true);
33 | }
34 | }, [data])
35 |
36 | const LoadingSkeleton = () => (
37 |
38 |
39 |
41 |
42 |
43 |
44 |
45 | {['Service', 'Region', 'Summary', 'Findings'].map((header) => (
46 |
47 |
49 | ))}
50 |
51 |
52 |
53 | {[...Array(10)].map((_, index) => (
54 |
55 | {[...Array(4)].map((_, cellIndex) => (
56 |
57 |
59 | ))}
60 |
61 | ))}
62 |
63 |
64 |
65 |
66 |
69 |
74 | {!loading ?
75 |
76 |
77 |
78 |
84 |
89 |
90 |
91 |
92 |
93 | :
94 |
95 |
97 | }
98 |
99 |
(GET_TEAMS, { variables: { teamSlug: undefined } });
12 | const { data } = useQuery(GET_EXTERNAL_ID);
13 | const externalId = data?.getExternalId;
14 |
15 | const router = useRouter();
16 | useEffect(() => {
17 | if (team?.teams.length) {
18 | router.push(`/console/${team?.teams[0].teamSlug}/project/${team?.teams[0].projects[0].projectSlug}`)
19 | }
20 | }, [team]);
21 |
22 | return (
23 |
24 |
25 | {team?.teams.length === 0 && (
26 |
27 | {/* Header */}
28 |
29 |
30 | {process.env.NEXT_PUBLIC_SELF_HOSTING ? "Set Up Your IAM User" : "Connect your AWS Account"}
31 |
32 |
33 |
34 | {process.env.NEXT_PUBLIC_SELF_HOSTING
35 | ? "To allow Guard to scan your AWS account, you need to create an IAM User with read-only permissions. This IAM User will allow Guard to securely access your AWS resources for security scans without modifying them."
36 | : "To allow Guard to scan your AWS account, you'll need to add a read-only permission using AWS CloudFormation. This will allow Guard to securely access your AWS resources for security scans without modifying them."}
37 |
38 |
39 |
40 |
42 |
43 | Scanning your account will not incur any charges to your AWS account.
44 |
45 |
46 |
47 |
48 |
49 | {/* Installation Steps */}
50 |
51 |
53 |
54 | )}
55 |
56 |
> = TDocumentType extends DocumentTypeDecoration<
8 | infer TType,
9 | any
10 | >
11 | ? [TType] extends [{ ' $fragmentName'?: infer TKey }]
12 | ? TKey extends string
13 | ? { ' $fragmentRefs'?: { [key in TKey]: TType } }
14 | : never
15 | : never
16 | : never;
17 |
18 | // return non-nullable if `fragmentType` is non-nullable
19 | export function useFragment(
20 | _documentNode: DocumentTypeDecoration,
21 | fragmentType: FragmentType>
22 | ): TType;
23 | // return nullable if `fragmentType` is undefined
24 | export function useFragment(
25 | _documentNode: DocumentTypeDecoration,
26 | fragmentType: FragmentType> | undefined
27 | ): TType | undefined;
28 | // return nullable if `fragmentType` is nullable
29 | export function useFragment(
30 | _documentNode: DocumentTypeDecoration,
31 | fragmentType: FragmentType> | null
32 | ): TType | null;
33 | // return nullable if `fragmentType` is nullable or undefined
34 | export function useFragment(
35 | _documentNode: DocumentTypeDecoration,
36 | fragmentType: FragmentType> | null | undefined
37 | ): TType | null | undefined;
38 | // return array of non-nullable if `fragmentType` is array of non-nullable
39 | export function useFragment(
40 | _documentNode: DocumentTypeDecoration,
41 | fragmentType: Array>>
42 | ): Array;
43 | // return array of nullable if `fragmentType` is array of nullable
44 | export function useFragment(
45 | _documentNode: DocumentTypeDecoration,
46 | fragmentType: Array>> | null | undefined
47 | ): Array | null | undefined;
48 | // return readonly array of non-nullable if `fragmentType` is array of non-nullable
49 | export function useFragment(
50 | _documentNode: DocumentTypeDecoration,
51 | fragmentType: ReadonlyArray>>
52 | ): ReadonlyArray;
53 | // return readonly array of nullable if `fragmentType` is array of nullable
54 | export function useFragment(
55 | _documentNode: DocumentTypeDecoration,
56 | fragmentType: ReadonlyArray>> | null | undefined
57 | ): ReadonlyArray | null | undefined;
58 | export function useFragment(
59 | _documentNode: DocumentTypeDecoration,
60 | fragmentType: FragmentType> | Array>> | ReadonlyArray>> | null | undefined
61 | ): TType | Array | ReadonlyArray | null | undefined {
62 | return fragmentType as any;
63 | }
64 |
65 |
66 | export function makeFragmentData<
67 | F extends DocumentTypeDecoration,
68 | FT extends ResultOf
69 | >(data: FT, _fragment: F): FragmentType {
70 | return data as FragmentType;
71 | }
72 | export function isFragmentReady(
73 | queryNode: DocumentTypeDecoration,
74 | fragmentNode: TypedDocumentNode,
75 | data: FragmentType, any>> | null | undefined
76 | ): data is FragmentType {
77 | const deferredFields = (queryNode as { __meta__?: { deferredFields: Record } }).__meta__
78 | ?.deferredFields;
79 |
80 | if (!deferredFields) return true;
81 |
82 | const fragDef = fragmentNode.definitions[0] as FragmentDefinitionNode | undefined;
83 | const fragName = fragDef?.name?.value;
84 |
85 | const fields = (fragName && deferredFields[fragName]) || [];
86 | return fields.length > 0 && fields.every(field => data && field in data);
87 | }
88 |
--------------------------------------------------------------------------------
/backend/awsmiddleware/scanner.go:
--------------------------------------------------------------------------------
1 | package awsmiddleware
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "guarddev/awsmiddleware/dynamodbscanner"
7 | "guarddev/awsmiddleware/ec2scanner"
8 | "guarddev/awsmiddleware/ecsscanner"
9 | "guarddev/awsmiddleware/iamscanner"
10 | "guarddev/awsmiddleware/lambdascanner"
11 | "guarddev/awsmiddleware/s3scanner"
12 | "guarddev/database/postgres"
13 |
14 | "go.opentelemetry.io/otel"
15 | "go.opentelemetry.io/otel/attribute"
16 | "go.uber.org/zap"
17 | )
18 |
19 | type ScanResults struct {
20 | ScanItem postgres.ScanItem
21 | ScanItemEntries []postgres.CreateNewScanItemEntryParams
22 | }
23 |
24 | func (a *AWSMiddleware) StartScan(ctx context.Context, accessKey, secretKey, sessionToken string, regions, services []string, accountId string) ([]ScanResults, error) {
25 | tracer := otel.Tracer("awsmiddleware/StartScan")
26 | ctx, span := tracer.Start(ctx, "StartScan")
27 | defer span.End()
28 |
29 | span.SetAttributes(
30 | attribute.StringSlice("aws.regions", regions),
31 | attribute.StringSlice("aws.services", services),
32 | attribute.String("aws.account_id", accountId),
33 | )
34 |
35 | var results []ScanResults
36 |
37 | logger := a.logger.Logger(ctx)
38 |
39 | for _, region := range regions {
40 | for _, service := range services {
41 | logger.Info("[AWSMiddleware/StartScan] Scanning Service", zap.String("Service", service), zap.String("Region", region))
42 | result, scanItems, err := a.scanService(ctx, accessKey, secretKey, sessionToken, region, service, accountId)
43 | if err != nil {
44 | span.RecordError(err)
45 | return nil, fmt.Errorf("error scanning %s in %s: %v", service, region, err)
46 | }
47 | results = append(results, ScanResults{
48 | ScanItem: result,
49 | ScanItemEntries: scanItems,
50 | })
51 | }
52 | }
53 |
54 | return results, nil
55 | }
56 |
57 | func (a *AWSMiddleware) scanService(ctx context.Context, accessKey, secretKey, sessionToken, region, service, accountId string) (postgres.ScanItem, []postgres.CreateNewScanItemEntryParams, error) {
58 | tracer := otel.Tracer("awsmiddleware/scanService")
59 | ctx, span := tracer.Start(ctx, "scanService")
60 | defer span.End()
61 |
62 | span.SetAttributes(
63 | attribute.String("aws.region", region),
64 | attribute.String("aws.service", service),
65 | attribute.String("aws.account_id", accountId),
66 | )
67 |
68 | result := postgres.ScanItem{
69 | Service: service,
70 | Region: region,
71 | }
72 |
73 | var scanItemEntries []postgres.CreateNewScanItemEntryParams = []postgres.CreateNewScanItemEntryParams{}
74 |
75 | var err error
76 | var findings []string
77 |
78 | switch service {
79 | case "s3":
80 | scanner := s3scanner.NewS3Scanner(accessKey, secretKey, sessionToken, region, accountId, a.logger, a.model)
81 | findings, scanItemEntries, err = scanner.ScanS3(ctx, region)
82 | case "ec2":
83 | scanner := ec2scanner.NewEC2Scanner(accessKey, secretKey, sessionToken, region, accountId, a.logger, a.model)
84 | findings, scanItemEntries, err = scanner.ScanEC2(ctx, region)
85 | case "ecs":
86 | scanner := ecsscanner.NewECSScanner(accessKey, secretKey, sessionToken, region, accountId, a.logger, a.model)
87 | findings, scanItemEntries, err = scanner.ScanECS(ctx, region)
88 | case "lambda":
89 | scanner := lambdascanner.NewLambdaScanner(accessKey, secretKey, sessionToken, region, accountId, a.logger, a.model)
90 | findings, scanItemEntries, err = scanner.ScanLambda(ctx, region)
91 | case "dynamodb":
92 | scanner := dynamodbscanner.NewDynamoDBScanner(accessKey, secretKey, sessionToken, region, accountId, a.logger, a.model)
93 | findings, scanItemEntries, err = scanner.ScanDynamoDB(ctx, region)
94 | case "iam":
95 | scanner := iamscanner.NewIAMScanner(accessKey, secretKey, sessionToken, region, accountId, a.logger, a.model)
96 | findings, scanItemEntries, err = scanner.ScanIAM(ctx, region)
97 | default:
98 | err = fmt.Errorf("unsupported service: %s", service)
99 | }
100 |
101 | if err != nil {
102 | span.RecordError(err)
103 | return result, nil, err
104 | }
105 |
106 | result.Findings = findings
107 | span.SetAttributes(attribute.Int("findings.count", len(findings)))
108 |
109 | return result, scanItemEntries, nil
110 | }
111 |
--------------------------------------------------------------------------------
/backend/awsmiddleware/main.go:
--------------------------------------------------------------------------------
1 | package awsmiddleware
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "guarddev/logger"
7 | "guarddev/modelapi"
8 | "os"
9 |
10 | "github.com/aws/aws-sdk-go/aws"
11 | "github.com/aws/aws-sdk-go/aws/credentials"
12 | "github.com/aws/aws-sdk-go/aws/session"
13 | "github.com/aws/aws-sdk-go/service/sts"
14 | "go.opentelemetry.io/otel"
15 | "go.opentelemetry.io/otel/attribute"
16 | )
17 |
18 | type AWSMiddleware struct {
19 | stsClient *sts.STS
20 | logger *logger.LogMiddleware
21 | model modelapi.ModelAPI
22 | selfHosted bool
23 | }
24 |
25 | type AssumeRoleProps struct {
26 | AWSAccountID string
27 | ExternalID string
28 | }
29 |
30 | type AssumeRoleResult struct {
31 | AccessKeyID string
32 | SecretAccessKey string
33 | SessionToken string
34 | }
35 |
36 | func Connect(logger *logger.LogMiddleware, model modelapi.ModelAPI) *AWSMiddleware {
37 | tracer := otel.Tracer("awsmiddleware/Connect")
38 | _, span := tracer.Start(context.Background(), "Connect")
39 | defer span.End()
40 |
41 | AWS_REGION := os.Getenv("AWS_REGION")
42 | selfHosting := os.Getenv("SELF_HOSTING") != ""
43 |
44 | span.SetAttributes(
45 | attribute.String("aws.region", AWS_REGION),
46 | )
47 |
48 | var sess *session.Session
49 | var stsClient *sts.STS
50 |
51 | if selfHosting {
52 | // Self-Hosting: Use provided credentials directly
53 | AWS_ACCESS_KEY_ID := os.Getenv("AWS_ACCESS_KEY_ID")
54 | AWS_SECRET_ACCESS_KEY := os.Getenv("AWS_SECRET_ACCESS_KEY")
55 |
56 | sess = session.Must(session.NewSession(&aws.Config{
57 | Region: aws.String(AWS_REGION),
58 | Credentials: credentials.NewStaticCredentials(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, ""),
59 | }))
60 | } else {
61 | // Production: Create a session that will use STS
62 | sess = session.Must(session.NewSession(&aws.Config{
63 | Region: aws.String(AWS_REGION),
64 | }))
65 | stsClient = sts.New(sess)
66 | }
67 |
68 | return &AWSMiddleware{
69 | stsClient: stsClient,
70 | logger: logger,
71 | model: model,
72 | selfHosted: selfHosting,
73 | }
74 | }
75 |
76 | func (a *AWSMiddleware) AssumeRole(ctx context.Context, props AssumeRoleProps) (*AssumeRoleResult, error) {
77 | tracer := otel.Tracer("awsmiddleware/AssumeRole")
78 | ctx, span := tracer.Start(ctx, "AssumeRole")
79 | defer span.End()
80 |
81 | if a.selfHosted {
82 | // Self-Hosting: Direct access is used, no role assumption necessary
83 | return nil, fmt.Errorf("AssumeRole is not applicable in self-hosting mode")
84 | }
85 |
86 | roleArn := fmt.Sprintf("arn:aws:iam::%s:role/GuardSecurityScanRole", props.AWSAccountID)
87 |
88 | span.SetAttributes(
89 | attribute.String("aws.account_id", props.AWSAccountID),
90 | attribute.String("aws.role_arn", roleArn),
91 | )
92 |
93 | input := &sts.AssumeRoleInput{
94 | RoleArn: aws.String(roleArn),
95 | RoleSessionName: aws.String("GuardSession"),
96 | ExternalId: aws.String(props.ExternalID),
97 | }
98 |
99 | result, err := a.stsClient.AssumeRoleWithContext(ctx, input)
100 | if err != nil {
101 | span.RecordError(err)
102 | return nil, fmt.Errorf("error assuming role: %v", err)
103 | }
104 |
105 | return &AssumeRoleResult{
106 | AccessKeyID: *result.Credentials.AccessKeyId,
107 | SecretAccessKey: *result.Credentials.SecretAccessKey,
108 | SessionToken: *result.Credentials.SessionToken,
109 | }, nil
110 | }
111 |
112 | // GetAccountID retrieves the AWS account ID for the given access key and secret key
113 | func (a *AWSMiddleware) GetAccountID(accessKey, secretKey string) (string, error) {
114 | // Create a new AWS session with provided credentials
115 | sess, err := session.NewSession(&aws.Config{
116 | Credentials: credentials.NewStaticCredentials(accessKey, secretKey, ""),
117 | Region: aws.String("us-west-2"), // Region is required, but it doesn’t matter for STS calls
118 | })
119 | if err != nil {
120 | return "", fmt.Errorf("failed to create session, %w", err)
121 | }
122 |
123 | // Create an STS client
124 | svc := sts.New(sess)
125 |
126 | // Call GetCallerIdentity to get account information
127 | result, err := svc.GetCallerIdentity(&sts.GetCallerIdentityInput{})
128 | if err != nil {
129 | return "", fmt.Errorf("failed to get caller identity, %w", err)
130 | }
131 |
132 | // Return the Account ID
133 | return *result.Account, nil
134 | }
135 |
--------------------------------------------------------------------------------
/backend/auth/main.go:
--------------------------------------------------------------------------------
1 | package auth
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "log"
7 | "net/http"
8 | "os"
9 | "strings"
10 |
11 | "github.com/clerkinc/clerk-sdk-go/clerk"
12 | "go.opentelemetry.io/otel"
13 | "go.opentelemetry.io/otel/attribute"
14 | )
15 |
16 | var userCtxKey = &contextKey{"userId"}
17 |
18 | type contextKey struct {
19 | name string
20 | }
21 |
22 | func Middleware() func(http.Handler) http.Handler {
23 | return func(next http.Handler) http.Handler {
24 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
25 | tracer := otel.Tracer("auth/Middleware")
26 | ctx, span := tracer.Start(r.Context(), "AuthMiddleware")
27 | defer span.End()
28 |
29 | selfHosting := os.Getenv("SELF_HOSTING") != ""
30 | if selfHosting {
31 | firstName := "Self"
32 | lastName := "Hosted"
33 | emailID := "mock_email_id"
34 | email := "support@guard.dev"
35 | user := clerk.User{
36 | ID: "mock_user_id",
37 | FirstName: &firstName,
38 | LastName: &lastName,
39 | PrimaryEmailAddressID: &emailID,
40 | EmailAddresses: []clerk.EmailAddress{
41 | {
42 | ID: emailID,
43 | EmailAddress: email,
44 | },
45 | },
46 | }
47 | ctx = AttachContext(ctx, &user)
48 | r = r.WithContext(ctx)
49 | next.ServeHTTP(w, r)
50 | return
51 | }
52 |
53 | vercelEnv := r.Header.Get("vercel_env")
54 | clientKey := os.Getenv("CLERK_SECRET_KEY")
55 |
56 | if vercelEnv == "preview" {
57 | clientKey = os.Getenv("CLERK_SECRET_KEY_ALTERNATIVE")
58 | }
59 |
60 | if clientKey == "" {
61 | log.Fatalln("ERROR: CANNOT FIND CLERK CLIENT KEY")
62 | }
63 |
64 | client, _ := clerk.NewClient(clientKey)
65 | header := r.Header.Get("Authorization")
66 |
67 | // User is unauthenticated.
68 | if header == "" {
69 | span.AddEvent("Unauthenticated user, no Authorization header")
70 | next.ServeHTTP(w, r)
71 | return
72 | }
73 |
74 | sessionToken := strings.Split(header, " ")[1]
75 | sessClaims, err := client.VerifyToken(sessionToken)
76 | if err != nil {
77 | span.RecordError(err)
78 | http.Error(w, "Invalid Authorization Token", http.StatusForbidden)
79 | return
80 | }
81 |
82 | user, err := client.Users().Read(sessClaims.Claims.Subject)
83 | if err != nil {
84 | span.RecordError(err)
85 | http.Error(w, "Malformed Authorization Token", http.StatusForbidden)
86 | return
87 | }
88 |
89 | span.SetAttributes(
90 | attribute.String("user.id", user.ID),
91 | attribute.String("user.email", user.EmailAddresses[0].EmailAddress),
92 | )
93 |
94 | ctx = AttachContext(ctx, user)
95 | r = r.WithContext(ctx)
96 | next.ServeHTTP(w, r)
97 | })
98 | }
99 | }
100 |
101 | func AttachContext(ctx context.Context, user *clerk.User) context.Context {
102 | return context.WithValue(ctx, userCtxKey, user)
103 | }
104 |
105 | func FromContext(ctx context.Context) *clerk.User {
106 | raw, _ := ctx.Value(userCtxKey).(*clerk.User)
107 | return raw
108 | }
109 |
110 | func EmailFromContext(ctx context.Context) (string, error) {
111 | tracer := otel.Tracer("auth/EmailFromContext")
112 | ctx, span := tracer.Start(ctx, "EmailFromContext")
113 | defer span.End()
114 |
115 | user := FromContext(ctx)
116 | return getEmail(ctx, user)
117 | }
118 |
119 | func getEmail(ctx context.Context, user *clerk.User) (string, error) {
120 | tracer := otel.Tracer("auth/getEmail")
121 | _, span := tracer.Start(ctx, "getEmail")
122 | defer span.End()
123 |
124 | if user == nil {
125 | err := fmt.Errorf("not logged in")
126 | span.RecordError(err)
127 | return "", err
128 | }
129 | for _, emailAddr := range user.EmailAddresses {
130 | if emailAddr.ID == *user.PrimaryEmailAddressID {
131 | return emailAddr.EmailAddress, nil
132 | }
133 | }
134 | return user.EmailAddresses[0].EmailAddress, nil
135 | }
136 |
137 | func FullnameFromContext(ctx context.Context) (string, error) {
138 | tracer := otel.Tracer("auth/FullnameFromContext")
139 | ctx, span := tracer.Start(ctx, "FullnameFromContext")
140 | defer span.End()
141 |
142 | user := FromContext(ctx)
143 | if user == nil {
144 | err := fmt.Errorf("not logged in")
145 | span.RecordError(err)
146 | return "", err
147 | }
148 | return fmt.Sprintf("%s %s", *user.FirstName, *user.LastName), nil
149 | }
150 |
--------------------------------------------------------------------------------
/frontend/components/ui/dialog.tsx:
--------------------------------------------------------------------------------
1 | "use client"
2 |
3 | import * as React from "react"
4 | import * as DialogPrimitive from "@radix-ui/react-dialog"
5 | import { Cross2Icon } from "@radix-ui/react-icons"
6 |
7 | import { cn } from "@/lib/utils"
8 |
9 | const Dialog = DialogPrimitive.Root
10 |
11 | const DialogTrigger = DialogPrimitive.Trigger
12 |
13 | const DialogPortal = DialogPrimitive.Portal
14 |
15 | const DialogClose = DialogPrimitive.Close
16 |
17 | const DialogOverlay = React.forwardRef<
18 | React.ElementRef,
19 | React.ComponentPropsWithoutRef
20 | >(({ className, ...props }, ref) => (
21 | ,
34 | React.ComponentPropsWithoutRef
35 | >(({ className, children, ...props }, ref) => (
36 |
37 |
46 | {children}
47 |
48 | Close
50 |
51 |
52 |
53 | ))
54 | DialogContent.displayName = DialogPrimitive.Content.displayName
55 |
56 | const DialogHeader = ({
57 | className,
58 | ...props
59 | }: React.HTMLAttributes) => (
60 |
67 | )
68 | DialogHeader.displayName = "DialogHeader"
69 |
70 | const DialogFooter = ({
71 | className,
72 | ...props
73 | }: React.HTMLAttributes) => (
74 |
81 | )
82 | DialogFooter.displayName = "DialogFooter"
83 |
84 | const DialogTitle = React.forwardRef<
85 | React.ElementRef,
86 | React.ComponentPropsWithoutRef
87 | >(({ className, ...props }, ref) => (
88 | ,
101 | React.ComponentPropsWithoutRef
102 | >(({ className, ...props }, ref) => (
103 | ,
20 | React.ComponentPropsWithoutRef
21 | >(({ className, ...props }, ref) => (
22 | ,
54 | VariantProps {}
55 |
56 | const SheetContent = React.forwardRef<
57 | React.ElementRef,
58 | SheetContentProps
59 | >(({ side = "right", className, children, ...props }, ref) => (
60 |
61 |
67 |
68 | Close
70 |
71 | {children}
72 |
73 |
74 | ))
75 | SheetContent.displayName = SheetPrimitive.Content.displayName
76 |
77 | const SheetHeader = ({
78 | className,
79 | ...props
80 | }: React.HTMLAttributes) => (
81 |
88 | )
89 | SheetHeader.displayName = "SheetHeader"
90 |
91 | const SheetFooter = ({
92 | className,
93 | ...props
94 | }: React.HTMLAttributes) => (
95 |
102 | )
103 | SheetFooter.displayName = "SheetFooter"
104 |
105 | const SheetTitle = React.forwardRef<
106 | React.ElementRef,
107 | React.ComponentPropsWithoutRef
108 | >(({ className, ...props }, ref) => (
109 | ,
119 | React.ComponentPropsWithoutRef
120 | >(({ className, ...props }, ref) => (
121 |
125 |
--------------------------------------------------------------------------------
/frontend/components/ui/command.tsx:
--------------------------------------------------------------------------------
1 | "use client"
2 |
3 | import * as React from "react"
4 | import { type DialogProps } from "@radix-ui/react-dialog"
5 | import { MagnifyingGlassIcon } from "@radix-ui/react-icons"
6 | import { Command as CommandPrimitive } from "cmdk"
7 |
8 | import { cn } from "@/lib/utils"
9 | import { Dialog, DialogContent } from "@/components/ui/dialog"
10 |
11 | const Command = React.forwardRef<
12 | React.ElementRef,
13 | React.ComponentPropsWithoutRef
14 | >(({ className, ...props }, ref) => (
15 |
31 |
32 |
33 | {children}
34 |
35 |
36 |
37 | )
38 | }
39 |
40 | const CommandInput = React.forwardRef<
41 | React.ElementRef,
42 | React.ComponentPropsWithoutRef
43 | >(({ className, ...props }, ref) => (
44 |
45 |
55 | ))
56 |
57 | CommandInput.displayName = CommandPrimitive.Input.displayName
58 |
59 | const CommandList = React.forwardRef<
60 | React.ElementRef,
61 | React.ComponentPropsWithoutRef
62 | >(({ className, ...props }, ref) => (
63 | ,
74 | React.ComponentPropsWithoutRef
75 | >((props, ref) => (
76 | ,
87 | React.ComponentPropsWithoutRef
88 | >(({ className, ...props }, ref) => (
89 | ,
103 | React.ComponentPropsWithoutRef
104 | >(({ className, ...props }, ref) => (
105 | ,
115 | React.ComponentPropsWithoutRef
116 | >(({ className, ...props }, ref) => (
117 | ) => {
133 | return (
134 | ,
22 | React.ComponentPropsWithoutRef
23 | >(({ className, children, ...props }, ref) => (
24 | span]:line-clamp-1",
28 | className
29 | )}
30 | {...props}
31 | >
32 | {children}
33 |
34 |
36 |
37 | ))
38 | SelectTrigger.displayName = SelectPrimitive.Trigger.displayName
39 |
40 | const SelectScrollUpButton = React.forwardRef<
41 | React.ElementRef,
42 | React.ComponentPropsWithoutRef
43 | >(({ className, ...props }, ref) => (
44 |
52 |
54 | ))
55 | SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName
56 |
57 | const SelectScrollDownButton = React.forwardRef<
58 | React.ElementRef,
59 | React.ComponentPropsWithoutRef
60 | >(({ className, ...props }, ref) => (
61 |
69 |
71 | ))
72 | SelectScrollDownButton.displayName =
73 | SelectPrimitive.ScrollDownButton.displayName
74 |
75 | const SelectContent = React.forwardRef<
76 | React.ElementRef,
77 | React.ComponentPropsWithoutRef
78 | >(({ className, children, position = "popper", ...props }, ref) => (
79 |
80 |
91 |
99 | {children}
100 |
101 |
103 |
104 | ))
105 | SelectContent.displayName = SelectPrimitive.Content.displayName
106 |
107 | const SelectLabel = React.forwardRef<
108 | React.ElementRef,
109 | React.ComponentPropsWithoutRef
110 | >(({ className, ...props }, ref) => (
111 | ,
121 | React.ComponentPropsWithoutRef
122 | >(({ className, children, ...props }, ref) => (
123 |
131 |
132 |
133 |
135 |
136 | {children}
137 |
138 | ))
139 | SelectItem.displayName = SelectPrimitive.Item.displayName
140 |
141 | const SelectSeparator = React.forwardRef<
142 | React.ElementRef,
143 | React.ComponentPropsWithoutRef
144 | >(({ className, ...props }, ref) => (
145 | = ({ handleCheckout }) => {
11 | const plans = [
12 | {
13 | name: 'Open Source',
14 | price: 'Free',
15 | extraPrice: '-',
16 | resources: 'Unlimited Resources',
17 | support: 'Community Support',
18 | features: [],
19 | cta: 'Self Host',
20 | lookupKey: '',
21 | href: "https://www.github.com/guard-dev/guard"
22 | },
23 | {
24 | name: 'Basic',
25 | price: '$150/mo',
26 | extraPrice: '$6 per 100 extra resources',
27 | resources: '1,000 Resources Included',
28 | support: 'Standard Support',
29 | features: [],
30 | cta: 'Get Started',
31 | lookupKey: 'guard_basic_monthly',
32 | href: "/console"
33 | },
34 | {
35 | name: 'Pro',
36 | price: '$400/mo',
37 | extraPrice: '$5 per 100 extra resources',
38 | resources: '5,000 Resources Included',
39 | support: 'Priority Support',
40 | features: [],
41 | cta: 'Get Started',
42 | lookupKey: 'guard_pro_monthly',
43 | href: "/console"
44 | },
45 | {
46 | name: 'Enterprise',
47 | price: 'Contact Us',
48 | extraPrice: '',
49 | resources: 'Unlimited Resources',
50 | support: 'Dedicated Support',
51 | features: [],
52 | cta: 'Contact Us',
53 | lookupKey: '',
54 | href: "https://www.cal.com/guard"
55 | },
56 | ];
57 |
58 |
59 | return (
60 |
61 |
Pricing Plans
62 |
63 | {plans.map((plan) => (
64 |
69 |
70 |
{plan.name}
71 |
72 | {plan.price}
73 |
74 | {plan.extraPrice !== '-' && plan.extraPrice !== '' && (
75 |
76 | Extra: {plan.extraPrice}
77 |
78 | )}
79 |
80 |
81 |
82 |
83 |
84 |
{plan.resources}
85 |
86 |
87 |
88 |
{plan.support}
89 |
90 |
91 |
92 | {handleCheckout && plan.lookupKey ? (
93 |
handleCheckout(plan.lookupKey)}
100 | >
101 | {plan.cta}
102 |
103 | ) : (
104 |
110 |
117 | {plan.cta}
118 |
119 |
120 | )}
121 |
122 | ))}
123 |
124 |
10 |
11 |
12 | {/* Hero Section */}
13 |
18 |
19 | {/* Features Section */}
20 |
27 |
28 | {/* Pricing Section
29 |
36 | */}
37 |
38 |
39 |
41 |
48 |
49 |
50 | guard
51 |
52 |
53 | AI-Powered Cloud Security, Simplified.
54 |
55 |
56 | Detect AWS misconfigurations in real-time and fix them with AI-driven, actionable insights.
57 |
58 |
59 |
60 |
77 |
78 |
88 |
89 |
119 |
Features
120 |
121 | {features.map((feature, index) => (
122 |
123 | {feature.icon}
124 |
{feature.title}
125 |
{feature.description}
126 |
127 | ))}
128 |
129 |