summaryrefslogtreecommitdiff
path: root/src/gobang.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/gobang.go')
-rw-r--r--src/gobang.go725
1 files changed, 725 insertions, 0 deletions
diff --git a/src/gobang.go b/src/gobang.go
new file mode 100644
index 0000000..4ce13ff
--- /dev/null
+++ b/src/gobang.go
@@ -0,0 +1,725 @@
+package gobang
+
+import (
+ "crypto/hmac"
+ "crypto/rand"
+ "crypto/sha256"
+ "encoding/binary"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "hash"
+ "io"
+ "log/slog"
+ "math/big"
+ "math/bits"
+ "os"
+ "reflect"
+ "runtime/debug"
+ "strings"
+ "sync"
+ "syscall"
+ "testing"
+ "time"
+)
+
+
+
+type LogLevel int8
+const (
+ LevelNone LogLevel = 0
+ LevelError LogLevel = 1
+ LevelWarning LogLevel = 2
+ LevelInfo LogLevel = 3
+ LevelDebug LogLevel = 4
+)
+
+const lengthUUID = 16
+type UUID struct {
+ bytes [lengthUUID]byte
+}
+
+type Gauge struct {
+ Inc func(...any)
+ Dec func(...any)
+}
+
+type CopyResult struct {
+ Written int64
+ Err error
+ Label string
+}
+
+
+
+const MaxInt = int((^uint(0)) >> 1)
+
+
+
+// Private variables
+
+// lastV7time is the last time we returned stored as:
+//
+// 52 bits of time in milliseconds since epoch
+// 12 bits of (fractional nanoseconds) >> 8
+var lastV7Time int64
+var timeMu sync.Mutex
+
+// Global variables
+var (
+ Level LogLevel = LevelInfo
+ EmitMetric bool = true
+ Hostname string
+)
+
+
+
+// Package pbkdf2 implements the key derivation function PBKDF2 as defined in
+// RFC 2898 / PKCS #5 v2.0.
+//
+// A key derivation function is useful when encrypting data based on a password
+// or any other not-fully-random data. It uses a pseudorandom function to derive
+// a secure encryption key based on the password.
+//
+// While v2.0 of the standard defines only one pseudorandom function to use,
+// HMAC-SHA1, the drafted v2.1 specification allows use of all five FIPS
+// Approved Hash Functions SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 for
+// HMAC. To choose, you can pass the `New` functions from the different SHA
+// packages to pbkdf2.Key.
+//
+//
+// Key derives a key from the password, salt and iteration count, returning a
+// []byte of length keylen that can be used as cryptographic key. The key is
+// derived based on the method described as PBKDF2 with the HMAC variant using
+// the supplied hash function.
+//
+// For example, to use a HMAC-SHA-1 based PBKDF2 key derivation function, you
+// can get a derived key for e.g. AES-256 (which needs a 32-byte key) by
+// doing:
+//
+// dk := pbkdf2.Key([]byte("some password"), salt, 4096, 32, sha1.New)
+//
+// Remember to get a good random salt. At least 8 bytes is recommended by the
+// RFC.
+//
+// Using a higher iteration count will increase the cost of an exhaustive
+// search but will also make derivation proportionally slower.
+func PBKDF2Key(
+ password []byte,
+ salt []byte,
+ iter int,
+ keyLen int,
+ h func() hash.Hash,
+) []byte {
+ prf := hmac.New(h, password)
+ hashLen := prf.Size()
+ numBlocks := (keyLen + hashLen - 1) / hashLen
+
+ var buf [4]byte
+ dk := make([]byte, 0, numBlocks*hashLen)
+ U := make([]byte, hashLen)
+ for block := 1; block <= numBlocks; block++ {
+ // N.B.: || means concatenation, ^ means XOR
+ // for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
+ // U_1 = PRF(password, salt || uint(i))
+ prf.Reset()
+ prf.Write(salt)
+ buf[0] = byte(block >> 24)
+ buf[1] = byte(block >> 16)
+ buf[2] = byte(block >> 8)
+ buf[3] = byte(block)
+ prf.Write(buf[:4])
+ dk = prf.Sum(dk)
+ T := dk[len(dk) - hashLen:]
+ copy(U, T)
+
+ // U_n = PRF(password, U_(n - 1))
+ for n := 2; n <= iter; n++ {
+ prf.Reset()
+ prf.Write(U)
+ U = U[:0]
+ U = prf.Sum(U)
+ for x := range U {
+ T[x] ^= U[x]
+ }
+ }
+ }
+ return dk[:keyLen]
+}
+
+// blockCopy copies n numbers from src into dst.
+func blockCopy(dst []uint32, src []uint32, n int) {
+ copy(dst, src[:n])
+}
+
+// blockXOR XORs numbers from dst with n numbers from src.
+func blockXOR(dst []uint32, src []uint32, n int) {
+ for i, v := range src[:n] {
+ dst[i] ^= v
+ }
+}
+
+// salsaXOR applies Salsa20/8 to the XOR of 16 numbers from tmp and in,
+// and puts the result into both tmp and out.
+func salsaXOR(tmp *[16]uint32, in []uint32, out []uint32) {
+ w0 := tmp[0] ^ in[0]
+ w1 := tmp[1] ^ in[1]
+ w2 := tmp[2] ^ in[2]
+ w3 := tmp[3] ^ in[3]
+ w4 := tmp[4] ^ in[4]
+ w5 := tmp[5] ^ in[5]
+ w6 := tmp[6] ^ in[6]
+ w7 := tmp[7] ^ in[7]
+ w8 := tmp[8] ^ in[8]
+ w9 := tmp[9] ^ in[9]
+ w10 := tmp[10] ^ in[10]
+ w11 := tmp[11] ^ in[11]
+ w12 := tmp[12] ^ in[12]
+ w13 := tmp[13] ^ in[13]
+ w14 := tmp[14] ^ in[14]
+ w15 := tmp[15] ^ in[15]
+
+ x0 := w0
+ x1 := w1
+ x2 := w2
+ x3 := w3
+ x4 := w4
+ x5 := w5
+ x6 := w6
+ x7 := w7
+ x8 := w8
+ x9 := w9
+ x10 := w10
+ x11 := w11
+ x12 := w12
+ x13 := w13
+ x14 := w14
+ x15 := w15
+
+ for i := 0; i < 8; i += 2 {
+ x4 ^= bits.RotateLeft32(x0 + x12, 7)
+ x8 ^= bits.RotateLeft32(x4 + x0, 9)
+ x12 ^= bits.RotateLeft32(x8 + x4, 13)
+ x0 ^= bits.RotateLeft32(x12 + x8, 18)
+
+ x9 ^= bits.RotateLeft32(x5 + x1, 7)
+ x13 ^= bits.RotateLeft32(x9 + x5, 9)
+ x1 ^= bits.RotateLeft32(x13 + x9, 13)
+ x5 ^= bits.RotateLeft32(x1 + x13, 18)
+
+ x14 ^= bits.RotateLeft32(x10 + x6, 7)
+ x2 ^= bits.RotateLeft32(x14 + x10, 9)
+ x6 ^= bits.RotateLeft32(x2 + x14, 13)
+ x10 ^= bits.RotateLeft32(x6 + x2, 18)
+
+ x3 ^= bits.RotateLeft32(x15 + x11, 7)
+ x7 ^= bits.RotateLeft32(x3 + x15, 9)
+ x11 ^= bits.RotateLeft32(x7 + x3, 13)
+ x15 ^= bits.RotateLeft32(x11 + x7, 18)
+
+ x1 ^= bits.RotateLeft32(x0 + x3, 7)
+ x2 ^= bits.RotateLeft32(x1 + x0, 9)
+ x3 ^= bits.RotateLeft32(x2 + x1, 13)
+ x0 ^= bits.RotateLeft32(x3 + x2, 18)
+
+ x6 ^= bits.RotateLeft32(x5 + x4, 7)
+ x7 ^= bits.RotateLeft32(x6 + x5, 9)
+ x4 ^= bits.RotateLeft32(x7 + x6, 13)
+ x5 ^= bits.RotateLeft32(x4 + x7, 18)
+
+ x11 ^= bits.RotateLeft32(x10 + x9, 7)
+ x8 ^= bits.RotateLeft32(x11 + x10, 9)
+ x9 ^= bits.RotateLeft32(x8 + x11, 13)
+ x10 ^= bits.RotateLeft32(x9 + x8, 18)
+
+ x12 ^= bits.RotateLeft32(x15 + x14, 7)
+ x13 ^= bits.RotateLeft32(x12 + x15, 9)
+ x14 ^= bits.RotateLeft32(x13 + x12, 13)
+ x15 ^= bits.RotateLeft32(x14 + x13, 18)
+ }
+
+ x0 += w0
+ x1 += w1
+ x2 += w2
+ x3 += w3
+ x4 += w4
+ x5 += w5
+ x6 += w6
+ x7 += w7
+ x8 += w8
+ x9 += w9
+ x10 += w10
+ x11 += w11
+ x12 += w12
+ x13 += w13
+ x14 += w14
+ x15 += w15
+
+ out[0], tmp[0] = x0, x0
+ out[1], tmp[1] = x1, x1
+ out[2], tmp[2] = x2, x2
+ out[3], tmp[3] = x3, x3
+ out[4], tmp[4] = x4, x4
+ out[5], tmp[5] = x5, x5
+ out[6], tmp[6] = x6, x6
+ out[7], tmp[7] = x7, x7
+ out[8], tmp[8] = x8, x8
+ out[9], tmp[9] = x9, x9
+ out[10], tmp[10] = x10, x10
+ out[11], tmp[11] = x11, x11
+ out[12], tmp[12] = x12, x12
+ out[13], tmp[13] = x13, x13
+ out[14], tmp[14] = x14, x14
+ out[15], tmp[15] = x15, x15
+}
+
+func blockMix(tmp *[16]uint32, in []uint32, out []uint32, r int) {
+ blockCopy(tmp[:], in[(2 * r - 1) * 16:], 16)
+ for i := 0; i < 2 * r; i += 2 {
+ salsaXOR(tmp, in[i * 16:], out[i * 8:])
+ salsaXOR(tmp, in[i * 16 + 16:], out[i * 8 + r * 16:])
+ }
+}
+
+func integer(b []uint32, r int) uint64 {
+ j := (2 * r - 1) * 16
+ return uint64(b[j]) | (uint64(b[j + 1]) << 32)
+}
+
+func smix(b []byte, r int, N int, v []uint32, xy []uint32) {
+ var tmp [16]uint32
+ R := 32 * r
+ x := xy
+ y := xy[R:]
+
+ j := 0
+ for i := 0; i < R; i++ {
+ x[i] = binary.LittleEndian.Uint32(b[j:])
+ j += 4
+ }
+ for i := 0; i < N; i += 2 {
+ blockCopy(v[i * R:], x, R)
+ blockMix(&tmp, x, y, r)
+
+ blockCopy(v[(i + 1) * R:], y, R)
+ blockMix(&tmp, y, x, r)
+ }
+ for i := 0; i < N; i += 2 {
+ j := int(integer(x, r) & uint64(N - 1))
+ blockXOR(x, v[j * R:], R)
+ blockMix(&tmp, x, y, r)
+
+ j = int(integer(y, r) & uint64(N - 1))
+ blockXOR(y, v[j * R:], R)
+ blockMix(&tmp, y, x, r)
+ }
+ j = 0
+ for _, v := range x[:R] {
+ binary.LittleEndian.PutUint32(b[j:], v)
+ j += 4
+ }
+}
+
+// Package scrypt implements the scrypt key derivation function as defined in
+// Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard
+// Functions" (https://www.tarsnap.com/scrypt/scrypt.pdf).
+//
+//
+// Key derives a key from the password, salt, and cost parameters, returning
+// a byte slice of length keyLen that can be used as cryptographic key.
+//
+// N is a CPU/memory cost parameter, which must be a power of 2 greater than 1.
+// r and p must satisfy r * p < 2³⁰. If the parameters do not satisfy the
+// limits, the function returns a nil byte slice and an error.
+//
+// For example, you can get a derived key for e.g. AES-256 (which needs a
+// 32-byte key) by doing:
+//
+// dk, err := scrypt.Key([]byte("some password"), salt, 32768, 8, 1, 32)
+//
+// The recommended parameters for interactive logins as of 2017 are N=32768, r=8
+// and p=1. The parameters N, r, and p should be increased as memory latency and
+// CPU parallelism increases; consider setting N to the highest power of 2 you
+// can derive within 100 milliseconds. Remember to get a good random salt.
+func Scrypt(
+ password []byte,
+ salt []byte,
+ N int,
+ r int,
+ p int,
+ keyLen int,
+) ([]byte, error) {
+ if N <= 1 || N & (N - 1) != 0 {
+ return nil, errors.New("scrypt: N must be > 1 and a power of 2")
+ }
+ if ((uint64(r) * uint64(p)) >= (1 << 30)) ||
+ r > MaxInt / 128 / p ||
+ r > MaxInt / 256 ||
+ N > MaxInt / 128 / r {
+ return nil, errors.New("scrypt: parameters are too large")
+ }
+
+ xy := make([]uint32, 64 * r)
+ v := make([]uint32, 32 * N * r)
+ b := PBKDF2Key(password, salt, 1, p * 128 * r, sha256.New)
+
+ for i := 0; i < p; i++ {
+ smix(b[i * 128 * r:], r, N, v, xy)
+ }
+
+ return PBKDF2Key(password, b, 1, keyLen, sha256.New), nil
+}
+
+func CopyData(
+ c chan CopyResult,
+ label string,
+ from io.Reader,
+ to io.WriteCloser,
+) {
+ written, err := io.Copy(to, from)
+ c <- CopyResult {
+ Written: written,
+ Err: err,
+ Label: label,
+ }
+}
+
+// FIXME: finish rewriting
+//
+// getV7Time returns the time in milliseconds and nanoseconds / 256.
+// The returned (milli << (12 + seq)) is guaranteed to be greater than
+// (milli << (12 + seq)) returned by any previous call to getV7Time.
+// `seq` Sequence number is between 0 and 3906 (nanoPerMilli >> 8)
+func getV7Time(nano int64) (int64, int64) {
+ const nanoPerMilli = 1000 * 1000
+
+ milli := nano / nanoPerMilli
+ seq := (nano - (milli * nanoPerMilli)) >> 8
+ now := milli << (12 + seq)
+
+ timeMu.Lock()
+ defer timeMu.Unlock()
+ if now <= lastV7Time {
+ now = lastV7Time + 1
+ milli = now >> 12
+ seq = now & 0xfff
+ }
+ lastV7Time = now
+ return milli, seq
+}
+
+func NewUUID() UUID {
+ var buf [lengthUUID]byte
+ _, err := io.ReadFull(rand.Reader, buf[7:])
+ if err != nil {
+ panic(err)
+ }
+
+ buf[6] = (buf[6] & 0x0f) | 0x40 // Version 4
+ buf[8] = (buf[8] & 0x3f) | 0x80 // Variant is 10
+
+ t, s := getV7Time(time.Now().UnixNano())
+
+ buf[0] = byte(t >> 40)
+ buf[1] = byte(t >> 32)
+ buf[2] = byte(t >> 24)
+ buf[3] = byte(t >> 16)
+ buf[4] = byte(t >> 8)
+ buf[5] = byte(t >> 0)
+
+ buf[6] = 0x70 | (0x0f & byte(s >> 8))
+ buf[7] = byte(s)
+ return UUID { bytes: buf }
+}
+
+func (uuid UUID) ToString() string {
+ const dashCount = 4
+ const encodedLength = (lengthUUID * 2) + dashCount
+ dst := [encodedLength]byte {
+ 0, 0, 0, 0,
+ 0, 0, 0, 0,
+ '-',
+ 0, 0, 0, 0,
+ '-',
+ 0, 0, 0, 0,
+ '-',
+ 0, 0, 0, 0,
+ '-',
+ 0, 0, 0, 0,
+ 0, 0, 0, 0,
+ 0, 0, 0, 0,
+ }
+
+ hex.Encode(dst[ 0:8], uuid.bytes[0:4])
+ hex.Encode(dst[ 9:13], uuid.bytes[4:6])
+ hex.Encode(dst[14:18], uuid.bytes[6:8])
+ hex.Encode(dst[19:23], uuid.bytes[8:10])
+ hex.Encode(dst[24:36], uuid.bytes[10:])
+
+ return string(dst[:])
+}
+
+func Debug(message string, type_ string, args ...any) {
+ if Level < LevelDebug {
+ return
+ }
+
+ slog.Debug(
+ message,
+ append(
+ []any {
+ "id", NewUUID().ToString(),
+ "kind", "log",
+ "type", type_,
+ },
+ args...,
+ )...,
+ )
+}
+
+func Info(message string, type_ string, args ...any) {
+ if Level < LevelInfo {
+ return
+ }
+
+ slog.Info(
+ message,
+ append(
+ []any {
+ "id", NewUUID().ToString(),
+ "kind", "log",
+ "type", type_,
+ },
+ args...,
+ )...,
+ )
+}
+
+func Warning(message string, type_ string, args ...any) {
+ if Level < LevelWarning {
+ return
+ }
+
+ slog.Warn(
+ message,
+ append(
+ []any {
+ "id", NewUUID().ToString(),
+ "kind", "log",
+ "type", type_,
+ },
+ args...,
+ )...,
+ )
+}
+
+func Error(message string, type_ string, args ...any) {
+ if Level < LevelError {
+ return
+ }
+
+ slog.Error(
+ message,
+ append(
+ []any {
+ "id", NewUUID().ToString(),
+ "kind", "log",
+ "type", type_,
+ },
+ args...,
+ )...,
+ )
+}
+
+func Metric(type_ string, label string, args ...any) {
+ if !EmitMetric {
+ return
+ }
+
+ slog.Info(
+ "_",
+ append(
+ []any {
+ "id", NewUUID().ToString(),
+ "kind", "metric",
+ "type", type_,
+ "label", label,
+ },
+ args...,
+ )...,
+ )
+}
+
+func MakeGauge(label string, staticArgs ...any) Gauge {
+ var zero = big.NewInt(0)
+ var one = big.NewInt(1)
+ count := big.NewInt(0)
+ emitGauge := func(dynamicArgs ...any) {
+ if count.Cmp(zero) == -1 {
+ Error(
+ "Gauge went negative",
+ "process-metric",
+ append(
+ []any { "value", count },
+ append(
+ staticArgs,
+ dynamicArgs...,
+ )...,
+ )...,
+ )
+ return // avoid wrong metrics being emitted
+ }
+ Metric(
+ "gauge", label,
+ // TODO: we'll have slices.Concat on Go 1.22
+ append(
+ []any { "value", count },
+ append(
+ staticArgs,
+ dynamicArgs...,
+ )...,
+ )...,
+ )
+ }
+ return Gauge {
+ Inc: func(dynamicArgs ...any) {
+ count.Add(count, one)
+ emitGauge(dynamicArgs...)
+ },
+ Dec: func(dynamicArgs ...any) {
+ count.Sub(count, one)
+ emitGauge(dynamicArgs...)
+ },
+ }
+}
+
+func MakeCounter(label string) func(...any) {
+ return func(args ...any) {
+ Metric(
+ "counter", label,
+ append([]any { "value", 1 }, args...)...,
+ )
+ }
+}
+
+func ErrorIf(t *testing.T, err error) {
+ if err != nil {
+ t.Errorf("Unexpected error: %#v\n", err)
+ }
+}
+
+func ErrorNil(t *testing.T, err error) {
+ if err == nil {
+ t.Errorf("Expected error, got nil\n")
+ }
+}
+
+func AssertEqual(t *testing.T, given any, expected any) {
+ if !reflect.DeepEqual(given, expected) {
+ t.Errorf("given != expected\n")
+ t.Errorf("given: %#v\n", given)
+ t.Errorf("expected: %#v\n", expected)
+ }
+}
+
+func AssertEqualI(t *testing.T, i int, given any, expected any) {
+ if !reflect.DeepEqual(given, expected) {
+ t.Errorf("given != expected (i = %d)\n", i)
+ t.Errorf("given: %#v\n", given)
+ t.Errorf("expected: %#v\n", expected)
+ }
+}
+
+func SetLoggerOutput(w io.Writer) {
+ slog.SetDefault(slog.New(slog.NewJSONHandler(w, &slog.HandlerOptions {
+ AddSource: true,
+ })).With(
+ slog.Group(
+ "info",
+ "pid", os.Getpid(),
+ "ppid", os.Getppid(),
+ "puuid", NewUUID().ToString(),
+ ),
+ ))
+}
+
+func LevelFromString(name string) (bool, LogLevel) {
+ level := strings.ToUpper(name)
+
+ if level == "NONE" {
+ return true, LevelNone
+ }
+
+ if level == "ERROR" {
+ return true, LevelError
+ }
+
+ if level == "WARNING" {
+ return true, LevelWarning
+ }
+
+ if level == "INFO" {
+ return true, LevelInfo
+ }
+
+ if level == "DEBUG" {
+ return true, LevelDebug
+ }
+
+ return false, Level
+}
+
+func SetLogLevel() {
+ ok, level := LevelFromString(os.Getenv("LOG_LEVEL"))
+
+ if ok {
+ Level = level
+ }
+}
+
+func SetMetric() {
+ if os.Getenv("NO_METRIC") != "" {
+ EmitMetric = false
+ }
+}
+
+func SetTraceback() {
+ if os.Getenv("GOTRACEBACK") == "" {
+ debug.SetTraceback("crash")
+ }
+}
+
+func Fatal(err error) {
+ Error(
+ "Fatal error", "fatal-error",
+ "error", err,
+ "stack", string(debug.Stack()),
+ )
+ syscall.Kill(os.Getpid(), syscall.SIGABRT)
+ os.Exit(3)
+}
+
+func FatalIf(err error) {
+ if err != nil {
+ Fatal(err)
+ }
+}
+
+func SetHostname() {
+ var err error
+ Hostname, err = os.Hostname()
+ FatalIf(err)
+}
+
+func Init() {
+ SetLoggerOutput(os.Stdout)
+ SetLogLevel()
+ SetMetric()
+ SetTraceback()
+ SetHostname()
+}
+
+
+func Main() {
+ fmt.Println(NewUUID().ToString())
+}
generated by cgit v1.2.3 (git 2.49.0) at 2025-07-22 22:50:19 +0000