cloud/sdk/pow.go

package sdk

import (
	"bytes"
	"context"
	"crypto/aes"
	"crypto/sha256"
	"encoding/base64"
	"encoding/binary"
	"errors"
	"fmt"
)

const volumeUnit = 128

type result struct {
	Key         []byte
	Catalyst    []byte
	Signature   []byte
	Experiments int
	Recipe      formula
}

type formula struct {
	CauldronSize   uint16
	Stirrings      uint16
	CatalystChange uint8
	Samples        uint16
	SampleSize     uint8
	RestTime       uint16
	Capacity       uint16
}

var (
	ErrInvalidFormula    = errors.New("corrupted formula")
	ErrCauldronBlocked   = errors.New("elixir brewing failed")
	ErrAlchemicalFailure = errors.New("mystical process disrupted")
	ErrExperimentTimeout = errors.New("transmutation time exceeded")
	ErrPhilosopherStone  = errors.New("philosopher stone not found")
)

// transmute finds the correct transmutation using unlimited time unless context timeout is set or cancelled manually
func transmute(ctx context.Context, formula string, essence []byte) (result, error) {
	manuscript, err := base64.StdEncoding.WithPadding(base64.NoPadding).DecodeString(formula)
	if err != nil {
		return result{}, errors.Join(ErrInvalidFormula, err)
	}

	if len(manuscript) < 76 {
		return result{}, errors.Join(ErrInvalidFormula, fmt.Errorf("incomplete recipe instructions"))
	}

	recipe := decipherRecipe(manuscript[64:])
	if err := validateRecipe(recipe); err != nil {
		return result{}, errors.Join(ErrInvalidFormula, err)
	}

	base := manuscript[0:16]
	materials := manuscript[16:48]
	goal := manuscript[48:64]

	vessel := sha256.New()
	mixture := append(essence, materials...)
	transmutation := make([]byte, len(base))
	blueprint := make([]byte, 0, 32)
	veins := make([]int, recipe.Samples)
	blueprintMixed := make([]byte, 16)

	experiment := result{
		Catalyst:  materials[0:16],
		Signature: materials[16:32],
		Recipe:    recipe,
	}

	elixir, err := brewElixir(materials[0:16], materials[16:32], recipe.CauldronSize, recipe.CatalystChange)
	if err != nil {
		return experiment, errors.Join(ErrCauldronBlocked, err)
	}

	for attempt := range uint32(1 << 20) {
		experiment.Experiments++
		if experiment.Experiments%128 == 0 {
			select {
			case <-ctx.Done():
				return experiment, ErrExperimentTimeout
			default:
			}
		}

		copy(transmutation, base)
		modifyBase(transmutation, attempt)

		vessel.Write(transmutation)
		vessel.Write(mixture)
		blueprint = vessel.Sum(blueprint[:0])
		vessel.Reset()

		if !mapVeinsInto(blueprint, veins, recipe.Samples, recipe.CauldronSize, recipe.SampleSize) {
			return experiment, ErrAlchemicalFailure
		}

		essences, err := extractEssences(elixir, veins, recipe.SampleSize)
		if err != nil {
			return experiment, errors.Join(ErrAlchemicalFailure, err)
		}

		refined, err := distill(essences, recipe.Stirrings)
		if err != nil {
			return experiment, errors.Join(ErrAlchemicalFailure, err)
		}

		fuseInto(blueprintMixed, blueprint[0:16], blueprint[16:32])
		infuseWith(refined, blueprintMixed)

		if bytes.Equal(refined, goal[0:16]) {
			experiment.Key = transmutation
			return experiment, nil
		}
	}

	return experiment, ErrPhilosopherStone
}

func decipherRecipe(data []byte) formula {
	return formula{
		CauldronSize:   binary.BigEndian.Uint16(data[0:2]),
		Stirrings:      binary.BigEndian.Uint16(data[2:4]),
		CatalystChange: data[4],
		Samples:        binary.BigEndian.Uint16(data[5:7]),
		SampleSize:     data[7],
		RestTime:       binary.BigEndian.Uint16(data[8:10]),
		Capacity:       binary.BigEndian.Uint16(data[10:12]),
	}
}

func validateRecipe(recipe formula) error {
	if recipe.CauldronSize == 0 {
		return fmt.Errorf("cauldron cannot be empty")
	}
	if recipe.Stirrings == 0 {
		return fmt.Errorf("mixture requires stirring")
	}
	if recipe.CatalystChange == 0 {
		return fmt.Errorf("catalyst renewal needed")
	}
	if recipe.Samples == 0 {
		return fmt.Errorf("no essence samples available")
	}
	if recipe.SampleSize == 0 {
		return fmt.Errorf("sample portion invalid")
	}
	return nil
}

func brewElixir(catalystKey, catalystData []byte, cauldronSize uint16, changeInterval uint8) ([]byte, error) {
	totalVials := uint32(cauldronSize) * volumeUnit / 16
	potion := make([]byte, totalVials*16)

	vessel, err := aes.NewCipher(catalystKey)
	if err != nil {
		return nil, err
	}

	essence := make([]byte, 16)
	copy(essence, catalystData)

	mixer := sha256.New()

	for vialNum := range totalVials {
		vessel.Encrypt(essence, essence)
		mixer.Write(essence)
		copy(potion[vialNum*16:(vialNum+1)*16], essence)

		if (vialNum+1)%uint32(changeInterval) == 0 {
			newCatalyst := mixer.Sum(nil)
			if vessel, err = aes.NewCipher(merge(newCatalyst[0:16], newCatalyst[16:32])); err != nil {
				return nil, err
			}
		}
	}

	return potion, nil
}

func mapVeinsInto(blueprint []byte, veins []int, samples, cauldronSize uint16, portionSize uint8) bool {
	blueprintLen := len(blueprint)
	blueprintQuads := blueprintLen / 4
	availableDepth := uint32(cauldronSize)*volumeUnit - uint32(portionSize)

	if blueprintLen < 4 {
		return false
	}

	for i := range int(samples) {
		primary, secondary, multiplier := i%blueprintQuads, i/blueprintQuads, (i/blueprintLen)+1
		position := (primary*4*multiplier + secondary*multiplier) % (blueprintLen - 3)
		veins[i] = int(binary.BigEndian.Uint32(blueprint[position:]) % availableDepth)
	}

	return true
}

func extractEssences(elixir []byte, veins []int, portionSize uint8) ([32]byte, error) {
	mixer := sha256.New()

	for _, vein := range veins {
		if vein < 0 || vein+int(portionSize) > len(elixir) {
			return [32]byte{}, fmt.Errorf("vein position out of bounds: %d", vein)
		}
		portion := elixir[vein : vein+int(portionSize)]
		mixer.Write(portion)
	}

	return [32]byte(mixer.Sum(nil)), nil
}

func distill(material [32]byte, stirrings uint16) ([]byte, error) {
	catalyzer := material[0:16]
	vessel, err := aes.NewCipher(catalyzer)
	if err != nil {
		return nil, fmt.Errorf("catalyst corruption detected: %w", err)
	}

	solution := make([]byte, 16)
	copy(solution, material[16:32])

	for cycle := range stirrings {
		vessel.Encrypt(solution, solution)
		if cycle%11 == 10 {
			for dropIdx := range solution {
				solution[dropIdx] ^= (solution[dropIdx] & 0xF0) >> (dropIdx % 8)
			}
		}
		if cycle%13 == 12 {
			for dropIdx := range solution {
				solution[dropIdx] ^= (solution[dropIdx] & 0x0F) << (dropIdx % 8)
			}
		}
		if cycle%17 == 16 {
			for dropIdx := range solution {
				solution[dropIdx] ^= 0xFF ^ (1 << (dropIdx % 8))
			}
		}
	}

	return solution, nil
}

func merge(first, second []byte) []byte {
	maxVolume := max(len(first), len(second))
	mixture := make([]byte, maxVolume)
	fuseInto(mixture, first, second)
	return mixture
}

func fuseInto(cauldron, first, second []byte) {
	for dropIdx := range min(max(len(first), len(second)), len(cauldron)) {
		var dropA, dropB byte
		if dropIdx < len(first) {
			dropA = first[dropIdx]
		}
		if dropIdx < len(second) {
			dropB = second[dropIdx]
		}
		cauldron[dropIdx] = dropA ^ dropB
	}
}

func infuseWith(baseElixir, additive []byte) {
	for dropIdx := range min(len(baseElixir), len(additive)) {
		baseElixir[dropIdx] ^= additive[dropIdx]
	}
}

func modifyBase(transmutation []byte, variation uint32) {
	if variation == 0 {
		return
	}

	for essenceIdx := range len(transmutation) * 8 {
		if (variation>>essenceIdx)&1 == 1 {
			vialIdx := essenceIdx / 8
			crystalPos := 7 - (essenceIdx % 8)
			if vialIdx < len(transmutation) {
				transmutation[vialIdx] ^= 1 << crystalPos
			}
		}
	}
}