HSL.js hcaptcha rewritten to golang

hsl.go

package nhelper

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"math"
	"strconv"
	"strings"
	"time"
)

var (
	t = "0123456789/:abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
)

type payload struct {
	S int    `json:"s"`
	T string `json:"t"`
	D string `json:"d"`
	L string `json:"l"`
	E int    `json:"e"`
}

func atob(input string) string {
	data, err := base64.RawStdEncoding.DecodeString(input)
	if err != nil {
		return ""
	}
	return string(data)
}

// Solve takes in a key and gives back a fully encoded N
func Solve(key string) string {
	parts := strings.Split(key, ".")
	o := &payload{}
	err := json.Unmarshal([]byte(atob(parts[1])), &o)
	if err != nil {
		return ""
	}
	a := o.D
	s := o.S
	return e(s, a)
}

func e(r int, t string) string {
	// unknownFunc := func(r int, t string) string {
	// 	for i := 0; i < 25; i++ {
	// 		unknownArr := []int{}
	// 		for s := 0; s < i; s++ {
	// 			if i > 0 {
	// 				unknownArr = append(unknownArr, 0)
	// 			}
	// 			for o(unknownArr) {
	// 				if n(r, t+"::"+a(unknownArr)) {
	// 					return a(unknownArr)
	// 				}
	// 			}
	// 		}
	// 	}

	// 	return ""
	// }
	//unknownVar := unknownFunc(r, t)
	formattedDate := getFormattedDate()
	return "1:" + fmt.Sprint(r) + ":" + formattedDate + ":" + t + "::" + "1"
}

func getFormattedDate() string {
	timeNow := getTimeISO()
	timeNow = timeNow[:len(timeNow)-5]
	timeNow = strings.ReplaceAll(timeNow, "-", "")
	timeNow = strings.ReplaceAll(timeNow, ":", "")
	timeNow = strings.ReplaceAll(timeNow, "T", "")
	return timeNow
}

func n(t int, r string) bool {

	finalFunc := func(r int, t []int) bool {
		ee := 0
		nn := -1
		for unknownArr := []int{}; nn+1 < 8*len(t); {
			ee = t[nn/8]
			ee = ee % 8 & 1
			unknownArr = append(unknownArr, ee)
			aa := unknownArr
			return 0 == aa[0] && (indexOf(aa, 1) >= r-1 || -1 == indexOf(aa, 1))
		}
		return false
	}

	return finalFunc(t, (digest(hash(r))))
}

func indexOf(arr []int, item int) int {
	for thing, position := range arr {
		if thing == item {
			return position
		}
	}
	return -1
}

func a(r []int) string {
	e := ""
	for n := 0; n < len(r); n++ {
		e += string(t[r[n]])
	}
	return e
}

func o(input []int) bool {
	for e := len(input) - 1; e >= 0; e-- {
		if input[e] < len(t)-1 {
			input[e] = input[e] + 1
			return true
		}
	}
	return false
}

func getTimeISO() string {
	return time.Now().UTC().Format("2006-01-02T15:04:05.999Z")
}

func digest(r []int) []int {
	newArr := []int{
		rightShift(r[0], 24) & 255,
		rightShift(r[0], 16) & 255,
		rightShift(r[0], 8) & 255,
		255 & r[0],
		rightShift(r[0], 24) & 255,
		rightShift(r[0], 16) & 255,
		rightShift(r[0], 8) & 255,
		255 & r[1],
		rightShift(r[0], 24) & 255,
		rightShift(r[0], 16) & 255,
		rightShift(r[0], 8) & 255,
		255 & r[2],
		rightShift(r[0], 24) & 255,
		rightShift(r[0], 16) & 255,
		rightShift(r[0], 8) & 255,
		255 & r[3],
		rightShift(r[0], 24) & 255,
		rightShift(r[0], 16) & 255,
		rightShift(r[0], 8) & 255,
		255 & r[4],
	}
	return newArr
}

func hash(input string) []int {
	e := []int{1518500249, 1859775393, 2400959708, 3395469782}
	n := []int{1732584193, 4023233417, 2562383102, 271733878, 3285377520}
	o := input
	a := len(o+string(rune(128)))/4 + 2
	i := int(math.Ceil(float64(a) / 16))
	s := [4][16]int{}
	runeArray := []rune{}
	for _, v := range o {
		runeArray = append(runeArray, v)
	}
	for u := 0; u < i; u++ {
		s[u] = [16]int{}
		for c := 0; c < 16; c++ {
			letter1 := 0
			letter2 := 0
			letter3 := 0
			letter4 := 0
			var err error
			if 64*u+4*c+0 < len(runeArray) {
				letter1, err = strconv.Atoi(fmt.Sprintf("%d", runeArray[64*u+4*c+0]))
				if err != nil {
					return []int{}
				}
			}
			if 64*u+4*c+1 < len(runeArray) {
				letter2, err = strconv.Atoi(fmt.Sprintf("%d", runeArray[64*u+4*c+1]))
				if err != nil {
					return []int{}
				}
			}
			if 64*u+4*c+2 < len(runeArray) {
				letter3, err = strconv.Atoi(fmt.Sprintf("%d", runeArray[64*u+4*c+2]))
				if err != nil {
					return []int{}
				}
			}
			if 64*u+4*c+3 < len(runeArray) {
				letter4, err = strconv.Atoi(fmt.Sprintf("%d", runeArray[64*u+4*c+3]))
				if err != nil {
					return []int{}
				}
			}
			if u == 3 && c == 4 {
				s[u][c] = -2147483648
				continue
			}
			s[u][c] = letter1<<24 | letter2<<16 | letter3<<8 | letter4<<0
		}

	}
	s[i-1][14] = int(math.Floor(float64(8*(len(o)-1)) / math.Pow(float64(2), float64(32))))
	s[i-1][15] = 8 * (len(o[:len(o)])) & 4294967295

	for f := 0; f < i; f++ {
		h := [80]int{}
		for l := 0; l < 16; l++ {
			h[l] = s[f][l]
		}
		for g := 16; g < 80; g++ {
			h[g] = rotateLeft(h[g-3]^h[g-8]^h[g-14]^h[g-16], 1)
		}
		d := n[0]
		v := n[1]
		p := n[2]
		w := n[3]
		y := n[4]
		for S := 0; S < 80; S++ {
			C := int(math.Floor(float64(S) / float64(20)))
			T := trippleShift(rotateLeft(d, 5)+ff(C, v, p, w)+y+e[C]+h[S], 0)
			y = w
			w = p
			p = trippleShift(rotateLeft(v, 30), 0)
			v = d
			d = T
		}
		n[0] = trippleShift(n[0]+d, 0)
		n[1] = trippleShift(n[1]+v, 0)
		n[2] = trippleShift(n[2]+p, 0)
		n[3] = trippleShift(n[3]+w, 0)
		n[4] = trippleShift(n[4]+y, 0)
	}

	return n
}

func ff(r int, t int, e int, n int) int {
	var operation int32
	num := t
	overflow := int32(num)
	num1 := e
	overflow1 := int32(num1)
	num2 := n
	overflow2 := int32(num2)
	switch r {
	case 0:
		operation = overflow&overflow1 ^ ^overflow&overflow2
	case 1:
		operation = overflow ^ overflow1 ^ overflow2
	case 2:
		operation = overflow&overflow1 ^ overflow&overflow2 ^ overflow1&overflow2
	case 3:
		operation = overflow ^ overflow1 ^ overflow2
	}
	return int(operation)
}

func trippleShift(num, t int) int {
	overflow := int32(num)
	return int(uint32(overflow) >> t)
}

func rotateLeft(num, t int) int {
	overflow := int32(num)
	return int(overflow<<t) | int(uint32(num)>>(32-t))
}

func rightShift(num, t int) int {
	overflow := int32(num)
	return int(overflow >> t)
}