hashcat

Documentation

Index

• Constants
• type Params
  • func (params Params) Validate() error
• type Result
• type Session
  • func NewHashcatSession(id string, params Params) (*Session, error)
  • func (sess *Session) Cleanup()
  • func (sess *Session) CmdLine() string
  • func (sess *Session) Kill() error
  • func (sess *Session) Start() error
• type Status
• type StatusDevice
• type StatusGuess

Constants

const (
	AttackModeDictionary = 0 // AttackModeDictionary is the attack mode for dictionary attacks
	AttackModeCombinator = 1 // AttackModeCombinator is the attack mode for combinator attacks
	AttackModeMask       = 3 // AttackModeMask is the attack mode for mask attacks
	AttackModeHybridDM   = 6 // AttackModeHybridDM is the attack mode for hybrid dictionary + mask attacks
	AttackModeHybridMD   = 7 // AttackModeHybridMD is the attack mode for hybrid mask + dictionary attacks
	AttackBenchmark      = 9 // AttackBenchmark is the attack mode for benchmarking
)

Types

type Params

type Params struct {
	AttackMode uint8  `json:"attack_mode"` // Attack mode to use
	HashType   int32  `json:"hash_type"`   // Hash type to crack
	HashFile   string `json:"hash_file"`   // Path to the file containing the hashes to crack

	Mask               string   `json:"mask"`                 // Mask to use for mask attack
	MaskIncrement      bool     `json:"mask_increment"`       // Whether to use mask increment
	MaskIncrementMin   int32    `json:"mask_increment_min"`   // Min mask length for increment
	MaskIncrementMax   int32    `json:"mask_increment_max"`   // Max mask length for increment
	MaskCustomCharsets []string `json:"mask_custom_charsets"` // Custom charsets for mask attack

	WordlistFilenames []string `json:"wordlist_filenames"` // Wordlists to use for dictionary and combinator attacks
	RulesFilenames    []string `json:"rules_filenames"`    // Rules to use for dictionary attack
	AdditionalArgs    []string `json:"additional_args"`    // Additional arguments to pass to hashcat
	OptimizedKernels  bool     `json:"optimized_kernels"`  // Whether to use optimized kernels
	SlowCandidates    bool     `json:"slow_candidates"`    // Whether to use slow candidates

	Skip  int64 `json:"skip"`  // Keyspace offset to start at
	Limit int64 `json:"limit"` // Maximum keyspace to process
}

func (Params) Validate

func (params Params) Validate() error

Validate checks if the parameters for the attack mode are valid. It returns an error if the parameters are invalid, or nil if they are valid.

type Result

type Result struct {
	Timestamp time.Time `json:"timestamp"` // The time the result was received
	Hash      string    `json:"hash"`      // The hash
	Plaintext string    `json:"plaintext"` // The plaintext
}

type Session

type Session struct {
	CrackedHashes     chan Result // Channel to send cracked hashes to
	StatusUpdates     chan Status // Channel to send status updates to
	StderrMessages    chan string // Channel to send stderr messages to
	StdoutLines       chan string // Channel to send stdout lines to
	DoneChan          chan error  // Channel to send the done signal to
	SkipStatusUpdates bool        // Whether to skip sending status updates
	// contains filtered or unexported fields
}

func NewHashcatSession

func NewHashcatSession(id string, params Params) (*Session, error)

func (*Session) Cleanup

func (sess *Session) Cleanup()

Cleanup removes any temporary files associated with the session. It deletes the hash file, output file, charset files, and sharded charset file (if present).

func (*Session) CmdLine

func (sess *Session) CmdLine() string

CmdLine returns the command line string used to start the session.

func (*Session) Kill

func (sess *Session) Kill() error

Kill terminates the running process associated with the session. If the session process is already terminated or not started, it returns nil. If an error occurs while terminating the process, it returns the error.

func (*Session) Start

func (sess *Session) Start() error

Start starts the hashcat session by attaching the stdout and stderr pipes, starting the hashcat process, and setting up goroutines to handle the output. It returns an error if any of the steps fail.

type Status

type Status struct {
	OriginalLine string    `json:"original_line"` // The original line from hashcat
	Time         time.Time `json:"time"`          // The time the status was received

	Session         string         `json:"session"`          // The session ID
	Guess           StatusGuess    `json:"guess"`            // The current guess
	Status          int32          `json:"status"`           // The status of the attack
	Target          string         `json:"target"`           // The target hash
	Progress        []int64        `json:"progress"`         // The progress of the attack
	RestorePoint    int64          `json:"restore_point"`    // The restore point
	RecoveredHashes []int32        `json:"recovered_hashes"` // The number of recovered hashes
	RecoveredSalts  []int32        `json:"recovered_salts"`  // The number of recovered salts
	Rejected        int64          `json:"rejected"`         // The number of rejected hashes
	Devices         []StatusDevice `json:"devices"`          // The devices used for the attack

	TimeStart     int64 `json:"time_start"`     // The start time of the attack
	EstimatedStop int64 `json:"estimated_stop"` // The estimated stop time of the attack
}

type StatusDevice

type StatusDevice struct {
	DeviceID   int32  `json:"device_id"`   // The device ID
	DeviceName string `json:"device_name"` // The device name
	DeviceType string `json:"device_type"` // The device type
	Speed      int64  `json:"speed"`       // The speed of the device
	Util       int32  `json:"util"`        // The utilization of the device
	Temp       int32  `json:"temp"`        // The temperature of the device
}

type StatusGuess

type StatusGuess struct {
	GuessBase        string  `json:"guess_base"`         // The base wordlist used for the attack
	GuessBaseCount   int64   `json:"guess_base_count"`   // The number of words in the base wordlist
	GuessBaseOffset  int64   `json:"guess_base_offset"`  // The offset into the base wordlist
	GuessBasePercent float32 `json:"guess_base_percent"` // The percentage of the base wordlist that has been processed

	GuessMod        string  `json:"guess_mod"`         // The modifier wordlist used for the attack
	GuessModCount   int64   `json:"guess_mod_count"`   // The number of words in the modifier wordlist
	GuessModOffset  int64   `json:"guess_mod_offset"`  // The offset into the modifier wordlist
	GuessModPercent float32 `json:"guess_mod_percent"` // The percentage of the modifier wordlist that has been processed

	GuessMode int32 `json:"guess_mode"` // The attack mode
}