Evan Hosinski
336 lines
9.4 KiB
Go
336 lines
9.4 KiB
Go
package dehashed
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"go.uber.org/zap"
|
|
"hub.krkn.tech/KrakenTech/crowsnest/internal/debug"
|
|
"hub.krkn.tech/KrakenTech/crowsnest/internal/export"
|
|
"hub.krkn.tech/KrakenTech/crowsnest/internal/pretty"
|
|
"hub.krkn.tech/KrakenTech/crowsnest/internal/sqlite"
|
|
)
|
|
|
|
const (
|
|
maxSearchResultsPerPage = 10000
|
|
maxSearchResultsPerQuery = 50000
|
|
)
|
|
|
|
// Dehasher is a struct for querying the Dehashed API
|
|
type Dehasher struct {
|
|
options sqlite.QueryOptions
|
|
nextPage int
|
|
debug bool
|
|
balance int
|
|
maxResults int
|
|
request *DehashedSearchRequest
|
|
client *DehashedClientV2
|
|
}
|
|
|
|
// NewDehasher creates a new Dehasher
|
|
func NewDehasher(options *sqlite.QueryOptions) *Dehasher {
|
|
dh := &Dehasher{
|
|
options: *options,
|
|
nextPage: options.StartingPage + 1,
|
|
debug: options.Debug,
|
|
balance: 0,
|
|
}
|
|
dh.setQueries()
|
|
dh.request = NewDehashedSearchRequest(dh.options.StartingPage, dh.options.MaxRecords, dh.options.WildcardMatch, dh.options.RegexMatch, false, options.Debug)
|
|
dh.buildRequest()
|
|
return dh
|
|
}
|
|
|
|
// SetClientCredentials sets the client credentials for the dehasher
|
|
func (dh *Dehasher) SetClientCredentials(key string) {
|
|
dh.client = NewDehashedClientV2(key, dh.debug)
|
|
}
|
|
|
|
func (dh *Dehasher) getNextPage() int {
|
|
if dh.debug {
|
|
debug.PrintInfo(fmt.Sprintf("getting next page: %d", dh.nextPage))
|
|
}
|
|
nextPage := dh.nextPage
|
|
dh.nextPage += 1
|
|
return nextPage
|
|
}
|
|
|
|
// setQueries sets the number of queries to make based on the number of records and requests
|
|
func (dh *Dehasher) setQueries() {
|
|
if dh.debug {
|
|
debug.PrintInfo("setting queries")
|
|
}
|
|
|
|
if dh.options.MaxRequests == 0 {
|
|
zap.L().Error("max requests cannot be zero")
|
|
fmt.Println("[!] Max Requests cannot be zero")
|
|
os.Exit(1)
|
|
}
|
|
|
|
requestedMaxResults := dh.options.MaxRecords
|
|
if requestedMaxResults <= 0 {
|
|
requestedMaxResults = maxSearchResultsPerQuery
|
|
}
|
|
if requestedMaxResults > maxSearchResultsPerQuery {
|
|
requestedMaxResults = maxSearchResultsPerQuery
|
|
}
|
|
|
|
pageSize := requestedMaxResults
|
|
if pageSize > maxSearchResultsPerPage {
|
|
pageSize = maxSearchResultsPerPage
|
|
}
|
|
|
|
numQueries := (requestedMaxResults + pageSize - 1) / pageSize
|
|
if dh.options.MaxRequests > 0 && dh.options.MaxRequests < numQueries {
|
|
numQueries = dh.options.MaxRequests
|
|
}
|
|
|
|
dh.maxResults = requestedMaxResults
|
|
if requestLimit := numQueries * pageSize; requestLimit < dh.maxResults {
|
|
dh.maxResults = requestLimit
|
|
}
|
|
|
|
dh.options.MaxRecords = pageSize
|
|
dh.options.MaxRequests = numQueries
|
|
|
|
zap.L().Info("dehashed_search_pagination",
|
|
zap.Int("max_results", dh.maxResults),
|
|
zap.Int("page_size", dh.options.MaxRecords),
|
|
zap.Int("max_requests", dh.options.MaxRequests),
|
|
)
|
|
|
|
if dh.debug {
|
|
debug.PrintInfo(fmt.Sprintf("setting max requests: %d", numQueries))
|
|
debug.PrintInfo(fmt.Sprintf("setting page size: %d", dh.options.MaxRecords))
|
|
debug.PrintInfo(fmt.Sprintf("setting max results: %d", dh.maxResults))
|
|
}
|
|
|
|
fmt.Printf("Making %d Requests for up to %d Records (%d per request)\n", dh.options.MaxRequests, dh.maxResults, dh.options.MaxRecords)
|
|
}
|
|
|
|
// Start starts the querying process
|
|
func (dh *Dehasher) Start() {
|
|
fmt.Printf("[*] Querying Dehashed API...\n")
|
|
for i := 0; i < dh.options.MaxRequests; i++ {
|
|
fmt.Printf(" [*] Performing Request...\n")
|
|
count, balance, err := dh.client.Search(*dh.request)
|
|
if err != nil {
|
|
if dh.debug {
|
|
debug.PrintInfo("error performing request")
|
|
debug.PrintError(err)
|
|
}
|
|
|
|
// Check if it's a DehashError
|
|
if dhErr, ok := err.(*DehashError); ok {
|
|
fmt.Printf(" [!] Dehashed API Error: %s (Code: %d)\n", dhErr.Message, dhErr.Code)
|
|
zap.L().Error("dehashed_api_error",
|
|
zap.String("message", dhErr.Message),
|
|
zap.Int("code", dhErr.Code),
|
|
)
|
|
} else {
|
|
fmt.Printf(" [!] Error performing request: %v\n", err)
|
|
zap.L().Error("request_error",
|
|
zap.String("message", "failed to perform request"),
|
|
zap.Error(err),
|
|
)
|
|
}
|
|
|
|
if len(dh.client.results) > 0 {
|
|
fmt.Printf(" [!] Partial results retrieved. Storing Results...\n")
|
|
err := sqlite.StoreDehashedResults(dh.client.GetResults())
|
|
if err != nil {
|
|
zap.L().Error("store_results",
|
|
zap.String("message", "failed to store results"),
|
|
zap.Error(err),
|
|
)
|
|
fmt.Printf(" [!] Error storing results: %v\n", err)
|
|
}
|
|
}
|
|
dh.parseResults()
|
|
os.Exit(-1)
|
|
}
|
|
|
|
dh.balance = balance
|
|
|
|
if count < dh.options.MaxRecords {
|
|
fmt.Printf(" [+] Retrieved %d records\n", count)
|
|
fmt.Printf(" [-] Not enough entries, ending queries\n")
|
|
break
|
|
} else {
|
|
fmt.Printf(" [+] Retrieved %d records\n", count)
|
|
}
|
|
|
|
if dh.options.PrintBalance {
|
|
fmt.Printf(" [*] Balance: %d\n", balance)
|
|
}
|
|
|
|
dh.request.Page = dh.getNextPage()
|
|
}
|
|
|
|
dh.parseResults()
|
|
}
|
|
|
|
// buildRequest constructs the query map
|
|
func (dh *Dehasher) buildRequest() {
|
|
if len(dh.options.UsernameQuery) > 0 {
|
|
dh.request.AddUsernameQuery(dh.options.UsernameQuery)
|
|
}
|
|
if len(dh.options.EmailQuery) > 0 {
|
|
dh.request.AddEmailQuery(dh.options.EmailQuery)
|
|
}
|
|
if len(dh.options.IpQuery) > 0 {
|
|
dh.request.AddIpAddressQuery(dh.options.IpQuery)
|
|
}
|
|
if len(dh.options.HashQuery) > 0 {
|
|
dh.request.AddHashedPasswordQuery(dh.options.HashQuery)
|
|
}
|
|
if len(dh.options.PassQuery) > 0 {
|
|
dh.request.AddPasswordQuery(dh.options.PassQuery)
|
|
}
|
|
if len(dh.options.NameQuery) > 0 {
|
|
dh.request.AddNameQuery(dh.options.NameQuery)
|
|
}
|
|
if len(dh.options.DomainQuery) > 0 {
|
|
dh.request.AddDomainQuery(dh.options.DomainQuery)
|
|
}
|
|
if len(dh.options.VinQuery) > 0 {
|
|
dh.request.AddVinQuery(dh.options.VinQuery)
|
|
}
|
|
if len(dh.options.LicensePlateQuery) > 0 {
|
|
dh.request.AddLicensePlateQuery(dh.options.LicensePlateQuery)
|
|
}
|
|
if len(dh.options.AddressQuery) > 0 {
|
|
dh.request.AddAddressQuery(dh.options.AddressQuery)
|
|
}
|
|
if len(dh.options.PhoneQuery) > 0 {
|
|
dh.request.AddPhoneQuery(dh.options.PhoneQuery)
|
|
}
|
|
if len(dh.options.SocialQuery) > 0 {
|
|
dh.request.AddSocialQuery(dh.options.SocialQuery)
|
|
}
|
|
if len(dh.options.CryptoAddressQuery) > 0 {
|
|
dh.request.AddCryptoAddressQuery(dh.options.CryptoAddressQuery)
|
|
}
|
|
}
|
|
|
|
// parseResults parses the results and writes them to a file
|
|
func (dh *Dehasher) parseResults() {
|
|
zap.L().Info("extracting_credentials")
|
|
results := dh.client.GetResults()
|
|
if dh.maxResults > 0 && len(results.Results) > dh.maxResults {
|
|
results.Results = results.Results[:dh.maxResults]
|
|
}
|
|
creds := results.ExtractUsers()
|
|
fmt.Printf(" [+] Discovered %d Credentials\n", len(creds))
|
|
err := sqlite.StoreUsers(creds)
|
|
if err != nil {
|
|
zap.L().Error("store_creds",
|
|
zap.String("message", "failed to store creds"),
|
|
zap.Error(err),
|
|
)
|
|
}
|
|
zap.L().Info("creds_stored", zap.Int("count", len(creds)))
|
|
|
|
zap.L().Info("storing_results")
|
|
err = sqlite.StoreDehashedResults(results)
|
|
if err != nil {
|
|
zap.L().Error("store_results",
|
|
zap.String("message", "failed to store results"),
|
|
zap.Error(err),
|
|
)
|
|
}
|
|
zap.L().Info("results_stored", zap.Int("count", len(results.Results)))
|
|
|
|
if len(results.Results) > 0 {
|
|
var (
|
|
headers = []string{"Email", "Username", "Password"}
|
|
rows [][]string
|
|
)
|
|
|
|
fmt.Printf(" [*] Writing entries to file: %s.%s\n", dh.options.OutputFile, dh.options.OutputFormat.String())
|
|
if !dh.options.CredsOnly {
|
|
err := export.WriteToFile(results, dh.options.OutputFile, dh.options.OutputFormat)
|
|
if err != nil {
|
|
fmt.Printf("[!] Error Writing to file: %v Outputting to terminal.\n", err)
|
|
zap.L().Error("write_results",
|
|
zap.String("message", "failed to write results to file"),
|
|
zap.Error(err),
|
|
)
|
|
} else {
|
|
fmt.Println(" [*] Success")
|
|
}
|
|
|
|
if dh.debug {
|
|
debug.PrintInfo("printing results table")
|
|
}
|
|
|
|
headers = []string{"Email", "Username", "Password", "Phone", "Company"}
|
|
if len(results.Results) > 50 {
|
|
fmt.Println(" [-] Large number of results recovered, displaying first 50...")
|
|
for i := 0; i < 50; i++ {
|
|
r := results.Results[i]
|
|
rows = append(rows, []string{
|
|
strings.Join(r.Email, ", "),
|
|
strings.Join(r.Username, ", "),
|
|
strings.Join(r.Password, ", "),
|
|
strings.Join(r.Phone, ", "),
|
|
strings.Join(r.Company, ", ")})
|
|
}
|
|
} else {
|
|
for _, r := range results.Results {
|
|
rows = append(rows, []string{
|
|
strings.Join(r.Email, ", "),
|
|
strings.Join(r.Username, ", "),
|
|
strings.Join(r.Password, ", "),
|
|
strings.Join(r.Phone, ", "),
|
|
strings.Join(r.Company, ", ")})
|
|
}
|
|
}
|
|
|
|
// Print Table
|
|
pretty.Table(headers, rows)
|
|
} else {
|
|
if dh.debug {
|
|
debug.PrintInfo("extracting credentials")
|
|
}
|
|
creds := results.ExtractUsers()
|
|
if dh.debug {
|
|
debug.PrintInfo("writing credentials to file")
|
|
}
|
|
err := export.WriteCredsToFile(creds, dh.options.OutputFile, dh.options.OutputFormat)
|
|
if err != nil {
|
|
fmt.Printf("[!] Error Writing to file: %v\n Outputting to terminal.", err)
|
|
zap.L().Error("write_creds",
|
|
zap.String("message", "failed to write creds to file"),
|
|
zap.Error(err),
|
|
)
|
|
} else {
|
|
fmt.Println(" [*] Success")
|
|
}
|
|
|
|
if dh.debug {
|
|
debug.PrintInfo("printing credentials table")
|
|
}
|
|
|
|
headers = []string{"Email", "Username", "Password"}
|
|
if len(creds) > 50 {
|
|
fmt.Println(" [-] Large number of results recovered, displaying first 50...")
|
|
for i := 0; i < 50; i++ {
|
|
c := creds[i]
|
|
rows = append(rows, []string{c.Email, c.Username, c.Password})
|
|
}
|
|
} else {
|
|
for _, c := range creds {
|
|
rows = append(rows, []string{c.Email, c.Username, c.Password})
|
|
}
|
|
}
|
|
|
|
// Print Table
|
|
pretty.Table(headers, rows)
|
|
}
|
|
} else {
|
|
fmt.Println(" [-] No results found")
|
|
}
|
|
}
|