storage

type ActivityLogEntry struct {
	OccuredAt  time.Time
	UserUUID   string
	Username   string
	EntityID   string
	StatusCode int
	Type       ActivityType
	Path       string
	IPAddress  string
}

type ActivityType uint8

type Backend interface {
	Close() error

	LogActivity(ActivityLogEntry) error
	GetActivityLog(string) ([]ActivityLogEntry, error)
	RemoveActivityEntries(string) error

	NewTaskFileTransaction() (TaskFileTxn, error)
	GetTaskFileByID(string) (*TaskFile, error)
	ListTasksForUser(User) ([]TaskFile, error)
	NewEngineFileTransaction() (EngineFileTxn, error)
	GetEngineFileByID(storageID string) (*EngineFile, error)
	GetEngineFilesForUser(User) ([]EngineFile, error)
	DeleteEngineFile(string) error
	DeleteTaskFile(string) error

	// Task Management APIs
	NewTaskCreateTransaction() (CreateTaskTxn, error)
	GetTaskByID(string) (*Task, error)
	ChangeTaskStatus(string, TaskStatus, *string) error
	TasksSearch(page, limit int, orderby, searchQuery string, isAscending bool, user User) (*SearchResults, error)
	SaveCrackedHash(taskid, hash, value string, crackedAt time.Time) error
	GetCrackedPasswords(string) (*[]CrackedHash, error)
	GetPendingTasks(GetPendingTasksRequest) ([]GetPendingTasksResponseItem, error)
	UpdateTask(string, ModifiableTaskRequest) error
	SaveTaskCheckpoint(CheckpointFile) error
	GetTaskCheckpoint(string) ([]byte, error)
	DeleteTask(string) error

	// Rights Management APIs
	CheckEntitlement(userUUID, entityID string, entType EntitlementType) (bool, error)
	// GrantEntitlement grants the user access to the record passed in via document
	GrantEntitlement(user User, document interface{}) (err error)
	// RevokeEntitlement removes the user's access to the document
	RevokeEntitlement(user User, document interface{}) (err error)
	GetEntitlementsForTask(entityID string) ([]EntitlementEntry, error)
	RemoveEntitlements(string, EntitlementType) error

	// User Management APIs
	SearchForUserByPassword(username string, passcheck PasswordCheckFunc) (userRecord *User, err error)
	CreateUser(user *User) (err error)
	GetUserByID(userUUID string) (user *User, err error)
	GetUsers() ([]User, error)
	EditUser(string, UserModifyRequest) error
}

type CLDevices []int

type CheckpointFile struct {
	TaskID string
	Data   []byte
}

type Config struct {
	Backend          string `yaml:"backend"`
	ConnectionString string `yaml:"connection_string"`
}

type CrackedHash struct {
	Hash      string `storm:"unique"`
	Value     string
	CrackedAt time.Time
}

type CreateTaskTxn interface {
	CreateTask(t *Task) error
	GrantEntitlement(userUUID string, t Task) (err error)
	Rollback() error
	Commit() error
}

type Driver interface {
	Open(cfg Config) (Backend, error)
}

type EngineFile struct {
	FileID          string
	FileName        string
	FileSize        int64
	Description     *string
	UploadedBy      string
	UploadedByUUID  string // UUID of the user who initially uploaded the file
	UploadedAt      time.Time
	LastUpdatedAt   time.Time
	FileType        EngineFileType
	NumberOfEntries int64
	IsShared        bool
	SHA1Hash        string
	SavedAt         string // The physical location on the server where the file is located
}

type EngineFileTxn interface {
	SaveEngineFile(tf EngineFile) error
	AddEntitlement(tf EngineFile, userid string) error
	Rollback() error
	Commit() error
}

type EngineFileType uint8

type EntitlementEntry struct {
	UserUUID        string
	EntitledID      string
	GrantedAccessAt time.Time
}

type EntitlementType uint8

type GetPendingTasksRequest struct {
	Hostname        string
	DevicesInUse    CLDevices
	RunningTasks    []string
	CheckForNewTask bool
}

type GetPendingTasksResponseItem struct {
	Type    PendingTaskPayloadType
	Payload interface{}
}

type ModifiableTaskRequest struct {
	AssignedToHost    *string
	AssignedToDevices *CLDevices
	Status            *TaskStatus
	TaskDuration      *int
}

type PasswordCheckFunc func(password string) (ok bool)

type PendingTaskPayloadType uint8

type PendingTaskStatusChangeItem struct {
	TaskID    string
	NewStatus TaskStatus
}

type SearchResults struct {
	Results interface{}
	Total   int
}

type StorageError struct {
	DriverError error
}

type Task struct {
	TaskID            string `storm:"id,unique"`
	TaskName          string
	Status            TaskStatus
	Engine            WorkerCrackEngine
	EnginePayload     interface{} // As of now, this can only be shared.HashcatUserOptions
	Priority          WorkerPriority
	FileID            string // FileID is a reference to TaskFile via TaskFile.FileID
	CreatedBy         string
	CreatedByUUID     string // CreatedBy is a reference to User via User.UserUUID
	CreatedAt         time.Time
	TaskDuration      int
	LastUpdatedAt     time.Time
	AssignedToHost    string
	AssignedToDevices *CLDevices
	Comment           *string
	CaseCode          *string
	NumberCracked     int
	NumberPasswords   int
	Error             *string
}

type TaskFile struct {
	FileID            string `storm:"unique"`
	SavedAt           string // The physical location on the server where the file is located
	UploadedAt        time.Time
	UploadedBy        string
	UploadedByUUID    string // UUID of the user who initially uploaded the file
	FileSize          int64
	FileName          string
	SHA1Hash          string
	ForEngine         TaskFileEngine
	NumberOfPasswords int
	NumberOfSalts     int
}

type TaskFileEngine uint8

type TaskFileTxn interface {
	SaveTaskFile(tf TaskFile) error
	AddEntitlement(tf TaskFile, userid string) error
	Rollback() error
	Commit() error
}

type TaskStatus string

type User struct {
	UserUUID     string `storm:"unique"`
	Username     string `storm:"unique"`
	Password     string
	Enabled      *bool
	EmailAddress string
	IsSuperUser  bool
	CreatedAt    time.Time
}

type UserModifyRequest struct {
	Password    *string
	UserIsAdmin *bool
	Email       *string
}

type WorkerCrackEngine uint8

type WorkerPriority int