backend

type BruteForceBucketCache uint

type DatabaseResult map[string][]any

type Done struct{}

type LDAPAuthRequest struct {
	// GUID is the unique identifier for the LDAP auth request.
	// It can be nil.
	GUID *string

	// BindDN is the Distinguished Name for binding to the LDAP server.
	BindDN string

	// BindPW is the password for binding to the LDAP server.
	BindPW string

	// LDAPReplyChan is a channel where the LDAP responses will be sent.
	LDAPReplyChan chan *LDAPReply

	// HTTPClientContext is the context for the HTTP client
	// carrying the LDAP auth request.
	HTTPClientContext context.Context
}

type LDAPConnection struct {

	// Mu is a Mutex used to synchronize access to the Conn field,
	// essential when multiple goroutines need to access or modify the same connection concurrently.
	Mu sync.Mutex

	// Conn is the active LDAP connection. It is a pointer to an ldap.Conn object.
	Conn *ldap.Conn
	// contains filtered or unexported fields
}

type LDAPModifyAttributes map[string][]string

type LDAPPool struct {
	// contains filtered or unexported fields
}

type LDAPReply struct {
	// Result holds the result retrieved from the database.
	// It is of type DatabaseResult which can accommodate different types of database operations.
	Result DatabaseResult

	// RawResult holds a list of entries returned by the LDAP operation.
	// It is an array of pointers to ldap.Entry objects.
	// Each ldap.Entry object represents a single directory entry in the LDAP directory.
	RawResult []*ldap.Entry

	// Err holds any error that occurred during the LDAP operation.
	// It is of type 'error', the built-in interface type for representing an error condition.
	Err error
}

type LDAPRequest struct {
	// GUID is the globally unique identifier for this LDAP request, optional.
	GUID *string

	// Filter is the criteria that the LDAP request uses to filter during the search.
	Filter string

	// BaseDN is the base distinguished name used as the search base.
	BaseDN string

	// SearchAttributes are the attributes for which values are to be returned in the search results.
	SearchAttributes []string

	// MacroSource is the source of macros to be used, optional.
	MacroSource *util.MacroSource

	// Scope defines the scope for LDAP search (base, one, or sub).
	Scope config.LDAPScope

	// Command represents the LDAP command to be executed (add, modify, delete, or search).
	Command global.LDAPCommand

	// ModifyAttributes contains attributes information used in modify command.
	ModifyAttributes LDAPModifyAttributes

	// LDAPReplyChan is the channel where reply from LDAP server is sent.
	LDAPReplyChan chan *LDAPReply

	// HTTPClientContext is the context for managing HTTP requests and responses.
	HTTPClientContext context.Context
}

type LuaBackendResult struct {
	// Authenticated represents whether the user is authenticated or not
	Authenticated bool

	// UserFound indicates whether the user was found in the system or not
	UserFound bool

	// AccountField is the field associated with the user's account
	AccountField string

	// TOTPSecretField is the field that holds the user's TOTP Secret
	TOTPSecretField string

	// TOTPRecoveryField is the field for the user's TOTP recovery code
	TOTPRecoveryField string

	// UniqueUserIDField is the unique user id field
	UniqueUserIDField string

	// DisplayNameField is the display name associated with the user's account
	DisplayNameField string

	// Err captures any error that occurred during the backend process
	Err error

	// Attributes holds any other attributes related to the user's account
	Attributes map[any]any

	// Logs is a pointer to a custom log key-value pair associated with the Lua script.
	Logs *lualib.CustomLogKeyValue
}

type LuaBackendResultStatePool struct {
	*lualib.LuaStatePool
}

type LuaRequest struct {
	// Debug is a flag that is set, if the server is running in debug mode.
	Debug bool

	// NoAuth is a flag that when set as true, implies that the request does not require authentication.
	NoAuth bool

	// Function is the Lua command that will be executed.
	Function global.LuaCommand

	// Session is a pointer to a unique session ID for the current request.
	Session *string

	// Username is the username used for authentication.
	Username string

	// Password is the respective password for the user.
	Password string

	// ClientIP is the IP address of the client making the request.
	ClientIP string

	// ClientPort is the network port of the client making the request.
	ClientPort string

	// ClientHost is the hostname of the client making the request.
	ClientHost string

	// LocalIP is the IP address of the server handling the request.
	LocalIP string

	// LocalPprt is the network port of the server receiving the request.
	LocalPprt string

	// ClientID is the unique identifier for the client making the request.
	ClientID string

	// TOTPSecret is the secret value used in time-based one-time password (TOTP) authentication.
	TOTPSecret string

	// XSSL holds the SSL certificate of the XSSL server.
	XSSL string

	// XSSLSessionID is the unique identifier for the XSSL session.
	XSSLSessionID string

	// XSSLClientVerify verifies the client under XSSL session.
	XSSLClientVerify string

	// XSSLClientDN is the client's DN under XSSL.
	XSSLClientDN string

	// XSSLClientCN is the Client CN under XSSL.
	XSSLClientCN string

	// XSSLIssuer is the issuer of XSSL.
	XSSLIssuer string

	// XSSLClientNotBefore is the starting time before which the certificate is not valid.
	XSSLClientNotBefore string

	// XSSLClientNotAfter is the time after which the certificate is not valid.
	XSSLClientNotAfter string

	// XSSLSubjectDN denotes XSSL subject's distinguished name.
	XSSLSubjectDN string

	// XSSLIssuerDN denotes XSSL issuer's distinguished name.
	XSSLIssuerDN string

	// XSSLClientSubjectDN is the Client Subject DN under XSSL.
	XSSLClientSubjectDN string

	// XSSLClientIssuerDN is the Client Issuer DN under XSSL.
	XSSLClientIssuerDN string

	// XSSLProtocol is the protocol used under XSSL.
	XSSLProtocol string

	// XSSLCipher is the cipher used under XSSL.
	XSSLCipher string

	// UserAgent is a string representing the user agent making the request.
	UserAgent string

	// Service is the specific service requested by the client.
	Service string

	// Protocol points to the protocol that was used by a client to make the request.
	Protocol *config.Protocol

	// Logs points to custom log key-value pairs to help track the request.
	Logs *lualib.CustomLogKeyValue

	// Context provides context for the Lua command request.
	*lualib.Context

	// LuaReplyChan is a channel to receive the response from the Lua backend.
	LuaReplyChan chan *LuaBackendResult
}

type PasswordHistory map[string]uint

type PoolRequest[T any] interface {
	GetLDAPReplyChan() chan *LDAPReply
}

type PositivePasswordCache struct {
	Backend           global.Backend `redis:"passdb_backend"`
	Password          string         `redis:"password"`
	AccountField      *string        `redis:"account_field"`
	TOTPSecretField   *string        `redis:"totp_secret_field"`
	UniqueUserIDField *string        `redis:"webauth_userid_field"`
	DisplayNameField  *string        `redis:"display_name_field"`
	Attributes        DatabaseResult `redis:"attributes"`
}

type RedisCache interface {
	PositivePasswordCache | BruteForceBucketCache
}

type User struct {
	Id          string `redis:"Id"`
	Name        string `redis:"name"`
	DisplayName string `redis:"display_name"`

	Credentials []webauthn.Credential `redis:"credentials"`
}