Sign Up
21 |22 |
17 |
27 | {loading ? ( 28 |
41 | );
42 | }
43 |
--------------------------------------------------------------------------------
/server/test/admin_logout_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 |
7 | "github.com/authorizerdev/authorizer/server/constants"
8 | "github.com/authorizerdev/authorizer/server/crypto"
9 | "github.com/authorizerdev/authorizer/server/memorystore"
10 | "github.com/authorizerdev/authorizer/server/resolvers"
11 | "github.com/stretchr/testify/assert"
12 | )
13 |
14 | func adminLogoutTests(t *testing.T, s TestSetup) {
15 | t.Helper()
16 | t.Run(`should get admin session`, func(t *testing.T) {
17 | req, ctx := createContext(s)
18 | _, err := resolvers.AdminLogoutResolver(ctx)
19 | assert.NotNil(t, err)
20 |
21 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
22 | assert.Nil(t, err)
23 |
24 | h, err := crypto.EncryptPassword(adminSecret)
25 | assert.Nil(t, err)
26 | req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
27 | _, err = resolvers.AdminLogoutResolver(ctx)
28 |
29 | assert.Nil(t, err)
30 | })
31 | }
32 |
--------------------------------------------------------------------------------
/server/resolvers/webhook.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/authorizerdev/authorizer/server/db"
8 | "github.com/authorizerdev/authorizer/server/graph/model"
9 | "github.com/authorizerdev/authorizer/server/token"
10 | "github.com/authorizerdev/authorizer/server/utils"
11 | log "github.com/sirupsen/logrus"
12 | )
13 |
14 | // WebhookResolver resolver for getting webhook by identifier
15 | func WebhookResolver(ctx context.Context, params model.WebhookRequest) (*model.Webhook, error) {
16 | gc, err := utils.GinContextFromContext(ctx)
17 | if err != nil {
18 | log.Debug("Failed to get GinContext: ", err)
19 | return nil, err
20 | }
21 |
22 | if !token.IsSuperAdmin(gc) {
23 | log.Debug("Not logged in as super admin")
24 | return nil, fmt.Errorf("unauthorized")
25 | }
26 |
27 | webhook, err := db.Provider.GetWebhookByID(ctx, params.ID)
28 | if err != nil {
29 | log.Debug("error getting webhook: ", err)
30 | return nil, err
31 | }
32 | return webhook, nil
33 | }
34 |
--------------------------------------------------------------------------------
/server/test/admin_session_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 |
7 | "github.com/authorizerdev/authorizer/server/constants"
8 | "github.com/authorizerdev/authorizer/server/crypto"
9 | "github.com/authorizerdev/authorizer/server/memorystore"
10 | "github.com/authorizerdev/authorizer/server/resolvers"
11 | "github.com/stretchr/testify/assert"
12 | )
13 |
14 | func adminSessionTests(t *testing.T, s TestSetup) {
15 | t.Helper()
16 | t.Run(`should get admin session`, func(t *testing.T) {
17 | req, ctx := createContext(s)
18 | _, err := resolvers.AdminSessionResolver(ctx)
19 | assert.NotNil(t, err)
20 |
21 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
22 | assert.Nil(t, err)
23 |
24 | h, err := crypto.EncryptPassword(adminSecret)
25 | assert.Nil(t, err)
26 | req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
27 | _, err = resolvers.AdminSessionResolver(ctx)
28 |
29 | assert.Nil(t, err)
30 | })
31 | }
32 |
--------------------------------------------------------------------------------
/server/db/models/env.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | // Note: any change here should be reflected in providers/casandra/provider.go as it does not have model support in collection creation
4 |
5 | // Env model for db
6 | type Env struct {
7 | Key string `json:"_key,omitempty" bson:"_key,omitempty" cql:"_key,omitempty" dynamo:"key,omitempty"` // for arangodb
8 | ID string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id" cql:"id" dynamo:"id,hash"`
9 | EnvData string `json:"env" bson:"env" cql:"env" dynamo:"env"`
10 | Hash string `json:"hash" bson:"hash" cql:"hash" dynamo:"hash"`
11 | EncryptionKey string `json:"encryption_key" bson:"encryption_key" cql:"encryption_key" dynamo:"encryption_key"` // couchbase has "hash" as reserved keyword so we cannot use it. This will be empty for other dbs.
12 | UpdatedAt int64 `json:"updated_at" bson:"updated_at" cql:"updated_at" dynamo:"updated_at"`
13 | CreatedAt int64 `json:"created_at" bson:"created_at" cql:"created_at" dynamo:"created_at"`
14 | }
15 |
--------------------------------------------------------------------------------
/server/memorystore/providers/inmemory/stores/state_store.go:
--------------------------------------------------------------------------------
1 | package stores
2 |
3 | import (
4 | "sync"
5 | )
6 |
7 | // StateStore struct to store the env variables
8 | type StateStore struct {
9 | mutex sync.Mutex
10 | store map[string]string
11 | }
12 |
13 | // NewStateStore create a new state store
14 | func NewStateStore() *StateStore {
15 | return &StateStore{
16 | mutex: sync.Mutex{},
17 | store: make(map[string]string),
18 | }
19 | }
20 |
21 | // Get returns the value of the key in state store
22 | func (s *StateStore) Get(key string) string {
23 | s.mutex.Lock()
24 | defer s.mutex.Unlock()
25 | return s.store[key]
26 | }
27 |
28 | // Set sets the value of the key in state store
29 | func (s *StateStore) Set(key string, value string) {
30 | s.mutex.Lock()
31 | defer s.mutex.Unlock()
32 |
33 | s.store[key] = value
34 | }
35 |
36 | // Remove removes the key from state store
37 | func (s *StateStore) Remove(key string) {
38 | s.mutex.Lock()
39 | defer s.mutex.Unlock()
40 |
41 | delete(s.store, key)
42 | }
43 |
--------------------------------------------------------------------------------
/server/test/env_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 |
7 | "github.com/authorizerdev/authorizer/server/constants"
8 | "github.com/authorizerdev/authorizer/server/crypto"
9 | "github.com/authorizerdev/authorizer/server/memorystore"
10 | "github.com/authorizerdev/authorizer/server/resolvers"
11 | "github.com/stretchr/testify/assert"
12 | )
13 |
14 | func envTests(t *testing.T, s TestSetup) {
15 | t.Helper()
16 | t.Run(`should get envs`, func(t *testing.T) {
17 | req, ctx := createContext(s)
18 | _, err := resolvers.EnvResolver(ctx)
19 | assert.NotNil(t, err)
20 |
21 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
22 | assert.Nil(t, err)
23 |
24 | h, err := crypto.EncryptPassword(adminSecret)
25 | assert.Nil(t, err)
26 | req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
27 | res, err := resolvers.EnvResolver(ctx)
28 | assert.Nil(t, err)
29 | assert.Equal(t, *res.AdminSecret, adminSecret)
30 | })
31 | }
32 |
--------------------------------------------------------------------------------
/server/db/providers/dynamodb/shared.go:
--------------------------------------------------------------------------------
1 | package dynamodb
2 |
3 | import (
4 | "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
5 | "github.com/guregu/dynamo"
6 | )
7 |
8 | // As updpate all item not supported so set manually via Set and SetNullable for empty field
9 | func UpdateByHashKey(table dynamo.Table, hashKey string, hashValue string, item interface{}) error {
10 | existingValue, err := dynamo.MarshalItem(item)
11 | var i interface{}
12 | if err != nil {
13 | return err
14 | }
15 | nullableValue, err := dynamodbattribute.MarshalMap(item)
16 | if err != nil {
17 | return err
18 | }
19 | u := table.Update(hashKey, hashValue)
20 | for k, v := range existingValue {
21 | if k == hashKey {
22 | continue
23 | }
24 | u = u.Set(k, v)
25 | }
26 | for k, v := range nullableValue {
27 | if k == hashKey {
28 | continue
29 | }
30 | dynamodbattribute.Unmarshal(v, &i)
31 | if i == nil {
32 | u = u.SetNullable(k, v)
33 | }
34 | }
35 | err = u.Run()
36 | if err != nil {
37 | return err
38 | }
39 | return nil
40 | }
41 |
--------------------------------------------------------------------------------
/scripts/build-mac.sh:
--------------------------------------------------------------------------------
1 | VERSION="$1"
2 | make clean && make build-app && CGO_ENABLED=1 VERSION=${VERSION} make
3 | FILE_NAME=authorizer-${VERSION}-darwin-amd64.tar.gz
4 | tar cvfz ${FILE_NAME} .env app/build build templates dashboard/build
5 | AUTH="Authorization: token $GITHUB_TOKEN"
6 | RELASE_INFO=$(curl -sH "$AUTH" https://api.github.com/repos/authorizerdev/authorizer/releases/tags/${VERSION})
7 | echo $RELASE_INFO
8 |
9 | eval $(echo "$RELASE_INFO" | grep -m 1 "id.:" | grep -w id | tr : = | tr -cd '[[:alnum:]]=')
10 | [ "$id" ] || { echo "Error: Failed to get release id for tag: $VERSION"; echo "$RELASE_INFO" | awk 'length($0)<100' >&2; exit 1; }
11 | echo $id
12 | GH_ASSET="https://uploads.github.com/repos/authorizerdev/authorizer/releases/$id/assets?name=$(basename $FILE_NAME)"
13 |
14 | echo $GH_ASSET
15 |
16 | curl -H $AUTH -H "Content-Type: $(file -b --mime-type $FILE_NAME)" --data-binary @$FILE_NAME $GH_ASSET
17 |
18 | curl "$GITHUB_OAUTH_BASIC" --data-binary @"$FILE_NAME" -H "Authorization: token $GITHUB_TOKEN" -H "Content-Type: application/octet-stream" $GH_ASSET
19 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Bug report
3 | about: Create a report to help us improve
4 | title: ''
5 | labels: bug
6 | assignees: ''
7 | ---
8 |
9 | **Version:** x.y.z
10 |
11 |
12 |
13 | **Describe the bug**
14 |
15 |
16 |
17 | **Steps To Reproduce**
18 |
19 |
20 |
21 | **Expected behavior**
22 |
23 |
24 |
25 | **Screenshots**
26 |
27 |
28 |
29 | **Desktop (please complete the following information):**
30 |
31 | - OS: [e.g. iOS]
32 | - Browser [e.g. chrome, safari]
33 | - Version [e.g. 22]
34 |
35 | **Additional context**
36 |
37 |
38 |
--------------------------------------------------------------------------------
/server/utils/file.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "errors"
5 | "os"
6 | )
7 |
8 | // CreateFolder creates a folder in Current working dir
9 | func CreateFolder(dir string) (string, error) {
10 | pwd, err := os.Getwd()
11 | if err != nil {
12 | return "", err
13 | }
14 | path := pwd + "/" + dir
15 | err = os.Mkdir(path, 0o755)
16 | if err == nil {
17 | return path, nil
18 | }
19 | if os.IsExist(err) {
20 | // check that the existing path is a directory
21 | info, err := os.Stat(path)
22 | if err != nil {
23 | return "", err
24 | }
25 | if !info.IsDir() {
26 | return "", errors.New("path exists but is not a directory")
27 | }
28 | return path, nil
29 | }
30 | return path, err
31 | }
32 |
33 | // CreateFile creates a file on given path with given content
34 | func CreateFile(filePath string, content string) error {
35 | f, err := os.Create(filePath)
36 | if err != nil {
37 | return err
38 | }
39 |
40 | defer f.Close()
41 |
42 | _, err = f.WriteString(content)
43 |
44 | if err != nil {
45 | return err
46 | }
47 | return nil
48 | }
49 |
--------------------------------------------------------------------------------
/server/constants/oauth2.go:
--------------------------------------------------------------------------------
1 | package constants
2 |
3 | const (
4 | // - query: for Authorization Code grant. 302 Found triggers redirect.
5 | ResponseModeQuery = "query"
6 | // - fragment: for Implicit grant. 302 Found triggers redirect.
7 | ResponseModeFragment = "fragment"
8 | // - form_post: 200 OK with response parameters embedded in an HTML form as hidden parameters.
9 | ResponseModeFormPost = "form_post"
10 | // - web_message: For Silent Authentication. Uses HTML5 web messaging.
11 | ResponseModeWebMessage = "web_message"
12 |
13 | // For the Authorization Code grant, use response_type=code to include the authorization code.
14 | ResponseTypeCode = "code"
15 | // For the Implicit grant, use response_type=token to include an access token.
16 | ResponseTypeToken = "token"
17 | // For the Implicit grant of id_token, use response_type=id_token to include an identifier token.
18 | ResponseTypeIDToken = "id_token"
19 |
20 | // Constant indicating the "signup" screen hint for customizing authentication process and redirect to a signup page.
21 | ScreenHintSignUp = "signup"
22 | )
23 |
--------------------------------------------------------------------------------
/server/resolvers/users.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | log "github.com/sirupsen/logrus"
8 |
9 | "github.com/authorizerdev/authorizer/server/db"
10 | "github.com/authorizerdev/authorizer/server/graph/model"
11 | "github.com/authorizerdev/authorizer/server/token"
12 | "github.com/authorizerdev/authorizer/server/utils"
13 | )
14 |
15 | // UsersResolver is a resolver for users query
16 | // This is admin only query
17 | func UsersResolver(ctx context.Context, params *model.PaginatedInput) (*model.Users, error) {
18 | gc, err := utils.GinContextFromContext(ctx)
19 | if err != nil {
20 | log.Debug("Failed to get GinContext: ", err)
21 | return nil, err
22 | }
23 |
24 | if !token.IsSuperAdmin(gc) {
25 | log.Debug("Not logged in as super admin.")
26 | return nil, fmt.Errorf("unauthorized")
27 | }
28 |
29 | pagination := utils.GetPagination(params)
30 |
31 | res, err := db.Provider.ListUsers(ctx, pagination)
32 | if err != nil {
33 | log.Debug("Failed to get users: ", err)
34 | return nil, err
35 | }
36 |
37 | return res, nil
38 | }
39 |
--------------------------------------------------------------------------------
/server/authenticators/providers/providers.go:
--------------------------------------------------------------------------------
1 | package providers
2 |
3 | import "context"
4 |
5 | // AuthenticatorConfig defines authenticator config
6 | type AuthenticatorConfig struct {
7 | // ScannerImage is the base64 of QR code image
8 | ScannerImage string
9 | // Secrets is the secret key
10 | Secret string
11 | // RecoveryCode is the list of recovery codes
12 | RecoveryCodes []string
13 | // RecoveryCodeMap is the map of recovery codes
14 | RecoveryCodeMap map[string]bool
15 | }
16 |
17 | // Provider defines authenticators provider
18 | type Provider interface {
19 | // Generate totp: to generate totp, store secret into db and returns base64 of QR code image
20 | Generate(ctx context.Context, id string) (*AuthenticatorConfig, error)
21 | // Validate totp: user passcode with secret stored in our db
22 | Validate(ctx context.Context, passcode string, userID string) (bool, error)
23 | // ValidateRecoveryCode totp: allows user to validate using recovery code incase if they lost their device
24 | ValidateRecoveryCode(ctx context.Context, recoveryCode, userID string) (bool, error)
25 | }
26 |
--------------------------------------------------------------------------------
/server/resolvers/webhooks.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/authorizerdev/authorizer/server/db"
8 | "github.com/authorizerdev/authorizer/server/graph/model"
9 | "github.com/authorizerdev/authorizer/server/token"
10 | "github.com/authorizerdev/authorizer/server/utils"
11 | log "github.com/sirupsen/logrus"
12 | )
13 |
14 | // WebhooksResolver resolver for getting the list of webhooks based on pagination
15 | func WebhooksResolver(ctx context.Context, params *model.PaginatedInput) (*model.Webhooks, error) {
16 | gc, err := utils.GinContextFromContext(ctx)
17 | if err != nil {
18 | log.Debug("Failed to get GinContext: ", err)
19 | return nil, err
20 | }
21 |
22 | if !token.IsSuperAdmin(gc) {
23 | log.Debug("Not logged in as super admin")
24 | return nil, fmt.Errorf("unauthorized")
25 | }
26 |
27 | pagination := utils.GetPagination(params)
28 | webhooks, err := db.Provider.ListWebhook(ctx, pagination)
29 | if err != nil {
30 | log.Debug("failed to get webhooks: ", err)
31 | return nil, err
32 | }
33 | return webhooks, nil
34 | }
35 |
--------------------------------------------------------------------------------
/server/db/providers/cassandradb/session.go:
--------------------------------------------------------------------------------
1 | package cassandradb
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "time"
7 |
8 | "github.com/authorizerdev/authorizer/server/db/models"
9 | "github.com/google/uuid"
10 | )
11 |
12 | // AddSession to save session information in database
13 | func (p *provider) AddSession(ctx context.Context, session *models.Session) error {
14 | if session.ID == "" {
15 | session.ID = uuid.New().String()
16 | }
17 | session.CreatedAt = time.Now().Unix()
18 | session.UpdatedAt = time.Now().Unix()
19 | insertSessionQuery := fmt.Sprintf("INSERT INTO %s (id, user_id, user_agent, ip, created_at, updated_at) VALUES ('%s', '%s', '%s', '%s', %d, %d)", KeySpace+"."+models.Collections.Session, session.ID, session.UserID, session.UserAgent, session.IP, session.CreatedAt, session.UpdatedAt)
20 | err := p.db.Query(insertSessionQuery).Exec()
21 | if err != nil {
22 | return err
23 | }
24 | return nil
25 | }
26 |
27 | // DeleteSession to delete session information from database
28 | func (p *provider) DeleteSession(ctx context.Context, userId string) error {
29 | return nil
30 | }
31 |
--------------------------------------------------------------------------------
/dashboard/src/layouts/DashboardLayout.tsx:
--------------------------------------------------------------------------------
1 | import {
2 | Box,
3 | Drawer,
4 | DrawerContent,
5 | useDisclosure,
6 | useColorModeValue,
7 | } from '@chakra-ui/react';
8 | import React, { ReactNode } from 'react';
9 | import { Sidebar, MobileNav } from '../components/Menu';
10 |
11 | export function DashboardLayout({ children }: { children: ReactNode }) {
12 | const { isOpen, onOpen, onClose } = useDisclosure();
13 | return (
14 | Hey 👋,
18 |Thank you for using authorizer.
19 |20 | Your email address is{' '} 21 | 22 | {user?.email} 23 | 24 |
25 | 26 |27 | {loading ? ( 28 |
Processing....
29 | ) : ( 30 |37 | Logout 38 |
39 | )} 40 |
10 | {' '}
11 |
12 | Domain White Listing
13 |
14 |
15 |
16 |
17 | Allowed Origins:
18 |
19 |
23 |
29 |
30 |
31 |
32 | );
33 | };
34 |
35 | export default DomainWhiteListing;
36 |
--------------------------------------------------------------------------------
/dashboard/src/utils/parseCSV.ts:
--------------------------------------------------------------------------------
1 | import _flatten from 'lodash/flatten';
2 | import { validateEmail } from '.';
3 |
4 | interface dataTypes {
5 | value: string;
6 | isInvalid: boolean;
7 | }
8 |
9 | const parseCSV = (file: File, delimiter: string): Promise
9 | {' '}
10 |
11 | Session Storage
12 |
13 |
14 | Note: Redis related environment variables cannot be updated from
15 | dashboard. Please use .env file or OS environment variables to update
16 | it.
17 |
18 |
19 |
20 |
21 | Redis URL:
22 |
23 |
27 |
36 |
37 |
38 |
39 | );
40 | };
41 |
42 | export default SessionStorage;
43 |
--------------------------------------------------------------------------------
/server/resolvers/delete_webhook.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/authorizerdev/authorizer/server/db"
8 | "github.com/authorizerdev/authorizer/server/graph/model"
9 | "github.com/authorizerdev/authorizer/server/token"
10 | "github.com/authorizerdev/authorizer/server/utils"
11 | log "github.com/sirupsen/logrus"
12 | )
13 |
14 | // DeleteWebhookResolver resolver to delete webhook and its relevant logs
15 | func DeleteWebhookResolver(ctx context.Context, params model.WebhookRequest) (*model.Response, error) {
16 | gc, err := utils.GinContextFromContext(ctx)
17 | if err != nil {
18 | log.Debug("Failed to get GinContext: ", err)
19 | return nil, err
20 | }
21 |
22 | if !token.IsSuperAdmin(gc) {
23 | log.Debug("Not logged in as super admin")
24 | return nil, fmt.Errorf("unauthorized")
25 | }
26 |
27 | if params.ID == "" {
28 | log.Debug("webhookID is required")
29 | return nil, fmt.Errorf("webhook ID required")
30 | }
31 |
32 | log := log.WithField("webhook_id", params.ID)
33 |
34 | webhook, err := db.Provider.GetWebhookByID(ctx, params.ID)
35 | if err != nil {
36 | log.Debug("failed to get webhook: ", err)
37 | return nil, err
38 | }
39 |
40 | err = db.Provider.DeleteWebhook(ctx, webhook)
41 | if err != nil {
42 | log.Debug("failed to delete webhook: ", err)
43 | return nil, err
44 | }
45 |
46 | return &model.Response{
47 | Message: "Webhook deleted successfully",
48 | }, nil
49 | }
50 |
--------------------------------------------------------------------------------
/scripts/couchbase-test.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | set -x
4 | set -m
5 |
6 | sleep 15
7 |
8 | # Setup index and memory quota
9 | # curl -v -X POST http://127.0.0.1:8091/pools/default -d memoryQuota=300 -d indexMemoryQuota=300
10 |
11 | # Setup services
12 | curl -v http://127.0.0.1:8091/node/controller/setupServices -d services=kv%2Cn1ql%2Cindex
13 |
14 | # Setup credentials
15 | curl -v http://127.0.0.1:8091/settings/web -d port=8091 -d username=Administrator -d password=password
16 |
17 | # Setup Memory Optimized Indexes
18 | curl -i -u Administrator:password -X POST http://127.0.0.1:8091/settings/indexes -d 'storageMode=memory_optimized'
19 |
20 | # Load travel-sample bucket
21 | #curl -v -u Administrator:password -X POST http://127.0.0.1:8091/sampleBuckets/install -d '["travel-sample"]'
22 |
23 | echo "Type: $TYPE"
24 |
25 | if [ "$TYPE" = "WORKER" ]; then
26 | echo "Sleeping ..."
27 | sleep 15
28 |
29 | #IP=`hostname -s`
30 | IP=`hostname -I | cut -d ' ' -f1`
31 | echo "IP: " $IP
32 |
33 | echo "Auto Rebalance: $AUTO_REBALANCE"
34 | if [ "$AUTO_REBALANCE" = "true" ]; then
35 | couchbase-cli rebalance --cluster=$COUCHBASE_MASTER:8091 --user=Administrator --password=password --server-add=$IP --server-add-username=Administrator --server-add-password=password
36 | else
37 | couchbase-cli server-add --cluster=$COUCHBASE_MASTER:8091 --user=Administrator --password=password --server-add=$IP --server-add-username=Administrator --server-add-password=password
38 | fi;
39 | fi;
--------------------------------------------------------------------------------
/server/resolvers/admin_login.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | log "github.com/sirupsen/logrus"
8 |
9 | "github.com/authorizerdev/authorizer/server/constants"
10 | "github.com/authorizerdev/authorizer/server/cookie"
11 | "github.com/authorizerdev/authorizer/server/crypto"
12 | "github.com/authorizerdev/authorizer/server/graph/model"
13 | "github.com/authorizerdev/authorizer/server/memorystore"
14 | "github.com/authorizerdev/authorizer/server/utils"
15 | )
16 |
17 | // AdminLoginResolver is a resolver for admin login mutation
18 | func AdminLoginResolver(ctx context.Context, params model.AdminLoginInput) (*model.Response, error) {
19 | var res *model.Response
20 |
21 | gc, err := utils.GinContextFromContext(ctx)
22 | if err != nil {
23 | log.Debug("Failed to get GinContext: ", err)
24 | return res, err
25 | }
26 |
27 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
28 | if err != nil {
29 | log.Debug("Error getting admin secret: ", err)
30 | return res, err
31 | }
32 | if params.AdminSecret != adminSecret {
33 | log.Debug("Admin secret is not correct")
34 | return res, fmt.Errorf(`invalid admin secret`)
35 | }
36 |
37 | hashedKey, err := crypto.EncryptPassword(adminSecret)
38 | if err != nil {
39 | return res, err
40 | }
41 | cookie.SetAdminCookie(gc, hashedKey)
42 |
43 | res = &model.Response{
44 | Message: "admin logged in successfully",
45 | }
46 | return res, nil
47 | }
48 |
--------------------------------------------------------------------------------
/server/logs/logs.go:
--------------------------------------------------------------------------------
1 | package logs
2 |
3 | import (
4 | "os"
5 |
6 | "github.com/sirupsen/logrus"
7 | log "github.com/sirupsen/logrus"
8 | )
9 |
10 | // LogUTCFormatter hels in setting UTC time format for the logs
11 | type LogUTCFormatter struct {
12 | log.Formatter
13 | }
14 |
15 | // Format helps fomratting time to UTC
16 | func (u LogUTCFormatter) Format(e *log.Entry) ([]byte, error) {
17 | e.Time = e.Time.UTC()
18 | return u.Formatter.Format(e)
19 | }
20 |
21 | func InitLog(cliLogLevel string) *log.Logger {
22 |
23 | // log instance for gin server
24 | log := logrus.New()
25 | log.SetFormatter(LogUTCFormatter{&logrus.JSONFormatter{}})
26 |
27 | if cliLogLevel == "" {
28 | cliLogLevel = os.Getenv("LOG_LEVEL")
29 | }
30 |
31 | var logLevel logrus.Level
32 | switch cliLogLevel {
33 | case "debug":
34 | logLevel = logrus.DebugLevel
35 | case "info":
36 | logLevel = logrus.InfoLevel
37 | case "warn":
38 | logLevel = logrus.WarnLevel
39 | case "error":
40 | logLevel = logrus.ErrorLevel
41 | case "fatal":
42 | logLevel = logrus.FatalLevel
43 | case "panic":
44 | logLevel = logrus.PanicLevel
45 | default:
46 | logLevel = logrus.InfoLevel
47 | }
48 | // set log level globally
49 | logrus.SetLevel(logLevel)
50 |
51 | // set log level for go-gin middleware
52 | log.SetLevel(logLevel)
53 |
54 | // show file path in log for debug or other log levels.
55 | if logLevel != logrus.InfoLevel {
56 | logrus.SetReportCaller(true)
57 | log.SetReportCaller(true)
58 | }
59 |
60 | return log
61 | }
62 |
--------------------------------------------------------------------------------
/server/handlers/playground.go:
--------------------------------------------------------------------------------
1 | package handlers
2 |
3 | import (
4 | "net/http"
5 |
6 | "github.com/99designs/gqlgen/graphql/playground"
7 | "github.com/gin-gonic/gin"
8 |
9 | log "github.com/sirupsen/logrus"
10 |
11 | "github.com/authorizerdev/authorizer/server/constants"
12 | "github.com/authorizerdev/authorizer/server/memorystore"
13 | "github.com/authorizerdev/authorizer/server/token"
14 | )
15 |
16 | // PlaygroundHandler is the handler for the /playground route
17 | func PlaygroundHandler() gin.HandlerFunc {
18 | return func(c *gin.Context) {
19 | var h http.HandlerFunc
20 |
21 | disablePlayground, err := memorystore.Provider.GetBoolStoreEnvVariable(constants.EnvKeyDisablePlayGround)
22 | if err != nil {
23 | log.Debug("error while getting disable playground value")
24 | disablePlayground = false
25 | }
26 |
27 | // if env set to false, then check if logged in as super admin, if logged in then return graphql else 401 error
28 | // if env set to true, then disabled the playground with 404 error
29 | if !disablePlayground {
30 | if token.IsSuperAdmin(c) {
31 | h = playground.Handler("GraphQL", "/graphql")
32 | } else {
33 | log.Debug("not logged in as super admin")
34 | c.JSON(http.StatusUnauthorized, gin.H{"error": "not logged in as super admin"})
35 | return
36 | }
37 | } else {
38 | log.Debug("playground is disabled")
39 | c.JSON(http.StatusNotFound, gin.H{"error": "playground is disabled"})
40 | return
41 | }
42 | h.ServeHTTP(c.Writer, c.Request)
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/server/resolvers/webhook_logs.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/authorizerdev/authorizer/server/db"
8 | "github.com/authorizerdev/authorizer/server/graph/model"
9 | "github.com/authorizerdev/authorizer/server/refs"
10 | "github.com/authorizerdev/authorizer/server/token"
11 | "github.com/authorizerdev/authorizer/server/utils"
12 | log "github.com/sirupsen/logrus"
13 | )
14 |
15 | // WebhookLogsResolver resolver for getting the list of webhook_logs based on pagination & webhook identifier
16 | func WebhookLogsResolver(ctx context.Context, params *model.ListWebhookLogRequest) (*model.WebhookLogs, error) {
17 | gc, err := utils.GinContextFromContext(ctx)
18 | if err != nil {
19 | log.Debug("Failed to get GinContext: ", err)
20 | return nil, err
21 | }
22 |
23 | if !token.IsSuperAdmin(gc) {
24 | log.Debug("Not logged in as super admin")
25 | return nil, fmt.Errorf("unauthorized")
26 | }
27 |
28 | var pagination *model.Pagination
29 | var webhookID string
30 |
31 | if params != nil {
32 | pagination = utils.GetPagination(&model.PaginatedInput{
33 | Pagination: params.Pagination,
34 | })
35 | webhookID = refs.StringValue(params.WebhookID)
36 | } else {
37 | pagination = utils.GetPagination(nil)
38 | webhookID = ""
39 | }
40 | // TODO fix
41 | webhookLogs, err := db.Provider.ListWebhookLogs(ctx, pagination, webhookID)
42 | if err != nil {
43 | log.Debug("failed to get webhook logs: ", err)
44 | return nil, err
45 | }
46 | return webhookLogs, nil
47 | }
48 |
--------------------------------------------------------------------------------
/server/test/delete_user_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 |
7 | "github.com/authorizerdev/authorizer/server/constants"
8 | "github.com/authorizerdev/authorizer/server/crypto"
9 | "github.com/authorizerdev/authorizer/server/graph/model"
10 | "github.com/authorizerdev/authorizer/server/memorystore"
11 | "github.com/authorizerdev/authorizer/server/refs"
12 | "github.com/authorizerdev/authorizer/server/resolvers"
13 | "github.com/stretchr/testify/assert"
14 | )
15 |
16 | func deleteUserTest(t *testing.T, s TestSetup) {
17 | t.Helper()
18 | t.Run(`should delete users with admin secret only`, func(t *testing.T) {
19 | req, ctx := createContext(s)
20 | email := "delete_user." + s.TestInfo.Email
21 | resolvers.SignupResolver(ctx, model.SignUpInput{
22 | Email: refs.NewStringRef(email),
23 | Password: s.TestInfo.Password,
24 | ConfirmPassword: s.TestInfo.Password,
25 | })
26 |
27 | _, err := resolvers.DeleteUserResolver(ctx, model.DeleteUserInput{
28 | Email: email,
29 | })
30 | assert.NotNil(t, err, "unauthorized")
31 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
32 | assert.Nil(t, err)
33 |
34 | h, err := crypto.EncryptPassword(adminSecret)
35 | assert.Nil(t, err)
36 | req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
37 |
38 | _, err = resolvers.DeleteUserResolver(ctx, model.DeleteUserInput{
39 | Email: email,
40 | })
41 | assert.Nil(t, err)
42 | cleanData(email)
43 | })
44 | }
45 |
--------------------------------------------------------------------------------
/server/db/providers/couchbase/shared.go:
--------------------------------------------------------------------------------
1 | package couchbase
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "reflect"
7 | "strings"
8 |
9 | "github.com/couchbase/gocb/v2"
10 | )
11 |
12 | func GetSetFields(webhookMap map[string]interface{}) (string, map[string]interface{}) {
13 | params := make(map[string]interface{}, 1)
14 | updateFields := ""
15 | for key, value := range webhookMap {
16 | if key == "_id" {
17 | continue
18 | }
19 | if key == "_key" {
20 | continue
21 | }
22 | if value == nil {
23 | updateFields += fmt.Sprintf("%s=$%s,", key, key)
24 | params[key] = "null"
25 | continue
26 | }
27 | valueType := reflect.TypeOf(value)
28 | if valueType.Name() == "string" {
29 | updateFields += fmt.Sprintf("%s = $%s, ", key, key)
30 | params[key] = value.(string)
31 |
32 | } else {
33 | updateFields += fmt.Sprintf("%s = $%s, ", key, key)
34 | params[key] = value
35 | }
36 | }
37 | updateFields = strings.Trim(updateFields, " ")
38 | updateFields = strings.TrimSuffix(updateFields, ",")
39 | return updateFields, params
40 | }
41 |
42 | func (p *provider) GetTotalDocs(ctx context.Context, collection string) (int64, error) {
43 | totalDocs := TotalDocs{}
44 | countQuery := fmt.Sprintf("SELECT COUNT(*) as Total FROM %s.%s", p.scopeName, collection)
45 | queryRes, err := p.db.Query(countQuery, &gocb.QueryOptions{
46 | Context: ctx,
47 | })
48 | queryRes.One(&totalDocs)
49 | if err != nil {
50 | return 0, err
51 | }
52 | return totalDocs.Total, nil
53 | }
54 |
55 | type TotalDocs struct {
56 | Total int64
57 | }
58 |
--------------------------------------------------------------------------------
/server/resolvers/delete_email_template.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | "github.com/authorizerdev/authorizer/server/db"
8 | "github.com/authorizerdev/authorizer/server/graph/model"
9 | "github.com/authorizerdev/authorizer/server/token"
10 | "github.com/authorizerdev/authorizer/server/utils"
11 | log "github.com/sirupsen/logrus"
12 | )
13 |
14 | // DeleteEmailTemplateResolver resolver to delete email template and its relevant logs
15 | func DeleteEmailTemplateResolver(ctx context.Context, params model.DeleteEmailTemplateRequest) (*model.Response, error) {
16 | gc, err := utils.GinContextFromContext(ctx)
17 | if err != nil {
18 | log.Debug("Failed to get GinContext: ", err)
19 | return nil, err
20 | }
21 |
22 | if !token.IsSuperAdmin(gc) {
23 | log.Debug("Not logged in as super admin")
24 | return nil, fmt.Errorf("unauthorized")
25 | }
26 |
27 | if params.ID == "" {
28 | log.Debug("email template is required")
29 | return nil, fmt.Errorf("email template ID required")
30 | }
31 |
32 | log := log.WithField("email_template_id", params.ID)
33 |
34 | emailTemplate, err := db.Provider.GetEmailTemplateByID(ctx, params.ID)
35 | if err != nil {
36 | log.Debug("failed to get email template: ", err)
37 | return nil, err
38 | }
39 |
40 | err = db.Provider.DeleteEmailTemplate(ctx, emailTemplate)
41 | if err != nil {
42 | log.Debug("failed to delete email template: ", err)
43 | return nil, err
44 | }
45 |
46 | return &model.Response{
47 | Message: "Email templated deleted successfully",
48 | }, nil
49 | }
50 |
--------------------------------------------------------------------------------
/server/resolvers/admin_session.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | log "github.com/sirupsen/logrus"
8 |
9 | "github.com/authorizerdev/authorizer/server/constants"
10 | "github.com/authorizerdev/authorizer/server/cookie"
11 | "github.com/authorizerdev/authorizer/server/crypto"
12 | "github.com/authorizerdev/authorizer/server/graph/model"
13 | "github.com/authorizerdev/authorizer/server/memorystore"
14 | "github.com/authorizerdev/authorizer/server/token"
15 | "github.com/authorizerdev/authorizer/server/utils"
16 | )
17 |
18 | // AdminSessionResolver is a resolver for admin session query
19 | func AdminSessionResolver(ctx context.Context) (*model.Response, error) {
20 | var res *model.Response
21 |
22 | gc, err := utils.GinContextFromContext(ctx)
23 | if err != nil {
24 | log.Debug("Failed to get GinContext: ", err)
25 | return res, err
26 | }
27 |
28 | if !token.IsSuperAdmin(gc) {
29 | log.Debug("Not logged in as super admin")
30 | return res, fmt.Errorf("unauthorized")
31 | }
32 |
33 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
34 | if err != nil {
35 | log.Debug("Error getting admin secret: ", err)
36 | return res, fmt.Errorf("unauthorized")
37 | }
38 | hashedKey, err := crypto.EncryptPassword(adminSecret)
39 | if err != nil {
40 | log.Debug("Failed to encrypt key: ", err)
41 | return res, err
42 | }
43 | cookie.SetAdminCookie(gc, hashedKey)
44 |
45 | res = &model.Response{
46 | Message: "admin logged in successfully",
47 | }
48 | return res, nil
49 | }
50 |
--------------------------------------------------------------------------------
/server/constants/auth_methods.go:
--------------------------------------------------------------------------------
1 | package constants
2 |
3 | const (
4 | // AuthRecipeMethodBasicAuth is the basic_auth auth method
5 | AuthRecipeMethodBasicAuth = "basic_auth"
6 | // AuthRecipeMethodMobileBasicAuth is the mobile basic_auth method, where user can signup using mobile number and password
7 | AuthRecipeMethodMobileBasicAuth = "mobile_basic_auth"
8 | // AuthRecipeMethodMagicLinkLogin is the magic_link_login auth method
9 | AuthRecipeMethodMagicLinkLogin = "magic_link_login"
10 | // AuthRecipeMethodMobileOTP is the mobile_otp auth method
11 | AuthRecipeMethodMobileOTP = "mobile_otp"
12 | // AuthRecipeMethodGoogle is the google auth method
13 | AuthRecipeMethodGoogle = "google"
14 | // AuthRecipeMethodGithub is the github auth method
15 | AuthRecipeMethodGithub = "github"
16 | // AuthRecipeMethodFacebook is the facebook auth method
17 | AuthRecipeMethodFacebook = "facebook"
18 | // AuthRecipeMethodLinkedin is the linkedin auth method
19 | AuthRecipeMethodLinkedIn = "linkedin"
20 | // AuthRecipeMethodApple is the apple auth method
21 | AuthRecipeMethodApple = "apple"
22 | // AuthRecipeMethodDiscord is the discord auth method
23 | AuthRecipeMethodDiscord = "discord"
24 | // AuthRecipeMethodTwitter is the twitter auth method
25 | AuthRecipeMethodTwitter = "twitter"
26 | // AuthRecipeMethodMicrosoft is the microsoft auth method
27 | AuthRecipeMethodMicrosoft = "microsoft"
28 | // AuthRecipeMethodTwitch is the twitch auth method
29 | AuthRecipeMethodTwitch = "twitch"
30 | // AuthRecipeMethodRoblox is the roblox auth method
31 | AuthRecipeMethodRoblox = "roblox"
32 | )
33 |
--------------------------------------------------------------------------------
/server/validators/url.go:
--------------------------------------------------------------------------------
1 | package validators
2 |
3 | import (
4 | "regexp"
5 | "strings"
6 |
7 | "github.com/authorizerdev/authorizer/server/constants"
8 | "github.com/authorizerdev/authorizer/server/memorystore"
9 | "github.com/authorizerdev/authorizer/server/parsers"
10 | )
11 |
12 | // IsValidOrigin validates origin based on ALLOWED_ORIGINS
13 | func IsValidOrigin(url string) bool {
14 | allowedOriginsString, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAllowedOrigins)
15 | allowedOrigins := []string{}
16 | if err != nil {
17 | allowedOrigins = []string{"*"}
18 | } else {
19 | allowedOrigins = strings.Split(allowedOriginsString, ",")
20 | }
21 | if len(allowedOrigins) == 1 && allowedOrigins[0] == "*" {
22 | return true
23 | }
24 |
25 | hasValidURL := false
26 | hostName, port := parsers.GetHostParts(url)
27 | currentOrigin := hostName + ":" + port
28 |
29 | for _, origin := range allowedOrigins {
30 | replacedString := origin
31 | // if has regex whitelisted domains
32 | if strings.Contains(origin, "*") {
33 | replacedString = strings.ReplaceAll(origin, ".", "\\.")
34 | replacedString = strings.ReplaceAll(replacedString, "*", ".*")
35 |
36 | if strings.HasPrefix(replacedString, ".*") {
37 | replacedString += "\\b"
38 | }
39 |
40 | if strings.HasSuffix(replacedString, ".*") {
41 | replacedString = "\\b" + replacedString
42 | }
43 | }
44 |
45 | if matched, _ := regexp.MatchString(replacedString, currentOrigin); matched {
46 | hasValidURL = true
47 | break
48 | }
49 | }
50 |
51 | return hasValidURL
52 | }
53 |
--------------------------------------------------------------------------------
/server/resolvers/user.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "strings"
7 |
8 | log "github.com/sirupsen/logrus"
9 |
10 | "github.com/authorizerdev/authorizer/server/db"
11 | "github.com/authorizerdev/authorizer/server/graph/model"
12 | "github.com/authorizerdev/authorizer/server/token"
13 | "github.com/authorizerdev/authorizer/server/utils"
14 | )
15 |
16 | // UserResolver is a resolver for user query
17 | // This is admin only query
18 | func UserResolver(ctx context.Context, params model.GetUserRequest) (*model.User, error) {
19 | gc, err := utils.GinContextFromContext(ctx)
20 | if err != nil {
21 | log.Debug("Failed to get GinContext: ", err)
22 | return nil, err
23 | }
24 | if !token.IsSuperAdmin(gc) {
25 | log.Debug("Not logged in as super admin.")
26 | return nil, fmt.Errorf("unauthorized")
27 | }
28 | // Try getting user by ID
29 | if params.ID != nil && strings.Trim(*params.ID, " ") != "" {
30 | res, err := db.Provider.GetUserByID(ctx, *params.ID)
31 | if err != nil {
32 | log.Debug("Failed to get users by ID: ", err)
33 | return nil, err
34 | }
35 | return res.AsAPIUser(), nil
36 | }
37 | // Try getting user by email
38 | if params.Email != nil && strings.Trim(*params.Email, " ") != "" {
39 | res, err := db.Provider.GetUserByEmail(ctx, *params.Email)
40 | if err != nil {
41 | log.Debug("Failed to get users by email: ", err)
42 | return nil, err
43 | }
44 | return res.AsAPIUser(), nil
45 | }
46 | // Return error if no params are provided
47 | return nil, fmt.Errorf("invalid params, user id or email is required")
48 | }
49 |
--------------------------------------------------------------------------------
/server/resolvers/enable_access.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 |
7 | log "github.com/sirupsen/logrus"
8 |
9 | "github.com/authorizerdev/authorizer/server/constants"
10 | "github.com/authorizerdev/authorizer/server/db"
11 | "github.com/authorizerdev/authorizer/server/graph/model"
12 | "github.com/authorizerdev/authorizer/server/token"
13 | "github.com/authorizerdev/authorizer/server/utils"
14 | )
15 |
16 | // EnableAccessResolver is a resolver for enabling user access
17 | func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (*model.Response, error) {
18 | var res *model.Response
19 |
20 | gc, err := utils.GinContextFromContext(ctx)
21 | if err != nil {
22 | log.Debug("Failed to get GinContext: ", err)
23 | return res, err
24 | }
25 |
26 | if !token.IsSuperAdmin(gc) {
27 | log.Debug("Not logged in as super admin.")
28 | return res, fmt.Errorf("unauthorized")
29 | }
30 |
31 | log := log.WithFields(log.Fields{
32 | "user_id": params.UserID,
33 | })
34 |
35 | user, err := db.Provider.GetUserByID(ctx, params.UserID)
36 | if err != nil {
37 | log.Debug("Failed to get user from DB: ", err)
38 | return res, err
39 | }
40 |
41 | user.RevokedTimestamp = nil
42 |
43 | user, err = db.Provider.UpdateUser(ctx, user)
44 | if err != nil {
45 | log.Debug("Failed to update user: ", err)
46 | return res, err
47 | }
48 |
49 | res = &model.Response{
50 | Message: `user access enabled successfully`,
51 | }
52 |
53 | go utils.RegisterEvent(ctx, constants.UserAccessEnabledWebhookEvent, "", user)
54 |
55 | return res, nil
56 | }
57 |
--------------------------------------------------------------------------------
/server/db/models/email_templates.go:
--------------------------------------------------------------------------------
1 | package models
2 |
3 | import (
4 | "strings"
5 |
6 | "github.com/authorizerdev/authorizer/server/graph/model"
7 | "github.com/authorizerdev/authorizer/server/refs"
8 | )
9 |
10 | // EmailTemplate model for database
11 | type EmailTemplate struct {
12 | Key string `json:"_key,omitempty" bson:"_key,omitempty" cql:"_key,omitempty" dynamo:"key,omitempty"` // for arangodb
13 | ID string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id" cql:"id" dynamo:"id,hash"`
14 | EventName string `gorm:"unique" json:"event_name" bson:"event_name" cql:"event_name" dynamo:"event_name" index:"event_name,hash"`
15 | Subject string `json:"subject" bson:"subject" cql:"subject" dynamo:"subject"`
16 | Template string `json:"template" bson:"template" cql:"template" dynamo:"template"`
17 | Design string `json:"design" bson:"design" cql:"design" dynamo:"design"`
18 | CreatedAt int64 `json:"created_at" bson:"created_at" cql:"created_at" dynamo:"created_at"`
19 | UpdatedAt int64 `json:"updated_at" bson:"updated_at" cql:"updated_at" dynamo:"updated_at"`
20 | }
21 |
22 | // AsAPIEmailTemplate to return email template as graphql response object
23 | func (e *EmailTemplate) AsAPIEmailTemplate() *model.EmailTemplate {
24 | id := e.ID
25 | if strings.Contains(id, Collections.EmailTemplate+"/") {
26 | id = strings.TrimPrefix(id, Collections.EmailTemplate+"/")
27 | }
28 | return &model.EmailTemplate{
29 | ID: id,
30 | EventName: e.EventName,
31 | Subject: e.Subject,
32 | Template: e.Template,
33 | Design: e.Design,
34 | CreatedAt: refs.NewInt64Ref(e.CreatedAt),
35 | UpdatedAt: refs.NewInt64Ref(e.UpdatedAt),
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/dashboard/src/routes/index.tsx:
--------------------------------------------------------------------------------
1 | import React, { lazy, Suspense } from 'react';
2 | import { Outlet, Route, Routes } from 'react-router-dom';
3 |
4 | import { useAuthContext } from '../contexts/AuthContext';
5 | import { DashboardLayout } from '../layouts/DashboardLayout';
6 | import EmailTemplates from '../pages/EmailTemplates';
7 |
8 | const Auth = lazy(() => import('../pages/Auth'));
9 | const Environment = lazy(() => import('../pages/Environment'));
10 | const Home = lazy(() => import('../pages/Home'));
11 | const Users = lazy(() => import('../pages/Users'));
12 | const Webhooks = lazy(() => import('../pages/Webhooks'));
13 |
14 | export const AppRoutes = () => {
15 | const { isLoggedIn } = useAuthContext();
16 |
17 | if (isLoggedIn) {
18 | return (
19 |
20 | }>
21 |
22 |
25 |
33 |
39 |
40 |
41 | );
42 | }
43 | return (
44 |
10 | {' '}
11 |
12 | Organization Information
13 |
14 |
15 |
16 |
21 | Organization Name:
22 |
23 |
27 |
34 |
35 |
36 |
41 | Organization Logo:
42 |
43 |
47 |
54 |
55 |
56 |
57 | );
58 | };
59 |
60 | export default OrganizationInfo;
61 |
--------------------------------------------------------------------------------
/server/db/providers/mongodb/env.go:
--------------------------------------------------------------------------------
1 | package mongodb
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "time"
7 |
8 | "github.com/authorizerdev/authorizer/server/db/models"
9 | "github.com/google/uuid"
10 | "go.mongodb.org/mongo-driver/bson"
11 | "go.mongodb.org/mongo-driver/mongo/options"
12 | )
13 |
14 | // AddEnv to save environment information in database
15 | func (p *provider) AddEnv(ctx context.Context, env *models.Env) (*models.Env, error) {
16 | if env.ID == "" {
17 | env.ID = uuid.New().String()
18 | }
19 | env.CreatedAt = time.Now().Unix()
20 | env.UpdatedAt = time.Now().Unix()
21 | env.Key = env.ID
22 | configCollection := p.db.Collection(models.Collections.Env, options.Collection())
23 | _, err := configCollection.InsertOne(ctx, env)
24 | if err != nil {
25 | return nil, err
26 | }
27 | return env, nil
28 | }
29 |
30 | // UpdateEnv to update environment information in database
31 | func (p *provider) UpdateEnv(ctx context.Context, env *models.Env) (*models.Env, error) {
32 | env.UpdatedAt = time.Now().Unix()
33 | configCollection := p.db.Collection(models.Collections.Env, options.Collection())
34 | _, err := configCollection.UpdateOne(ctx, bson.M{"_id": bson.M{"$eq": env.ID}}, bson.M{"$set": env}, options.MergeUpdateOptions())
35 | if err != nil {
36 | return nil, err
37 | }
38 | return env, nil
39 | }
40 |
41 | // GetEnv to get environment information from database
42 | func (p *provider) GetEnv(ctx context.Context) (*models.Env, error) {
43 | var env *models.Env
44 | configCollection := p.db.Collection(models.Collections.Env, options.Collection())
45 | cursor, err := configCollection.Find(ctx, bson.M{}, options.Find())
46 | if err != nil {
47 | return nil, err
48 | }
49 | defer cursor.Close(ctx)
50 | for cursor.Next(nil) {
51 | err := cursor.Decode(&env)
52 | if err != nil {
53 | return nil, err
54 | }
55 | }
56 | if env == nil {
57 | return env, fmt.Errorf("config not found")
58 | }
59 | return env, nil
60 | }
61 |
--------------------------------------------------------------------------------
/server/test/invite_member_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 |
7 | "github.com/authorizerdev/authorizer/server/constants"
8 | "github.com/authorizerdev/authorizer/server/crypto"
9 | "github.com/authorizerdev/authorizer/server/graph/model"
10 | "github.com/authorizerdev/authorizer/server/memorystore"
11 | "github.com/authorizerdev/authorizer/server/resolvers"
12 | "github.com/stretchr/testify/assert"
13 | )
14 |
15 | func inviteUserTest(t *testing.T, s TestSetup) {
16 | t.Helper()
17 | t.Run(`should invite user successfully`, func(t *testing.T) {
18 | req, ctx := createContext(s)
19 | emails := []string{"invite_member1." + s.TestInfo.Email}
20 |
21 | // unauthorized error
22 | res, err := resolvers.InviteMembersResolver(ctx, model.InviteMemberInput{
23 | Emails: emails,
24 | })
25 |
26 | assert.Error(t, err)
27 | assert.Nil(t, res)
28 |
29 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
30 | assert.Nil(t, err)
31 |
32 | h, err := crypto.EncryptPassword(adminSecret)
33 | assert.Nil(t, err)
34 | req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
35 |
36 | // invalid emails test
37 | invalidEmailsTest := []string{
38 | "test",
39 | "test.com",
40 | }
41 | res, err = resolvers.InviteMembersResolver(ctx, model.InviteMemberInput{
42 | Emails: invalidEmailsTest,
43 | })
44 | assert.Error(t, err)
45 | assert.Nil(t, res)
46 | // valid test
47 | res, err = resolvers.InviteMembersResolver(ctx, model.InviteMemberInput{
48 | Emails: emails,
49 | })
50 | assert.Nil(t, err)
51 | assert.NotNil(t, res)
52 | assert.NotNil(t, res.Message)
53 | assert.NotNil(t, res.Users)
54 | // duplicate error test
55 | res, err = resolvers.InviteMembersResolver(ctx, model.InviteMemberInput{
56 | Emails: emails,
57 | })
58 | assert.Error(t, err)
59 | assert.Nil(t, res)
60 | cleanData(emails[0])
61 | })
62 | }
63 |
--------------------------------------------------------------------------------
/server/handlers/logout.go:
--------------------------------------------------------------------------------
1 | package handlers
2 |
3 | import (
4 | "encoding/json"
5 | "net/http"
6 | "strings"
7 |
8 | "github.com/gin-gonic/gin"
9 | log "github.com/sirupsen/logrus"
10 |
11 | "github.com/authorizerdev/authorizer/server/cookie"
12 | "github.com/authorizerdev/authorizer/server/crypto"
13 | "github.com/authorizerdev/authorizer/server/memorystore"
14 | "github.com/authorizerdev/authorizer/server/token"
15 | )
16 |
17 | // Handler to logout user
18 | func LogoutHandler() gin.HandlerFunc {
19 | return func(gc *gin.Context) {
20 | redirectURL := strings.TrimSpace(gc.Query("redirect_uri"))
21 | // get fingerprint hash
22 | fingerprintHash, err := cookie.GetSession(gc)
23 | if err != nil {
24 | log.Debug("Failed to get session: ", err)
25 | gc.JSON(http.StatusUnauthorized, gin.H{
26 | "error": err.Error(),
27 | })
28 | return
29 | }
30 |
31 | decryptedFingerPrint, err := crypto.DecryptAES(fingerprintHash)
32 | if err != nil {
33 | log.Debug("Failed to decrypt fingerprint: ", err)
34 | gc.JSON(http.StatusUnauthorized, gin.H{
35 | "error": err.Error(),
36 | })
37 | return
38 | }
39 |
40 | var sessionData token.SessionData
41 | err = json.Unmarshal([]byte(decryptedFingerPrint), &sessionData)
42 | if err != nil {
43 | log.Debug("Failed to decrypt fingerprint: ", err)
44 | gc.JSON(http.StatusUnauthorized, gin.H{
45 | "error": err.Error(),
46 | })
47 | return
48 | }
49 |
50 | userID := sessionData.Subject
51 | loginMethod := sessionData.LoginMethod
52 | sessionToken := userID
53 | if loginMethod != "" {
54 | sessionToken = loginMethod + ":" + userID
55 | }
56 |
57 | memorystore.Provider.DeleteUserSession(sessionToken, sessionData.Nonce)
58 | cookie.DeleteSession(gc)
59 |
60 | if redirectURL != "" {
61 | gc.Redirect(http.StatusFound, redirectURL)
62 | } else {
63 | gc.JSON(http.StatusOK, gin.H{
64 | "message": "Logged out successfully",
65 | })
66 | }
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/server/db/providers/dynamodb/authenticator.go:
--------------------------------------------------------------------------------
1 | package dynamodb
2 |
3 | import (
4 | "context"
5 | "time"
6 |
7 | "github.com/google/uuid"
8 |
9 | "github.com/authorizerdev/authorizer/server/db/models"
10 | )
11 |
12 | func (p *provider) AddAuthenticator(ctx context.Context, authenticators *models.Authenticator) (*models.Authenticator, error) {
13 | exists, _ := p.GetAuthenticatorDetailsByUserId(ctx, authenticators.UserID, authenticators.Method)
14 | if exists != nil {
15 | return authenticators, nil
16 | }
17 |
18 | collection := p.db.Table(models.Collections.Authenticators)
19 | if authenticators.ID == "" {
20 | authenticators.ID = uuid.New().String()
21 | }
22 |
23 | authenticators.CreatedAt = time.Now().Unix()
24 | authenticators.UpdatedAt = time.Now().Unix()
25 | err := collection.Put(authenticators).RunWithContext(ctx)
26 | if err != nil {
27 | return nil, err
28 | }
29 | return authenticators, nil
30 | }
31 |
32 | func (p *provider) UpdateAuthenticator(ctx context.Context, authenticators *models.Authenticator) (*models.Authenticator, error) {
33 | collection := p.db.Table(models.Collections.Authenticators)
34 | if authenticators.ID != "" {
35 | authenticators.UpdatedAt = time.Now().Unix()
36 | err := UpdateByHashKey(collection, "id", authenticators.ID, authenticators)
37 | if err != nil {
38 | return nil, err
39 | }
40 | }
41 | return authenticators, nil
42 |
43 | }
44 |
45 | func (p *provider) GetAuthenticatorDetailsByUserId(ctx context.Context, userId string, authenticatorType string) (*models.Authenticator, error) {
46 | var authenticators *models.Authenticator
47 | collection := p.db.Table(models.Collections.Authenticators)
48 | iter := collection.Scan().Filter("'user_id' = ?", userId).Filter("'method' = ?", authenticatorType).Iter()
49 | for iter.NextWithContext(ctx, &authenticators) {
50 | return authenticators, nil
51 | }
52 | err := iter.Err()
53 | if err != nil {
54 | return nil, err
55 | }
56 | return authenticators, nil
57 | }
58 |
--------------------------------------------------------------------------------
/server/db/providers/arangodb/env.go:
--------------------------------------------------------------------------------
1 | package arangodb
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "time"
7 |
8 | arangoDriver "github.com/arangodb/go-driver"
9 | "github.com/google/uuid"
10 |
11 | "github.com/authorizerdev/authorizer/server/db/models"
12 | )
13 |
14 | // AddEnv to save environment information in database
15 | func (p *provider) AddEnv(ctx context.Context, env *models.Env) (*models.Env, error) {
16 | if env.ID == "" {
17 | env.ID = uuid.New().String()
18 | env.Key = env.ID
19 | }
20 |
21 | env.CreatedAt = time.Now().Unix()
22 | env.UpdatedAt = time.Now().Unix()
23 | configCollection, _ := p.db.Collection(ctx, models.Collections.Env)
24 | meta, err := configCollection.CreateDocument(arangoDriver.WithOverwrite(ctx), env)
25 | if err != nil {
26 | return nil, err
27 | }
28 | env.Key = meta.Key
29 | env.ID = meta.ID.String()
30 | return env, nil
31 | }
32 |
33 | // UpdateEnv to update environment information in database
34 | func (p *provider) UpdateEnv(ctx context.Context, env *models.Env) (*models.Env, error) {
35 | env.UpdatedAt = time.Now().Unix()
36 | collection, _ := p.db.Collection(ctx, models.Collections.Env)
37 | meta, err := collection.UpdateDocument(ctx, env.Key, env)
38 | if err != nil {
39 | return nil, err
40 | }
41 |
42 | env.Key = meta.Key
43 | env.ID = meta.ID.String()
44 | return env, nil
45 | }
46 |
47 | // GetEnv to get environment information from database
48 | func (p *provider) GetEnv(ctx context.Context) (*models.Env, error) {
49 | var env *models.Env
50 | query := fmt.Sprintf("FOR d in %s RETURN d", models.Collections.Env)
51 | cursor, err := p.db.Query(ctx, query, nil)
52 | if err != nil {
53 | return nil, err
54 | }
55 | defer cursor.Close()
56 | for {
57 | if !cursor.HasMore() {
58 | if env == nil {
59 | return env, fmt.Errorf("config not found")
60 | }
61 | break
62 | }
63 | _, err := cursor.ReadDocument(ctx, &env)
64 | if err != nil {
65 | return nil, err
66 | }
67 | }
68 |
69 | return env, nil
70 | }
71 |
--------------------------------------------------------------------------------
/server/db/providers/provider_template/webhook.go:
--------------------------------------------------------------------------------
1 | package provider_template
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "strings"
7 | "time"
8 |
9 | "github.com/authorizerdev/authorizer/server/db/models"
10 | "github.com/authorizerdev/authorizer/server/graph/model"
11 | "github.com/google/uuid"
12 | )
13 |
14 | // AddWebhook to add webhook
15 | func (p *provider) AddWebhook(ctx context.Context, webhook *models.Webhook) (*model.Webhook, error) {
16 | if webhook.ID == "" {
17 | webhook.ID = uuid.New().String()
18 | }
19 | webhook.Key = webhook.ID
20 | webhook.CreatedAt = time.Now().Unix()
21 | webhook.UpdatedAt = time.Now().Unix()
22 | // Add timestamp to make event name unique for legacy version
23 | webhook.EventName = fmt.Sprintf("%s-%d", webhook.EventName, time.Now().Unix())
24 | return webhook.AsAPIWebhook(), nil
25 | }
26 |
27 | // UpdateWebhook to update webhook
28 | func (p *provider) UpdateWebhook(ctx context.Context, webhook *models.Webhook) (*model.Webhook, error) {
29 | webhook.UpdatedAt = time.Now().Unix()
30 | // Event is changed
31 | if !strings.Contains(webhook.EventName, "-") {
32 | webhook.EventName = fmt.Sprintf("%s-%d", webhook.EventName, time.Now().Unix())
33 | }
34 | return webhook.AsAPIWebhook(), nil
35 | }
36 |
37 | // ListWebhooks to list webhook
38 | func (p *provider) ListWebhook(ctx context.Context, pagination *model.Pagination) (*model.Webhooks, error) {
39 | return nil, nil
40 | }
41 |
42 | // GetWebhookByID to get webhook by id
43 | func (p *provider) GetWebhookByID(ctx context.Context, webhookID string) (*model.Webhook, error) {
44 | return nil, nil
45 | }
46 |
47 | // GetWebhookByEventName to get webhook by event_name
48 | func (p *provider) GetWebhookByEventName(ctx context.Context, eventName string) ([]*model.Webhook, error) {
49 | return nil, nil
50 | }
51 |
52 | // DeleteWebhook to delete webhook
53 | func (p *provider) DeleteWebhook(ctx context.Context, webhook *model.Webhook) error {
54 | // Also delete webhook logs for given webhook id
55 | return nil
56 | }
57 |
--------------------------------------------------------------------------------
/server/test/webhook_logs_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 | "time"
7 |
8 | "github.com/authorizerdev/authorizer/server/constants"
9 | "github.com/authorizerdev/authorizer/server/crypto"
10 | "github.com/authorizerdev/authorizer/server/graph/model"
11 | "github.com/authorizerdev/authorizer/server/memorystore"
12 | "github.com/authorizerdev/authorizer/server/refs"
13 | "github.com/authorizerdev/authorizer/server/resolvers"
14 | "github.com/stretchr/testify/assert"
15 | )
16 |
17 | func webhookLogsTest(t *testing.T, s TestSetup) {
18 | time.Sleep(30 * time.Second) // add sleep for webhooklogs to get generated as they are async
19 | t.Helper()
20 | t.Run("should get webhook logs", func(t *testing.T) {
21 | req, ctx := createContext(s)
22 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
23 | assert.NoError(t, err)
24 | h, err := crypto.EncryptPassword(adminSecret)
25 | assert.NoError(t, err)
26 | req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
27 |
28 | webhookLogs, err := resolvers.WebhookLogsResolver(ctx, nil)
29 | assert.NoError(t, err)
30 | assert.Greater(t, len(webhookLogs.WebhookLogs), 1)
31 |
32 | webhooks, err := resolvers.WebhooksResolver(ctx, &model.PaginatedInput{
33 | Pagination: &model.PaginationInput{
34 | Limit: refs.NewInt64Ref(20),
35 | },
36 | })
37 | assert.NoError(t, err)
38 | assert.NotEmpty(t, webhooks)
39 | for _, w := range webhooks.Webhooks {
40 | t.Run(fmt.Sprintf("should get webhook for webhook_id:%s", w.ID), func(t *testing.T) {
41 | webhookLogs, err := resolvers.WebhookLogsResolver(ctx, &model.ListWebhookLogRequest{
42 | WebhookID: &w.ID,
43 | })
44 | assert.NoError(t, err)
45 | assert.GreaterOrEqual(t, len(webhookLogs.WebhookLogs), 1, refs.StringValue(w.EventName))
46 | for _, wl := range webhookLogs.WebhookLogs {
47 | assert.Equal(t, refs.StringValue(wl.WebhookID), w.ID)
48 | }
49 | })
50 | }
51 | })
52 | }
53 |
--------------------------------------------------------------------------------
/server/test/update_profile_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "context"
5 | "testing"
6 |
7 | "github.com/authorizerdev/authorizer/server/constants"
8 | "github.com/authorizerdev/authorizer/server/db"
9 | "github.com/authorizerdev/authorizer/server/graph/model"
10 | "github.com/authorizerdev/authorizer/server/refs"
11 | "github.com/authorizerdev/authorizer/server/resolvers"
12 | "github.com/stretchr/testify/assert"
13 | )
14 |
15 | func updateProfileTests(t *testing.T, s TestSetup) {
16 | t.Helper()
17 | t.Run(`should update the profile with access token only`, func(t *testing.T) {
18 | req, ctx := createContext(s)
19 | email := "update_profile." + s.TestInfo.Email
20 |
21 | resolvers.SignupResolver(ctx, model.SignUpInput{
22 | Email: refs.NewStringRef(email),
23 | Password: s.TestInfo.Password,
24 | ConfirmPassword: s.TestInfo.Password,
25 | })
26 |
27 | fName := "samani"
28 | _, err := resolvers.UpdateProfileResolver(ctx, model.UpdateProfileInput{
29 | FamilyName: &fName,
30 | })
31 | assert.NotNil(t, err, "unauthorized")
32 |
33 | verificationRequest, err := db.Provider.GetVerificationRequestByEmail(ctx, email, constants.VerificationTypeBasicAuthSignup)
34 | assert.NoError(t, err)
35 | assert.NotNil(t, verificationRequest)
36 | verifyRes, err := resolvers.VerifyEmailResolver(ctx, model.VerifyEmailInput{
37 | Token: verificationRequest.Token,
38 | })
39 | assert.NoError(t, err)
40 | assert.NotNil(t, verifyRes)
41 | s.GinContext.Request.Header.Set("Authorization", "Bearer "+*verifyRes.AccessToken)
42 | ctx = context.WithValue(req.Context(), "GinContextKey", s.GinContext)
43 |
44 | newEmail := "new_" + email
45 | _, err = resolvers.UpdateProfileResolver(ctx, model.UpdateProfileInput{
46 | Email: &newEmail,
47 | })
48 | s.GinContext.Request.Header.Set("Authorization", "")
49 | assert.Nil(t, err)
50 | _, err = resolvers.ProfileResolver(ctx)
51 | assert.NotNil(t, err, "unauthorized")
52 |
53 | cleanData(newEmail)
54 | cleanData(email)
55 | })
56 | }
57 |
--------------------------------------------------------------------------------
/app/src/App.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { BrowserRouter } from 'react-router-dom';
3 | import { AuthorizerProvider } from '@authorizerdev/authorizer-react';
4 | import Root from './Root';
5 | import { createRandomString } from './utils/common';
6 |
7 | declare global {
8 | interface Window {
9 | __authorizer__: any;
10 | }
11 | }
12 |
13 | export default function App() {
14 | const searchParams = new URLSearchParams(window.location.search);
15 | const state = searchParams.get('state') || createRandomString();
16 | const scope = searchParams.get('scope')
17 | ? searchParams.get('scope')?.toString().split(' ')
18 | : `openid profile email`;
19 |
20 | const urlProps: Record
44 |
73 | );
74 | }
75 |
--------------------------------------------------------------------------------
/server/test/add_webhook_test.go:
--------------------------------------------------------------------------------
1 | package test
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 | "time"
7 |
8 | "github.com/authorizerdev/authorizer/server/constants"
9 | "github.com/authorizerdev/authorizer/server/crypto"
10 | "github.com/authorizerdev/authorizer/server/graph/model"
11 | "github.com/authorizerdev/authorizer/server/memorystore"
12 | "github.com/authorizerdev/authorizer/server/refs"
13 | "github.com/authorizerdev/authorizer/server/resolvers"
14 | "github.com/stretchr/testify/assert"
15 | )
16 |
17 | func addWebhookTest(t *testing.T, s TestSetup) {
18 | t.Helper()
19 | t.Run("should add webhook", func(t *testing.T) {
20 | req, ctx := createContext(s)
21 | adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
22 | assert.NoError(t, err)
23 | h, err := crypto.EncryptPassword(adminSecret)
24 | assert.NoError(t, err)
25 | req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
26 | for _, eventType := range s.TestInfo.TestWebhookEventTypes {
27 | webhook, err := resolvers.AddWebhookResolver(ctx, model.AddWebhookRequest{
28 | EventName: eventType,
29 | Endpoint: s.TestInfo.WebhookEndpoint,
30 | Enabled: true,
31 | Headers: map[string]interface{}{
32 | "x-test": "foo",
33 | },
34 | })
35 | assert.NoError(t, err)
36 | assert.NotNil(t, webhook)
37 | assert.NotEmpty(t, webhook.Message)
38 | }
39 | time.Sleep(2 * time.Second)
40 | // Allow setting multiple webhooks for same event
41 | for _, eventType := range s.TestInfo.TestWebhookEventTypes {
42 | webhook, err := resolvers.AddWebhookResolver(ctx, model.AddWebhookRequest{
43 | EventName: eventType,
44 | Endpoint: s.TestInfo.WebhookEndpoint,
45 | Enabled: true,
46 | EventDescription: refs.NewStringRef(eventType + "-2"),
47 | Headers: map[string]interface{}{
48 | "x-test": "foo",
49 | },
50 | })
51 | assert.NoError(t, err)
52 | assert.NotNil(t, webhook)
53 | assert.NotEmpty(t, webhook.Message)
54 | }
55 | })
56 | }
57 |
--------------------------------------------------------------------------------
/server/cookie/admin_cookie.go:
--------------------------------------------------------------------------------
1 | package cookie
2 |
3 | import (
4 | "net/url"
5 |
6 | log "github.com/sirupsen/logrus"
7 |
8 | "github.com/authorizerdev/authorizer/server/constants"
9 | "github.com/authorizerdev/authorizer/server/memorystore"
10 | "github.com/authorizerdev/authorizer/server/parsers"
11 | "github.com/gin-gonic/gin"
12 | )
13 |
14 | // SetAdminCookie sets the admin cookie in the response
15 | func SetAdminCookie(gc *gin.Context, token string) {
16 | adminCookieSecure, err := memorystore.Provider.GetBoolStoreEnvVariable(constants.EnvKeyAdminCookieSecure)
17 | if err != nil {
18 | log.Debug("Error while getting admin cookie secure from env variable: %v", err)
19 | adminCookieSecure = true
20 | }
21 |
22 | secure := adminCookieSecure
23 | httpOnly := adminCookieSecure
24 | hostname := parsers.GetHost(gc)
25 | host, _ := parsers.GetHostParts(hostname)
26 | gc.SetCookie(constants.AdminCookieName, token, 3600, "/", host, secure, httpOnly)
27 | }
28 |
29 | // GetAdminCookie gets the admin cookie from the request
30 | func GetAdminCookie(gc *gin.Context) (string, error) {
31 | cookie, err := gc.Request.Cookie(constants.AdminCookieName)
32 | if err != nil {
33 | return "", err
34 | }
35 |
36 | // cookie escapes special characters like $
37 | // hence we need to unescape before comparing
38 | decodedValue, err := url.QueryUnescape(cookie.Value)
39 | if err != nil {
40 | return "", err
41 | }
42 | return decodedValue, nil
43 | }
44 |
45 | // DeleteAdminCookie sets the response cookie to empty
46 | func DeleteAdminCookie(gc *gin.Context) {
47 | adminCookieSecure, err := memorystore.Provider.GetBoolStoreEnvVariable(constants.EnvKeyAdminCookieSecure)
48 | if err != nil {
49 | log.Debug("Error while getting admin cookie secure from env variable: %v", err)
50 | adminCookieSecure = true
51 | }
52 |
53 | secure := adminCookieSecure
54 | httpOnly := adminCookieSecure
55 | hostname := parsers.GetHost(gc)
56 | host, _ := parsers.GetHostParts(hostname)
57 | gc.SetCookie(constants.AdminCookieName, "", -1, "/", host, secure, httpOnly)
58 | }
59 |
--------------------------------------------------------------------------------
/server/resolvers/add_email_template.go:
--------------------------------------------------------------------------------
1 | package resolvers
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "strings"
7 |
8 | "github.com/authorizerdev/authorizer/server/db"
9 | "github.com/authorizerdev/authorizer/server/db/models"
10 | "github.com/authorizerdev/authorizer/server/graph/model"
11 | "github.com/authorizerdev/authorizer/server/refs"
12 | "github.com/authorizerdev/authorizer/server/token"
13 | "github.com/authorizerdev/authorizer/server/utils"
14 | "github.com/authorizerdev/authorizer/server/validators"
15 | log "github.com/sirupsen/logrus"
16 | )
17 |
18 | // AddEmailTemplateResolver resolver for add email template mutation
19 | func AddEmailTemplateResolver(ctx context.Context, params model.AddEmailTemplateRequest) (*model.Response, error) {
20 | gc, err := utils.GinContextFromContext(ctx)
21 | if err != nil {
22 | log.Debug("Failed to get GinContext: ", err)
23 | return nil, err
24 | }
25 |
26 | if !token.IsSuperAdmin(gc) {
27 | log.Debug("Not logged in as super admin")
28 | return nil, fmt.Errorf("unauthorized")
29 | }
30 |
31 | if !validators.IsValidEmailTemplateEventName(params.EventName) {
32 | log.Debug("Invalid Event Name: ", params.EventName)
33 | return nil, fmt.Errorf("invalid event name %s", params.EventName)
34 | }
35 |
36 | if strings.TrimSpace(params.Subject) == "" {
37 | return nil, fmt.Errorf("empty subject not allowed")
38 | }
39 |
40 | if strings.TrimSpace(params.Template) == "" {
41 | return nil, fmt.Errorf("empty template not allowed")
42 | }
43 |
44 | var design string
45 |
46 | if params.Design == nil || strings.TrimSpace(refs.StringValue(params.Design)) == "" {
47 | design = ""
48 | }
49 |
50 | _, err = db.Provider.AddEmailTemplate(ctx, &models.EmailTemplate{
51 | EventName: params.EventName,
52 | Template: params.Template,
53 | Subject: params.Subject,
54 | Design: design,
55 | })
56 | if err != nil {
57 | log.Debug("Failed to add email template: ", err)
58 | return nil, err
59 | }
60 |
61 | return &model.Response{
62 | Message: `Email template added successfully`,
63 | }, nil
64 | }
65 |
--------------------------------------------------------------------------------
/server/db/providers/couchbase/env.go:
--------------------------------------------------------------------------------
1 | package couchbase
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "time"
7 |
8 | "github.com/authorizerdev/authorizer/server/db/models"
9 | "github.com/couchbase/gocb/v2"
10 | "github.com/google/uuid"
11 | )
12 |
13 | // AddEnv to save environment information in database
14 | func (p *provider) AddEnv(ctx context.Context, env *models.Env) (*models.Env, error) {
15 | if env.ID == "" {
16 | env.ID = uuid.New().String()
17 | }
18 | env.CreatedAt = time.Now().Unix()
19 | env.UpdatedAt = time.Now().Unix()
20 | env.Key = env.ID
21 | env.EncryptionKey = env.Hash
22 | insertOpt := gocb.InsertOptions{
23 | Context: ctx,
24 | }
25 | _, err := p.db.Collection(models.Collections.Env).Insert(env.ID, env, &insertOpt)
26 | if err != nil {
27 | return nil, err
28 | }
29 | return env, nil
30 | }
31 |
32 | // UpdateEnv to update environment information in database
33 | func (p *provider) UpdateEnv(ctx context.Context, env *models.Env) (*models.Env, error) {
34 | env.UpdatedAt = time.Now().Unix()
35 | env.EncryptionKey = env.Hash
36 |
37 | updateEnvQuery := fmt.Sprintf("UPDATE %s.%s SET env = $1, updated_at = $2 WHERE _id = $3", p.scopeName, models.Collections.Env)
38 | _, err := p.db.Query(updateEnvQuery, &gocb.QueryOptions{
39 | Context: ctx,
40 | PositionalParameters: []interface{}{env.EnvData, env.UpdatedAt, env.UpdatedAt, env.ID},
41 | })
42 | if err != nil {
43 | return nil, err
44 | }
45 | return env, nil
46 | }
47 |
48 | // GetEnv to get environment information from database
49 | func (p *provider) GetEnv(ctx context.Context) (*models.Env, error) {
50 | var env *models.Env
51 |
52 | query := fmt.Sprintf("SELECT _id, env, encryption_key, created_at, updated_at FROM %s.%s LIMIT 1", p.scopeName, models.Collections.Env)
53 | q, err := p.db.Query(query, &gocb.QueryOptions{
54 | Context: ctx,
55 | ScanConsistency: gocb.QueryScanConsistencyRequestPlus,
56 | })
57 | if err != nil {
58 | return nil, err
59 | }
60 | err = q.One(&env)
61 | if err != nil {
62 | return nil, err
63 | }
64 | env.Hash = env.EncryptionKey
65 | return env, nil
66 | }
67 |
--------------------------------------------------------------------------------
/server/memorystore/providers/providers.go:
--------------------------------------------------------------------------------
1 | package providers
2 |
3 | // Provider defines current memory store provider
4 | type Provider interface {
5 | // SetUserSession sets the user session for given user identifier in form recipe:user_id
6 | SetUserSession(userId, key, token string, expiration int64) error
7 | // GetUserSession returns the session token for given token
8 | GetUserSession(userId, key string) (string, error)
9 | // DeleteUserSession deletes the user session
10 | DeleteUserSession(userId, key string) error
11 | // DeleteAllSessions deletes all the sessions from the session store
12 | DeleteAllUserSessions(userId string) error
13 | // DeleteSessionForNamespace deletes the session for a given namespace
14 | DeleteSessionForNamespace(namespace string) error
15 | // SetMfaSession sets the mfa session with key and value of userId
16 | SetMfaSession(userId, key string, expiration int64) error
17 | // GetMfaSession returns value of given mfa session
18 | GetMfaSession(userId, key string) (string, error)
19 | // DeleteMfaSession deletes given mfa session from in-memory store.
20 | DeleteMfaSession(userId, key string) error
21 |
22 | // SetState sets the login state (key, value form) in the session store
23 | SetState(key, state string) error
24 | // GetState returns the state from the session store
25 | GetState(key string) (string, error)
26 | // RemoveState removes the social login state from the session store
27 | RemoveState(key string) error
28 |
29 | // methods for env store
30 |
31 | // UpdateEnvStore to update the whole env store object
32 | UpdateEnvStore(store map[string]interface{}) error
33 | // GetEnvStore() returns the env store object
34 | GetEnvStore() (map[string]interface{}, error)
35 | // UpdateEnvVariable to update the particular env variable
36 | UpdateEnvVariable(key string, value interface{}) error
37 | // GetStringStoreEnvVariable to get the string env variable from env store
38 | GetStringStoreEnvVariable(key string) (string, error)
39 | // GetBoolStoreEnvVariable to get the bool env variable from env store
40 | GetBoolStoreEnvVariable(key string) (bool, error)
41 | }
42 |
--------------------------------------------------------------------------------
/server/db/providers/mongodb/authenticator.go:
--------------------------------------------------------------------------------
1 | package mongodb
2 |
3 | import (
4 | "context"
5 | "time"
6 |
7 | "github.com/google/uuid"
8 | "go.mongodb.org/mongo-driver/bson"
9 | "go.mongodb.org/mongo-driver/mongo/options"
10 |
11 | "github.com/authorizerdev/authorizer/server/db/models"
12 | )
13 |
14 | func (p *provider) AddAuthenticator(ctx context.Context, authenticators *models.Authenticator) (*models.Authenticator, error) {
15 | exists, _ := p.GetAuthenticatorDetailsByUserId(ctx, authenticators.UserID, authenticators.Method)
16 | if exists != nil {
17 | return authenticators, nil
18 | }
19 |
20 | if authenticators.ID == "" {
21 | authenticators.ID = uuid.New().String()
22 | }
23 | authenticators.CreatedAt = time.Now().Unix()
24 | authenticators.UpdatedAt = time.Now().Unix()
25 | authenticators.Key = authenticators.ID
26 | authenticatorsCollection := p.db.Collection(models.Collections.Authenticators, options.Collection())
27 | _, err := authenticatorsCollection.InsertOne(ctx, authenticators)
28 | if err != nil {
29 | return nil, err
30 | }
31 | return authenticators, nil
32 | }
33 |
34 | func (p *provider) UpdateAuthenticator(ctx context.Context, authenticators *models.Authenticator) (*models.Authenticator, error) {
35 | authenticators.UpdatedAt = time.Now().Unix()
36 | authenticatorsCollection := p.db.Collection(models.Collections.Authenticators, options.Collection())
37 | _, err := authenticatorsCollection.UpdateOne(ctx, bson.M{"_id": bson.M{"$eq": authenticators.ID}}, bson.M{"$set": authenticators})
38 | if err != nil {
39 | return nil, err
40 | }
41 | return authenticators, nil
42 | }
43 |
44 | func (p *provider) GetAuthenticatorDetailsByUserId(ctx context.Context, userId string, authenticatorType string) (*models.Authenticator, error) {
45 | var authenticators *models.Authenticator
46 | authenticatorsCollection := p.db.Collection(models.Collections.Authenticators, options.Collection())
47 | err := authenticatorsCollection.FindOne(ctx, bson.M{"user_id": userId, "method": authenticatorType}).Decode(&authenticators)
48 | if err != nil {
49 | return nil, err
50 | }
51 | return authenticators, nil
52 | }
53 |
--------------------------------------------------------------------------------
53 | 
58 |
60 | {globalState.organizationName}
59 |
61 |
62 |
68 |
70 |
71 |
72 |