hwt.go

// i legit say "NAH. NAH" on JWT when i was about to reinvent the whole JWT thing.
// just before i finished, i see the chaos.
//
// i mean, **5 ENCODING CALLS**.
// 2x JSON Encoding + 3x Base64 Encoding
//
// BRUH. WE COULD DO BETTER THAN THIS.
// so i stopped & reinvent something actually dead saner than any standard out here.
//
// HWT -> Hewo Web Token
//
// It's just <payload>.<sig>. That simple.
// You decode these two base64 fields, verify the bytes of <payload> with <sig>
// Isn't that saner?
package hwt

import (
	"bytes"
	"crypto/hmac"
	"crypto/sha256"
	"strings"
)

// Sign a payload of bytes with bytes of salt & make a token
func Sign(payload, salt []byte) (token string) {
	sig := l_hash(payload, salt)

	token = bytesToBase64(payload) + "." + bytesToBase64(sig)
	return
}

// Check whenever the token is valid with the hash and the salt
func Check(t string, salt []byte) (payload []byte, ok bool) {
	vals := strings.Split(t, ".")

	if len(vals) != 2 {
		return
	}

	var err error

	// before we unpack the entire nuts, we shall check hash.
	var thisHash []byte
	payload, err = base64ToBytes(vals[0])
	if err != nil {
		return
	}

	// get the hash value
	thisHash, err = base64ToBytes(vals[1])
	if err != nil {
		return
	}

	// validate whenever this goblin is valid
	ok = l_check(payload, thisHash, salt)

	return
}

func l_hash(b, salt []byte) (hash []byte) {
	h := hmac.New(sha256.New, salt)
	h.Write(b)
	hash = h.Sum(nil)
	return
}

func l_check(payload, hash, salt []byte) (valid bool) {
	actualHash := l_hash(payload, salt)
	valid = bytes.Equal(hash, actualHash)

	return
}